FG Praktische Informatik / Softwaresystemtechnik
Refine
Year of publication
Document Type
Way of publication
- Open Access (3)
Keywords
- Softwaretechnik (10)
- Konfigurationsmanagement (4)
- Produktlinien (4)
- software evolution (4)
- Applications (2)
- Capture (2)
- Clustering (2)
- Design Rationale (2)
- Research Proposal (2)
- Softwaremetriken (2)
Institute
Documenting design rationale (DR) helps to preserve knowledge over long time to diminish software erosion and to ease maintenance and refactoring. However, use of DR in practice is still limited. One reason for this is the lack of concrete guidance for capturing DR. This paper provides a first step towards identifying DR questions that can guide DR capturing and discusses required future research.
In order to increase the level of efficiency and automation, we propose a conceptual model and corresponding tool support to plan and manage the systematic evolution of softwareintensive systems, in particular software product lines (SPL). We support planning on a high abstraction level using decision-making concepts like goals, options, criteria, and rationale. We extend earlier work by broadening the scope in two dimensions: 1) in time, supporting continuous planning over long periods of time and many releases, and 2) in space, supporting traces from high-level decisions down to the implementation. We present a metamodel which allows to represent these concepts, corresponding prototypical tool support, and a first example case using data extracted from an open-source project, Eclipse SWT.
Software cities are visualizations of software systems in the form of virtual cities. They are used as platforms to integrate a large variety of product- and process-related analysis data. Their usability, however, for real-world software development often suffers from their inability to appropriately deal with software changes. Even small structural changes can disrupt the overall structure of the city, which in turn corrupts the mental maps of its users. In this article we describe a systematic approach to utilize the city metaphor for the visualization of evolving software systems as growing software cities. The main contribution is a new layout approach which explicitly takes the development history of software systems into account. The approach has two important effects: first, it creates a stable gestalt of software cities even when the underlying software systems evolve; thus, by preserving its users’ mental maps these cities are especially suitable for use during ongoing system development. Second, it makes history directly visible in the city layouts, which allows for supporting novel analysis scenarios. We illustrate such scenarios by presenting several thematic cities’ maps, each capturing specific development history aspects.
Software Product Lines are a strategic long-term investment and must evolve to meet new requirements over many years. In previous work, we have shown a model-driven approach (called EvoPL [21]) for planning and managing long-term evolution of product lines. It allows specifying historic and planned future evolution in terms of changes on feature model level. It provides benefits like abstraction, efficiency through automation, and the capability to perform analysis based on models.
In this paper, we argue that specifying changes alone is beneficial but not sufficient. This is because for strategic evolution planning "decision drivers" like goals, requirements, and rationale are essential information as well.
Hence, we propose a modeling approach that represents such decision drivers and their interrelationships. The approach is based on concepts from literature (e.g., QOC and goal-oriented requirements engineering) and combines and extends them to address the specific needs of model-driven long-term evolution management. Beyond the basic usage for documentation, the suggested models can be used for systematic future planning and tool-supported analysis, e.g., to evaluate the consistency of planned evolutionary changes.
Abstract. Software architectures are key enabling assets within organizationsthat develop complex software systems. Among other purposes,software architectures are useful to maintain intellectual control overa software product. We propose a method to continuously check theconsistency between a specified architecture model and structural informationreverse engineered from the code. We develop criteria that adesign language for architectures should fulfill and show that an ontologybased description has substantial benefits over the standard modelinglanguages MOF/UML/OCL. Using ontologies allows the explicitmodelling of architectural styles as well as concrete system structuresin a single architecture design language. The resulting specifications aremodular, compositional and evolvable. Using ontologies we can apply anontology reasoner to implement consistency checks. Our method integratespreviously separate checks such as checking for allowed dependenciesand coding style into a single framework and enables more powerfuland flexible analyses.
Coherent Software Cities are a software visualization approach which adopts the city metaphor to support the comprehension of various aspects of evolving software systems. For this purpose, the approach implements a three-staged modeling chain yielding coherent sets of application specific visualizations. In this context, a new layout approach for software cities is presented, which explicitly takes development history into account. Its effects are twofold: First, evolution becomes visible in the layouts, which allows for supporting new application scenarios. Second, layouts evolve smoothly and stable during system evolution, which allows software cities to be used online, i.e. during ongoing system development and maintenance.
Abstract. In this paper we describe a systematic approach to utilize the citymetaphor for the visualization of large software systems asevolving software cities. The main contribution is a new layoutapproach which explicitly takes the development history ofsoftware systems into account and makes history directly visiblein the layouts. These layouts incrementally evolve in a verysmooth and stable way during the development of the representedsoftware system. They are used as a visualization platform forintegrating a large variety of product and process data and thuscreate a coherent set of specialized visualizations. To illustratethis we present some example maps capturing specificdevelopment history aspects.
Modularity is a widely used quality measure for graph clusterings. Its exact maximization is prohibitively expensive for large graphs. Popular heuristics progressively merge clusters starting from singletons (coarsening), and optionally improve the resulting clustering by moving vertices between clusters (refinement). This paper experimentally compares existing and new heuristics of this type with respect to their effectiveness (achieved modularity) and runtime. For coarsening, it turns out that the most widely used criterion for merging clusters (modularity increase) is outperformed by other simple criteria, and that a recent multi-step algorithm is no improvement over simple single-step coarsening for these criteria. For refinement, a new multi-level algorithm produces significantly better clusterings than conventional single-level algorithms. A comparison with published benchmark results and algorithm implementations shows that combinations of coarsening and multi-level refinement are competitive with the best algorithms in the literature.
Abstract. Our feature configuration tool S2T2 Configurator integrates (1) a visual interactive representation of the feature model and (2) a formal reasoning engine that calculates consequences of the user's actions and provides formal explanations. The tool's software architecture is designed as a chain of components, whichprovide mappings between visual elements and their corresponding formal representations. Using these mappings, consequences and explanations calculated by thereasoning engine are communicated in the interactive representation.