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)
- Softwarevisualisierung (2)
- Visualisierung (2)
- rationale management (2)
- software cities (2)
- software maintenance (2)
- software product lines (2)
- software visualization (2)
- Algorithmen (1)
- BDD (1)
- Case Study (1)
- Computer Science (1)
- Computer-Communication Networks (1)
- Computergraphik (1)
- Conference Proceedings (1)
- Cost (1)
- Coverage criteria (1)
- Debugging (1)
- Effectiveness (1)
- Embedded Systems (1)
- Evolutionary Computation (1)
- Experimentation (1)
- Formal Method (1)
- Formal Verification (1)
- Graph Theory (1)
- Graph logic (1)
- Graphical User Interfaces (1)
- Graphical environments (1)
- Graphische Darstellung (1)
- Graphvisualisierung (1)
- Informatics (1)
- Language Server Protocol (1)
- Logic coverage (1)
- Logics and Meanings (1)
- Management (1)
- Measurement (1)
- Model generation (1)
- Model-Driven Engineering (1)
- Open Access (1)
- Organizations (1)
- Performance (1)
- Process Metrics (1)
- Product Metrics (1)
- Programming Languages (1)
- Programming Techniques (1)
- Programming teams (1)
- Projektmanagement (1)
- Protocol Verification (1)
- Reachability Analysis (1)
- Reactive Systems (1)
- Requirements engineering (1)
- Research (1)
- Restructuring (1)
- SPCC (1)
- Search-Based Software Engineering (1)
- Software Engineering (1)
- Software engineering (1)
- Software-Ontologien (1)
- Software/Program Verification (1)
- Softwarearchitektur (1)
- Softwarearchitekturen (1)
- Softwareentwicklung (1)
- Softwareevolution (1)
- Softwareleitstand (1)
- Stakeholders (1)
- Systematics (1)
- Timed Automata (1)
- Validation (1)
- agile (1)
- agile software development (1)
- case study (1)
- decision making (1)
- decision types (1)
- decision-making (1)
- design decision (1)
- design rationale (1)
- documentation (1)
- domain-specific languages (1)
- education (1)
- literature review (1)
- metrics (1)
- modeling (1)
- question catalogue (1)
- rationale (1)
- reengineering (1)
- reverse engineering (1)
- scrum (1)
- simulation (1)
- software comprehension (1)
- software erosion (1)
- software landscapes (1)
- software release planning (1)
- statecharts (1)
- teaching (1)
- tool support (1)
- validation framework (1)
Institute
In model-driven engineering, the adaptation of large software systems with dynamic structure is enabled by architectural runtime models. Such a model represents an abstract state of the system as a graph of interacting components. Every relevant change in the system is mirrored in the model and triggers an evaluation of model queries, which search the model for structural patterns that should be adapted. This thesis focuses on a type of runtime models where the expressiveness of the model and model queries is extended to capture past changes and their timing. These history-aware models and temporal queries enable more informed decision-making during adaptation, as they support the formulation of requirements on the evolution of the pattern that should be adapted. However, evaluating temporal queries during adaptation poses significant challenges. First, it implies the capability to specify and evaluate requirements on the structure, as well as the ordering and timing in which structural changes occur. Then, query answers have to reflect that the history-aware model represents the architecture of a system whose execution may be ongoing, and thus answers may depend on future changes. Finally, query evaluation needs to be adequately fast and memory-efficient despite the increasing size of the history---especially for models that are altered by numerous, rapid changes.
The thesis presents a query language and a querying approach for the specification and evaluation of temporal queries. These contributions aim to cope with the challenges of evaluating temporal queries at runtime, a prerequisite for history-aware architectural monitoring and adaptation which has not been systematically treated by prior model-based solutions. The distinguishing features of our contributions are: the specification of queries based on a temporal logic which encodes structural patterns as graphs; the provision of formally precise query answers which account for timing constraints and ongoing executions; the incremental evaluation which avoids the re-computation of query answers after each change; and the option to discard history that is no longer relevant to queries. The query evaluation searches the model for occurrences of a pattern whose evolution satisfies a temporal logic formula. Therefore, besides model-driven engineering, another related research community is runtime verification. The approach differs from prior logic-based runtime verification solutions by supporting the representation and querying of structure via graphs and graph queries, respectively, which is more efficient for queries with complex patterns. We present a prototypical implementation of the approach and measure its speed and memory consumption in monitoring and adaptation scenarios from two application domains, with executions of an increasing size. We assess scalability by a comparison to the state-of-the-art from both related research communities. The implementation yields promising results, which pave the way for sophisticated history-aware self-adaptation solutions and indicate that the approach constitutes a highly effective technique for runtime monitoring on an architectural level.…
Graphs are used as a universal data structure in various domains. Sets of graphs (and likewise graph morphisms) can be specified using, e.g., the graph logic Image 1 of Graph Conditions (GCs). The evaluation of a graph against such a GC results in a Boolean satisfaction judgement on whether the graph is specified by the GC. The graph logic Image 1 is known to be as expressive as first-order logic on graphs. However, since infinitely many graphs exist, there are also infinitely many evaluations for each given GC. To support GC validation, testing, debugging, and repair, a suitable synthesis procedure generating a complete compact overview of how a given GC may be evaluated for possibly varying graphs is called for.
In a previous paper, we generated such an overview for a given GC in the form of a complete finite set of diverse evaluations for varying associated graphs formally given by so called Evaluation Trees (ETs). Each of these ETs concretely describes how its associated graph is evaluated against the given GC by recording the executed evaluation steps. Moreover, these generated ETs and the given GC for which they are generated have the same underlying structure easing comprehensibility of the represented evaluation steps. The returned ETs are complete since each possible ET subsumes one of the returned ETs and diverse by not containing superfluous ETs subsuming smaller ETs.
We now extend and refine this approach still solving the ET synthesis problem by (a) extending the graph logic GL allowing for the specification of a minimal number of graph patterns to be contained in specified graphs, (b) provide means to scale the size of the generated ETs up to a user-provided bound allowing for the generation of not just minimal ETs, (c) record the order of evaluations steps also for operators where the evaluation but not the operator itself defines such an order, and (d) generate ETs recording combinations of reasons for (non-)satisfaction of GCs where only single reasons were recorded before.
Modeling tools are commonly adopted in classrooms. However, complex state-based behavioral models still pose a challenge for students to understand and validate, mostly because of the intricate semantics of these models. We investigated this challenge and developed dedicated tool support in the form of a validation framework based on the YAKINDU Statechart Tools. Our validation framework simulates environments that interact with the code generated from statecharts as a means to animate various open-ended scenarios and predefined test cases that challenge the students' models. This enables short and user-friendly feedback cycles, which lowers the barrier for students to learn state-based behavioral models. We designed the validation framework to be extensible and made it available as an open source project together with two example environments and complete teaching materials. We report on our experiences in two undergraduate modeling courses (approx. 100 students each). Our results are promising in the sense that we detected positive effects of tool adoption and a surprising lack thereof, which we discuss w.r.t. lessons learned and future work.
Optimization problems in software engineering typically deal with structures as they occur in the design and maintenance of software systems. In model-driven optimization (MDO), domain-specific models are used to represent these structures while evolutionary algorithms are often used to solve optimization problems. However, designing appropriate models and evolutionary algorithms to represent and evolve structures is not always straightforward. Domain experts often need deep knowledge of how to configure an evolutionary algorithm. This makes the use of model-driven meta-heuristic search difficult and expensive. We present a graph-based framework for MDO that identifies and clarifies core concepts and relies on mutation operators to specify evolutionary change. This framework is intended to help domain experts develop and study evolutionary algorithms based on domain-specific models and operators. In addition, it can help in clarifying the critical factors for conducting reproducible experiments in MDO. Based on the framework, we are able to take a first step toward identifying and studying important properties of evolutionary operators in the context of MDO. As a showcase, we investigate the impact of soundness and completeness at the level of mutation operator sets on the effectiveness and efficiency of evolutionary algorithms.
This open access book constitutes the proceedings of the 26th International Conference on Fundamental Approaches to Software Engineering, FASE 2023, which was held during April 22-27, 2023, in Paris, France, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2023.
The 12 regular papers presented in this volume were carefully reviewed and selected from 50 submissions. The proceedings also contain 2 tool papers, 2 NIER papers, and 2 competition papers from the Test-Comp Competition. The papers deal with the foundations on which software engineering is built, including topics like software engineering as an engineering discipline, requirements engineering, software architectures, software quality, model-driven development, software processes, software evolution, AI-based software engineering, and the specification, design, and implementation of particular classes of systems, such as (self-)adaptive, collaborative, AI, embedded, distributed, mobile, pervasive, cyber-physical, or service-oriented applications.
Managing rationale in software development projects can be a cumbersome task with a potentially low return on investment. Especially in the agile context, documentation is therefore very unpopular. Research has not yet properly addressed an agile documentation workflow. In this paper, the author presents an integrated approach to agile rationale management based on a highly-flexible modelling approach using domainspecific languages. It facilitates the complete documentation workflow from capture to reuse, partially automates it and offers various customisation opportunities, making it applicable to agile methods.
Documenting design decisions and their rationale (Design Rationale, DR) in software development projects is vital
for supporting the comprehension of the product, product quality, and future maintenance. Although an increasing number of research publications address this topic, systematic approaches and supporting DR tools are found very rarely in practice. In software engineering education, DR is usually not well covered in teaching. The lack of suitable decision documentation is mainly an issue in agile software development. In agile approaches, documentation is regarded as less important than working products. To explore possibilities for integrating decision documentation into Scrum processes for educational software development projects, we conducted a series of eight case studies. These were part of software lab courses in three universities, i.e., BTU Cottbus, PUT Poznan, University of Stuttgart, with about 400 participants in 82 project teams. We introduced additional process elements in Scrum and developed a lightweight capture technique to support the decision capture.
This paper describes the case study setup and corresponding implementation and, thus, an example approach of managing
rationale in Scrum. Additionally, it presents a data analysis of the students’ most relevant decisions documented throughout the case studies. We conclude the paper with a discussion on the observations we made during the case study executions and the applicability of the approach in educational software projects.
Requirements are identified and elaborated on the basis of stakeholders' decisions. The reasoning behind those decisions can be expressed as rationales. Systematic rationale management offers both short-term benefits, such as clearer requirements leading to fewer defects, and long-term benefits, such as simplified requirements evolution. However, little guidance exists for managing requirements rationales. This article presents guidelines to pragmatically capture, trace, maintain, and reuse such rationales. A list of questions augments the guidelines, improving their usability.
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.
More than thirty years of research on the topic of design rationale (DR) have passed. However, as of today there are just some exceptional cases where DR are applied in industrial practise. Researchers analysed them for its nature, its structure, its quality, and for analyses to be performed on them. The results showed that DR have the potential to sustainably contribute to the product life cycle in terms of product design, product re-design, product testing, maintenance, and product quality. Hence, this paper presents a proposal to tackle the lack DR usage in documenting software architectures. We strive to promote the use of DR for designing software architectures. Therefore, as a complement to the numerous approaches to formalise the representation of DR, this paper is proposing to pay more attention on research how to capture rationale. 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.
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.