Introduction

Model-Driven Engineering (MDE) is a unified conceptual framework in which the whole software life cycle is seen as a process of model production, refinement and integration. Models are built representing different views of a software system using different formalisms, i.e. modelling languages. The formalism is chosen in such a way that the model concisely expresses the properties of the system that are important at the current level of abstraction. During development, high-level specification models are refined or combined with other models to include more solution details, such as the chosen architecture, data structures, algorithms, and finally even platform and execution environment-specific properties. The manipulation of models is achieved by means of model transformations. Model refinement and integration continues until a model is produced that can be executed. This model can take the form of source code, but does not need to.

The object-oriented software development industry has gone through the process of standardizing visual modelling notations. The Unified Modelling Language (UML), a modelling language for specifying, visualizing, constructing, and documenting, is the product of this effort; it unifies the notations that currently exist in the industry. Therefore, every computer scientist, and especially every software engineer should have had contact with UML during his or her studies. Using UML notations has many benefits, including:

1. •It offers a common language uniting different object-oriented software development methodologies in terms of notation and vocabulary.
   

2. •It provides a rich set of notations that can be used to describe many different aspects of the software under development, including complex concurrency and distribution.
   

3. •It contains extension mechanisms and a constraint language called the Object Constraint Language (OCL). OCL is based on standard set-theory and is free of side-effects. It can be used to place additional constraints on models and describe pre- and postconditions of operations.
   

4. •UML provides a semantic base in the form of a metamodel that defines well formed models, and possible relationships between models and model elements.
   

5. •UML is a OMG standard.
   

6. •It allows tool interoperability between different vendors.
   

However, UML is only a language: it is process independent and therefore does not prescribe how and when during the software development cycle its notations should be used. Using UML to model software systems still requires a method - a choice of models and a process of their elaboration.

Course Content

The goal of this software engineering course is expose the students to model-driven engineering by teaching them a rigorous UML-based software development method. The emphasis of the course is on how to put the different pieces of the UML puzzle together, i.e. which UML notations are the most appropriate to model the system under development within each software development phase. It teaches the students how to choose a coherent subset of UML to produce complete and consistent analysis and design models, and in which order the different models should be produced, and how models from one development phase are used as input / transformed into models at the next development phase.

The course teaches Fondue, a UML extension of the second-generation object-oriented development method Fusion (Hewlett Packhard). Fondue uses a coherent subset of UML to establish complete and precise analysis and design documents for a software system. Fondue’s requirements engineering is based on use cases. The analysis phase establishes a Domain, a Concept, an Environment, a Protocol, and an Operation Model. During design, a Design Class Model, an Object Interaction Model, a Dependency Model and an Inheritance Model are constructed. Finally, Java-specific mapping strategies lead to the system implementation.

Most models use graphical UML notations (e.g. class diagrams, object-interaction diagrams, state diagrams). The course covers these UML notations in detail. In addition, a major part of the lectures present how to elaborate one model based on the others, and ensure completeness and consistency among the different views. When the graphical notations are not strong (or “formal”) enough to produce a precise model, the models are augmented using the Object Constraint Language (OCL). OCL is a formal, set-theory based language that allows software engineers to augment UML models with additional constraints, or state preconditions, postconditions and invariants of operations in a precise way.

Finally, since model-driven engineering advocates to use the most appropriate modelling formalism(s) at each development phase to express the concerns at hand, this course also exposes the students to more advanced modelling notations. In particular, I am planning to introduce this year alternative modelling notations for requirements elicitation and analysis, in particular URN and AoURN (the User Requirements Notation and its aspect-oriented extension), and an aspect-oriented software design notation called Reusable Aspect Models.

Last modified: November 23, 2015, Jörg Kienzle