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.

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.

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.

References:

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, http://www.rational.com/uml.
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

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.

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.

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.

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

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.

This tutorial is cancelled - Ce tutoriel est annulé

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.

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.

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

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.

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+.

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.

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.

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:

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.

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.)

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.