waashk/dblp huggingface dataset:
tool support for just-in-time architecture reconstruction and evaluation: an experience report. the need for software architecture evaluation has drawn considerable attention in recent years. in practice, this is a challenging exercise for two main reasons. first, in deployed projects, software architecture documentation is often not readily available, and may not be a correct representation of the as built architecture. second, large software systems have numerous potential views of the various architecturally significant structures in the system. in this paper we assess the capabilities of software reverse engineering and architecture reconstruction tools to support just-in-time architecture reconstruction. if an application's architecture can be reconstructed efficiently, this could promote more effective architecture reviews and evaluations. we describe our experiences in leveraging multiple reconstruction tools and how these guided the choice of design artifacts to construct. we discovered that the tools complemented each other in identifying reconstruction scope, critical architectural elements, potential design irregularities and creating useful architectural views for different evaluation tasks. with the help of these tools, the reconstruction and evaluation effort was significantly streamlined and productive. finally, we also report some potential improvements these tools could make.
ethical considerations in software engineering. the author discusses ethical considerations that arise in the practice of software engineering and uses cases to help focus the discussion on ethical concerns in the practice of software engineering. the author comments on the relationship between software safety and ethics, informed consent and ethical decisions, the customer's responsibility for end-product quality, internal performance standards and customer consent to inferior work, and techniques for addressing ethical issues
on the modelling, analysis and design of protocols - a special class of software structures. in this paper we review briefly some of the formal models and techniques that can be applied on the modelling, analysis and design of communication protocols.
static checking of dynamically generated queries in database applications. many data-intensive applications dynamically constructqueries in response to client requests and execute them.java servlets, e.g., can create string representations ofsql queries and then send the queries, using jdbc, to adatabase server for execution. the servlet programmer enjoysstatic checking via javaýs strong type system. however,the java type system does little to check for possible errorsin the dynamically generated sql query strings. thus,a type error in a generated selection query (e.g., comparinga string attribute with an integer) can result in an sqlruntime exception. currently, such defects must be rootedout through careful testing, or (worse) might be found bycustomers at runtime. in this paper, we present a sound,static, program analysis technique to verify the correctnessof dynamically generated query strings. we describe ouranalysis technique and provide soundness results for ourstatic analysis algorithm. we also describe the details of aprototype tool based on the algorithm and present severalillustrative defects found in senior software-engineeringstudent-team projects, online tutorial examples, and a real-worldpurchase order system written by one of the authors.
dynamic restructuring in an experimental operating system. a well-structured system can easily be understood and modified. moreover, it may lend itself even to dynamic modification: under special conditions, the possibility of changing system parts while the system is running can be provided at little additional cost. our approach to the design of dynamically modifiable systems is based on the principle of data abstraction applied to types and modules. it allows for dynamic replacement or restructuring of a module's implementation if this does not affect its specification (or if it leads to some kdnd of compatible specification). the fundamental principles of such "replugging" are exhibited, and the implementation of a replugging facility for an experimental operating system on a pdp-11/40e is described.
linguistic support for the evolutionary design of software architectures. as a program's functionality evolves over time, its software architecture should evolve as well so that it continues to match the program's design. this paper introduces the architecture language of clock, a language for the development of interactive, multiuser applications. this architecture language possesses three properties supporting the easy restructuring of software architectures: restricted scoping supported by a constraint-based communication system, automatic message routing, and easy hierarchical restructuring of architectures. clock's architecture language has a visual syntax, supported by the clock-works programming environment.
advanced control flows for flexible graphical user interfaces: or, growing guis on trees or, bookmarking guis. web and gui programs represent two extremely common and popular modes of human-computer interaction. many gui programs share the web's notion of browsing through data- and decision-trees. this paper compares the user's browsing power in the two cases and illustrates that many gui programs fall short of the web's power to clone windows and bookmark applications. it identifies a key implementation problem that gui programs must overcome to provide this power. it then describes a theoretically well-founded programming pattern, which we have automated, that endows gui programs with these capabilities. the paper provides concrete examples of the transformation in action.
an empirical study of regression test selection techniques. regression testing is the process of validating modified software to detect whether new errors have been introduced into previously tested code and to provide confidence that modifications are correct. since regression testing is an expensive process, researchers have proposed regression test selection techniques as a way to reduce some of this expense. these techniques attempt to reduce costs by selecting and running only a subset of the test cases in a program's existing test suite. although there have been some analytical and empirical evaluations of individual techniques, to our knowledge only one comparative study, focusing on one aspect of two of these techniques, has been reported in the literature. we conducted an experiment to examine the relative costs and benefits of several regression test selection techniques. the experiment examined five techniques for reusing test cases, focusing on their relative ablilities to reduce regression testing effort and uncover faults in modified programs. our results highlight several differences between the techiques, and expose essential trade-offs that should be considered when choosing a technique for practical application.
using software component generators to contstruct a meta-weaver framework. several new modularity technologies have been proposed that improve separation of concerns in programming languages. the initial efforts to demonstrate these technologies are usually focused on a single programming language. since we live in a polyglot world, this proposal addresses the goal of being able to take these new powerful technologies to other languages. the approach uses software generators that create new &ldquo;weavers&rdquo; from meta-specifications of programming languages.
design of large-scale polylingual systems. building systems from existing applications writtenin two or more languages is common practice. such systemsare polylingual. polylingual systems are relatively easyto build when the number of apis needed to achieve languageinteroperability is small. however, when the numberof distinct apis become large, maintaining and evolvingpolylingual systems becomes a notoriously difficult task.in this paper, we present a simple, practical, and effectiveway to develop, maintain, and evolve large-scale polylingualsystems. our approach relies on recursive type systemswhose instances can be manipulated by reflection. foreignobjects (i.e. objects that are not defined in a host programminglanguage) are abstracted as graphs and path expressionsare used for accessing and manipulating data. pathexpressions are implemented by type reification ¿ turningforeign type instances into first-class objects and enablingaccess to and manipulation of them in a host programminglanguage. doing this results in multiple benefits, includingcoding simplicity and uniformity that we demonstrate in acomplex commercial project.
the design of the psi program synthesis system. this paper presents an overview of the current state of the psi automatic program synthesis system and discusses the design considerations. the psi system allows a user to specify a desired program in a dialogue using natural language and traces. psi then synthesizes a program meeting these specifications. the target programs are simple symbolic computation programs in lisp. psi may be described as a knowledge-based program understanding system. it is organized as a collection of closely interacting modules, or experts in the areas of natural language, discourse, traces, application domain, high-level program modelling, coding, and efficiency. an implementation effort is underway and several modules are now working.
assuring and evolving concurrent programs: annotations and policy. assuring and evolving concurrent programs requires understanding the concurrency-related design decisions used in their implementation. in java-style shared-memory programs, these decisions include which state is shared, how access to it is regulated, the roles of threads, and the policy that distinguishes desired concurrency from race conditions. these decisions rarely have purely local manifestations in code.in this paper, we use case studies from production java code to explore the costs and benefits of a new annotation-based approach for expressing design intent. our intent is both to assist in establishing "thread safety" attributes in code and to support tools that safely restructure code---for example, shifting critical section boundaries or splitting locks. the annotations we use express "mechanical" properties such as lock-state associations, uniqueness of references, and encapsulation of state into named aggregations. our analyses revealed race conditions in our case study samples, drawn from open-source projects and library code.the novel technical features of this approach include (1) flexible encapsulation via aggregations of state that can cross object boundaries, (2) the association of locks with state aggregations, (3) policy descriptions for allowable method interleavings, and (4) the incremental process for inserting, validating, and exploiting annotations.
capturing more world knowledge in the requirements specification. the view is adopted that software requirements involve the representation (modeling) of considerable real-world knowledge, not just functional specifications. a framework (rmf) for requirements models is presented and its main features are illustrated. rmf allows information about three types of conceptual entities (objects, activities, and assertions) to be recorded uniformly using the notion of properties. by grouping all entities into classes or metaclasses, and by organizing classes into generalization (specialization) hierarchies, rmf supports three abstraction principles (classification, aggregation, and generalization) which appear to be of universal importance in the development and organization of complex descriptions. finally, by providing a mathematical model underlying our terminology, we achieve both unambiguity and the potential to verify consistency of the model.
on formal requirements modeling languages: rml revisited. research issues related to requirements modeling are introduced and discussed through a review of the requirements modeling language rml, its peers and its successors from the time it was first proposed at the sixth international conference on software engineering (icse-6) to the present - ten icses later. we note that the central theme of &ldquo;capturing more world knowledge&rdquo; in the original rml proposal is becoming increasingly important in requirements engineering. the paper highlights key ideas and research issues that have driven rml and its peers, evaluates them retrospectively in the context of experience and more recent developments, and points out significant remaining problems and directions for requirements modeling research
cooperating evolving components: a rigorous approach to evolving large software systems. large software systems have a large number of components and are developed over a long time period frequently by a large number of people. we describe a framework approach to evolving such systems based on an integration of product and process modelling. the evolving system is represented as a product tower, a hierarchy of components which provides views of the product at multiple levels of refinement. the evolution process is component based with the cooperation between components being mediated by the product tower. this ensures that the evolution process is scaleable and that it maintains, and evolves, the design model. we illustrate our approach with an example, outlining an evolution both of the product and of the process. the reflexive facilities of the process are shown to be key in ensuring the framework's ability to evolve.
software technology in an automotive company - major challenges. the automotive industry is one of the sectors which has been affected significantly by the industrial software revolution during the last few years. competitive challenges, which are of major relevance for the growing number of software-based automotive innovations, are presented by a dramatic growth in system complexity, rising time and cost pressure, and high quality demands.all these requirements lead to a number of software-related challenges which will be of significant competitive importance for the automotive industry in the future. asides from the question of whether an automotive company decides to develop software in-house or whether this is carried out by suppliers, every automotive key player has to hold or to build up specific software competencies. the most important competence areas are the software development process, software quality management including supplier cooperation, the overall architecture of the in-vehicle software, as well as the ability to specify, to integrate and to test the system.
software needs engineering: a position paper. when the general press refers to 'software' in its headlines, then this is often not to relate a success story, but to expand on yet another 'software-risk-turned-problem-story.'for many people the term 'software' evokes the image of an application package running either on a pc or some similar stand-alone usage. over 70% of all software, however, are not developed in the traditional software houses as part of the creation of such packages. much of this software comes in the form of products and services that end users would not readily associate with software. these can be complex systems with crucial connections made through software, such as telecommunications or banking systems, or the logistics systems of airports. or these can be end-user products with software embedded, ranging from battery management systems in electric shavers, over mobile phones to engine management and safety systems in cars. e-commerce systems fall into this category, too.yes, there is software that works reliably and as expected, and there are professional approaches to create such products &mdash; one can engineer software, in the right environment, with the right people.
software reuse experience at hewlett-packard. at hewlett-packard, we have had visible divisional software reuse efforts since the mid-1980s. in 1990, we initiated a multi-faceted corporate reuse program to gather information about reuse from within hp and from other companies. as we studied the existing reuse programs, we discovered that certain issues were poorly understood, and as a consequence, mistakes were made in starting and running certain programs at hp and elsewhere. our corporate reuse program focused on packaging best-practice information and guidelines to avoid common pitfalls. we also developed technology transfer and educational processes to spread this information and enhance reuse practice within the company. in 1992, we launched a multi-disciplinary research program to investigate and develop better methods for domain-specific, reuse-based software engineering. we have learned that for large-scale reuse to work, the problems to be overcome are mostly non-technical
architecting for large-scale systematic component reuse. organizations building highly complex business and technical systems need to architect families of systems and implement these with large-scale component reuse. without carefully architecting the systems, components, organizations and processes for reuse, object reuse will not succeed. experience with software reuse practice and adoption experience at hp and ericsson led us to a systematic approach to component-based software engineering, based on object-oriented business and system modeling. this article explains how higher-level uml constructs support architected reuse, and describes a systematic process, leading from the business processes of an enterprise, through the system architecture for a family of applications that support these business processes, to the design and use of highly reusable component systems.
a component architecture for an extensible, highly integrated context-aware computing infrastructure. ubiquitous context-aware computing systems present several challenges in their construction. principal among them is the tradeoff between easily providing new context-aware services to users and the tight integration of those services, as demanded by the small form factor of the devices typically found in ubiquitous computing environments. performance issues further complicate the management of this tradeoff.mechanisms have been proposed and toolkits developed for aiding the construction of context-aware systems, but there has been little consideration of how to specialize, organize, and compose these mechanisms to meet the above requirements. we motivate and describe a software architecture that provides the desired integration and extensibility of services in a context-aware application infrastructure. a key result is the fissioning of intuitive class organizations, both across layers and within layers, to achieve the required integration of services and separation of concerns.
introduction to research papers. at the heart of the icse-2005 program are the 44 research papers selected by the program committee (pc) from the 313 submissions to the conference. all submissions were rigorously reviewed by the pc -- each submission received reviews from at least three different pc members. the pc then met on 5-6 november 2004 in newport beach, california, usa, to discuss the submissions and make the final selections for the program. each of the papers selected for publication in the proceedings and presentation at the conference was chosen on its own merits and without comparison to any others.the papers selected cover a wide range of research areas, which are not always amenable to a simple classification. nevertheless, the papers are clustered into sessions that broadly represent the dominant research themes of the work described.the pc comprised 43 members drawn from a wide cross section of the software engineering community. the pc members worked hard to put the program of research papers together. each pc member received an average of 22 papers to review prior to the pc meeting, followed by a substantial e-mail conversation and two full days discussing papers at the pc meeting. it was our pleasure and privilege to work with such a professional group of people to produce the quality of the program before you. our deepest thanks go to the pc.we must also thank the organizers of sigsoft fse 2005, who generously hosted our pc meeting and assisted in numerous local arrangements. in particular, we thank dick taylor, debra brodbeck, and susan knight. their help in producing a trouble-free, enjoyable pc meeting helped keep the pc's spirits high through two long days.we would be remiss if we did not lavish praise and thanks on richard van de stadt and the cyberchair conference management system. cyberchair streamlined many of the pc's activities, and richard added several new features to cyberchair that saved us days of work in staging the pc meeting.finally, we thank our general chair, catalin roman, for bringing us together, making us partners in creating icse 2005, and giving us the guidance and freedom we needed to create the best possible research program. in doing so, he has given us one of the most rewarding experiences of our professional lives.
exploiting the map metaphor in a tool for software evolution. software maintenance and evolution are the dominant activities in the software lifecycle. modularization can allow design decisions to be independently evolved, but eventually modularizations fail to do so, and then complicated global changes are required. tool support can reduce the costs of these unfortunate changes, but current tools are limited in their ability to manage information for large-scale software evolution. in this paper we argue that the map metaphor can serve as an organizing principle for the design of effective tools for performing global software changes. we describe the design of aspect browser, developed around the map metaphor, and discuss a case study of removing a feature from a 500,000 line program written in fortran and c.
workflow management based on process model repositories. workflow management is an area of increasing interest. nonetheless there are only a few workflow systems which are actually used for supporting business processes in an industrial context. most of these systems only deal with processes which create and manipulate unstructured pieces of information, like documents and images. our workflow management approach, called the funsoft net approach, additionally supports the management of structured pieces of information, called objects. in doing so, we use a repository which is used to store information about process models and about individual processes. this repository is particularly useful for processes dealing with highly structured information, such as software processes. we describe the experience in using such a repository. we point out which of these experiences may be useful for developers of other workflow management systems as well
software process modeling and enactment: an experience report related to problem tracking in an industrial project. the paper provides an overview of process research and the application of research results to practice and then describes process models using funsoft nets and a workflow management system leu. the example from which the experience is drawn is that of a problem tracking system and the components of the model are described and illustrated. the experience reported comes in three flavors: the appropriateness of funsoft nets as a modeling mechanisms and the alternative use of state transition diagrams; the benefits of the model and its support of the business process; and finally some implications for process research
workshop on directions in software engineering environments (wodisee). the goal of this workshop was is to bring togetherresearchers and practitioners with an interest indeveloping, extending, deploying and using softwareengineering tools. theis workshop will provides aninteractive forum for the exchange of ideas anddiscussion about future trends in software engineeringenvironment research and development.the outcomes of this workshop will beare a summary ofthe state of the art in software engineering environmentresearch and development, and the identification of keydirections for future research in this area.