Bernhard Rumpe

Model-driven Development of Complex Software: A Research Roadmap

The term model-driven engineering (MDE) is typically used to describe software development approaches in which abstract models of software systems are created and systematically transformed to concrete implementations. In this paper we give an overview of current research in MDE and discuss some of the major challenges that must be tackled in order to realize the MDE vision of software development. We argue that full realizations of the MDE vision may not be possible in the near to medium-term primarily because of the wicked problems involved. On the other hand, attempting to realize the vision will provide insights that can be used to significantly reduce the gap between evolving software complexity and the technologies used to manage complexity.

Meaningful modeling: what's the semantics of "semantics"?

The Unified Modeling Language (UML) is a complex collection of mostly diagrammatic notations for software modeling, and its standardization has prompted an animated discussion about UMLs semantics and how to represent it. We have thus set out to clarify some of the notions involved in defining modeling languages, with an eye toward the particular difficulties arising in defining UML. We are primarily interested in distinguishing a languages notation, or syntax, from its meaning, or semantics, as well as recognizing the differences between variants of syntax and semantics in their nature, purpose, style, and use.

The UML as a formal modeling notation

The Unified Modeling Language (UML) is rapidly emerging as a de-facto standard for modelling OO systems. Given this role, it is imperative that the UML needs a well-defined, fully explored semantics. Such semantics is required in order to ensure that UML concepts are precisely stated and defined. In this paper we motivate an approach to formalizing UML in which formal specification techniques are used to gain insight into the semantics of UML notations and diagrams and describe a roadmap for this approach. The authors initiated the Precise UML (PUML) group in order to develop a precise semantic model for UML diagrams. The semantic model is to be used as the basis for a set of diagrammatical transformation rules, which enable formal deductions to be made about UML diagrams. A small example shows how these rules can be used to verify whether one class diagram is a valid deduction of another. Because these rules are presented at the diagrammatical level, it will be argued that UML can be successfully used as a formal modelling tool without the notational complexities that are commonly found in textual specification techniques.

Assumptions Underlying Agile Software-Development Processes

Agile processes focus on the early facilitation and fast production of working code, and are based on software-development process models that support iterative, incremental development of software. Although agile methods have existed for a number of years now, answers to questions concerning the suitability of agile processes to particular software-development environments are still often based on anecdotal accounts of experiences. An appreciation of the (often unstated) assumptions underlying agile processes can lead to a better understanding of the applicability of agile processes to particular situations. Agile processes are less likely to be applicable in situations in which core assumptions do not hold. This article examines the principles and advocated practices of agile processes to identify underlying assumptions. It also identifies limitations that may arise from these assumptions and outlines how the limitations can be addressed by incorporating other software-development techniques and practices into agile development environments.

«UML»’99 — The Unified Modeling Language

The Web and its related technologies have made possible new means of access to and visualization of information. As such, it has shaped the structure of systems in many domains, from enterprise, mission critical e-business to distributed, embedded systems. Although experience with developing and deploying quality systems for the Web, by the Web and to the Web is a fairly recent activity, it appears that there are a relatively small number of canonical architectures that work. It is possible and desirable to codify those architectural patterns in order to offer a vehicle for controlling the development of a Web system over its lifetime, and to accelerate the development of new Web systems. The UML is well suited to representing these architectural patterns. In this presentation, we will examine the nature of Web-centric systems, and will study the common architectural patterns that apply. We will also examine the dozen or so underlying mechanisms upon which these architectures build, and show how both these architectural patterns and design patterns can be represented in the UML. We will conclude by addressing how these representations can be used in the lifecycle, supporting the notions of executable architectures and round trip engineering.

MontiCore: a framework for compositional development of domain specific languages

Domain specific languages (DSLs) are increasingly used today. Coping with complex language definitions, evolving them in a structured way, and ensuring their error freeness are the main challenges of DSL design and implementation. The use of modular language definitions and composition operators are therefore inevitable in the independent development of language components. In this article, we discuss these arising issues by describing a framework for the compositional development of textual DSLs and their supporting tools. We use a redundance-free definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. For enhancing the usability of the abstract syntax, we added concepts like associations and inheritance to a grammar-based definition in order to build up arbitrary graphs (as known from metamodeling). Two modularity concepts, grammar inheritance and embedding, are discussed. They permit compositional language definition and thus simplify the extension of languages based on already existing ones. We demonstrate that compositional engineering of new languages is a useful concept when project-individual DSLs with appropriate tool support are defined.

Towards a formalization of the Unified Modeling Language

The Unified Modeling Language UML is a language for specifying, visualizing and documenting object-oriented systems. UML combines the concepts of OOA/OOD, OMT and OOSE and is intended as a standard in the domain of object-oriented analysis and design. Due to the missing formal, mathematical foundation of UML the syntax and the semantics of a number of UML constructs are not precisely defined. This paper outlines a proposal for the formal foundation of UML that is based on a mathematical system model.

Behavioral Specifications of Businesses and Systems

Preface. 1. Object-oriented transformation K. Baclawski, et al. 2. Being served: The purposes, strengths and limitations of formal service modelling B. Cohen. 3. What vs. how of visual modelling: The arrow-diagram logic of visual modelling Z. Diskin, et al. 4. Meta-modelling semantics of UML A. Evans, et al. 5. Combining JSD and Cleanroom for object-oriented scenario specification M. Frappier, R. St-Denis. 6. What is behind UML-RT R. Grosu, et al. 7. Applying ISO RM-ODP in the specification of CORBA(R) interfaces and semantics to general ledger systems J. Hassall, J. Eaton. 8. Component-based algebraic specifications S. Iida, et al. 9. A meta-model semantics for structural constraints in UML S. Kent, et al. 10. On the structure of convincing specifications H. Kilov, A. Ash. 11. Formalising the UML in structured temporal theories K. Lano, J. Bicarregui. 12. JML: A notation for detailed design G. Leavens, et al. 13. Agents: Between order and chaos J. Odell. 14. UML, the future standard software architecture description language? A. Schurr, A. Winter. 15. Using information modelling to define business requirements M. Shafer. 16. A layered context perspective on enterprises and information systems I. Simmonds, D. Ing. 17. 30 Things that go wrong in object-oriented modelling with UML 1.3 A. Simons, I. Graham. 18. Formalizing association semantics in terminologies H.Solbrig.19. On the specification of the business and economic foundations of electronic commerce A. Thalassinidis, I. Sack. 20. Embedding object-oriented design in system engineering R. Wieringa. Index.

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.

Developing the UML as a Formal Modelling Notation.

The Unified Modeling Language (UML) is rapidly emerging as a de-facto standard for modelling OO systems. Given this role, it is imperative that the UML needs a well-defined, fully explored semantics. Such semantics is required in order to ensure that UML concepts are precisely stated and defined. In this paper we motivate an approach to formalizing UML in which formal specification techniques are used to gain insight into the semantics of UML notations and diagrams and describe a roadmap for this approach. The authors initiated the Precise UML (PUML) group in order to develop a precise semantic model for UML diagrams. The semantic model is to be used as the basis for a set of diagrammatical transformation rules, which enable formal deductions to be made about UML diagrams. A small example shows how these rules can be used to verify whether one class diagram is a valid deduction of another. Because these rules are presented at the diagrammatical level, it will be argued that UML can be successfully used as a formal modelling tool without the notational complexities that are commonly found in textual specification techniques.