In many projects, lexical preprocessors are used to manage different variants of the project (using conditional compilation) and to define compile-time code transformations (using macros). Unfortunately, while being a simple way to implement variability, conditional compilation and lexical macros hinder automatic analysis, even though such analysis is urgently needed to combat variability-induced complexity. To analyze code with its variability, we need to parse it without preprocessing it. However, current parsing solutions use unsound heuristics, support only a subset of the language, or suffer from exponential explosion. As part of the TypeChef project, we contribute a novel variability-aware parser that can parse almost all unpreprocessed code without heuristics in practicable time. Beyond the obvious task of detecting syntax errors, our parser paves the road for further analysis, such as variability-aware type checking. We implement variability-aware parsers for Java and GNU C and demonstrate practicability by parsing the product line MobileMedia and the entire X86 architecture of the Linux kernel with 6065 variable features.

Runtime architecture is important because it helps reason about quality attributes such as performance and security. We conducted an on-site field study to help us understand how developers understand object relationships, and what tool features a developer might need to convey their mental model of object relationships. The subject of our study was an experienced, professional programmer. We asked the developer questions to check if he understood which tiers objects belonged to, and whether certain objects were conceptually part of other objects. We also took an initial runtime architecture and refined it to convey his intent. The developer’s mental model seemed to agree with the one supported by the current, batch-oriented approach for extracting architectures. This indicates that an interactive tool that allows making anobjectconceptuallypartofanother, andabstractingaway a low-level object would be useful to iteratively refine an initial object model.

We present a semi-automated approach, Secoria, for analyzing a security runtime architecture for security and for conformance to an object-oriented implementation. Typecheckable annotations describe architectural intent within the code, enabling a static analysis to extract a hierarchical object graph that soundly reflects all runtime objects and runtime relations between them. In addition, the annotations can describe modular, code-level policies. A separate analysis establishes traceability between the extracted object graph and a target architecture documented in an architecturedescription language. Finally, architecturaltypes, properties, and logic predicates describe global constraints on the target architecture, which will also hold in the implementation. We validate the Secoria approach by analyzing a 3,000-line pedagogical Java implementation and a runtime architecture designed by a security expert.

Architecture recovery is an activity applied to a system whose initial architecture has eroded. When the system is large, the user must use dedicated tools to support the recovery process. We present Softwarenaut – a tool which supports architecture recovery through interactive exploration and visualization. Classical architecture recovery features, such as filtering and details on demand, are enhanced with evolutionary capabilities when multi-version information about a subject system is available. The tool allows sharing and discovering the results of previous analysis sessions through a global repository of architectural views indexed by systems. We present the features of the tool together with the architecture recovery process that it supports using as a case-study ArgoUML, a well-known open source Java system.

c t i v it y e p o r t 2009 Table of contents

Software product line engineering is an efficient means to generate a set of tailored software products from a common implementation. However, adopting a product-line approach poses a major challenge and significant risks, since typically legacy code must be migrated toward a product line. Our aim is to lower the adoption barrier by providing semiautomatic tool support—called variability mining—to support developers in locating, documenting, and extracting implementations of product-line features from legacy code. Variability mining combines prior work on concern location, reverse engineering, and variability-aware type systems, but is tailored specifically for the use in product lines. Our work extends prior work in three important aspects: (1) we provide a consistency indicator based on a variability-aware type system, (2) we mine features at a fine level of granularity, and (3) we exploit domain knowledge about the relationship between features when available. With a quantitative study, we demonstrate that variability mining can efficiently support developers in locating features. 1

c t i v it y e p o r t

Abstract. Software structuring techniques aim to make systems easier to develop and maintain, increasing their quality. Aspect-Oriented Software Development (AOSD) and Software Architectural Styles are examples of such techniques. In spite of all the benefits of such structuring techniques, it is not always easy or even advantageous to integrate two or more of these techniques. For example, the effects of combining AOSD and Layered Software Architectures are still not well understood. This paper proposes a metrics suite to assess the impact of AOSD on layered software architectures. To better account for the influence of aspects on the layered system, we defined new metrics and extended existing ones to measure coupling between system layers and layering violations. These metrics are an initial effort to measure the maintainability of aspectoriented software adopting the layered architectural style. In addition, they can be used to support decision making on combining aspects and layered software architectures. We also developed a tool to automatically collect the proposed metrics. 1