Professional Documents
Culture Documents
Static Evaluation of Software Architectures: Jens Knodel, Mikael Lindvall, Dirk Muthig, and Matthias Naab
Static Evaluation of Software Architectures: Jens Knodel, Mikael Lindvall, Dirk Muthig, and Matthias Naab
Jens Knodel1, Mikael Lindvall2, Dirk Muthig1, and Matthias Naab1 Fraunhofer Institute for Experimental Software Engineering (IESE), Fraunhofer-Platz 1, D-67663 Kaiserslautern, Germany {knodel, muthig, naab}@iese.fraunhofer.de Abstract
The software architecture is one of the most crucial artifacts within the lifecycle of a software system. Decisions made at the architectural level directly enable, facilitate, hamper, or interfere with the achievement of business goals, functional and quality requirements. Architecture evaluations play an important role in the development and evolution of software systems since they determine how adequate the architecture is for its intended usage. This paper summarizes our practical experience with using architecture evaluations and gives an overview on when and how static architecture evaluations contribute to architecture development. We identify ten distinct purposes and needs for static architecture evaluations and illustrate them using a set of industrial and academic case studies. In particular, we show how subsequent steps in architecture development are influenced by the results from architecture evaluations. Keywords: ADORE, architecture, architecture evaluation, product line, PuLSE-DSSA, reverse engineering.
1
Fraunhofer USA Center for Experimental Software Engineering Maryland (FC-MD), 4321 Hartwick Road, College Park, MD USA mikli@fc-md.umd.edu
architecture embraces the decisions and principles for each family member. Static architecture evaluation is a sound instrument for assessing and ensuring architectural quality. Static architecture evaluations compare the planned architecture, as described by architectural artifacts, with the actual architecture, as implemented in source code, based on a mapping between the two representations, which is conducted by an expert. In this paper, we demonstrate the integration of static architecture evaluation into our architecture development method, PuLSE-DSSA, and identify ten distinct purposes and needs for conducting static architecture evaluations. The results of such an evaluation influence and determine subsequent architecture development, which we show in a set of industrial and academic case studies where we applied Fraunhofer PuLSE (Product Line Software Engineering) [4] and Fraunhofer ADORE (Architecture- and Domain-Oriented Re-Engineering)1. The remainder of the paper is structured as follows: Section 2 presents Fraunhofers PuLSE and ADORE approach. Then section 3 discusses static architecture evaluations and introduces the ten distinct purposes. Section 4 illustrates the purposes and needs in nine case studies. Section 5 then discusses related work, while section 6 concludes this experience report.
1. Introduction
One of the most important artifacts in the life cycle of a software system is the architecture since it embraces the decisions and principles for the system to be developed. The software architecture is the fundamental organization of a system embodied in its components, their relationships to each other and to the environment and the principles guiding its design and evolution [14]. The goal of an architecture development method is to address such aspects and to provide the fundament for achieving organizational and business goals as well as meeting the functional and quality requirements of the system. To ensure the achievement of these goals, it is mandatory to integrate quality engineering activities into the architecture development method. This is especially true for software product lines [10] since the product line
2. Approach
The case studies combine two methods: Fraunhofer PuLSE, in particular its architectural component PuLSEDSSA, and ADORE for reverse engineering activities. This section presents an overview of the two methods and how they relate to the following typical phases of the software life cycle (see Figure 1): architecture development, component engineering, implementation, and finally reverse engineering. Other software development phases (e.g., requirements engineering, testing), feedback cycles and iterations are left out. Next PuLSE and ADORE are registered trademarks of Fraunhofer Institute for Experimental Software Engineering (IESE), Kaiserslautern, Germany
1
Proceedings of the Conference on Software Maintenance and Reengineering (CSMR06) 0-7695-2536-9/06 $20.00 2006
IEEE
Figure 1: Lifecycle Phases to each phase in the figure, the main artifact produced is named.
2.1. PuLSE-DSSA
PuLSE-DSSA (DSSA stand for Domain-Specific Software Architectures) deals with product line activities at the architectural level (it can also be applied in single system development). Since Greenfield scenarios [10] are rare in industrial contexts, PuLSE-DSSA is designed to smoothly integrate reverse engineering activities to exploit existing knowledge. The main concepts are: Scenario-based development in iterations in order to explicitly address stakeholders needs. Incremental development in order to successively prioritize and realize requirements. Direct integration of reverse engineering activities into the development process in order to conduct such activities on demand. View-based documentation in order to support the communication among stakeholders. The main process loop of PuLSE-DSSA consists of four major steps (see left part of Figure 2):
Architecture Development
Business and organizational goals Functional and quality req. Stakeholder analysis Definition of architectural views
Planning: The planning step defines the content and delineates the scope of the current iteration. This includes the selection of a limited set of scenarios that are currently addressed, the identification of relevant stakeholders and roles, the selection and definition of the architectural views to be used, as well as the definition of whether or not an architecture assessment is included at the end of the iteration. Realization: In the realization step, solutions are selected and design decisions made in order to fulfill the requirements derived from the scenarios. When applying the selected solutions, an implicit assessment regarding the suitability of the solutions for the given requirements and their compatibility with decisions of earlier iterations is made. A catalog of means and patterns is used in this step. Means are principles, techniques, or mechanisms that facilitate the achievement of certain qualities in an architecture whereas patterns are concrete solutions for recurring problems in the design of architectures. Documentation: This step documents architectures by using an organizational-specific set of views. It relies on standard views as, for example, defined by Kruchten [20] Hofmeister [13], and customizes or complements them by additional aspects as requested by key stakeholders [6]. Assessment: The goal of the assessment step is to analyze and evaluate the resulting architecture with respect to functional and quality requirements and the achievement of business goals. In an intermediate state of the architecture, this step might be skipped and the next iteration immediately started. PuLSE-DSSA results in (product line) architectures documented in a selection of architectural views.
Reverse Engineering
Planning
Set up infrastructure
Assessment (optional)
infrastructureextension (optional)
Special Analyses
Extraction
Documentation
Proceedings of the Conference on Software Maintenance and Reengineering (CSMR06) 0-7695-2536-9/06 $20.00 2006
IEEE
should be reused or a new product line component should be developed from scratch. Finally, when reusing the component, necessary renovation and extension activities are conducted in order to adapt the component for its use within the product line.
2.3. Implementation
The implementation comprises all activities that transform the component engineering models into source code written in a certain programming language. This involves the realization of functionality described in the models, the creation and optimization of the algorithms required to solve computation problems, and restructuring and refactoring of the implemented parts to avoid quality problems like code clones, high complexity of the implementation, or large routines with respect to lines of code.
2.4. ADORE
The architecture development yields product line components that have to be engineered. In presence of existing systems, this allows the identification of existing components that already completely or partially fulfill the requirements. To decide about reusing such existing components, the components internal quality and suitability for the product line have to be evaluated. It has to be ensured that the component is able to serve the product line needs. ADORE (Architecture- and Domain-Oriented Reengineering) is a request-driven reengineering approach that evaluates existing components with respect to their adequacy and integrates selected components into the product line: First, existing components are identified and reverse engineered [8] to assess their adequacy. This activity is initiated by requests from the product line architects. Second, based on the analysis results, the product line architects decide whether the existing component
ADORE is mainly instantiated in step 2 of PuLSEDSSA (realization), when the architects reason about whether or not to reuse existing components. The architectural needs drive the selection of appropriate reverse engineering analyses. Analyses and, potentially, renovation activities are conducted asynchronously to the PuLSE-DSSA iterations. That is, the current iteration of the architecture development may proceed even if the ADORE activities are delayed. The advantage of such a demand-driven approach is that the investment in reverse engineering is kept as small as possible. To enable stakeholders to reason about such decisions, certain aspects of the component have to be lifted to a higher level of abstraction. Existing component artifacts (e.g., source code, documentation) are exploited and the information extracted is aggregated into a repository. Since the repository usually has much content, relevant information is often hidden in detailed low-level models. Thus, further analysis activities process the information and aim at creating meaningful views of the existing component. Typical goals of the reverse engineering process of ADORE address the evaluation of the internal quality of a component, the degree of variability support, the provided flexibility towards anticipated changes, the compliance of a component to the product line architecture, or in case there are several similar implementations of a component, the identification of commonalities among them.
Proceedings of the Conference on Software Maintenance and Reengineering (CSMR06) 0-7695-2536-9/06 $20.00 2006
IEEE
Architecture Model
Mapping Experts
Results Report
Figure 3: Architecture Evaluations with SAVE Convergence a specific model element or relation exists in both the high level model and in the low level model Divergence a specific model element or relation is only present in the low level model Absence a specific model element or relation is only present in the high level model
ID 1.1 1.2 2.1 2.2 2.3 3.1 3.2 3.3 4.1 4.2
Documentation
Assessment
Purpose Product line potential Product alignment Reuse potential Component adequacy Comprehension Consistency Completeness Re-documentation Evolution control Structure
Figure 4: Evaluation Purposes migrated towards the product line architecture (if necessary). Thus, it guides the planning of the first iteration of PuLSE-DSSA in order to assess the product line potential that is already embodied in existing systems. 1.2 Product alignment: This is an analysis of a system that is subject to be merged into an already existing product line. The purpose is to compare the systems architecture to the product line architecture in order to assess conformity and to detect differences. This is conducted using the systems documentation in order to put the PuLSE-DSSA planning step on a sound foundation. This analysis determines the modifications required in order to align the system to the product line architecture and supports estimating the effort to implement those modifications. 2.1 Reuse potential: The decision whether to reuse (and integrate into a given architecture) a component, an architectural fragment or part within a product line is often a difficult one. The reuse candidate typically can not be used as is, since it was not designed and realized for the product line, so it is questionable whether it fits the architecture. The degree of dependencies between the reuse candidate and other components of the system and the need for adaptation determine the cost of using the reuse candidate and should drive the reuse decision. Static architecture evaluations are used to visualize the dependencies and the position of the reuse candidate within a decomposition hierarchy. This information helps the product line architects derive sound architectural decisions. In case there are several reuse candidates to the same design problem (see [16] for an example of a comparison approach) the architect can select the best candidate. 2.2 Component adequacy: This static evaluation aims at uncovering the internal quality of the subject component. When a component fits the architecture, it is crucial to analyze the components internal structure and quality. The scope is narrowed down to a single component and its context only. The component is analyzed in depth (usually combined