· · · Institutional Repository

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 stored. This provides insight into the behaviour of software developers with regard to resolving code smells and anti-patterns. This thesis presents a custom built application that computes the lifespans of certain types of code smells in a software repository. As a case study, this tool is applied on seven open source systems in order to answer research questions concerning the lifespan of code smells and the refactoring behaviour of developers. The results of this study reveal that engineers are aware of code smells, but not very concerned with their impact, given the low refactoring activity. Finally, several suggestions are given to further develop the application and to extend the work done in this thesis.

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 after a code change, in order to check for regressions. The implementation is based on dynamic code analysis and the purpose of the tool is to eliminate the time spent on testing using inappropriate test cases (tests that bring no value in checking for regressions). The adequacy, usability and completeness of this tool have been evaluated through the meanings of a user study. During the study, a number of developers used the tool and expressed their opinion about it through questionnaires.

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 extract the clone size information from mined software repositories is shown. Using this approach an insight can be gained into how clone sizes evolve over time, as well as whether the size has an influence on other evolutionary patterns of a clone. We present our findings and conclude that clone size influences a clone's evolution in several ways.

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 architectures. Automation and abstraction are two basic software engineering techniques to deal with complexity. In this thesis we investigate the applicability of model-driven engineering, a new software development approach based on abstraction and automation, to support the evolution of software architectures. The main research question we address in this thesis is: "How can evolution of software architectures be supported?". Three subquestions related to industrial integration, software product lines, and automation further clarify the scope of our work. We first conducted a survey among several software development organisation to inventory the state-of-the-practice in software engineering technologies. Some trends we observed from this inventory include: the informal use modelling in industry, the use of product-line approaches, and the importance of the evolutionary aspect of software. Next, we investigated how to support four tasks related to software architecture evolution: evaluation, conformance checking, migration, and documentation. We aim to automate this support where possible. To this end, we employ model-driven software development technologies. For each of the software evolution tasks, we present a case study that investigates how that task can be supported. The informal use of modelling in industry calls for a normalisation step to enable the integration of evolution support in practice. Several chapters address the impact of the use of product-line approaches on the evolution support. Although the increased scope make such support more difficult to develop, the return on investment for the model-driven support is much improved. The model-driven evolution support follows a similar three-step pattern. First, a set of source models is preprocessed into a form suitable for the application of model transformations. Then, model transformations are applied that do the actual work, such as conformance checking or a migration. Finally, the resulting models are postprocessed in a resulting into a desired target form.

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 which have to be inferred from source code. Particularly challenging for software comprehension, and consequently, software evolution, are those concerns said to be crosscutting: implementation of such concerns lacks modularity and results in scattered and tangled code. The research presented in this thesis proposes an integrated approach to consistent comprehension, identification, documentation, and migration of crosscutting concerns in existing systems. This work is aimed at helping software engineers to more easily understand and manage such concerns in source code. As a final step of our approach, we also experiment with the refactoring of crosscutting concerns to aspect-oriented programming and reflect on the support provided by this new programming technique for improving modularization of concerns.

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 architectural degradation. Recently there has been a surge of collaboration, communication and sharing with the advent of Web 2.0 applications. In this thesis we have investigated how Web 2.0 can be used to support software architecture management. In particular in the area of architecture documentation, architecture retrieval, and collaboration. We created an approach which applies Web 2.0 concepts such as traceability, integration, usability, navigability, and user experience, to software architecture management. This approach is supported by a prototype tool called ArchWiki, which has features such as traceability between different artifacts (e.g. source code, architectural diagrams, architectural documentation), context-sensitive views, hyperlinks, notifications, tags, and bookmarks. We performed an initial evaluation study to assess ArchWiki. In this study we found that Web 2.0 has the potential to support software architecture knowledge management.