Software evolution: the lifetime of fine-grained elements

A model regarding the lifetime of individual source code lines or tokens can estimate maintenance effort, guide preventive maintenance, and, more broadly, identify factors that can improve the efficiency of software development. We present methods and tools that allow tracking of each line’s or token’s birth and death. Through them, we...

Evolution of the Unix System Architecture: An Exploratory Case Study

Unix has evolved for almost five decades, shaping modern operating systems, key software technologies, and development practices. Studying the evolution of this remarkable system from an architectural perspective can provide insights on how to manage the growth of large, complex, and long-lived software systems. Along main Unix releases...

Visualizing code and coverage changes for code review

One of the tasks of reviewers is to verify that code modifications are well tested. However, current tools offer little support in understanding precisely how changes to the code relate to changes to the tests. In particular, it is hard to see whether (modified) test code covers the changed code. To mitigate this problem, we developed OPERIAS...

Circumventing refactoring masking using fine-grained change recording

Today, refactoring reconstruction techniques are snapshot-based: they compare two revisions from a source code man-agement system and calculate the shortest path of edit op-erations to go from the one to the other. An inherent risk with snapshot-based approaches is that a refactoring may be concealed by later edit operations acting on the...

Web Service Growing Pains: Understanding Services and Their Clients

At an implementation level, web services serve the basic purpose of message exchange between potentially heterogeneous software systems. Through abstracting language- and platform-specific implementations into text-based, human-readable XML and JSON-based formats, different software systems are able to execute procedures and retrieve data from...

Web API growing pains: Loosely coupled yet strongly tied

Web APIs provide a systematic and extensible approach for application-to-application interaction. Developers using web APIs are forced to accompany the API providers in their software evolution tasks. In order to understand the distress caused by this imposition on web API client developers we perform a semi-structured interview with six such...

Web API Growing Pains: Loosely Coupled yet Strongly Tied

Web APIs provide a systematic and extensible approach for application-toapplication interaction. Developers using web APIs are forced to accompany the API providers in their software evolution tasks. In order to understand the distress caused by this imposition on web API client developers we perform a semi-structured interview with six such...

Crawl-Based Analysis of Web Applications: Prospects and Challenges

In this paper we review five years of research in the field of automated crawling and testing of web applications. We describe the open source Crawljax tool, and the various extensions that have been proposed in order to address such issues as cross-browser compatibility testing, web application regression testing, and style sheet usage analysis...

Exploring Characteristics of Code Churn

Software is a centerpiece in today’s society. Because of that, much effort is spent measuring various aspects of software. This is done using software metrics. Code churn is one of these metrics. Code churn is a metric measuring change volume between two versions of a system, defined as sum of added, modified and deleted lines. We use code churn...

Analyzing the Evolution of WSDL Interfaces using Metrics

Recent studies have investigated the use of source code metrics to predict the change- and defect-proneness of source code. While the indicative power of these metrics was validated for several systems, it has not been tested on Service-Oriented Architectures (SOA). In particular, the SOA paradigm prescribes the development of systems through...

Analyzing the Evolution of Web Services using Fine-Grained Changes

Preprint of paper published in: ICWS 2012 - IEEE 19th International Conference on Web Services, 24-29 June 2012; doi:10.1109/ICWS.2012.29 In the service-oriented paradigm web service interfaces are considered contracts between web service subscribers and providers. However, these interfaces are continuously evolving over time to satisfy changes...

ArchWiki: Using Web 2.0 for Architecture Knowledge Management

Software architecture plays an important part in program comprehension, which is one of the most time consuming tasks in software development. If software developers don’t properly share their architectural knowledge with team members, the team will act based on an incomplete or even possibly incorrect view on the code base, and this can lead to...

Studying the Effects of Code Clone Size on Clone Evolution

The practice of code cloning is something every software developer has to deal with at some point. The evolution of code clones is of particular interest, because the effects of cloning code show up later in the lifetime of a project. We research the effects a clone's properties have on its evolutionary behavior. For this purpose an approach to...

Aiding Software Developers to Test with TestNForce

Regression testing is an expensive process because, most of times, all the available test cases are executed. Many techniques of test selection/filtering have been researched and implemented, each having its own strong and weak points. This paper introduces a tool that helps developers and testers to identify the tests that need to be executed...

Evaluating the Lifespan of Code Smells in a Software System using Software Repository Mining

An anti-pattern is a commonly occurring solution that will always have negative consequences, when applied to a recurring problem. Code smells are considered to be symptoms of anti-patterns and occur at source code level. The lifespan of code smells in a software system can be determined by mining the software repository on which the system is...

Studying the co-evolution of production and test code in open source and industrial developer test processes through repository mining

Many software production processes advocate rigorous development testing alongside functional code writing, which implies that both test code and production code should co-evolve. To gain insight in the nature of this co-evolution, this paper proposes three views (realized by a tool called TeMo) that combine information from a software project’s...

An Integrated System to Manage Crosscutting Concerns in Source Code

Evolution of software systems accounts for the largest part of their lifecycle and costs. Software engineers therefore, more often than developing new systems, work on complex, existing ones that they have to understand in order to modify them. Understanding such systems requires insight into the various concerns the systems implement, many of...

Model-driven evolution of software architectures

Software evolves continuously. As a consequence, software systems tend to become increasingly complex and, as such, more difficult to change. A software system's complexity is for a large part determined by its structure, or architecture. In this thesis we investigate how to reduce the risks and costs associated with the evolution of software...