Introduction

The object-oriented software development industry has gone through the process of standardizing visual modeling notations. The Unified Modeling Language (UML), a modeling 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 to teach the students 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. 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.

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.

Specific Objectives

At the end of the course, the student should be capable of:

1. •Describing particularities of object-oriented development approaches
   

2. •Applying the Fondue object-oriented development method, e.g.:
   

3. •Discover the needs of the user
   

4. •Analyse what features the software must provide
   

5. •Design a solution for those needs
   

6. •Methodically develop a piece of software that is feasible (within the constraints of resources) and satisfactory (in respect to the requirements)
   

7. •Documenting analysis and design decisions using UML (class diagrams, object-interaction diagrams and state diagrams) and OCL
   

Last modified: January 17, 2013, Jörg Kienzle