TOOLS Europe'2000
June, 5-8, 2000
Mont St Michel & St Malo, France,
5-8 juin 2000

List of tutorials - Liste des tutoriels

WARNING :The tutorial of A. ARSANJANI initially planned on Thursday morning is cancelled and the tutorials of J BOSCH (T2-T5) initially planned on Tuesday are shifted on Thursday morning (J2). The current program takes into account these modifications.

ATTENTION : Le tutoriel de A. ARSANJANI initialement prévu le jeudi matin est annulé et les tutoriels de J. BOSCH (T2-T5) initialement prévus le mardi sont décalés au jeudi matin (J2). Le programme actuel tient compte de ces modifications.


Monday, June 5, 2000
9:15 - 12:30
Lundi 5 juin 2000

Tutorial M1
An Introduction to the Object Constraint Language (OCL)
Anneke Kleppe - Jos Warmer
( Klasse Objecten, The Netherlands)

Visual modeling languages are appealing because "a picture tells more than a thousand words". The UML is such a visual language and is well known for its graphical notation and diagramming techniques. However, pictures often only tell half of the story and additional information needs to be captured in a different way. For this reason the UML includes the Object Constraint Language (OCL), a textual language which allows a UML modeler to specify these additional constraints.

This tutorial shows the importance of constraints as an object-oriented modeling technique and how they add value to the visual modeling techniques and help "telling the complete story". The OCL language itself and the connection with the visual UML diagrams is thoroughly explained. The final part of the tutorial will show how one can achieve a good balance between the visual and constraint modeling in UML.

Tutorial M2
Introduction to Concurrent Object-Oriented Programming in Java
David Holmes
(DSTC Pty. Ltd., The University of Queensland, Australia)
Doug Lea
(Macquarie University, State University of New York at Oswego Oswego, USA)

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java's support of concurrency has enticed many to try their hand at concurrent applications. However concurrent programming poses many traps for the unwary.
This tutorial demonstrates various design patterns and techniques for constructing concurrent applications in Java and for managing that concurrency. On the language side we look at Java's mechanisms to support concurrent programming.
On the design side we look at object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems.

Tutorial M3
Object-oriented modelling with events
Snoeck Monique - Dedene Guido
(Katholieke Universiteit Leuven, Belgium)

OO models and patterns Events are a fundamental part of the structure of experience [3]. Events are atomic units of action: they represent things that happen in the world. Without events nothing would happen: they are the way information and objects come into existence (creating events), the way information and objects are modified (modifying events) and disappear from our universe of discourse (ending events).

As a result, also in object-oriented modelling, events have an essential role to play. Some object-oriented development methods already have identified events as a fundamental component of an object-oriented real-world model. This is, for example, the case for Syntropy [3], OO-SSADM [7] and MERODE [9, 10].

Although in the object-oriented paradigm objects play the central role, putting events forward is not in contradiction with current object-oriented practice. Indeed, most object-oriented methods use a state and transition-based formalism to specify behaviour such as finite state machines or statecharts [1, 2, 4, 5, 6, 8]. In such formalisms the different states of an object are taken as starting point and the transitions describe how objects can go from one state to another. The triggers of these transitions are events.

In this tutorial, we will focus on event modelling as an essential element in object-oriented analysis and design. First we will elaborate on business events, what they are, how business event modelling can effectively be integrated with existing object-oriented modelling techniques and how business events can allow for a first level of integrity checking on an object-oriented conceptual model. We will then move on to information system events. By means of a number of examples, we will show how they are linked to business events and how they can play a role in information system design. Finally, we will move on to implementation questions and discuss possible implementation patterns, generic architectures for dealing with events and possible event handling patterns.

The tutorial will be conducted around a few case-studies, one of which is an existing application. We will alternate between presentation of theoretical concepts, modelling exercises in small groups and discussion of the alternative solutions.


1. Booch G., Object Oriented Analysis and Design with Applications, Second Edition, Benjamin/Cummings, Redwood City, CA, 1994.
2. Coleman D., Arnold P., Bodoff S., Dollin C., Gilchrist H., Hayes F., Jeremaes P., Object-Oriented Development, The FUSION Method, Prentice Hall, Englewood Cliffs, N.J., 1994.
3. Cook Steve, Daniels John, Designing object systems: object-oriented modelling with Syntropy, Prentice Hall, 1994
4. Harel David, On visual formalisms, Communications of the ACM, Volume 31, Number 5, May 1988, pp. 514-530.
5. Jacobson Ivar et al., Object-Oriented Software Engineering, A Use Case Driven Approach, Addison-Wesley, 1992.
6. Rational Software Corporation, The Unified Modeling Language, Version 1.1, 1 September 1997,
7. Robinson Keith, Berrisford Graham, Object-oriented SSADM, Prentice Hall, 1994
8. Rumbaugh J., Blaha M., Premerlani W., Eddy F., Lorensen W., Object Oriented Modelling and Design, Prentice Hall International, 1991.
9. Snoeck M., Dedene G. Existence Dependency: The key to semantic integrity between structural and behavioural aspects of object types, IEEE Transactions on Software Engineering , Vol. 24, No. 24, April 1998, pp.233-251
10. Snoeck M., Dedene G., Verhelst M; Depuydt A.M., Object-oriented Enterprise Modelling with MERODE, Leuven University Press, 1999

Monday, June 5, 2000
14:00 - 17:30
Lundi 5 juin 2000

Tutorial M4
Programming with agents: combining O-O and functional techniques
Bertrand Meyer
(Interactive Software Engineering, USA)

The introduction into an object-oriented framework such as Eiffel of "agents", a higher-level functional abstraction, brings a whole new set of expressive possibilities. This tutorial will explain how to use agents in the best possible way and detail their application to a wide range of areas including: graphical programming; error handling; writing extensive contract specifications; numerical programming; iterators.

Bio: Bertrand Meyer has been involved with object-oriented development for a long time.

Tutorial M5
Designing Concurrent Object-Oriented Programs in Java

David Holmes
(DSTC Pty. Ltd., The University of Queensland, Australia)
Doug Lea
(Macquarie University, State University of New York at Oswego Oswego, USA)

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java's support of concurrency has enticed many to try their hand at concurrent applications. Effectively creating and managing concurrency within an application poses many design choices and trade-offs.
This tutorial looks at more advanced issues in designing concurrent applications. It describes mechanisms for introducing concurrency into applications (threads, message- passing, asynchronous calls) and different models for application architectures, such as data-flow and event- driven designs. The tutorial also shows how concurrency controls can be abstracted into reusable support classes, and finally discusses how concurrent components and applications should be documented.

Tutorial M6
GOF Pursuit --- Learning Patterns by Playing
James Noble (Victoria University of Wellington, New Zealand)
Charles Weir (CWC Limited, England)

Design patterns allow us to learn software design from the experience of others. Unfortunately patterns are difficult to learn using conventional techniques, so many designers have only a partial or incorrect understanding of the patterns available.

This tutorial is based around GOF Pursuit, a game based loosely on 'Trivial Pursuit'. This game is effective in helping practitioners learn the patterns in the "Design Patterns" book by the so-called 'Gang of Four' (Gamma, Helm, Johnson and Vlissides). This tutorial will be a hands-on-workshop to help participants learn and re-learn patterns, to teach participants how to organize GOF Pursuit games and to be fun at the same time.

Tuesday, June 6, 2000
9:15 - 12:30
Mardi 6 juin 2000

Tutorial T1
Adding value to the Unified Process
Richard Mitchell
(InferData Corporation, USA)

Both the Unified Modeling Language and the Unified Process are quite loosely defined. Guidelines that constrain the language and the process in very practical ways can make the process much more effective. This tutorial proposes a coherent body of such guidelines.

Audience The tutorial is intended for developers and managers who are considering adopting Rational's Unified Process for use with the Unified Modeling Language. The tutorial will assume an elementary knowledge of object-oriented concepts and their use in OO modeling.

Issues the tutorial will concentrate on

  • The UP is “use-case driven.” Generalise this to “behaviour driven.” For example, events can be more helpful than use cases when modelling a domain with no business or system boundaries .
  • The UP is “architecture-centric.” Distinguish the many kinds of architecture needed (technically-oriented, subject-based, logical, physical, etc.).
  • Raise the status of domain, or business, models. A model of the key types in a domain can provide a single vocabulary for other models.
  • Separate the content of a model from its time of construction. For example, making a design decision early in a project does not turn it into an analysis issue, as the UP implicitly suggests.
  • Distinguish adding detail in order to increase precision from adding detail in order to support refinement. For example, avoid premature design of behaviour by describing use cases with informal preconditions and postconditions rather than with sequences of actions.
  • Individual models are projections of a single, underlying model, and can sometimes be combined to good effect. For example, you can get the benefits of a sequence diagram and a collaboration diagram by overlaying the diagrams.
  • Define the UML carefully enough to support cross-checking between diagrams. For example, check that states are distinguishable on type models. (The tutorial will offer a list of more than 20 cross-checks.)
  • Work with example-level models as well as general-level models. For example, use snapshots to uncover subtleties of type models.
  • Define maturity tests on models. For example, ascertain whether certain cross-checks have been performed, and determine whether key example-level models are supported by the general-level models.

This list does not define a new process. Rather, it reduces the number of interpretations of the Unified Process.

The list is not comprehensive. For example, we could add support for project-management through time-boxing of development activities, or support for high levels of precision through the use of OCL. Or we could focus more on modelling support, through such topics as design patterns. Our particular selection focuses on process issues, and reflects what we have found in practice adds considerable value to many kinds of projects with only a small investment in learning.

By design, the elements in the selection work together to form a coherent whole. For example, it is easier to avoid premature design of behaviour when you have an architectural model that shows where such design choices belong.

Tutorial T2
Design and Implementation of Business Rules in Object-oriented Applications
Ali Arsanjani

This tutorial is cancelled - Ce tutoriel est annulé

Tutorial T3
Java Design Traps and Pitfalls
Todd Lauinger

Most software developers think a thorough knowledge of the Java programming language and its numerous APIs is the key to developing good Java software. This is often done at the expense of understanding and applying solid object technique. Participants in this tutorial will discuss the most common object design mistakes I have seen in working with over 200 designers in the past seven years. We will analyze the source of the mistakes, understand object principles so you do not make these mistakes, and apply the newly understood principles to an example problem.

Tuesday, June 6, 2000
14:00 - 17:15
Mardi 6 juin 2000

Tutorial T4
Beyond RUP
Brian Henderson-Sellers
(University of Technology, Sydney, Australia)

The increased complexity associated with large-scale software development requires an increase in the sophistication of the methodology utilized. The third generation method/process RUP is evaluated and recast to remove its deficiences. The result is the Object-oriented Process, Environment and Notation or OPEN method/process, a public domain, third-generation approach, which is then outlined.
Object technology is a growing approach for the development of quality software. It provides a sophisticated environment to support good software engineering practice. Use of object technology should not be restricted to languages but should encompass full lifecycle support by use of an object-oriented (OO) development methodology or process. Integrated process-focussed OO approaches to software development, whilst vital to successful project management, have not been a strong feature of extant approaches popularly practised. RUP and OPEN have been developed independently primarily to address these issues.

Tutorial T6
Aspect-Oriented Programming
Cristina Videira Lopes - Gregor Kiczales
(Xerox PARC, Pola Alto, USA)

All software developers have been faced with situations where one aspect of their design spread itself across the code, rather than being localized in a dedicated object. As a result, they end up with an OO version of spaghetti code.

This talk presents a new kind of solution to this problem -- aspect-oriented programming. Like objects, aspects are intended to be used in both design and implementation. During design, the concept of aspect facilitates thinking about cross-cutting concerns as well-defined entities. During implementation, aspect-oriented programming languages - namely AspectJ(tm) - make it possible to program directly in terms of design aspects.

Several examples of aspects will be presented, including aspects for tracing, contracts, feature addition/deletion, distribution support and error handling

Wednesday, June 7, 2000
9:15 - 12:30
Mercredi 7 juin 2000

Tutorial W1
Framework development and adaptation with UML
Marcus Fontoura (Princeton University, USA) - Wolfgang Pree (University of Constance, Germany) - Bernhard Rumpe (Munich University of Technology, Germany)

Object-oriented frameworks and product line architectures have become popular in the software industry during the 1990s. A vast number of frameworks has been developed in the industry for various domains, including graphical user interfaces (e.g. Java's Swing, Microsoft's MFC), graph-based editors (HotDraw, Stingray's Objective Views), business applications (IBM's San Francisco), electronic commerce (Sun/IBM), network servers (Java's Jeeves), just to mention few. When combined with components, frameworks provide the most promising current technology supporting large-scale reuse.

A framework is a collection of several fully or partially implemented components with predefined cooperation patterns between them. A framework implements the software architecture for a family of applications, to be specialized by application-specific code. Hence, some of these components are designed to be replaceable (variation points). Applications built on top of a framework not only reuse its source code but architecture design, which we consider as the most important characteristic of frameworks. Besides the fact that reuse of architecture design amounts to a standardization of the application structure, frameworks offer an additional important advantage. Framework-based software development implies a significant reduction in the size of the source code that has to be written by the programmer who adapts a framework.

The bad news is that framework development requires an extra effort. The costs are higher compared to the development of a specific application. Today proper techniques for describing frameworks, especially the points where application developers need to adapt the framework, are not elaborated. Furthermore, tools and methods assisting in both framework development and adaptation are almost non-existent or in their infancy.

The recent standardization efforts of the Unified Modeling Language (UML) provide a unique chance to harness UML as notational basis for framework development projects. However, UML does not provide adequate constructs to model frameworks. There is no indication in UML design diagrams what are the variation points and how they need to be instantiated.

This tutorial shows how to explicitly model framework variation points in UML using static and dynamic description diagrams to capture allowed structure and semantics of the variation points. A new member of the UML language family is proposed, including a few extensions to assist framework development and adaptation. The new extensions have been defined mainly by applying the UML extensibility mechanisms: stereotypes, tagged values, and constraints. A case study in the e-commerce domain will be presented to illustrate the approach in a real-world framework development scenario.

Tutorial W2
Component-Based Design: A Complete Worked Example
John Daniels
(Consultant, Syntropy Limited, UK)

Much has been written about component-based design but most books and articles deal in generalisations and possibilities, rather than providing explicit and clear guidance. This tutorial will follow a small case study through from requirements capture to code-ready specifications, and will set out the full client and server architectures needed to make it work. The modeling and specificiation techniques used will follow the UML, with the target technologies being EJB or COM+.

Tutorial W3
Smaller Software: Patterns for Objects in Limited Memory
James Noble (Victoria University of Wellington, New Zealand)
Charles Weir (CWC Limited, Cumbria, England)

Typical object-oriented development techniques assume target systems have relatively large amounts of RAM available to the user. Developers working with tight memory requirements also need the flexibility and encapsulation which OO can provide, but cannot afford to produce systems with large memory requirements. This tutorial will describe how you can use OO techniques in a memory-constrained environment. Using an approach based on design patterns and practical examples, this tutorial will explore some of the most important techniques that successful designers use in object oriented systems for small memory machines.

This tutorial will help participants manage object oriented development in limited-memory environments. The tutorial will present specialized design patterns, including patterns for preparing and managing memory budgets, designing and allocating object structures, transparently exploiting auxiliary storage, and tailoring user interfaces for small machines. The patterns will be illustrated with case studies to provide experience for the participants in designing their own solutions.

Wednesday, June 7, 2000
14:00 - 17:15
Mercredi 7 juin 2000

Tutorial W4
Coherent Enterprise Modeling
Alan Cameron Wills
(TriReme International Ltd, UK)

Requirements capture is about getting as accurate a picture as possible of what the users want, before investing overmuch effort in design. Despite RAD techniques, there can still be a substantial delay between requirement and first delivery; and despite joint application development, it's still possible for substantial questions about exactly what the software should do to turn up unpleasantly late in the development process.

This tutorial will explore techniques for exposing gaps and inconsistencies in requirements models, using high-precision UML to throw up important questions about requirements, that might otherwise have been glossed over or understood differently by all concerned.

Many texts on UML say little about how the different diagrams should cohere with each other. In this tutorial, we will exercise a requirements analysis cycle in which cross-checks between the different parts of a model tell you when your requirements are consistent and inclusive.

This process, developed as part of the Catalysis method, has proved very effective in a variety of fields.

Tutorial W5
Enterprise JavaBeans (EJB): New Opportunities for Component-Based
Development of Web-Based Enterprise Solutions
Gilda Pour
(San Jose State University, USA)

Component-based software development (CBSD) delivers the promise of large-scale software reuse. CBSD has the potential to reduce significantly the cost and time-to-market of enterprise systems, and enhance the reliability, maintainability, and quality of enterprise systems.

Enterprise JavaBeans (EJB) provides a fully-scalable, distributed, and platform-independent component architecture for development of enterprise software systems while leveraging existing applications. EJB specification provides a server component environment that monitors and modifies the client-server communications to ensure the use of correct thread, security, transaction, and persistence semantics. This will allow software developers to focus on the application logic and configuration.

The list of major topics to be covered in this tutorial includes:

  • Component-Based Enterprise Software Development
  • An Overview of Java 2 Enterprise Edition (J2EE)
  • Enterprise JavaBeans (EJB) Architecture
  • Key Features of EJB
  • EJB versus MTS and the OMG CORBA Components
  • Session and Entity Beans
  • Developing Server-Side Enterprise Components Using EJB
  • Integrating EJB and Jini for Component-Based Development of Web-based Enterprise Solutions
  • Useful Resources

Thursday, June 8, 2000
9:15 - 12:30
Jeudi 8 juin 2000

Tutorial J1
Advanced Visual Modelling: Beyond UML
Joseph Gil (SSDL, Technion - Israel Institute of Technology, Haifa, Israël)
John Howse
(University of Brighton, UK)
Stuart Kent (The University of Kent, Canterbury, UK)

With the adoption of UML by the OMG and industry as the linguae-francae of visual systems modelling, one begins to ponder what will come next in this field? This tutorial brings a vision for visual modelling beyond UML. We present and consolidate radical new notations, proposed in a series of research papers and with quickly increasing adoption by industry, for the specification of complex systems in an intuitive visual, yet precise manner. The recurring theme of these notations is the upgrading of familiar, grammar school diagrams into a powerful visual language. ``Spider diagrams'' considerably extend Venn-diagrams to the specification of OO-systems. Most familiar OO-concepts are being translated to set theoretical terms: class into set of objects, inheritance corresponding to subset, and even Harel's statecharts interpreted as the set of objects in that state. "Constraint diagrams" enhance the arrow notation to describe static system invariants, such as "the enemy of my enemy is my friend", which cannot be described by UML class-object diagram. Finally, "3D-diagrams" show how the third dimension and VRML modelling can be used for a conceptual modelling of dynamic system behaviour. Much of the tutorial will be based on a case study developed in industry, illustrating how the new notations are combined with those of UML, including OCL.

The tutorial will start with a crash critical overview in UML, stressing its weaknesses and strengths. Based on this we present the rich visual constraint language and an insight into subtle issues that arise when defining a visual language, for applying the popular design-by-contract using a visual formalism. The presentation will use a case study and a demonstration of a graphical editor for the constraint-diagrams language. We then will show how the language can extended into three dimensions, in a series of 3D notations for providing rich visualisations of dynamic behaviour. We finally give the vision for visual modelling tools of the future.

Tutorial J2
Software Architecture
Jan Bosch
(University of Karlskrona/Ronneby, Sweden)

This tutorial presents a method for architectural design explicitly focussing on assessment of and transformation for quality attributes. It is based on a forthcoming book (tentative publication date: early June 2000) authored by the presenter and published by Addison-Wesley.

(The tutorial on Software Product Lines is companion to this.)

Tutorial J3
The What, Why and How of the UML Collaboration
Trygve Reenskaug
(Numerica Taskon, Oslo, Norway)

The UML Collaboration is a powerful tool for modeling system behavior. We use it for many purposes ranging from enterprise modeling and designing distributed systems architectures right down to shaping the details of object oriented programs. We will focus on the practical application of the Collaboration and illustrate how it helps us create simple solutions to complex problems through separation of concern.

Material covered will be the interaction diagrams, sequence diagrams, interfaces and the relationships between use cases, collaborations, roles, objects and classes. They will all be critically discussed against a background of appropriate examples. Most of the presentation will be based on UML version 1.3, but it will be colored by the ongoing work with version 1.4.