Figure 1 - uploaded by Bernhard Rumpe
Content may be subject to copyright.
Source publication
Relating formal refinement techniques with commercial objectoriented software development methods is important to achieve enhancement of the power and flexibility 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...
Similar publications
Object-oriented techniques, when applied seriously and on a broad scale, reflect a new culture of software engineering. which may be called the component culture. After contrasting this new culture with the more traditional project culture, this article examines some of the technical. economical and managerial implications of the new approach. The...
Citations
... We call the developed theory System Model. Its first version is explicitly defined in [RKB95] and [BHP + 98] (including work from [GKR96], [KRB96] and [RK96]). ...
... Starting with [PR94], we investigated how to use state machines to describe the abstract behavior of superclasses and refine it in subclasses. While the description in [PR94] was rather informal, we have formalized the refinement relation in [RK96] by mapping a state machine to a set of possible component behaviors based on the streams of the Focus (see Section 2.8) theory. In [Rum96], constructive transformation rules for refining automata behavior are provided and proven correct. ...
Engineering software and software-intensive systems have become increasingly complex over the last decades. In the ongoing digitalization of all aspects of our lives in almost every domain, including, e.g., mechanical engineering, electrical engineering, medicine, entertainment, or jurisdiction, the software is not only used to enable low-level controls of machines but also to understand system conditions and optimizations potentials. To remain in control of all these heterogeneous systems of systems, a precise, but an abstract understanding of these systems is necessary. To this end, models in their various forms are an important prerequisite to gain this understanding. In this article, we summarize research activities focusing on the development and use of models in software and systems engineering. This research has been carried out by the working group of Bernhard Rumpe, which started 25 years ago in Munich, continued in Braunschweig, and since 10 years carries on at RWTH Aachen University.
... Our contributions to state based modeling can currently be split into three parts: (1) understanding how to model object-oriented and distributed software using statemachines resp. Statecharts [GKR96, BCR07b, BCGR09b, BCGR09a], (2) understanding the renement [PR94, RK96,Rum96] and composition [GR95] of statemachines, and (3) applying statemachines for modeling systems. In [Rum96] constructive transformation rules for rening automata behavior are given and proven correct. ...
This book presents MontiArcAutomaton, a modeling language for architecture
and be- havior modeling of Cyber-Physical Systems as interactive Component &
Connector mod- els. MontiArcAutomaton extends the Architecture Description
Language MontiArc with automata to describe component behavior. The modeling
language MontiArcAutomaton provides syntactical elements for defin- ing
automata with states, variables, and transitions inside MontiArc components.
These syntactical elements and a basic set of well-formedness rules provide the
syntax for a fam- ily of modeling languages for state-based behavior modeling
in Component & Connector architectures. We present two concrete language
profiles with additional well-formedness rules to model time-synchronous
component behavior and untimed, event-driven behav- ior of components. This
book gives an overview of the MontiArcAutomaton language including examples, a
language reference, and a context-free grammar for MontiArcAutomaton models. It
also provides syntax definition, well-formedness rules, and semantics for two
language profiles. We summarize projects and case studies applying
MontiArcAutomaton. MontiArcAutomaton is implemented using the DSL framework
MontiCore. Available tools include a textual editor with syntax highlighting
and code completion as well as a graphical editor and a powerful and extensible
code generation framework for target languages including EMF, Java, Mona, and
Python.
... Many other models and notations for specifying behavior have been developed. Examples for graphical notations are SDL process graphs [5], statecharts [15], state transition diagrams ( [14], [23]). Other, formally based approaches are I/O-automata [20] or TLA [19]. ...
... In order to enhance the acceptance of formal approaches for software specification and development, graphical and textual notations are needed, which provide a convenient "user interface" to formal models for software systems. Therefore, in this section we introduce a graphical description technique -state transition diagrams -along the lines of [14,23,22] for the specification of components in our semantic model. ...
... However, the above semantical characterization is not yet useful from a practical point of view. Therefore, in [23,22,17] a refinement calculus working on STDs is given and proven correct. The refinement calculus is very tractable, since the applicability of the refinement rules can be checked almost automatically on the syntactical level. ...
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].
... The set of possible transformations is to bechosen carefully, to ensure systematic and correct manipulation of documents. Then it is, e.g., possible to inherit the STD-based behaviour description of a class to its subclasses using a re nement calculus, as, e.g., given in Rum96,RK96], which is similar to re nement calculi, like e . g. the work of C. Morgan Mor90]. ...
In this paper we present a possible way how a precise semantics of object
oriented modeling techniques can be achieved and what the possible benefits are
.We outline the main modeling techniques used in the SysLab project sketch how
a precise semantics can be given and how this semantics can be used during the
development process.
... Interestingly, the notions of refinement and compatibility are covered in several existing works from quite different research fields using similar, automata-based artifacts. This includes model-based development [13][8] [12], model checking and formal methods [4] [17], object lifecycle modeling [14], and UML modeling [15][10] [16], including aspect-oriented modeling [17]. Furthermore, work on interface automata consideres a different notion of compatibility between two automata [1,5,2], focusing on input/output compatibility. ...
... Our semantic model builds on the work in [13][8] [12] and employs an external black-box view of the system. It is based on event traces from the outside that trigger transitions. ...
... We use the loose, "chaos" semantics from [13][8] [12] where the semantics of a component is given as the set of possible traces. The set of traces includes any possible trace by transitions specified in the statechart. ...
We compare the notions of refinement and compatibility for system models and their variants described as statecharts. Compatibility, in the sense of substitutability, means that a system can be used in any place where the original one was used. We show that existing definitions of refinement and compatibility are orthogonal, if they include an interface extension. Then, we focus on extended compatibility, which means that the system returns to a compatible behavior after some time even if the newly added features are used. Our new result shows under what conditions the usage of a newly added feature preserves behavior. More specifically, we perform a novel kind of elimination of the newly added behavior on a trace level. In this way, we can achieve extended compatibility even if the newly added features use existing input and output events, which is not possible with existing abstractions and refinement concepts.
... In this way we show that graphical software modeling with statechart diagrams can be extended to modular composition of features. Our refinement concepts are based on automata-refinement [Klein97,Rumpe96], and using a precise semantic treatment of refinement on top of UML statecharts. ...
... We use several forms of statechart refinement, including transition refinement and parallel statechart diagrams. For a more detailed semantic treatment of refinement we refer to [Klein97,Rumpe96]. ...
In this paper, we present a graphic description method for modeling software components with statechart diagrams. We build components by composing features, which define particular services or aspects of the component. The behavior of features is specified individually with partial (or incomplete) diagrams. Using refinement concepts for automata complete component descriptions are created by combining the partial automata of the desired features. In addition to this cross-cutting of components, we also consider feature interactions, which is a well known problem from the telecommunications area. We use adaptors as a glue for combining highly-entangled features which do interact. In this way we show that graphical software modeling with statechart diagrams can be extended to modular composition of features.
... Furthermore, the semantic refinement relation can be adapted to various specification styles by definition of refinement rules on the syntax of the specification. This is for example done in [PR94,Rum96,RK96] for several types of automata and in [PR97,PR99] for pipes and filters dataflow networks. ...
Abstract Speci�cation of interactive distributed systems has been a challenge for decades.
We present an overview of the speci�cation techniques for these systems based on data
ow
networks and stream processing. It covers models of streams and speci�cation of stream
processing systems that are related to and based on the development method Focus invented
by Manfred Broy and his group. We introduce a basic set of manipulator operations for
streams, stream bundles, stream processing functions, and give a summary of related statebased
speci�cation techniques. Furthermore we sketch an overview of implementations for
the Focus framework. These range from formalizations using interactive proof assistants
and model checkers to the modeling IDE AutoFocus.
Key words: Focus, stream processing, automata, semantics
... This is modeled by synchronization on the read operations on the cAns–port. The behavior of the sub-type has to be a refinement of the behavior of its super-type[28]. This is achieved by computing the product of the automata describing the inherited behavior (ServerSide andClientSide) and the automaton synchronizing them (Peer). ...
This paper is an extended version of the Credo Methodology [16]. Credo offers tools and techniques to model and analyze highly reconfigurable distributed systems. In a previous version we presented
an integrated methodology to use the Credo tool suite. Following a compositional, component–based approach to model and analyze distributed systems, we presented a
separation of the system into components and the network. A high–level, abstract representation of the dataflow level on the
network was given in terms of behavioral interface automata and a detailed model of the components in terms of Creol models.
Here we extend the methodology with a detailed model of the network connecting these components. The Vereofy tool set is used to model and analyze the dataflow of the network in detail. The behavioral automata connect the detailed
model of the network and the detailed model of the components. We apply the extended methodology to our running example, a
peer-to-peer file-sharing system.
... For example, Douglass in [3] suggests that inherited state behaviors can be modified adding transitions or elaborating substates in inherited states, but inherited states or transitions should not be deleted. More formal approaches can be found in [21, 5]. Moreover, with regard to the specification of complex collaborative behaviors, the basic tools of UML have been acknowledged by many real-time methodologists quite weak, especially when considering real-time applications and event-based interactions . ...
This paper describes a formal framework for Object-Oriented (O-O) modelling of mechatronic systems, whose main contribution is, on the one hand, to unify the modelling approaches for dynamical systems and for industrial control software and, on the other hand, to provide a definition of inheritance, a cardinal concept in object-orientation, which emphasises the behavioural conformity of basic and derived classes of objects. The proposed framework exploits the coalgebraic description of software artefacts to provide a connection between the behavioural approach for modelling dynamical systems and the O-O approach for software modelling and design. In particular, our definition of inheritance aims to allow control engineers to apply the design by extension methodology, widely used in software engineering, to the development of mechatronic components for manufacturing systems.
... Parallel actions in software systems were modelled in [6] by their atomic representations, allowing to utilize methods originally developed for sequential systems. A mathematical foundation for object-oriented paradigm is presented in [7], where message-based automata for modelling object behavior in terms of cleanroom software engineering methodology [8] is presented. There software refinements is approached through a mathematical description of all possible transformations, capable to ensure refinement correctness with respect to other software objects. ...
Leveraging service oriented programming paradigm would significantly affect the way people build software systems. This paper contributes to the above goal proposing a lightweight formal framework capable of capturing the essential components of service-oriented pro- gramming paradigm.
