Architectural reflection for software evolution

Software evolution is expensive. Lehman identifies several problems associated with it: Continuous adaptation, increasing complexity, continuing growth, and declining quality. This paper proposes that a reflective software engineering environment will address these problems by employing languages and techniques from the software architecture community. Creating a software system will involve manipulating a collection of views, including low-level code views and high-level architectural views which will be tied together using reflection. This coupling will allow the development environment to automatically identify inconsistencies between the views, and support software engineers in managing architectures during evolution. This paper proposes a research programme which will result in a software engineering environment which addresses problems of software evolution and the maintenance of consistency between architectural views of a software system

A Software Evolution Process Model: Analysis of Software Failure Causes

This paper presents a study on the degree of impact of several components on the evolvability of software systems. In particular, it focuses on failure rates, testing, and other factors which force the evolution of a software system. Also, it studies the evolution of software systems in the presence of various failure scenarios. Unlike previous studies based on the system dynamic (SD) model, this study is modeled on the basis of actor-network theory (ANT) of software evolution, using the system dynamic environment. The main index used in this study is the destabilization period after the recovery from any failure scenario. The results show that more testing and quick recovery after failure are keys to a fast system return to stability

A Software Evolution Process Model: Analysis of Software Failure Causes

This paper presents a study on the degree of impact of several components on the evolvability of software systems. In particular, it focuses on failure rates, testing, and other factors which force the evolution of a software system. Also, it studies the evolution of software systems in the presence of various failure scenarios. Unlike previous studies based on the system dynamic (SD) model, this study is modeled on the basis of actor-network theory (ANT) of software evolution, using the system dynamic environment. The main index used in this study is the destabilization period after the recovery from any failure scenario. The results show that more testing and quick recovery after failure are keys to a fast system return to stability

Structural Complexity and Decay in FLOSS Systems: An Inter-Repository Study

Past software engineering literature has firmly established that software architectures and the associated code decay over time. Architectural decay is, potentially, a major issue in Free/Libre/Open Source Software (FLOSS) projects, since developers sporadically joining FLOSS projects do not always have a clear understanding of the underlying architecture, and may break the overall conceptual structure by several small changes to the code base. This paper investigates whether the structure of a FLOSS system and its decay can also be influenced by the repository in which it is retained: specifically, two FLOSS repositories are studied to understand whether the complexity of the software structure in the sampled projects is comparable, or one repository hosts more complex systems than the other. It is also studied whether the effort to counteract this complexity is dependent on the repository, and the governance it gives to the hosted projects. The results of the paper are two-fold: on one side, it is shown that the repository hosting larger and more active projects presents more complex structures. On the other side, these larger and more complex systems benefit from more anti-regressive work to reduce this complexity

An empirical study of evolution of inheritance in Java OSS

Previous studies of Object-Oriented (OO) software have reported avoidance of the inheritance mechanism and cast doubt on the wisdom of ‘deep’ inheritance levels. From an evolutionary perspective, the picture is unclear - we still know relatively little about how, over time, changes tend to be applied by developers. Our conjecture is that an inheritance hierarchy will tend to grow ‘breadth-wise’ rather than ‘depth-wise’. This claim is made on the basis that developers will avoid extending depth in favour of breadth because of the inherent complexity of having to understand the functionality of superclasses. Thus the goal of our study is to investigate this empirically. We conduct an empirical study of seven Java Open-Source Systems (OSSs) over a series of releases to observe the nature and location of changes within the inheritance hierarchies. Results show a strong tendency for classes to be added at levels one and two of the hierarchy (rather than anywhere else). Over 96% of classes added over the course of the versions of all systems were at level 1 or level 2. The results suggest that changes cluster in the shallow levels of a hierarchy; this is relevant for developers since it indicates where remedial activities such as refactoring should be focused

An architectural evolution dataset

A good evolution process and a good architecture can greatly support the maintainability of long-lived, large software systems. We present ArEvol, a dataset for the empirical study of architectural evolution. The dataset comprises two popular systems from the same domain and using the same component model, to make comparative studies possible. Besides the original component metadata, ArEvol includes scripts to obtain simplified models that nevertheless support rich studies of architectural evolution, as the authors’ previous work has shown