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

The run-time quality properties of software architecture, such as reliability and performance, are fundamental to telecom systems, but they are very hard to be precisely specified and evaluated with conventional methods. In our contribution we focus on modeling and analysis of architectural level run-time quality properties using formal methods. Colored Petri nets (CPN) is used to create specific system behavior models of reliability and performance properties of software architecture, these properties are then evaluated with analysis and simulation techniques supported by CPN and its tools. In this paper we report our approach and experience on using CPN to model and evaluate the reliability and performance properties of different architecture designs of a critical software subsystem in a telephone switch system. The reliability and performance properties of two alternative solutions were modeled and compared through model analysis and extensive model simulation. The results helped us to find an ideal solution with high performance, low cost and acceptable reliability that met the industry standards

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.

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.

The Unified Modeling Language (UML) has become a widely adopted standard in the software industry. While UML has established itself in detailed software design, its usage as an architecture description language is still taking its shape. In particular, there is a growing need for techniques to define domain specific architectural constraints and conventions in UML. We address this issue by adopting the concept of UML profiles for architectural design. Architectural profiles are specialized for describing and constraining software architecture descriptions for a given domain. We argue that these profiles represent an appropriate abstraction level to elaborate architectural constraints and conventions. We present a general schema for arranging architectural profiles and a set of conformance rules that define how these profiles are interpreted, constituting a profile definition language for validating architectural design. We introduce a tool for performing architectural validation and discuss the results of our initial case studies.

Nokia Research Center (NRC) has been leading Esprit project ARES (Architectural Reasoning for Embedded Systems) for two years. One of the main purposes of ARES is to demonstrate the use of architectural modeling in controlling properties of industrial scale products and product families. Two examples are documented. Forward architecting was applied in modeling the new architecture for our mobile phone family showing how to control the dynamic properties of the software. Reverse architecting was used to tune the performance of our telephone switch software. Both cases show that special purpose models can be constructed even for very large systems and they do give valuable insight to the properties of the software.