arXiv subjects

Bernhard Rumpe

Publications and source records attributed to Bernhard Rumpe.

At least 109 records · Page 6Linked to original sources

arXiv2014

Towards Enabling Architectural Refactorings through Source Code Annotations

It is well known that software needs to change to meet new requirements. The synchronization of software architecture models and implementation is of high importance to keep the architecture documents useful and the software evolution process manageable. In this paper we achieve this synchronization by a two-step process. First, we augment the source code with architectural information. Second, this "lightweight architectural model" can be checked more easily against the full architectural description. Based on this approach refactorings on either side (code or architecture) are detected automatically and conformance checks become possible.

cs.SE↗

arXiv2014

Towards a System Model for UML. The Structural Data Model

In this document we introduce a system model as the basis for a semantic model for UML 2.0. The system model is supposed to form the core and foundation of the UML semantics definition. For that purpose the basic system is targeted towards UML. This document is structured as follows: In the rest of Section 1 we will discuss the general approach and highlight the main decisions. This section is important to understand the rest of this document. Section 2 contains the actual definition of the structural part of the system model. It is built in layers as described in Section 1. For brevity of the approach, we defer deeper discussions into the Appendix in Section 4. This document is part of a project on the formalization of the UML 2.0 in cooperation between the Queens University Kingston and the Technische Universitäten Braunschweig and München. This version 1.0 is the result of a longer effort to define the structure, behavior and interaction of object-oriented, possibly distributed systems abstract enough to be of general value, but also in sufficient detail for a semantic foundation of the UML. We also wish to thank external reviewers, and especially Gregor von Bochmann, Gregor Engels and Sébastien Gérard for their help.

cs.SE↗

arXiv2014

Agile Test-based Modeling

Model driven architecture (MDA) concentrates on the use of models during software development. An approach using models as the central development artifact is more abstract, more compact and thus more effective and probably also less error prone. Although the ideas of MDA exist already for years, there is still much to improve in the development process as well as the underlying techniques and tools. Therefore, this paper is a follow up on, reexamining und updating the statements made there. Here two major and strongly related techniques are identified and discussed: Test case modeling and an evolutionary approach to model transformation.

cs.SE↗

arXiv2014

Model Driven Testing of Time Sensitive Distributed Systems

In this paper we demonstrate an approach to model structure and behavior of distributed systems, to map those models to a lightweight execution engine by using a functional programming language and to systematically define and execute tests for these models within the same technology. This is a prerequisite for a smooth integration of model based development into an agile method. The novelty of this paper is the demonstration, how composition and state machine models for distributed asynchronously communicating systems can easily be mapped to a lazy functional language and then using standard testing techniques to define test on those programs. In particular distributed timing aspects and underspecification can be treated accordingly within a functional language, using a certain style of functions.

cs.SE↗

arXiv2014

Roles in Software Development using Domain Specific Modeling Languages

Domain-specific modelling languages (DSMLs) successfully separate the conceptual and technical design of a software system by modelling requirements in the DSML and adding technical elements by appropriate generator technology. In this paper we describe the roles within an agile development process that allows us to implement a software system by using a combination of domain specific models and source code. We describe the setup of such a process using the MontiCore framework and demonstrate the advantages by describing how a group of developers with diverse individual skills can develop automotive HMI software.

cs.SE↗

arXiv2014

An Algebraic View on the Semantics of model Composition

Due to the increased complexity of software development projects more and more systems are described by models. The sheer size makes it impractical to describe these systems by a single model. Instead many models are developed that provide several complementary views on the system to be developed. This however leads to a need for compositional models. This paper describes a foundational theory of model composition in form of an algebra to explicitly clarify different variants and uses of composition, their interplay with the semantics of the involved models and their composition operators.

cs.SE↗

arXiv2014

System-Model-Based Simulation of UML Models

Previous work has presented our ongoing e orts to define a "reference semantics" for the UML, that is, a mathematically defined system model that is envisaged to cover all of the UML eventually, and that also carefully avoids the introduction of any unwarranted restrictions or biases. Due to the use of underspecification, the system model is not executable. This paper shows how the system model can serve as the basis for a highly customizable execution and simulation environment for the UML. The design and implementation of a prototype of such an environment is described and its use for the experimentation with different semantic variation points is illustrated.

cs.SE↗

arXiv2014

Textbased Modeling

As modeling becomes a crucial activity in software development the question may be asked whether currently used graphical representations are the best option to model systems efficiently. This position paper discusses the advantages of text-based modeling over commonly used graphical representations. It is inspired through the advent of new extensible development tools like Eclipse. The discussion is illustrated by showing a textual version of UML state machines as Eclipse plugins.

cs.SE↗

arXiv2014

Efficient Editor Generation for Compositional DSLs in Eclipse

When a domain specific language (DSL) shall be commonly used, it is important for the development team to have a comfortable editor well integrated in the project's development environment. As DSL are rather often subject to changes, efficient development and evolvement of a comfortable editor is an important success criterion for the acceptance of domain specific languages. In this paper we demonstrate how this issue is addressed in the MontiCore DSL development framework. Basically an extension of the MontiCore DSL definition language can be used to efficiently generate DSL editors for Eclipse. The generation tool also supports the compositional language definition features of MontiCore and allows therefore the reuse of existing language and editor definitions.

cs.SE↗

arXiv2014

View-Based Modeling of Function Nets

This paper presents an approach to model features and function nets of automotive systems comprehensively. In order to bridge the gap between feature requirements and function nets, we describe an approach to describe both using a SysML-based notation. If requirements on the automotive system are changed by several developers responsible for different features, it is important for developers to have a good overview and understanding of the functions affected. We show that this can be comprehensively modeled using so called "feature views". In order to validate these views against the complete function nets, consistency checks are provided.

cs.SE↗

arXiv2014

Modelling Automotive Function Nets with Views for Features, Variants, and Modes

Modelling the logical architecture of an automotive system as one central step in the development process leads to an early understanding of the fundamental functional properties of the system under design. This supports developers in making design decisions. However, due to the large size and complexity of the system and hence the logical architecture, a good notation, method and tooling is necessary. In this paper, we show how logical architectures can be modelled succinctly as function nets using a SysML-based notation. The usefulness for developers is increased by comprehensible views on the complete model that describe automotive features, variants, and modes.

cs.SE↗

arXiv2014

View-Centric Modeling of Automotive Logical Architectures

Modeling the logical architecture is an often underestimated development step to gain an early insight into the fundamental functional properties of an automotive system. An architectural description supports developers in making design decisions for further development steps like the refinement towards a software architecture or the partition of logical functions on ECUs and buses. However, due to the large size and complexity of the system and hence the logical architecture, a good notation, method, and tooling is necessary. In this paper, we show how the logical architectures can be modeled succinctly as function nets using a SysML-based notation. The usefulness for developers is increased by comprehensible views on the complete model to describe automotive features in a self contained way including their variants, modes, and related scenarios.

cs.SE↗

arXiv2014

MontiCore: A Framework for the Development of Textual Domain Specific Languages

In this paper we demonstrate a framework for efficient development of textual domain specific languages and supporting tools. We use a redundance-free and compact definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. To further improve the usability of the abstract syntax this definition format integrates additional concepts like associations and inheritance into the well-understood grammar-based approach. Modularity concepts like language inheritance and embedding are used to simplify the development of languages based on already existing ones. In addition, the generation of editors and a template approach for code generation is explained.

cs.SE↗

arXiv2014

MontiCore: Modular Development of Textual Domain Specific Languages

Reuse is a key technique for a more efficient development and ensures the quality of the results. In object technology explicit encapsulation, interfaces, and inheritance are well known principles for independent development that enable combination and reuse of developed artifacts. In this paper we apply modularity concepts for domain specific languages (DSLs) and discuss how they help to design new languages by extending existing ones and composing fragments to new DSLs. We use an extended grammar format with appropriate tool support that avoids redefinition of existing functionalities by introducing language inheritance and embedding as first class artifacts in a DSL definition. Language embedding and inheritance is not only assisted by the parser, but also by the editor, and algorithms based on tree traversal like context checkers, pretty printers, and code generators. We demonstrate that compositional engineering of new languages becomes a useful concept when starting to define project-individual DSLs using appropriate tool support.

cs.SE↗

arXiv2014

Evolving and Implanting Web-based E-Government Systems in Universities

The Bologna Process has triggered a major restructuring of the current university diploma into a bachelor/master system. As one effect, the administration effort for the new system has increased dramatically. As a second effect, students need and demand a much better information policy, given the new possibilities of the internet. Both to increase efficiency of the university's administration and to provide students as well as lecturers with modern e government services, it is inevitable to evolve the current IT-infrastructure of a university into a modern web-based landscape of systems that support business processes on campus. In this paper, we describe the approach taken at the Braunschweig University of Technology to evolve the existing landscape of legacy systems by adding bridges between previously unrelated parts, adding and customizing unused modules of existing software to bring information and services online and to develop new software, where old modules could not serve the necessary purposes. Most of all, both implementation of the results in university's business processes and the resulting quick feedback and wishes for feature enhancement are seen as part of the software development processes and discussed in this paper.

cs.CY↗

arXiv2014

System Model Semantics of Class Diagrams

Defining semantics for UML is a difficult task. Disagreements in the meaning of UML constructs as well as the size of UML are major obstacles. In this report, we describe our approach to define the semantics for UML. Semantics is defined denotationally as a mapping into our semantics domain called the system model [4, 5, 6]. We demonstrate our approach by defining the semantics for a comprehensive version of class diagrams. The semantics definition is detailed for UML/P class diagrams, a variant of class diagrams which restricts the use of a few methodologically and semantically involved concepts. Class diagrams are well-known and rather easy to understand and thus perfect to examine the usability of the system model for precise semantic mappings.

cs.SE↗

arXiv2014

System Model Semantics of Statecharts

In this report, semantics for Statecharts is defined based on a mathematical model of object systems called "system model". The semantics definition is detailed for UML/P Statecharts, a variant of Statecharts which restricts the use of a few methodologically and semantically difficult concepts. After transforming full UML/P Statecharts to simplified but semantically equivalent Statecharts, the semantics is defined denotationally as a mapping into the system model. It is also sketched how already existing Statechart semantics can be mapped into the system model. This report follows, in which we introduced our approach in detail and defined semantics for UML class diagrams.

cs.SE↗

arXiv2014

Modular Description of a Comprehensive Semantics Model for the UML (Version 2.0)

In this document, we introduce a system model as a semantic domain for the Unified Modeling Language (UML) [OMG07a, OMG07b]. The system model is supposed to form a possible core and foundation of the UML semantics definition. For that purpose, the definitions in this document are targeted towards UML which means that central concepts of UML have been formalized as theories of the system model. This document is structured as follows: In the rest of Chapter 1, we discuss the general approach and highlight the main decisions. This chapter is important to understand the rest of this document. Chapter 2 contains the definition of the structural part of the system model. Chapters 3 and 4 contain the control and communication related definition definitions which form the basis to describe the state of a system in Chapter 5. Two variants of state transitions systems are introduced to define object behavior in Chapters 6 (event-based) and 7 (timed). Chapter 8 concludes the document. This document is the second version of the system model which is the result of a major effort to define the structure, behavior and interaction of object oriented, possibly distributed systems abstract enough to be of general value, but also in sufficient detail for a semantic foundation of the UML. The first version of the system model can be found in [BCR06, BCR07a, BCR07b].

cs.SE↗