Abstract This paper presents our experiences in building a UML‐based approach for maintaining software products of a large‐scale industrial product family. It enables software architects to define rules and constraints for a product family architecture to be enforced on individual product architectures. The target system of our study was the Nokia ISA platform for a mobile phone product family, a complex software system comprising thousands of components and several million lines of code. We outline our approach and the accompanying tools, and report our experiences and lessons learned in assessing the architectural integrity of 10 ISA platform releases and the associated products. Copyright © 2009 John Wiley & Sons, Ltd.

The usage of software metrics for various purposes has become a hot research topic in academia and industry (e.g. detecting design patterns and bad smells, studying change-proneness, quality and maintainability, predicting faults). Most of these topics have one thing in common: they are all using some kind of metrics-based models to achieve their goal. Unfortunately, only few researchers have tested these models on unknown software systems so far. This paper tackles the question, which metrics are suitable for preparing portable models (which can be efficiently applied to unknown software systems). We have assessed several metrics on four large software systems and we found that the well-known RFC and WMC metrics differentiate the analyzed systems fairly well. Consequently, these metrics cannot be used to build portable models, while the CBO, LCOM and LOC metrics behave similarly on all systems, so they seem to be suitable for this purpose

Software architecture reconstruction is essentially the process of creating a set of architectural views with the information recovered from the actual implementation of a software system. While recovering the basic facts about the implementation can be automated with source code analyzers, mapping them to logical concepts is mainly a conceptual activity. We investigate the problem of how to bridge the logical and concrete domains for the purpose of creating architectural views. Our conclusion is that there is still a considerable gap between the theoretical framework and the practical experiences. This hinders the possibility of developing a general, rigorous and effective architecture reconstruction method.

Architecture reconstruction is the reverse engineering process that aims at recovering the past design decisions that have been made about the software architecture of a system. To be a successful activity, we need to identify the proper architecturally significant information and to extract it from the artefacts. How to identify extract/present/analyse it? What are the critical issues that have to be considered? How to manage the reconstruction process in a product family? What tools are available? This paper will address these and other questions that are relevant for the development of large and complex software systems. We introduce the key concepts of a software architecture description and the context of the architecture reconstruction activity. We present our architecture reconstruction method with a strong emphasis on its practical aspects and the tools supporting it. The extraction of architecturally significant information and its analysis are the key goals of our approach that will be demonstrated with a set of examples taken from real cases. We derive our experience mainly from the telecommunication domain. However, we believe the same general principles can be applied to other domains. The paper addresses software engineers and project managers that are involved in the development of complex software systems.

This paper proposes a UML-based software maintenance process. The process is guided by architectural descriptions and existing architectural models. The descriptions are given as variants of UML profiles describing the styles and rules relevant for a particular application domain. A reverse engineering subprocess, combining top-down and bottom-up reverse engineering activities, aims at constructing the architectural models. Resulting models are investigated in a model analysis subprocess. The models are checked against the profiles to find violations against the given architectural rules when maintaining and developing the subject system, and they are further analyzed using a set of UML model processing operations. The proposed approach is applied for maintaining a large-scale product platform architecture and real-life product-line products built on top of this platform. The model analysis results of the case study are discussed.

Authentic descriptions of a software architecture are required as a reliable foundation for any but trivial changes to a system. Far too often, architecture descriptions of existing systems are out of sync with the implementation. If they are, they must be reconstructed. There are many existing techniques for reconstructing individual architecture views, but no information about how to select views for reconstruction, or about process aspects of architecture reconstruction in general. In this paper we describe view-driven process for reconstructing software architecture that fills this gap. To describe Symphony, we present and compare different case studies, thus serving a secondary goal of sharing real-life reconstruction experience. The Symphony process incorporates the state of the practice, where reconstruction is problem-driven and uses a rich set of architecture views. Symphony provides a common framework for reporting reconstruction experiences and for comparing reconstruction approaches. Finally, it is a vehicle for exposing and demarcating research problems in software architecture reconstruction.

We present the work of establishing an integrated environment that facilitates architecture design, reconstruction, and maintenance in the entire life cycle of a software product line. This architecting environment (ART environment) has been used in modeling and analysis of both the designed platform architecture model and the reverse-engineered product implementation architecture models of different releases in a big product line of Nokia mobile terminals. ART environment comprises tools for architecture model validation, architecture model analysis and processing, and reverse architecting. The ART environment fits the current software development process inside Nokia, and is integrated with the design and documentation tools that have already been used by Nokia software architects. UML, after being customized with UML profiles for architecture design, is used as the architecture modeling language in ART environment.

We present the results of a research work targeted to understanding CASE tools usage in Nokia. By means of a survey questionnaire, we collected data aimed to identify what features are most useful and best implemented in current CASE tools according to senior developers and managers. With the aid of both descriptive and inferential statistical data analysis methods, we found out that the features that are rated most useful belong to the graphical editing, version management and document generation categories. The statistical methods we use allow us to extend the results to the whole population with a certain degree of confidence. The analysis of the data seems to give the indication that there is a general level of dissatisfaction on the quality of currently available CASE tools. Also, there is evidence that some of the most advanced features (reverse engineering, code generation) are not deemed as useful as others. Further research should focus on extending the survey to other types of industries, and attempt generalization of the results. This may constitute precious feedback for the software tools industry in order to develop products that correspond more to industry needs.

This paper briefly introduces a 3-D visualization tool (3DSoftVis) that has been developed for the analysis of the evolution of an industrial software system.

The data regarding the components of a software system consists of a large amount of information such as version history, number of lines, defect density, and complexity measures. The ability to quickly grasp a comprehensive view of the evolution and dependencies of such information is the key to making informed decisions about future developments of the system. Managers usually make such decision based only on expert judgement. For help in making such decisions, we can turn to the evolution history of large software systems, which contain a wealth of hidden information. Traditionally, this information is passed on through anecdotes without any supporting analytical data. This paper reports on our attempts to make such information more concrete through information visualization techniques. We present a three-dimensional visual representation for examining a system's software release history. The structure of the system is displayed by 2D or 3D graphs. The historical information is displayed by using time as the third dimension. Colors are used for displaying module properties and their historical changes in the system. A supporting software tool enables not only visualization but also navigation in the 3D space to change the viewpoint, to browse system information, to find interesting patterns and to discover previously unknown relationships among system components.