Software Evolution

Current research on code clones tries to address the question whether or not code clones are harmful for the quality of software. As most of these studies are based on the fine-grained analysis of inconsistent changes at the revision level, they capture much of the chaotic and experimental nature inherent to any ongoing software development process. Conclusions drawn from the inspection of highly fluctuating and short-lived clones are likely to exaggerate the ill effects of inconsistent changes. To gain a broader perspective, we perform an empirical study on the effect of inconsistent changes on software quality at the release level. Based on a case study on two open source software systems, we observe that only 1% to 3% of inconsistent changes to clones introduce software defects, as opposed to substantially higher percentages reported by other studies. Our findings suggest that developers are able to effectively manage and control the evolution of cloned code at the release level.

Software evolution is commonly characterized as a slow process of incremental change. Researchers have observed that software systems also exhibit characteristics of punctuation (sudden and discontinuous change) during their evolution. In this paper, we analyze punctuated evolution from the perspective of structural change. We developed a colorcoded visualization technique called the Evolution Spectrograph (ESG). ESG can be applied to highlight conspicuous changes across a historical sequence of software releases. We describe evolution spectrographs and present the empirical results from our studies of three open source software systems: OpenSSH, PostgreSQL, and Linux. We show that punctuated change occurred in the evolution of these three systems, and we validate our empirical results by examining related software documents such as change logs and release notes.

In this paper, we present an approach that examines the evolution of code stored in source control repositories. The technique identifies Change Clusters, which can help managers to classify different code change activities as either a software maintenance or a new development. Furthermore, identifying the variations in Change Clusters over time exposes trends in the development of a software system. We present a case study that uses a sequence of Change Clusters to track the evolution of the PostgreSQL software project. Our case study demonstrates that our technique reveals interesting patterns about the progress of code development within each release of PostgreSQL. We show that the increase in the number of clusters not only identifies the areas where development has occurred, but also reflects the amount of structural change in code. We also compare how the Change Clusters vary over time in order to make generalizations about the focus of development.

Software systems become progressively more complex and difficult to maintain. To facilitate maintenance tasks, project managers and developers often turn to the evolution history of the system to recover various kinds of useful information, such as anomalous phenomena and lost design decisions. An informative visualization of the evolution history can help cope with this complexity by highlighting conspicuous evolution events using strong visual cues. In this paper, we present a scalable visualization technique called evolution spectrographs (ESG). An evolution spectrograph portrays the evolution of a spectrum of components based on a particular property measurement. We describe several special-purpose spectrographs and discuss their use in understanding and supporting software evolution through the case studies of three large software systems (OpenSSH, KOffice and FreeBSD).

When changing source code, developers sometimes update the associated comments of the code (a consistent update), while at other times they do not (an inconsistent update). Similarly, developers sometimes only update a comment without its associated code (an inconsistent update). The relationship of such comment update practices and software bugs has never been explored empirically. While some (in)consistent updates might be harmless, software engineering folklore warns of the risks of inconsistent updates between code and comments, because these updates are likely to lead to out-of-date comments, which in turn might mislead developers and cause the introduction of bugs in the future. In this paper, we study comment update practices in three large open-source systems in C (FreeBSD and PostgreSQL) and Java (Eclipse). We find that these practices can better explain and predict future bugs than other indicators like the number of prior bugs or changes. Our findings suggest that inconsistent changes are not necessarily correlated with more bugs. Instead, a change in which a function and its comment are suddenly updated inconsistently, whereas they are usually updated consistently (or vice versa), is risky (high probability of introducing a bug) and should be reviewed carefully by practitioners.

The source code of a software system is in constant change. The impact of these changes spreads out across the software system and may lead to the sudden manifestation of failures in unchanged parts. To help developers fix such failures, we propose a method that, in a pre-processing stage, analyzes prior code changes to determine what functions have been modified. Next, given a particular period of time in the past, the functions changed during that period are propagated throughout the rest of the system using the dependence graph of the system. This information is visualized using Change Impact Graphs (CIGs). Through a case study based on the Apache Web Server, we demonstrate the benefit of using CIGs to investigate several real defects.

To study the impact of code clones on software quality, researchers typically carry out their studies based on fine-grained analysis of inconsistent changes at the revision level. As a result, they capture much of the chaotic and experimental nature inherent in any ongoing software development process. Analyzing highly fluctuating and short-lived clones is likely to exaggerate the ill effects of inconsistent changes on the quality of the released software product, as perceived by the end user. To gain a broader perspective, we perform an empirical study on the effect of inconsistent changes on software quality at the release level. Based on a case study on three open source software systems, we observe that only 1.02%-4.00% of all clone genealogies introduce software defects at the release level, as opposed to the substantially higher percentages reported by previous studies at the revision level. Our findings suggest that clones do not have a significant impact on the post-release quality of the studied systems, and that the developers are able to effectively manage the evolution of cloned code.

In evolutionary software development, knowing how design evolves with features can be valuable in guiding future projects. It helps answer questions like "How much upfront design should and can be done?" and "How and why are designs changed?" To shed light on these questions, we report on a study of the evolution history of the Eclipse Java editor. We find that the MVC-based design was cleanly laid out in the beginning of the project and carefully followed and maintained, which has contributed positively to the continuous growth of the editor features. Although design changes at the individual feature level happened for reasons like extensibility and reusability, they appear to be local and manageable. The AST facility is a key service that enables more than one half of the Java editor features.

When a program is modified during software evolution, developers typically run the new version of the program against its existing test suite to validate that the changes made on the program did not introduce unintended side effects (i.e., regression faults). This kind of regression testing can be effective in identifying some regression faults, but it is limited by the quality of the existing test suite. Due to the cost of testing, developers build test suites by finding acceptable tradeoffs between cost and thoroughness of the tests. As a result, these test suites tend to exercise only a small subset of the program's functionality and may be inadequate for testing the changes in a program. To address this issue, we propose a novel approach called BEhavioral Regression Testing (BERT). Given two versions of a program, BERT identifies behavioral differences between the two versions through dynamical analysis, in three steps. First, it generates a large number of test inputs that focus on the changed parts of the code. Second, it runs the generated test inputs on the old and new versions of the code and identifies differences in the tests' behavior. Third, it analyzes the identified differences and presents them to the developers. By focusing on a subset of the code and leveraging differential behavior, BERT can provide developers with more (and more detailed) information than traditional regression testing approaches. To evaluate BERT, we implemented it as a plug-in for Eclipse, a popular Integrated Development Environment, and used the plug-in to perform a preliminary study on two programs. The results of our study are promising, in that BERT was able to identify true regression faults in the programs.

The bug fix effort estimation model for open source software system plays an important role in software quality assurance and software project management. Most of the effort estimation models are related to commercial or closed software systems, whereas it is difficult to develop an effort estimation model for open source software systems (OSS). Reasons may be the large number of source files, and the large number of software developers and contributors. In case of OSS, the developers and contributors are randomly distributed throughout the world. It is complicated to obtain the actual time spent by each developer or contributor to fix a bug. To overcome these issues we have applied a heuristic approach, which estimates the actual bug fix time. The total time spent to fix a bug is considered as bug fix effort. To perform experiments we selected the Mozilla open source project and extracted the bug fix activity data from the corresponding bugzilla server and downloaded source files revisions from CVS repository. We processed the program files bug fix change data and obtained a set of metrics, which are related to program file changes. To develop a reliable effort estimation model we used regression, neural network, support vector machine, classification rules and decision tree methods. Furthermore, we compared the outcome of the different methods using several evaluation criteria. The results show that the machine learning based models are better compared to the statistical regression model. In case of support vector machine the relative absolute error (MMRE) is lowest, while in case of classification rule the correlation between the actual and predicted effort values is highest.

Program slicing is used as a basis for an approach to estimate maintenance effort. A case study of the GNU Linux kernel with over 900 versions spanning 17 years of history is presented. For each version a system dictionary is built using a lightweight slicing approach and encodes the forward decomposition static slice profiles for all variables in all the files in the system. Changes to the system are then modeled at the behavioral level using the difference between the system dictionaries of two versions. The three different granularities of slice (i.e., line, function, and file) are analyzed. We use a direct extension of srcML to represent computed change information. The retrieved information reflects the fact that additional knowledge of the differences can be automatically derived to help maintainers understand code changes. We consider the hypotheses: (1) The structured format helps create traceability links between the changes and other software artifacts. (2) This model is predictive of maintenance effort. The results demonstrate that the approach accurately predicts effort in a scalable manner.

Software evolution analysis can shed light on various aspects of software development and maintenance. Up to date, there is little empirical evidence on the evolution of JavaScript (JS) applications in terms of maintainability and changeability, even though JavaScript is among the most popular scripting languages for front-end web applications, including IoT applications. In this study, we investigate JS applications' quality and changeability trends over time by examining the relevant Laws of Lehman. We analyzed over 7,500 releases of JS applications and reached some interesting conclusions. The results show that JS applications continuously change and grow, there are no clear signs of quality degradation while the complexity remains the same over time, despite the fact that the understandability of the code deteriorates.

Successful software project survival and progress over time is highly dependent on effectively managing the maintenance process. Estimating accurately maintenance process factors like the maintenance effort and the level of changes required for a new release is considered a crucial task for allocating resources. In this work we examine the maintenance process factors of JavaScript applications, which at the moment are understudied despite the need of language specific maintenance models. Furthermore we propose two maintenance indices for estimating the changes and the effort required for maintaining JavaScript applications by considering a variety of maintenance drivers. We evaluated the proposed indices through a case study on 5,788 releases coming from 60 popular JavaScript applications. The results show that project activity factors (i.e., number of open bugs and number of corrective maintenance activities) are important maintenance drivers. The proposed indices are evaluated in terms of predictive and discriminative power and both achieve high accuracy.

Software evolution analysis can shed light on various aspects of software development and maintenance. Up to date, there is little empirical evidence on the evolution of JavaScript (JS) applications in terms of maintainability and changeability, even though JavaScript is among the most popular scripting languages for front-end web applications, including IoT applications. In this study, we investigate JS applications' quality and changeability trends over time by examining the relevant Laws of Lehman. We analyzed over 7,500 releases of JS applications and reached some interesting conclusions. The results show that JS applications continuously change and grow, there are no clear signs of quality degradation while the complexity remains the same over time, despite the fact that the understandability of the code deteriorates.

Failures of precondition checking when attempting to apply automated refactorings often discourage programmers from attempting to use these refactorings in the future. To alleviate this situation, the postponement of the failed refactoring instead its cancellation is beneficial. This poster paper proposes a new concept of postponable refactoring and a prototype tool that implements postponable EXTRACT METHOD as an Eclipse plug-in. We believe that this refactoring tool inspires a new field of reconciliation automated and manual refactoring.

ter verkrijging van de graad van doctor aan de Universiteit Twente, op gezag van de rector magnicificus, prof. dr. W.H.M. Zijm, volgens besluit van het College voor Promoties in het openbaar te verdedigen op donderdag 8 juni 2006 om 15.00 uur door István Nagy geboren op 30 juli 1977 te Karcag, Hongarije

class Point 1 extends Object{ private int _x, _y; void setX(int x){ _x=x; } int getX() { return _x; } void setY(int y){ _y=y; } int getY() { return _y; } ... } class Subject{ private Vector observers; public Subject() { /* … */} public void attach(Observer o) { observers.add(o); } public void Notify() { /* foreach observer.update() */} ...

Variability management is a key issue when building and evolving software-intensive systems, making it possible to extend, configure, customize and adapt such systems to customers' needs and specific deployment contexts. A wide form of variability can be found in extensible software systems, typically built on top of plugin-based architectures that offer a (large) number of configuration options through plugins. In an ideal world, a software architect should be able to generate a system variant on-demand, corresponding to a particular assembly of plugins. To this end, the variation points and constraints between architectural elements should be properly modeled and maintained over time (i.e., for each version of an architecture). A crucial, yet errorprone and time-consuming, task for a software architect is to build an accurate representation of the variability of an architecture, in order to prevent unsafe architectural variants and reach the highest possible level of flexibility. In this article, we propose a reverse engineering process for producing a variability model (i.e., a feature model) of a plugin-based architecture. We develop automated techniques to extract and combine different variability descriptions, including a hierarchical software architecture model, a plugin dependency model and the software architect knowledge. By computing and reasoning about differences between versions of architectural feature models, software architect can control both the variability extraction and evolution processes. The pro-Send offprint requests to: posed approach has been applied to a representative, large-scale plugin-based system (FraSCAti), considering different versions of its architecture. We report on our experience in this context. FraSCAti SCAParser Java Compiler JDK6 JDT Assembly Factory rest http Binding MMFrascati Component Factory Metamodel MMTuscany constraints rest implies MMFrascati http implies MMTuscany fm 1 Optional Mandatory Xor-Group Or-Group (a) an architectural FM (simplified from our case study) f m1 = {

Reusing code can produce duplicate or near-duplicate code clones in code repositories. Current code clone detection techniques, like Program Dependence Graphs, rely on code structure and their dependencies to detect clones. These techniques are expensive, using large amounts of processing power, time, and memory. In practice, programmers often utilize code comments to comprehend and reuse code, as comments carry important domain knowledge. But current code detection techniques ignore code comments, mainly due to the ambiguity of the English language. Recent advances in information retrieval techniques may have the potential to utilize code comments for clone detection. We investigated this by empirically comparing the accuracy of detecting clones with solely comments versus solely source code (without comments) on the JHotDraw package, which contains 315 classes and 27K lines of code. To detect clones at the file level, we used a topic modeling technique, Latent Dirichlet Allocation...

Large-scale code reuse significantly reduces both development costs and time. However, the massive share of third-party code in software projects poses new challenges, especially in terms of maintenance and security. In this paper, we propose a novel technique to specialize dependencies of Java projects, based on their actual usage. Given a project and its dependencies, we systematically identify the subset of each dependency that is necessary to build the project, and we remove the rest. As a result of this process, we package each specialized dependency in a JAR file. Then, we generate specialized dependency trees where the original dependencies are replaced by the specialized versions. This allows building the project with significantly less third-party code than the original. As a result, the specialized dependencies become a first-class concept in the software supply chain, rather than a transient artifact in an optimizing compiler toolchain. We implement our technique in a tool called DEPTRIM, which we evaluate with 30 notable open-source Java projects. DEPTRIM specializes a total of 343 (86.6 %) dependencies across these projects, and successfully rebuilds each project with a specialized dependency tree. Moreover, through this specialization, DEPTRIM removes a total of 57,444 (42.2 %) classes from the dependencies, reducing the ratio of dependency classes to project classes from 8.7 × in the original projects to 5.0 × after specialization. These novel results indicate that dependency specialization significantly reduces the share of third-party code in Java projects.

Model transformations need to be configured in order to satisfy particular user requirements in real scenarios. This paper introduces an strategy for configuring ATL transformations. This strategy, that is currently in practice in the MOSKitt tool, follows a model driven approach, where both the specification of configuration options and the user selections of those options are implemented as models. Additionally, the user interfaces that are provided by MOSKitt for selecting the configuration options are briefly introduced.

UML diagrams describe different views of one piece of software. These diagrams strongly depend on each other and must therefore be consistent with one another, since inconsistencies between diagrams may be a source of faults during software development activities that rely on these diagrams. It is therefore paramount that consistency rules be defined and that inconsistencies be detected, analyzed and fixed. The relevant literature shows that authors typically define their own UML consistency rules, sometimes defining the same rules and sometimes defining rules that are already in the UML standard. The reason might be that no consolidated set of rules that are deemed relevant by authors can be found to date. The aim of our research is to provide a consolidated set of UML consistency rules and obtain a detailed overview of the current research in this area. We therefore followed a systematic procedure in order to collect and analyze UML consistency rules. We then consolidated a set of 116 UML consistency rules (avoiding redundant definitions or definitions already in the UML standard) that can be used as an important reference for UML-based software development activities, for teaching UML-based software development, and for further research.

Different kinds of self-* systems ranging from autonomous self-organizing to hierarchical self-adaptive systems have been developed in the past. However, today there are no clear technical criteria how to classify distributed self-* systems within the resulting design spectrum. In this paper, we provide such a classification by looking on runtime models and their coupling. As runtime models capture the shared knowledge employed by feedback loops, at first, we provide an improved runtime model categorization. With such a basis, we subsequently derive impact relations describing the coupling of runtime models. Finally, we show that the existence of complex impact relations can be employed to describe the spectrum of self-* systems.

The healthcare consultation services here in the Philippines continues to rely on manual, paper-based appointment scheduling and non-centralized medical record management which are the primary sources of inefficiencies, prolonged patient waiting times, inconvenience, and limited continuity of proper care. This study presents Medbuddy, a web-based clinical consultation and health records management system designed to address the shortcomings of traditional system through convenient, user-friendly, and centralized solution for appointment scheduling and digital health records system. Medbuddy is implemented using modern web technologies to support three primary stakeholders, namely, patients, clinical doctors, and clinical staff in a role-based access control framework. The role-based design ensures that data is securely handled, workflow is properly separated, and consultation is made seamless and well-coordinated. The system integrates four core functional modules: (1) centralized health records management system for storing medical histories, diagnoses, results and prescription; (2) consultation appointment scheduling that allows patients to request appointments based on availability of clinical doctors; (3) appointment status tracker and notification system that delivers automated confirmation, reminders and updates about appointment schedule; and (4) integrated messaging functionality that enables, efficiency, usability, and security.

The healthcare consultation services here in the Philippines continues to rely on manual, paper-based appointment scheduling and non-centralized medical record management which are the primary sources of inefficiencies, prolonged patient waiting times, inconvenience, and limited continuity of proper care. This study presents Medbuddy, a web-based clinical consultation and health records management system designed to address the shortcomings of traditional system through convenient, user-friendly, and centralized solution for appointment scheduling and digital health records system. Medbuddy is implemented using modern web technologies to support three primary stakeholders, namely, patients, clinical doctors, and clinical staff in a role-based access control framework. The role-based design ensures that data is securely handled, workflow is properly separated, and consultation is made seamless and well-coordinated. The system integrates four core functional modules: (1) centralized health records management system for storing medical histories, diagnoses, results and prescription; (2) consultation appointment scheduling that allows patients to request appointments based on availability of clinical doctors; (3) appointment status tracker and notification system that delivers automated confirmation, reminders and updates about appointment schedule; and (4) integrated messaging functionality that enables, efficiency, usability, and security.

The comparison criteria described in this document represent a work-in-progress, begun at the Bellairs AOM1 workshop in April 2011, continued at the first CMA2 workshop in October 2011, and further discussed at the Bellairs AOM3 workshop in April/May 2012. The purpose of the criteria is to provide a basis for understanding, analyzing, and comparing various modeling approaches. Two groups of criteria are presented: Criteria related to general modeling dimensions (see Section 1) and those related to key modeling concepts (see ...