Searcharxiv⌕ Search

arXiv subjects

Bernhard Rumpe

Publications and source records attributed to Bernhard Rumpe.

At least 55 records · Page 3Linked to original sources

Using Models at Runtime to Address Assurance for Self-Adaptive Systems

A self-adaptive software system modifies its behavior at runtime in response to changes within the system or in its execution environment. The fulfillment of the system requirements needs to be guaranteed even in the presence of adverse conditions and adaptations. Thus, a key challenge for self-adaptive software systems is assurance. Traditionally, confidence in the correctness of a system is gained through a variety of activities and processes performed at development time, such as design analysis and testing. In the presence of selfadaptation, however, some of the assurance tasks may need to be performed at runtime. This need calls for the development of techniques that enable continuous assurance throughout the software life cycle. Fundamental to the development of runtime assurance techniques is research into the use of models at runtime (M@RT). This chapter explores the state of the art for usingM@RT to address the assurance of self-adaptive software systems. It defines what information can be captured by M@RT, specifically for the purpose of assurance, and puts this definition into the context of existing work. We then outline key research challenges for assurance at runtime and characterize assurance methods. The chapter concludes with an exploration of selected application areas where M@RT could provide significant benefits beyond existing assurance techniques for adaptive systems.

cs.SE↗

Code Generator Composition for Model-Driven Engineering of Robotics Component & Connector Systems

Engineering software for robotics applications requires multidomain and application-specific solutions. Model-driven engineering and modeling language integration provide means for developing specialized, yet reusable models of robotics software architectures. Code generators transform these platform independent models into executable code specific to robotic platforms. Generative software engineering for multidomain applications requires not only the integration of modeling languages but also the integration of validation mechanisms and code generators. In this paper we sketch a conceptual model for code generator composition and show an instantiation of this model in the MontiArc- Automaton framework. MontiArcAutomaton allows modeling software architectures as component and connector models with different component behavior modeling languages. Effective means for code generator integration are a necessity for the post hoc integration of applicationspecific languages in model-based robotics software engineering.

cs.SE↗

Integrating Heterogeneous Building and Periphery Data Models at the District Level: The NIM Approach

Integrating existing heterogeneous data models for buildings, neighbourhoods and periphery devices into a common data model that can be used by all participants, such as users, services or sensors is a cumbersome task. Usually new extended standards emerge or ontologies are used to define mappings between concrete data models. Within the COOPERaTE project a neighbourhood information model (NIM) has been developed to address interoperability and allow for various kinds of data to be stored and exchanged. The implementation of the NIM follows a meta model based approach, allowing for runtime extension and for easily integrating heterogeneous data models via a mapping DSL and code generation of adaptation components.

cs.SE↗

Multi-Platform Generative Development of Component & Connector Systems using Model and Code Libraries

Component-based software engineering aims to reduce software development effort by reusing established components as building blocks of complex systems. Defining components in general-purpose programming languages restricts their reuse to platforms supporting these languages and complicates component composition with implementation details. The vision of model-driven engineering is to reduce the gap between developer intention and implementation details by lifting abstract models to primary development artifacts and systematically transforming these into executable systems. For sufficiently complex systems the transformation from abstract models to platform-specific implementations requires augmentation with platform-specific components. We propose a model-driven mechanism to transform platform-independent logical component & connector architectures into platform-specific implementations combining model and code libraries. This mechanism allows to postpone commitment to a specific platform and thus increases reuse of software architectures and components.

cs.SE↗

The Influence of the Generator's License on Generated Artifacts

Open sourcing modelling tools and generators becomes more and more important as open source software as a whole becomes more important. We evaluate the impact open source licenses of code generators have on the intellectual property (IP) of generated artifacts comparing the most common open source licenses by categories found in literature. Restrictively licensed generators do have effects on the IP and therefore on the usability of the artifacts they produce. We then how how this effects can be shaped to the needs of the licensor and the licensee.

cs.SE↗

User-driven Privacy Enforcement for Cloud-based Services in the Internet of Things

Internet of Things devices are envisioned to penetrate essentially all aspects of life, including homes and urbanspaces, in use cases such as health care, assisted living, and smart cities. One often proposed solution for dealing with the massive amount of data collected by these devices and offering services on top of them is the federation of the Internet of Things and cloud computing. However, user acceptance of such systems is a critical factor that hinders the adoption of this promising approach due to severe privacy concerns. We present UPECSI, an approach for user-driven privacy enforcement for cloud-based services in the Internet of Things to address this critical factor. UPECSI enables enforcement of all privacy requirements of the user once her sensitive data leaves the border of her network, provides a novel approach for the integration of privacy functionality into the development process of cloud-based services, and offers the user an adaptable and transparent configuration of her privacy requirements. Hence, UPECSI demonstrates an approach for realizing user-accepted cloud services in the Internet of Things.

cs.SE↗

Systems, Views and Models of UML

In this paper we show by using the example of UML, how a software engineering method can benefit from an integrative mathematical foundation. The mathematical foundation is given by a mathematical system model. This model provides the basis both for integrating the various description techniques of UML and for implementing methodical support. After describing the basic concepts of the system model, we give a short overview of the UML description techniques. Then we show how they fit into the system model framework and sketch an approach to structure the UML development process such that it provides methodological guidance for developers.

cs.SE↗

Enhancing the SysLab System Model with State

In this report, the SYSLAB model is complemented in different ways: State-box models are provided through timed port automata, for which an operational and a corresponding denotational semantics are given. Composition is defined for components modeled in the state-box view as well as for components modeled in the black-box view. This composition is well-defined for networks of infinitely many components. To show the applicability of the model, several examples are given.

cs.SE↗

Automata Describing Object Behavior

Relating formal re nement techniques with commercial object oriented software development methods is important to achieve enhancement of the power and exibility of these software development methods and tools. We will present an automata model together with a denotational and an operational semantics to describe the behavior of objects. Based on the given semantics we de ne a set of powerful re nement rules and discuss their applicability in software engineering practice especially with the use of inheritance.

cs.SE↗

Concurrent Timed Port Automata

We present a new and powerful class of automata which are explicitly concurrent and allow a very simple definition of composition. The novelty of these automata is their time-synchronous message-asynchronous communication mechanism. Time synchrony is obtained by using global clock. Message asynchrony is obtained by requiring the automata to react to every input. Explicit concurrency is obtained by marking each transition with a set of input and output messages. We compare these automata with a history based approach which uses the same communication mechanism and show that they are equivalent.

cs.FL↗

Software and System Modeling Based on a Unified Formal Semantics

Modeling and documentation are two essential ingredients for the engineering discipline of software development. During the last twenty years a wide variety of description and modeling techniques as well as document formats has been proposed. However, often these are not integrated into a coherent methodology with well-defined dependencies between the models and documentations. This hampers focused software development as well as the provision of powerful tool-support. In this paper we present the main issues and outline solutions in the direction of a unified, formal basis for software and system modeling.

cs.SE↗

Refinement of Pipe-and-Filter Architectures

Software and hardware architectures are prone to modifications. We demonstrate how a mathematically founded powerful refinement calculus for a class of architectures, namely pipe and filter architectures, can be used to modify a system in a provably correct way. The calculus consists of basic rules to add and to remove filters (components) and pipes (channels) to a system. A networking example demonstrates some of the features of our calculus. The calculus is simple, flexible and compositional. Thus it allows us to build more complex and specific rules that e.g. embed models of existing architectures or define design patterns as transformation rules.

cs.SE↗

ALICE: An Advanced Logic for Interactive Component Engineering

This paper presents an overview of the verification framework ALICE in its current version 0.7. It is based on the generic theorem prover Isabelle [Pau03a]. Within ALICE a software or hardware component is specified as a state-full black-box with directed communication channels. Components send and receive asynchronous messages via these channels. The behavior of a component is generally described as a relation on the observations in form of streams of messages flowing over its input and output channels. Untimed and timed as well as state-based, recursive, relational, equational, assumption/guarantee, and functional styles of specification are supported. Hence, ALICE is well suited for the formalization and verification of distributed systems modeled with this stream-processing paradigm.

cs.SE↗

Softwaretechnische Absicherung intelligenter Systeme im Fahrzeug

"This article describes software engineering techniques to be used in order to ensure the necessary quality of intelligent and therefore massive software-based systems in vehicles. Quality assurance for intelligent software is achieved through a bundle of modern software engineering methods. Architecture and design patterns for securing the software components are supplemented by test concepts and frameworks for validation and checks of robustness of the implementation. These patterns describe established and therefore consolidated solutions for certain problems as for instance reliability or efficient execution. -- Dieser Artikel skizziert, welche Software-Entwurfstechniken heute zum Einsatz kommen können, um intelligente, Software-lastige Systeme im Fahrzeug abzusichern. Dabei spielt zunächst das Qualitätsmanagement durch Software-technische Maßnahmen eine zentrale Rolle. Architektur- und Entwurfmuster für die Software-technische Absicherung von Komponenten werden ergänzt um Test-Konzepte zur Validierung von Spezifikationen und der Robustheit der Implementierung. Architekturen und Entwurfs-Muster beschreiben erprobte und damit konsolidierte Lösungen für bestimmte Problemklassen wie etwa Zuverlässigkeit oder effiziente Ausführung.

cs.SE↗

Towards Development of Correct Software using Views

This paper aims at integrating heterogeneous documents used in pragmatic software develpoment methods to describe views with a formal refinement based software development process. Therefore we propose an integrated semantics of heterogeneous documents based on a common system model and a set of syntactic development steps with a well-defined semantics for document evolution. The use of the development steps is demonstrated in a small example.

cs.SE↗

Product Line Annotations with UML-F

The Unified Modeling Language (UML) community has started to define so-called profiles in order to better suit the needs of specific domains or settings. Product lines1 represent a special breed of systems they are extensible semi-finished pieces of software. Completing the semi-finished software leads to various software pieces, typically specific applications, which share the same core. Though product lines have been developed for a wide range of domains, they apply common construction principles. The intention of the UML-F profile (for framework architectures) is the definition of a UML subset, enriched with a few UML-compliant extensions, which allows the annotation of such artifacts. This paper presents aspects of the profile with a focus on patterns and exemplifies the profile's usage.

cs.SE↗

Exemplary and Complete Object Interaction Descriptions

In this paper we present a variant of message sequence diagrams called EETs Extended Event Traces We provide the graphical notation discuss the methodological use of EETs to describe behavior of object oriented business information systems and sketch their semantics Special emphasis is put on the different implications of using EETs for exemplary and complete interaction descriptions. The possibility to describe interactions between single objects as well as composite objects with EETs makes them particularly suitable to describe the behavior of large systems.

cs.SE↗

Feature Specification and Refinement with State Transition Diagrams

In this paper, we introduce a graphic specification technique, called state transition diagrams (STD), and show the application to the feature interaction problem. Using a stream-based formal semantics, we provide refinement rules for STDs. Refinements define an implementation relation on STD specifications. We view features as particular refinements which add previously unspecified behavior to a given STD specification. The refinement relation is then used to add features, and to define the notion of conflicting features. Our techniques are demonstrated by a systematic development of an example given in [25].

cs.SE↗