Many automated techniques of varying accuracy have been developed to help recover the architecture of a software system from its implementation. However, rigorously assessing these techniques has been hampered by the lack of architectural “ground truths”. Over the past several years, we have collected a set of eight architectures that have been recovered from open-source systems and independently, carefully verified. In this paper, we use these architectures as ground truths in performing a comparative analysis of six state-of-the-art software architecture recovery techniques. We use a number of metrics to assess each technique for its ability to identify a system's architectural components and overall architectural structure. Our results suggest that two of the techniques routinely outperform the rest, but even the best of the lot has surprisingly low accuracy. Based on the empirical data, we identify several avenues of future research in software architecture recovery.

Today, software intensive systems are developed more and more using product line approaches. These approaches require the definition of a set of product line artifacts including the product line architecture that implicitly or explicitly specifies some degree of variability. This variability is used to instantiate concrete software product instances. A product line approach not only implies reuse of architecture-level design knowledge, it also facilitates reuse of implementation-level artefacts, such as source code and executable components. The use of software product lines can reduce the cost of developing new products significantly.

Software evolution is an iterative and incremental process that encompasses the modification and alteration of software models at different levels of abstraction. These modifications are usually performed independently, but the objects to which they are applied to, are in most cases mutually dependent. Inconsistencies and drift among related artifacts may be created if the effects of an alteration are not properly identified, recorded, and propagated in other dependent models. For large systems, it is possible that there is a considerable number of such model dependencies, for which manual extraction is not feasible. In this paper, we introduce an approach for automating the identification and encoding of dependence relations among software models and their elements. The proposed dependency extraction technique first uses association rules to map types between models at different levels of abstraction. Formal concept analysis is then used to identify clusters of model elements that pertain to similar or associated concepts. Model elements that cluster together are considered related by a dependency relation. The technique is used to synchronize business process specifications with the underlying J2EE source code models.

Software evolution encompasses all activities related to engineering software, from its inception to retirement. Propagating change across software models that are altered due to maintenance activities is a first step towards maintaining consistency between architectural design, and implementation models. Model synchronization techniques initially presented within the context of model driven architecture provide an instrument for achieving change trace-ability and consistency. We present a framework whereby software artifacts at different levels of abstraction such as architecture diagrams, object models, and abstract syntax trees are represented by graph-based MOF compliant models that can be synchronized using model transformations. In such a framework model dependencies are implicitly encoded using transformation rules and an equivalence relation is used to evaluate when two models become synchronized.

A business software application often has two perspectives: the business flow and operation that the application intends to solve, and the source code and its design and flow upon which the application is built. As one changes and evolves, the other needs to be synchronized. This paper addresses an approach to synchronize these two models for effective software maintenance.