The cover image, by Vaclav Rajlich, is based on the Perspective Paper Five recommendations for software evolvability, https://doi.org/10.1002/smr.1949.

Abstract Evolvability of software lies in intersection of 3 factors: evolving system properties, human factors present in the developer team, and evolution demands. The paper presents 5 recommendations that enhance software evolvability: defined processes of software change, distinction between evolving and stabilized part of the code, analyzable code segments, significant concept encapsulation, and avoidance of wrapping.

During impact analysis on object-oriented code, statically extracting dependencies is often complicated by subclassing, programming to interfaces, aliasing, and collections, among others. When a tool recommends a large number of types or does not rank its recommendations, it may lead developers to explore more irrelevant code. We propose to mine and rank dependencies based on a global, hierarchical points-to graph that is extracted using abstract interpretation. A previous whole-program static analysis interprets a program enriched with annotations that express hierarchy, and over-approximates all the objects that may be created at runtime and how they may communicate. In this paper, an analysis mines the hierarchy and the edges in the graph to extract and rank dependencies such as the most important classes related to a class, or the most important classes behind an interface. An evaluation using two case studies on two systems totaling 10,000 lines of code and five completed code modification tasks shows that following dependencies based on abstract interpretation achieves higher effectiveness compared to following dependencies extracted from the abstract syntax tree. As a result, developers explore less irrelevant code.

The paradigm shift from waterfall to evolutionary software development (that includes agile development) has been widespread in industry, but academia is still struggling with it. This position paper reiterates the reasons for the paradigm shift that illustrate the importance of the shift. The position paper then discusses what the shift means for the software engineering education. As an example, it briefly presents how software engineering is taught at Wayne State University.

Both employers and graduate schools expect computer science graduates to be able to work as developers on software projects. Software engineering courses present the opportunity in the curriculum to learn the relevant skills. This paper presents our experience from Wayne State University and reviews challenges and constraints that we faced while trying to teach these skills. In our first software engineering course, we teach the iterative software development that includes practices of software change, summarized in the phased model of software change. The required resources for our software engineering course are comparable to the other computer science courses. The students - while working in teams - are graded based on their individual contribution to the team effort rather than on the work of the other team members, which improves the fairness of the grading and considerably lessens the stress for the best students in the course. Our students have expressed a high level of satisfaction, and in a survey, they indicated that the skills that they learned in the course are highly applicable to their careers.

This paper presents the practices observed in successful academic projects. It classifies them by the software lifecycle stage they belong to, most of the academic projects are in stage of evolution. It also classifies them by their purpose into the organizational and code development practices. The classification may help academic project managers and developers, who are often specialist in fields other than software engineering, to select the appropriate practices for their project.

This retrospective briefly recapitulates highlights of the original paper that was published at IWPC 2002. Then it overviews research directions of the last 10 years: research in tools and techniques of concept location a that aim to support software developer, research of integrated model of software change, creation of software engineering course that emphasizes the role of software developer in iterative and agile software processes, and further basic research into the role and properties of concepts.

The definitive version can be found at : http://onlinelibrary.wiley.com/ Copyright Wiley [Full text of this article is not available in the UHRA]

During the last decade, software engineering changed rapidly, from the emphasis on waterfall lifecycle to the emphasis on software evolution and agile programming. This tutorial provides a brief introduction and overview of the results of this development. It presents agile programming, Personal and Team Software Process, software change, concept location, refactoring, and so forth. The organizing principle is an outline of an undergraduate software engineering course that is based on these results. The audience interested in this tutorial may be teachers of software engineering, and also software practitioners who want learn how these results fit together and how to apply them in software projects.

In this paper, we study the hidden dependencies that are a special kind of data flows. They play an important role in software maintenance and evolution because they propagate changes among the classes and they are hard to detect. We propose a technique that finds hidden dependencies through the computation of an “execute completely after” relation that is filtered using dynamically generated preconditions and postconditions. We show that these hidden dependencies exist even in well-structured software, like the open source programs JUnit, Drawlets, and Apache FtpServer. We also discuss the precision of this technique.

This retrospective briefly recapitulates the original paper that was published at IWPC 2000, overviews selected papers that were published in its wake, presents recent clarifications and updates of the topic, and mentions the still unfinished agenda and future work.

Impact analysis is a specialized process of program comprehension that investigates the nature and extent of a planned software change. Traditionally, impact analysis involves inspecting dependencies among the software components of a fixed granularity; these components constitute a dependency graph. In this paper, we argue that a single granularity is insufficient and leads to imprecise analysis. We explain how the precision can be improved by variable granularity, where the programmers choose among the granularity of classes, the granularity of class members, and the granularity of code fragments. We assess the resulting precision in a case study on open-source software.

The classical comprehension theories study relations between extensions, intensions, and names. Originally developed in linguistics and mathematics, these theories are applicable to program comprehension as well. While extensions are present in the program, the intensions are usually missing, and evolution and maintenance programmers have to recover them as the program cannot be successfully comprehended and changed without them.

The paper explores Static Execute After (SEA) dependencies in the program and their dual Static Execute Before (SEB) dependencies. It empirically compares the SEA/SEB dependencies with the traditional dependencies that are computed by System Dependence Graph (SDG) and program slicers. In our case study we use about 30 subject programs that were previously used by other authors in empirical studies of program analysis. We report two main results. The computation of SEA/SEB is much less expensive and much more scalable than the computation of the SDG. At the same time, the precision declines only very slightly, by some 4% on average. In other words, the precision is comparable to that of the leading traditional algorithms, while intuitively a much larger difference would be expected. The paper then discusses whether based on these results the computation of the SDG should be replaced in some applications by the computation of the SEA/SEB.

Partial comprehension is a necessity in the evolution and maintenance of very large software systems. The programmers form not only partial comprehension of the code, but also partial comprehension of the application domain. To describe the comprehension process, we introduce ontology fragments and investigate how programmers form, use and extend them before and during concept location; concept location is a prerequisite of code changes. We conducted case studies of concept location in two large systems, Eclipse and Mozilla, that both have more than 50,000 methods. Using grep search and ontology fragments, the programmers were able to locate the concepts after inspecting on average less than 10 methods and operating with ontology fragments of around 14 concepts, a very small fraction of the total.

Abstract Testing firewalls have proven to be a useful approach for regression testing in both functional and object‐oriented software. They involve only the modules that are closely related to the changed modules. They lead to substantially reduced regression tests but still are very effective in detecting regression faults. This paper investigates situations when data‐flow paths are longer, and the testing of modules and components only one level away from the changed elements may not detect certain regression faults; an extended firewall considers these longer data paths. We report empirical studies that show the degree to which an extended firewall detected more faults, and how much more testing was required to achieve this increased detection. Copyright © 2008 John Wiley & Sons, Ltd.

In this paper, we introduce static execute after (SEA) relationship among program components and present an efficient analysis algorithm. Our case studies show that SEA may approximate static slicing with perfect recall and high precision, while being much less expensive and more usable. When differentiating between explicit and hidden dependencies, our case studies also show that SEA may correlate with direct and indirect class coupling. We speculate that SEA may find applications in computation of hidden dependencies and through it in many maintenance tasks, including change propagation and regression testing.

The paper presents a semi-automated technique for feature location in source code. The technique is based on combining information from two different sources: an execution trace, on one hand and the comments and identifiers from the source code, on the other hand.

This paper recasts the problem of feature location in source code as a decision-making problem in the presence of uncertainty. The solution to the problem is formulated as a combination of the opinions of different experts. The experts in this work are two existing techniques for feature location: a scenario-based probabilistic ranking of events and an information-retrieval-based technique that uses latent semantic indexing. The combination of these two experts is empirically evaluated through several case studies, which use the source code of the Mozilla Web browser and the Eclipse integrated development environment. The results show that the combination of experts significantly improves the effectiveness of feature location as compared to each of the experts used independently

In the traditional software engineering courses, the students develop small programs from scratch. This does not correspond to industry practice where programmers spend most of their time evolving medium to large systems. In order to narrow this gap, we developed a course where students practice software evolution through the implementation of change requests on medium-sized open-source software systems. The results of the course show that this type of software engineering course gives students a more realistic experience than traditional software engineering courses. In the survey at the end of the course, the students expressed a higher level of satisfaction with both rating the course and assessing how much they learned. Additionally, the resources required by such a course are not excessive

The paper recasts the problem of feature location in source code as a decision-making problem in the presence of uncertainty. The main contribution consists in the combination of two existing techniques for feature location in source code. Both techniques provide a set of ranked facts from the software, as result to the feature identification problem. One of the techniques is based on a scenario based probabilistic ranking of events observed while executing a program under given scenarios. The other technique is defined as an information retrieval task, based on the latent semantic indexing of the source code. We show the viability and effectiveness of the combined technique with two case studies. A first case study is a replication of feature identification in Mozilla, which allows us to directly compare the results with previously published data. The other case study is a bug location problem in Mozilla. The results show that the combined technique improves feature identification significantly with respect to each technique used independently

THE International Conference on Software Maintenance and Evolution (ICSM) is the leading research conference in software maintenance and evolution. It provides a widely recognized international forum for discussions and exchange of ideas between researchers and experts. ICSM 2005 was held in Budapest on 26-29 September 2005. In cooperation with the ICSM conference, several collocated workshops were organized. These included the Seventh IEEE International Symposium on Web Site Evolution (WSE), the Fifth IEEE International Workshop on Source Code Analysis and Manipulation (SCAM), the Third International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT), the Software Evolvability Workshop, and the 13th International Workshop on Software Technology and Engineering Practice (STEP). For ICSM 2005, 180 research papers were submitted. From this record number of papers the program committee selected 55 full papers for inclusion in the proceedings. Of these 55 papers, eight were extended from their conference version, passed through the standard TSE review process involving three anonymous reviewers per paper, and are contained in this special issue. The first paper, “Feature Identification: An Epidemiological Metaphor” by G. Antoniol and Y.-G. Gueheneuc, presents an epidemiology inspired approach to feature identification. The approach relies on statistical analysis of static and dynamic data and identifies features of large, multithreaded object-oriented programs: the Firefox e-mail tool and the Mozilla Web browser. The results suggest that the epidemiological analysis overcomes the limitations of existing methods and increases the accuracy of the feature identification. Extracted microarchitectures consist of variables, structures, classes, and methods, and support the maintenance and program understanding. The second paper, “Toward the Reverse Engineering of UML Sequence Diagrams for Distributed Java Programs” by L.C. Briand, Y. Labiche, and J. Leduc, provides a methodology to reverse engineer sequence diagrams from dynamic analysis data. Because of inheritance, polymorphism, and dynamic binding, reverse engineering and understanding the behavior of an object-oriented system is difficult. Multithreading and distribution further complicate the analysis. In order to separate the instrumentation from the application code, aspect-oriented programming was used. The approach is illustrated on a distributed library management system developed in Java, using RMI as the distribution middleware. The third paper, “Static Analysis of Object References in RMI-Based Java Software” by M. Sharp and A. Rountev, presents a points-to analysis of distributed Java programs that contain the Remote Method Invocation (RMI). Points-to information is often a prerequisite for program understanding, testing, and code optimizations. The existing points-to analysis techniques cannot be applied directly to RMI-based distributed applications. The approach presented in this paper allows us to represent the flow of remote objects, the effects of remote invocations, and the remote propagation of object graphs through serialization. The result of an experimental study suggests that the approximate version of the analysis could be a good option for a relatively precise and practical points-to analysis of RMI-based Java applications. The fourth paper, “Incremental Maintenance of Software Artifacts” by S.P. Reiss, presents a software development tool (CLIME) that identifies potential problems and inconsistencies between software design, specification, documentation, source code, test cases, and other artifacts. The approach is based on constraints implemented as database queries that describe the association of the different software artifacts. These constraints are maintained and checked incrementally during the evolution of a system and the inconsistencies are reported to the developers. The approach is validated on several software development projects where many language and documentation problems and inconsistencies between the code and documentation have been identified. The fifth paper, “Tool-Supported Refactoring of ObjectOriented Code into Aspects” by D. Binkley, M. Ceccato, M. Harman, F. Ricca, and P. Tonella, presents refactoring Object-Oriented Programs (OOP), written in Java, into equivalent Aspect-Oriented Programs (AOP) written in AspectJ. The approach relies on six refactorings to support migration from OOP to AOP. These refactorings are combined with existing OO transformations into a tool, AOP-Migrator, which is implemented as an Eclipse plug-in. The approach is applied to several Java systems: JHotDraw, IEEE TRANSACTIONS ON SOFTWARE ENGINEERING, VOL. 32, NO. 9, SEPTEMBER 2006 625

Software development process transforms requirements into source code. These requirements are formulated as concepts from the problem domain or the solution domain; among them, features are the concepts that describe user selectable behavior. During software evolution, existing concepts and features of the system are changed, deleted, or new ones are added. In order to solve any of these change tasks, the existing concepts need to be precisely identified in the source code. This identification process was initially defined as the concept assignment (location) problem [2]. It is of no surprise that searching and browsing the software artifacts with the goal to identify parts of the source code that implement a concept from the software domain is one of the most common activities during software evolution. The existing methods of concept and feature location fall into two broad categories, based on the information from the software used during the location process: static [3] and dynamic [4]. Concerns of the software system are closely related to the concepts. A major issue during software design is the separation of these concerns [1] from one another through the modularization mechanisms available in the chosen program language. The goal is to implement each concern as one module in the software. The limitations of existing programming paradigms and languages, often combined with the lack of design expertise, result in a sad reality, where concerns are implemented in several modules, often cross-cutting the primary decomposition of the system. 2. Discussion topics

This work presents data from a long-term (four year) case study of the effects of incremental software redocumentation of data communications services software that is a part of a check processing system. It presents data on the relative cost and completeness of the incremental redocumentation and its impact on programmer productivity and cost of the software change. The break-even point occurred after 1.5 years of effort, which means that the extra investment in redocumentation started paying off after 1.5 years of redocumentation activity.

We present an overview of the 5th International Workshop on Principles of Software Evolution (IWPSE 2002).

Incremental changes add new functionality and properties to software. They are the core of software evolution, maintenance, iterative development, agile development, and similar software processes. This paper presents a technique for unanticipated incremental software change and a case study. The technique uses programming concepts as the foundation, and contains steps of concept location, actualization, incorporation, and change propagation. The case study presents an unanticipated change in the open source software "Drawlets".

The aim of the panel session is to clarify issues involved in software evolution, but more particularly, to identify and explore promising solutions and research directions, in order to identify strategic goals for the research community and solution visions for practitioners.By evolution, we mean a stage of software lifecycle where the software undergoes substantial changes and this also includes iterative software development and/or agile software processes.

Key parts of software change are concept location and change propagation. We introduce a tool called RIPPLES that supports both. It uses the Abstract System Dependence Graph (ASDG) of the program, enriched by conceptual dependencies. A case study of NCSA Mosaic demonstrates the use of the tool. Precision and recall are used to evaluate the quality of support provided by RIPPLES.

Software change is the basic building block of software evolution, and problems of software evolution can be solved by research into software change. There is a need to develop reactive methodologies, tools, and techniques. This will solve the problems posed by unexpected changes and also address the issues of ultrafast software evolution.

No abstract available.

In this paper, we describe restructuring of C code into new C++ classes. Such restructuring is done to facilitate both software reuse and software evolution. The restructuring is accomplished by restructuring tools and scenarios. We discuss the transformation tool-set and the design of the individual tools. The approach is demonstrated on a case study We also discuss how this tool-set could be enhanced in the future.

The purpose of software redocumention is to recover comprehension of software and to record it for future use. This paper describes Partitioned Annotations of Software (PAS), where comprehension is recorded in hypertext and browsed by web browsers. The annotations for each code component are partitioned in order to keep different explanations separate, leverage the advantages of hypertext, and better support the processes of program comprehension. The paper describes a tool that parses code and generates PAS skeletons. The paper also describes a process of incremental redocumentation where comprehension of software is recorded incrementally during normal maintenance. The experience with PAS in an industrial project is summarized.

This paper reports on a process for eliminating function clones and class clones from industrial object-oriented code. Clone removal can decrease system code size and facilitate maintenance. We eliminate clones by re-engineering scenarios that are based on using automated restructuring tools. The clone elimination process described includes function insertion, function expulsion, function encapsulation, function and variable renaming, and argument reordering. The paper presents examples of clones, re-engineering scenarios and restructuring tools. The usefulness of the approach is demonstrated by experience from a case study. Copyright © 1999 John Wiley & Sons, Ltd.

In this paper, we describe the reengineering of a deteriorated object-oriented industrial program written in C++. The main problem of the program was misplaced code, most often functions that were members of the wrong class. In order to deal with this problem, we designed and implemented several restructuring tools and used them in specific reengineering scenarios. We also discuss how this set of tools could be enhanced in the future, and the importance of restructuring for object-oriented software maintenance.

No abstract available.

This paper presents a model of change propagation during software maintenance and evolution. Change propagation is modeled as a sequence of snapshots, where each snapshot represents one particular moment in the process, with some software dependencies being consistent and others being inconsistent. A snapshot is changed into the next one by a change in one software entity and the dependencies related to it. The formalism for this process is based on graph rewriting. The paper discusses two basic processes of change propagation: change-and-fix, and top-down propagation. It also describes a prototype tool “Ripples 2” which supports both processes, and an example of the use of the tool

Every program must continuously evolve, or it will become obsolete. This paper explores a methodology for software evolution within the setting of object-orientated programming. The methodology is based on the top–down propagation of change, and it is remotely related to stepwise refinement. To present the methodology, this paper uses one small example (Gregorian calendar) and one medium-sized example (calendar maintainer). This paper also explores an algorithm for scheduling object classes for update, and introduces a tool, ‘Ripples’, which helps programmers work with the process of software evolution. © 1997 by John Wiley & Sons, Ltd. J. Software Maintenance 9: 103–124, 1997.

During the maintenance of legacy systems, the structure and the documentation of the system usually deteriorates, and hence the maintenance becomes progressively harder and harder. In order to reverse this deterioration, it is essential to record the understanding of the system continually, before it is forgotten. It is also important to structure it in such a way that it can be easily accumulated and retrieved. The authors present a tool called VIFOR 2, which is oriented rewards this situation. The tool combines two technologies: browsing and hypertext documentation. The browser supports rapid navigation around the code. The layered hypertext supports the incremental recording and retrieval of the documentation on the desired level of abstraction (domain, algorithm, representation, etc.). They briefly discuss their own experience with the tool.

We present a case study of evolution (or vertical reuse) in the domain of visual interactive software tools. We introduce an architecture suitable for this purpose, called orthogonal architecture. The paper describes the architecture itself, the reverse engineering process by which it was obtained, and the forward engineering process by which it was evolved.

The authors present the design and implementation of VIPEG, a generator of environments for software maintenance. Environments generated by VIPEG extract information about software components and their interconnections, store it in a database, and make it available to software maintainers in a form which is easy to understand and work with. The generated environments consist of a graphical display, editing tools, a database to store programs, and a query system to retrieve information. The generator accepts specification of the target language in the Data Model Specification Language. An example of C language specification is described.>

VIFOR is a software tool for maintenance of large Fortran programs. The distinguishing feature of VIFOR layouts is the placement of all nodes into two columns depending on their class, which is referred to as a two-column graph (2CG). The 2CG consists of two subgraphs, the call graph and the reference graph. The algorithm proposed first builds the call graph by determining the positions of the nodes in the process column, and then it appends the reference graph to the drawing. The part of the algorithm that builds the layout of the call graph is described. The algorithm tries to communicate as much information about the call graph as possible. The space optimization is considered to be secondary.>

Abstract VIFOR is a software tool oriented towards maintenance of medium‐to‐large Fortran77 programs. With VIFOR, programs can be displayed and edited in two forms: as the code and as the graph. VIFOR also contains transformations in both directions, i.e. from code to graph and from graph to skeletons of code. Hence, it is suitable for re‐engineering and maintenance of existing code. Specially designed browsers implement the graphical interface. VIFOR contains a database that is based on a simple but effective data model of Fortran programs. The model contains only four entity classes and three relations, which makes the tool small, and easy to implement and use. A simple query language allows browsing through the database.

A brief description of the VIFOR (visual interactive Fortran) environment is given. VIFOR is based on a simple, but effective data model of Fortran programs containing three entity classes and three relation classes only. Programs can be displayed and edited in two forms: the traditional one (i.e., code) and the visual form. VIFOR contains transformation tools for both directions, i.e., from code to visual form and from visual form to skeletons of code. Hence, it is suitable for reverse engineering and maintenance of existing code. Specially designed browsers implement the graphical interface.>

This paper presents Refinement Methodology (RM) for the design of Ada® programs. The methodology combines stepwise refinement and the information hiding principle. The steps of the methodology are explained and illustrated by an example. A part of the methodology is a collection of rules by which procedures acquire parameters (called first and second rules for parameters).

Absolutely parallel grammars are defined and it is shown that the family of languages generated is equal to the family of languages generated by two-way deterministic finite-state transducers. Furthermore it is shown that this family forms a full AFL [4], is properly contained in the family of languages generated by two-way nondeterministic finite-state transducers (which is equal to the family of checking automata languages [8]) and properly contains the family of nonexpansive context-free languages [7].