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
Over the last thirty years many research has been conducted to capture the ”how” and ”why” behind design decisions. This information is known as design rationales (DR). Approaches to capture, store, preserve, and use DR have emerged from research activities. However, as of today they only found exceptional application within industrial practice. Rationales have been analysed in respect to its nature, its structure, and its quality. Additionally, some researchers performed analyses on them. They found out that DR have the potential to sustainably contribute to design, re-design, testing, maintenance, and improving product quality over the whole product-life cycle. Within this paper a research proposal is presented striving to tackle the exceptional use of DR in software documentation. We want to promote the capture of DR by paying more attention on the questions ”What information has to be captured by rationales?”, ”How detailed should the captured information be?”, and ”How should rationale capture be integrated into the development process?”. It is the goal to promote the use of DR within the whole software development process. In short, within this paper we introduce the topic of DR, related research and elaborate on the intended research on the topic of DR capture.
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.
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 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.
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. The architecture of a software system is both a success and a failure factor. Taking the wrong architectural decisions may break a project, since such errors are often systematic and affect cross-cutting aspects of the system to be built. Moreover, software projects get more and more challenging due to the rising complexity and dynamics of business processes, large team size and distributed development. As the software architecture is the common platform for many project activities, it constitutes a critical success factor. Thus, a comprehensive methodfor evaluating a software architecture and propagating important properties of it downstream to code is needed. At sd&m, we designed a comprehensive architecture evaluation and management framework in order to satisfy these needs. In this paper, we derive a list of requirements, such a framework should fulfill. We then present the components of our architecture evaluation method and demonstrate, how it fulfills these requirements.
Empirical results from using custom-made software project control centers in industrial environments
(2008)
One means for institutionalizing project control, systematic quality assurance, and management support on the basis of measurement and explicit models is the establishment of so-called Software Project Control Centers. Nowadays many companies develop their own dashboards for project control or use off-the-shelf tools that provide a predefined functionality. It is not clear how to tailor an existing tool to the specific needs and goals. An engineering-like approach providing the methodological foundation is needed for systematically defining and applying project control mechanisms. "Soft-Pit" is a research project focusing on an improvement-oriented approach for setting up and applying project control mechanisms in a goal-oriented way and evaluating the practical benefits of such a control center. This article describes the results of industrial case studies conducted in the context of the project. Moreover, lessons learned are discussed, related work is described, and future work is presented.
Abstract. Software Product Line engineering allows companies to realise significant improvements in time-to-market, cost, productivity, and system quality. One major difficulty with software product lines is that within industry there may exist thousands of variation points in a single product line. This scale of variability can become extremely complex to manage resulting in a product configuration process that bears significant costs. This paper presents a feature configuration meta-model and introduces a prototype tool that employs visualisation and interaction techniques to provide feature configuration functionality.
Abstract. Software Product Line engineering has emerged as a viable and important software development paradigm in the automotive industry. It allows companies to realise significant improvements in time-to-market, cost, productivity, and system quality. One major difficulty with software product line engineering is related to the fact that a product line of industrial size can easily incorporate thousands of variation points. This scale of variability can become extremely complex to manage resulting in a product configuration process that bears significant costs. This paper introduces a meta-model and research tool that employs visualisation and interaction techniques to improve product configuration in high-variability product lines. The meta-model and techniques utilised are illustrated using an automotive restraint system example.
Software Controlling
(2008)
Abstract. Die Entwicklung von großen Softwaresystemen erfordert ein effektives und effizientes Projektmanagement. Insbesondere muss im Hinblick auf die Softwarequalität in die Entwicklungsprozesse ein zielgerichtetes Risikomanagement integriert werden. Der bisher meist verfolgte "klassische" Ansatz des Projektcontrollings fokussiert vielfach nur auf die Erreichung von externen Qualitätseigenschaften des Endprodukts (wie der Erfüllung funktionaler Anforderungen, die vom Anwender wahrgenommen werden) und die Einhaltung von Zeit- und Budgetvorgaben. Die Erfahrung aus vielen lang laufenden Projekten zeigt, dass im Hinblick auf nachhaltige Entwicklung eine feinkörnigere und ganzheitlichere Betrachtung der Qualität von Softwaredokumenten und Entwicklungszwischenprodukten notwendig ist, um qualitätsbezogene Projektrisiken frühzeitig zu erkennen und geeignete Steuerungsmaßnahmen im Entwicklungsprozess ergreifen zu können.Bei Capgemini sd&m (München) wird deshalb gerade unter dem Begriff Software Controlling ein Bündel von technischen und organisatorischen Maßnahmen zum ganzheitlichen qualitätsbezogenen Risikomanagement in Softwareprojekten eingeführt. Wesentliche Komponenten sind ein Qualitätsmodell auf der Grundlage eines aus bisherigen Projekterfahrungen gewonnenen Kennzahlensystems, das interne Produkteigenschaften mit Aufwands-, Test- und Fehlerdaten verknüpft, ein in die Entwicklungsumgebung integrierter Projektleitstand und spezifische Prozesselemente zur Qualitäts- und Risikobewertung auf der Grundlage der Kennzahlen.
Two natural and widely used representations for the community structure of networks are clusterings,which partition the vertex set into disjoint subsets, and layouts, which assign the vertices to positions in a metric space. This paper unifies prominent characterizations of layout quality and clustering quality, by showing that energy models of pairwise attraction and repulsion subsume Newman and Girvan's modularity measure. Layouts with optimal energy are relaxations of, and are thus consistent with, clusterings with optimal modularity, which isof practical relevance because both representations are complementary and often used together.
Abstract. SoftUrbs is a systematic approach to utilize the City metaphor for the visualization and interpretation of large software systems as urban structures. The maincontributions are, firstly, a systematic approach to construct and use these visualizations by adopting thethree-staged cartographic modeling chain and, secondly, the use of force-directed layouts of the city map. The latter provides a framework for flexible and incrementally adaptable layouts, which are necessary to preserve a city's overall morphology throughout the structural evolution of the visualized software system. The distinction between different model stages helps to create uniform and consistent visualizations supporting different usage scenarios. The conceptshave been implemented and were successfully applied in some large scale industry projects.
Whenever a software engineer derives a product from a prod-uct line, he has to resolve variability by making con_guration decisions.This con_guration process can become rather complex because of depen-dencies within the variability model and knock-on e_ects and dependen-cies in other related artefacts. Because of the limited cognitive capacity ofthe human engineer, this complexity limits the ability of handling prod-uct lines with large con_guration spaces. To address this problem wefocus on techniques that support the interactive con_guration of largerfeature models, including (1) visual interaction with a formal reason-ing engine, (2) visual representation of multiple interrelated hierarchies,(3) indicators for con_guration progress and (4) _ltering of visible nodes.The concepts are demonstrated within S2T2 Con_gurator, an interactivefeature con_guration tool. The techniques are discussed and evaluatedwith feature models, however, we believe they can be generalised to othermodels that describe con_guration choices, e.g., variability models anddecision models.
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.
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.
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. 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.
We introduce an energy model whose minimum energy drawings reveal the clusters of the drawn graph. Here a cluster is a set of nodes with many internal edges and few edges to nodes outside the set. The drawings of the best-known force and energy models do not clearly show clusters for graphs whose diameter is small relative to the number of nodes. We formally characterize the minimum energy drawings of our energy model. This characterization shows in what sense the drawings separate clusters, and how the distance of separated clusters to the other nodes can be interpreted
We introduce energy models for drawing clustered small-world graphs. Clustered means that there exist (probably unknown) sets of nodes with many edges between nodes of the same set and few edges to nodes outside the set. Small-world means that the graph-theoretic distances between nodes are small relative to the number of nodes. Previous force or energy models do not produce satisfactory results for such graphs. In drawings that have minimum energy with respect to our new energy models, different clusters are clearly separated and have interpretable distances.We formally characterize the minimum energy drawings of our new energy mod%ADels and of a class of energy models that contains among others the well-known Fruchterman-Reingold model. These characterizations show 1) in what sense the minimum energy drawings of these energy models fulfill requirements like small, uniform edge lengths, well-distributed nodes, or separated clusters, and 2) what properties of the drawn graph can be inferred from the drawings
In this paper we analyze the efficiency of binary decision diagrams (BDDs) and clock difference diagrams (CDDs) in the verification of timed automata. Therefore we present analytical and empirical complexity results for three communication protocols. The contributions of the analyses are: Firstly, they show that BDDs and CDDs of polynomial size exist for the reachability sets of the three protocols. This is the first evidence that CDDs can grow only polynomially for models with non-trivial state space explosion. Secondly, they show that CDD-based tools, which currently use at least exponential space for two of the protocols, will only find polynomial-size CDDs if they use better variable orders, as the BDD-based tool Rabbit does. Finally, they give insight into the dependency of the BDD and CDD size on properties of the model, in particular the number of automata and the magnitude of the clock values.
Abstract. Many analyses of software systems can be formalized as relational queries, for example the detection of design patterns, of patterns of problematic design, of code clones, of dead code, and of differences between the as-built and the as-designed architecture. This paper describes the concepts of CrocoPat, a tool for querying and manipulating relations. CrocoPat is easy to use, because of its simple query and manipulation language based on predicate calculus, and its simple file format for relations. CrocoPat is efficient, because it internally represents relations as binary decision diagrams, a data structure that is well-known as a compact representation of large relations in computer-aided verification. CrocoPat is general, because it manipulates not only graphs (i.e. binary relations), but n-ary relations.
This paper gives a short overview of a model checking tool for real-time systems. The modeling language are timed automata extended with concepts for modular modeling. The tool provides reachability analysis and refinement checking, both implemented using the data structure BDD. Good variable orderings for the BDDs are computed from the modular structure of the model and an estimate of the BDD size. This leads to a significant performance improvement compared to the tool RED and the BDD-based version of Kronos.
In this paper we analyze the efficiency of binary decision diagrams (BDDs) and clock difference diagrams (CDDs) in the verification of timed automata. Therefore we present empirical and analytical complexity results for three communication protocols. The contributions of the analyses are: Firstly, they explain the empirical results. Secondly, they show that BDDs and CDDs of polynomial size exist for the reachability sets of the three protocols. Thirdly, they show that CDD-based tools, which currently use at least exponential space for two of the protocols, will only find polynomial-sized CDDs if they use better variable orders, as the BDD-based tool Rabbit does. Finally, they give insight into the dependency of the BDD and CDD size on properties of the model, in particular the number of automata and the magnitude of the clock values.
CrocoCosmos
(2002)
In this chapter we introduce the concept of structural quality assessments for industrial software systems (especially object-oriented code). Such a quality assessment can be used both to determine the current state with respect to quality and to plan further actions, i.e. reengineering steps, process adjustments or further education of engineers in an ongoing project. The assessment itself is based on an innovative software analysis workbench that integrates multiple interdependent views on a software system into a coherent analysis environment. These views provide information on four aspects: user-defined metrics and query results with high-level information about the system, detailed cross-reference information, browsing views and diagrams to support efficient understanding of the structure. The workbench applies powerful static analysis techniques on the source code under consideration and uses it to generate, access, visualise and browse the different views and analysis results. For practical assessments the workbench is used in a well-defined process such that a first quality assessment of large systems can be done within a very short period of time.
The quality assessment described here has been applied in various projects. In order to illustrate the results that such an assessment gives for project management, developers or managers of an outsourced project this paper ends with a short description of a typical example project. This is one of the projects supported jointly by SQS and the Software Systems Engineering Research Group Cottbus
Anpaßbare, explorierbare virtuelle Informationsräume zur Qualitätsbewertung großer Software-Systeme
(2001)
Metrics Based Refactoring
(2001)