≪UML≫ 2001 — The Unified Modeling Language. Modeling Languages, Concepts, and Tools

In the Dune novels, Paul Atreides fights a battle for survival against nefarious forces and succeeds in uniting the Universe under his control. Eventually, however, a bureaucratic and militaristic religion grows up around his legend. Disillusioned by the atrocities committed in his name, Paul abandons his throne and returns in disguise as the mysterious Preacher at Arrakeen to denounce the bureaucracy, fanaticism, and tyranny of his out-of-control followers. Sometimes that’s how I feel about UML. This talk (sermon?) will denounce the excesses of the UML cult and see if it can be saved from its friends.

This paper describes an action semantics for UML based on the Meta-Modelling Language (MML) - a precise meta-modelling language designed for developing families of UML languages. Actions are defined as computational procedures with side-effects. The action semantics are described in the MML style, with model, instance and semantic packages. Different actions are described as specializations of the basic action in their own package. The aim is to show that by using a Catalysis like package extension mechanism, with precise mappings to a simple semantic domain, a well-structured and extensible model for an action language can be obtained.

As the UMLattempts to make the transition from a single, albeit extensible, language to a framework for a family of languages, the nature and form of the underlying meta-modeling architecture will assume growing importance. It is generally recognized that without a simple, clean and intuitive theory of how metamodel levels are created and related to one another, the UML2.0 vision of a coherent family of languages with a common core set of concepts will remain elusive. However, no entirely satisfactory metamodeling approach has yet been found. Current (meta-)modeling theories used or proposed for the UML all have at least one fundamental problem that makes them unsuitable in their present form. In this paper we bring these problems into focus, and present some fundamental principles for overcoming them. We believe that these principles need to be embodied within the metamodeling framework ultimately adopted for the UML2.0 standard.

The Meta-Modeling Language is a static object-oriented modeling language whose focus is the declarative definition of languages. It aims to enable the UML metamodel to be precisely defined, and to enable UML to evolve into a family of languages. This paper argues that although MML takes a metamodeling approach to language definition, it cannot be described as strict metamodeling. This has significant implications for the nature of the metamodel architecture it supports, yet without contravening the OMG’s requirements for the UML 2.0 infrastructure. In particular it supports a rich generic nested architecture as opposed to the linear architecture that strict metamodeling imposes. In this nested architecture, the transformation of any model between its representations at two adjacent metalevels can be described by an information preserving one-to-one mapping. This mapping, which can itself be defined in UML, provides the basis for a powerful area of functionality that any potential metamodeling tool should seek to exploit.

We present a real-time execution semantics for UML activity graphs that is intended for workflow modelling. The semantics is defined in terms of execution algorithms that define how components of a workflow system execute an activity graph. The semantics stays close to the semantics of UML state machines, but differs from it in some minor points. Our semantics deals with real time. The semantics provides a basis for verification of UML activity graphs, for example using model checking, and also for executing UML activity graphs using simulation tools. We illustrate an execution by means of a small example.

UML activity diagrams can be used for modeling the dynamic aspects of systems and for constructing executable systems through forward and reverse engineering. They are very suitable for describing the model of program behaviour. In this paper, we extend UML activity diagrams by introducing timing constraints so that they can be used to model real-time software systems, and give the solution for timing analysis of UML activity diagrams. We give the solution for timing analysis of simple UML activity diagrams (containing no loop) by linear programming, and present an algorithm for checking UML activity diagrams using integer time verification techniques. This work forms a base for verification of real-time software systems.

If UML activity diagrams are to succeed as a standard in the area of organisational process modeling, they need to compare well to alternative languages such as those provided by commercial Workflow Management Systems. This paper examines the expressiveness and the adequacy of activity diagrams for workflow specification, by systematically evaluating their ability to capture a collection of workflow patterns. This analysis provides insights into the relative strengths and weaknesses of activity diagrams. In particular, it is shown that, given an appropriate clarification of their semantics, activity diagrams are able to capture situations arising in practice, which cannot be captured by most commercial Workflow Management Systems. On the other hand, the study shows that activity diagrams fail to capture some useful situations, thereby suggesting directions for improvement.

UML is the de-facto standard language for Object-Oriented analysis and design of information systems. Persistent storage and extraction of data in such systems is supported by databases and query languages. UML sustains many aspects of software engineering; however, it does not provide explicit facility for writing queries. It is crucial for any such query language to have, at least, the expressive power of Relational Algebra, which serves as a benchmark for evaluating its expressiveness. The combination of UML and OCL can form queries with the required expressive power. However, certain extensions to OCL are essential if it is to be used effectively as a Query Language. The adoption of the ideas presented in this paper will enable query expressions to be written using OCL, that are elegant and ideally suited for use in conjunction with UML data models. This technique is illustrated by expressing the UML equivalent of an example Relational data model and associated query expressions.

Business rules are often specified only implicitly by applications to express user-defined constraints. OCL provides the chance to explicitly and automatically deal with business rules when building object-oriented applications. We investigate how OCL constraints can be handled in database applications as one of the most important kind of business applications. Based on our OCL toolset prototype and earlier research work we particularly experiment with various strategies for the evaluation of OCL constraints in object-oriented applications which use relational databases. For this work, a flexible SQL code generator is needed which can be used and adapted for different relational database systems and different object-to-table mappings. We implement such a database tool as an additional module for our OCL toolset using XML techniques.

The OCL 1.4 specification introduces let-declarations for adding auxiliary class features in static structures of the UML. We provide a type inference system and a big-step operational semantics for the OCL 1.4 that treat UML static structures and UML object models abstractly and accommodate for additional declarations; the operational semantics satisfies a subject reduction property with respect to the type inference system. We also discuss an alternative, non-operational interpretation of let-declarations as constraints.

Software developers spend most of their time modifying and maintaining existing products. This is because systems, and consequently their design, are in perpetual evolution before they die. Nevertheless, dealing with this evolution is a complex task. Before evolving a system, structural modifications are often required. The goal of this kind of modification is to make certain elements more extensible, permitting the addition of new features. However, designers are seldom able to evaluate the impact, on the whole model, of a single modification. That is, they cannot precisely verify if a change modifies the behavior of the modeled system. A possible solution for this problem is to provide designers with a set of basic transformations, which can ensure behavior preservation. These transformations, also known as refactorings, can then be used, step by step, to improve the design of the system. In this paper we present a set of refactorings and explain how they can be designed so as to preserve the behavior of a UML model. Some of these refactorings are illustrated with examples.

Much of the research work on design patterns has primarily focused on discovering and documenting patterns. Design patterns promise early reuse benefits at the design stage. To reap the benefits of deploying these proven design solutions, we need to develop techniques to construct applications using patterns. These techniques should define a composition mechanism by which patterns can be integrated and deployed in the design of software applications. Versatile design models should be used to model the patterns themselves as well as their composition. In this paper, we describe an approach called Pattern- Oriented Analysis and Design (POAD) that utilizes UML modeling capabilities to compose design patterns at various levels of abstractions. In POAD, the internal details of the pattern structure are hidden at high design levels (pattern views) and are revealed at lower design levels (class views). We define three hierarchical traceable logical views based on UML models for developing pattern- oriented designs; namely the Pattern-Level view, the Pattern Interfaces view, and the Detailed Pattern-Level view. The discussion is illustrated by a case study of building a framework for feedback control systems.

We describe ConcernBASE, a UML-based approach that is an instantiation of the IEEE’s Conceptual Framework (Std 1471) for describing software architectures. We show how the approach supports advanced separation of concerns in software architecture by allowing one to identify and define multiple viewpoints, concern spaces and views of an architecture. Our work focuses on integrating the ConcernBASE approach with the Structural Architecture Description Language (SADL) in order to make the verification capabilities of SADL available to those who develop in UML. The result is a UML profile for structural description of software architecture. The paper also presents a prototype tool that supports this UML profile.

The message paradigm is one of the most specific concepts of object orientation. This paradigm works well as long as one object is involved. When more than one object is involved, a choice has to be made with which type the message will be associated. In our opinion, this choice has to be postponed during object-oriented analysis. We propose to extend the concept of the message paradigm to messages with more than one implicit argument. Postponing the choice results in one model for one reality. Another problem rises when no object is involved. In our opinion this issue can best be tackled by introducing a domain layer and a functionality layer.

System testing is concerned with testing an entire system based on its specifications. In the context of object-oriented, UML development, this means that system test requirements are derived from UML analysis artifacts such as use cases, their corresponding sequence and collaboration diagrams, class diagrams, and possibly the use of the Object Constraint Language across all these artifacts. Our goal is to support the derivation of test requirements, which will be transformed into test cases, test oracles, and test drivers once we have detailed design information.Another important issue we address is the one of testability. Testability requirements (or rules) need to be imposed on UML artifacts so as to be able to support system testing efficiently. Those testability requirements result from a trade-off between analysis and design overhead and improved testability. The potential for automation is also an overriding concern all across our work as the ultimate goal is to fully support testing activities with high-capability tools.

Modern distributed software applications generally operate in complex and heterogeneous computing environments (like the World Wide Web). Different paradigms (client-server, mobility based, etc.) have been suggested and adopted to cope with the complexity of designing the software architecture of distributed applications for such environments, and deciding the “best” paradigm is a typical choice to be made in the very early software design phases. Several factors should drive this choice, one of them being the impact of the adopted paradigm on the application performance. Within this framework, the contribute of this paper is twofold: we suggest an extension of UML to best modeling the possible adoption of mobility-based paradigms in the software architecture of an application; we introduce a complete methodology that, starting from a software architecture described using this extended notation, generates a performance model (namely a Markov Reward or Decision Process) that allows the designer to evaluate the convenience of introducing logical mobility into a software application.

The most common way of designing databases is using de E/R model without taking into account other views of the system. However, new object-oriented design languages, such as UML (Unified Modelling Language), permit modelling the full system, including the database schema, in a uniform way. Besides, as UML is an extensible language, it allows introducing new stereotypes for specific applications if it is needed. There are some proposals to extend UML with stereotypes for database design but, unfortunately, they are focused on relational databases. However, new applications require representing complex objects related with complex relationships and object-relational databases are more appropriated to support the new application requirements. The framework of this paper is an Object- Relational Database Design Methodology. The methodology defines new UML stereotypes for Object-Relational Database Design and proposes some guidelines to translate an UML schema into an object-relational one. The guidelines are based on the SQL:1999 object-relational model and on Oracle8i as an example of product. In this paper we focus on the UML extensions required for object-relational database design.

UML is there — it’s accepted, it’s booming, and even more: it’s a standard. From telecom to train systems to avionics: using UML to capture the system is “in”. But do we really understand what we model?This talk takes for granted, that models are alive, are executable, are used to explore the design space, are used to communicate design decisions, and ultimately are evolving to target code. And it asks plenty of nasty questions about the meaning of all these diagrams, which are so intuitive, but which require clarification if viewed from the most rigorous possible perspective — that of a formal semantics.Formal Semantics are to modeling languages what X rays are to the human body: they bring to the surface problem spots not typically seen — and this process is painful. It shows, that what we see, is possibly far from what we expect: it highlights design decisions in giving a rigorous semantics to UML, which could have significant impact on e.g. meeting timeliness requirements.But it also shows the rewards derivable from this painful exercise: giving a rigorous semantics offers the floor for powerful analysis techniques allowing to boost the quality of models.

UML state machines are quite popular and useful to specify dynamic components of software systems. They have a formal static semantics but their execution semantics is described only informally. Graph transformation, on the other hand, constitutes a well-studied area with many theoretical results and practical application domains. In this paper, an operational semantics for a subset of UML state machines is proposed which is based on graph transformation. In more detail, a UML state machine is described as a structured graph transformation system in such a way that the wellformedness rules of UML state machines are satisfied and the firing of a (maximum) set of enabled non-conflicting transitions corresponds to the application of a graph transformation rule. The presented approach uses the concept of transformation units, a recently developed modularization concept for graph transformation systems.

We propose a visualization of OCL within the context of the UML meta model, so that OCL expressions are represented by extending collaboration diagrams. We exploit the OCL meta model introduced in [9] and further elaborated on in [1] and base the description of properties of objects on collaborations, while classifier and association roles are used to describe navigation paths. Operations computing properties are described by interactions consisting of messages between classifier roles. The introduction of new graphical core elements is kept to a minimum. New notation mainly concerns the predefined operations in OCL and provides more convenient visual forms for the notation by interactions here. The proposed visualization is described in detail and is illustrated with examples taken from an industrial project under development.

Object-oriented modeling favors the modeling of object behavior from different viewpoints and at different levels of abstraction. This gives rise to consistency problems between overlapping or semantically related submodels. The absence of a formal semantics for the UML and the numerous ways of employing the language within the development process lead to a number of different consistency notions. Therefore, general meta-level techniques are required for specifying, analyzing, and communicating consistency constraints. In this paper, we discuss the issue of consistency of behavioral models in the UML and present techniques for specifying and analyzing consistency. Using meta-model rules we transform elements of UML models into a semantic domain. Then, consistency constraints can by specified and validated using the language and the tools of the semantic domain. This general methodology is exemplified by the problem of protocol statechart inheritance.

UML solutions in competition on the real-time system market share three common drawbacks: an incomplete formal semantics, temporal operators with limited expression and analysis power, and implementation-oriented tools with limited verification capabilities. To overcome these limitations, the paper proposes a UML profile designed with real-time system validation in mind. Extended class diagrams with associations attributed by composition operators give an explicit semantics to associations between classes. Enhanced activity diagrams with a deterministic delay, a non deterministic delay and a timelimited offering make it possible to work with temporal intervals in lieu of timers with fixed duration. The UML profile is given a precise semantics via its translation into the Formal Description Technique RT-LOTOS. A RT-LOTOS validation tool generates simulation chronograms and reachability graphs for RT-LOTOS specifications derived from UML class and activity diagrams. A coffee machine serves as example. The proposed profile is under evaluation on a satellite-based software reconfiguration system.

Sequence Diagrams (SDs) have proven useful for describing transaction-oriented systems, and can form a basis for creating statecharts. However, distributed embedded systems require special support for branching, state information, and composing SDs. Actors must traverse many SDs when using a complex embedded system. Current techniques are insufficiently rich to represent the behavior of real systems, such as elevators, without augmentation, and cannot identify the correct SD to execute next from any given state of the system. We propose the application of formal language theory to ensure that SDs (which can be thought of as specifying a grammar) have sufficient information to create statecharts (which implement the automata that recognize that grammar). A promising approach for SD to statechart synthesis then involves ‘compiling’ SDs represented in an LL(1) grammar into statecharts, and permits us to bring the wealth of formal language and compiler theory to bear on this problem area.

In this paper it is shown how Sequence Diagrams can be used both for monitoring and testing functional and real-time requirements of an executable UML design. We show how this testing approach can be integrated in an UML-based development process. In addition, we will present how a prototype which implements the described monitoring and testing methods is integrated in a well known UML design tool.

The concept of multiplicity in UML derives from that of cardinality in entity-relationship modeling techniques. The UML documentation defines this concept but at the same time acknowledges some lack of obviousness in the specification of multiplicities for n-ary associations. This paper shows an ambiguity in the definition given by UML documentation and proposes a clarification to this definition, as well as a simple extension to the current notation to represent other multiplicity constraints, such as participation constraints, that are equally valuable in understanding n-ary associations.

There is rapidly growing momentum for web enabled agents that reason about and dynamically integrate the appropriate knowledge and services at run-time. The World Wide Web Consortium and the DARPA Agent Markup Language (DAML) program have been actively involved in furthering this trend. The dynamic integration of knowledge and services depends on the existence of explicit declarative semantic models (ontologies). DAML is an emerging language for specifying machine-readable ontologies on the web. DAML was designed to support tractable reasoning.We have been developing tools for developing ontologies in the Unified Modeling Language (UML) and generating DAML. This allows the many mature UML tools, models and expertise to be applied to knowledge representation systems, not only for visualizing complex ontologies but also for managing the ontology development process. Furthermore, UML has many features, such as profiles, global modularity and extension mechanisms that have yet to be considered in DAML.Our paper identifies the similarities and differences (with examples) between UML and DAML. To reconcile these differences, we propose a modest extension to the UML infrastructure for one of the most problematic differences. This is the DAML concept of property which is a first-class modeling element in DAML, while UML associations are not. For example, a DAML property can have more than one domain class. Our proposal is backward-compatible with existing UML models while enhancing its viability for ontology modeling.While we have focused on DAML in our research and development activities, the same issues apply to many of the knowledge representation languages. This is especially the case for semantic network and concept graph approaches to knowledge representations.

Associations between classifiers are among the most fundamental of UML concepts. However, there is considerable room for disagreement concerning what an association is, semantically. These have implications for the modeller because they can result in serious misunderstandings of static structure diagrams; similarly, they have implications for tool developers. In this paper we describe and classify the variants which have implicitly or explicitly been described. We discuss the scope for, and difficulties in, understanding these as specialisations of a more general notion and we address the implications for future versions of UML.

We describe formal steps in the design of iState, a tool for translating statecharts into programming languages. Currently iState generates code in either Pascal, Java, or the Abstract Machine Notation of the B method. The translation proceeds in several phases. The focus of this paper is the formal description of the intermediate representations, for which we use class diagrams together with their textual counterparts.We describe how the class diagrams are further refined. The notions of representable, normalized, and legal statecharts are introduced, where normalized statecharts appear as an intermediate representation and code is generated only for legal statecharts.

Despite advances in implementation technologies for distributed systems during the last few years, little attention has been given to distributed systems within software development methodologies. The contribution of this paper is a UML-based approach for specifying concurrent behavior and timing constraints— often inherent characteristics of distributed systems. We propose a novel approach for specifying concurrent behavior of reactive systems in OCL and several constructs for precisely describing timing constraints on UML state-machines.More precisely, we show how we enriched operation schemas—pre- and postcondition assertions of system operations written in OCL—by extending the current calculus with constructs for asserting synchronization on shared resources. Also, we describe how we use new and existing constructs for UML statemachines to specify timing constraints on the system interface protocol (SIP)—a restricted form of UML protocol statemachine. Finally, we discuss how both the extended system operation and SIP models are complementary.

The Unified Modeling Language (UML) has gained wide acceptance in very short time because of its variety of well-known and intuitive graphical notations. However, this comes at the prize of an unprecise and incomplete semantics definition. This insufficiency concerns single UML diagram notations on their own as well as their integration. In this paper, we focus on the notation of UML-Statecharts. Starting with a precise textual syntax definition, we develop quite a concise structured operational semantics (SOS) for UML-Statecharts based on labeled transition systems. Besides the support of interlevel transitions and in contrast to related work, our semantics definition supports characteristic UMLStatechart features like the history mechanism as well as entry and exit actions.

We describe a software development methodology called Tropos for agent-oriented software systems. The methodology adopts the i* modeling framework [29], which offers the notions of actor, goal and (actor) dependency, and uses these as a foundation to model early and late requirements, architectural and detailed design. The paper outlines the methodology, and shows how the concepts of Tropos can be accommodated within UML. In addition, we also adopt recent proposals for extensions of UML to support design specifications for agent software. Finally the paper compares Tropos to other research on agent-oriented software development.

We present an extension to the UML meta-model which allows modelling of contract aware components. Contracts are a novel way of describing the functional and non-functional behaviour of components. The usage of contracts in component diagrams allows tools to check whether all requirements for a successful assembly and deployment of the components are fulfilled. Furthermore, we investigate how components can be used in the different development phases and how design phase transitions can be managed.

The paper describes a model and tool support for a UMLbased specification approach, extending UML with templates for structured specifications deriving from the ISpec approach. The approach is component-oriented where the unit of description is an interface suite: a coherent collection of interfaces defining interactions that transcend component boundaries. To handle complexity, descriptions from various points of view are necessary, expressed by UML diagrams, templates, etc. The issue is to ensure that the views are consistent. For this, we provide a model to integrate the views. The model is sequence-based; the elements of the sequences are carefully designed tuples that reflect the interface suite approach. Abstractions from the model reflect the views. The model provides the underlying structure for tooling. We developed extensions to Rational Rose by customizing specifications, automating diagram generation and enabling some consistency checks.

Use cases are a powerful and widely recognised tool for functional requirements elicitation and specification of prospective software applications. However, there still are major problems and misunderstandings about the use case approach. One of these is the troublesome notion of use case interleaving which is discussed in this work. Interleaving is still present in the current UML specification. A. Simons correctly realised that interleaving compares with goto/comefrom semantics that were already judged harmful by Dijkstra at the emergence of the Structured Programming era. Simons, thus, has requested the explicit dropping of interleaving semantics. The authors give further support for Simons’ request by showing that interleaving causes severe inconsistencies within UML and contradicts other proven and practically relevant use case concepts such as Goal-Based Use Cases of A. Cockburn, and contractual specifications of use cases expressed by pre- and postcondition approaches. Significant fixes to UML are proposed, in addition to those suggested by Simons. These will dramatically clarify prevailing problems and confusion with use cases and use case relationships among both practitioners and researchers.

Use case models are used in object-oriented analysis for capturing and describing the functional requirements of a system. Several methods for estimating software development effort are based on attributes of a use case model. This paper reports the results of three industrial case studies on the application of a method for effort estimation based on use case points. The aim of this paper is to provide guidance for other organizations that want to improve their estimation process applying use cases. Our results support existing claims that use cases can be used successfully in estimating software development effort. The results indicate that the guidance provided by the use case points method can support expert knowledge in the estimation process. Our experience is also that the design of the use case models has a strong impact on the estimates.

As part of the UML 2001 conference, nine tutorials and five workshops were held. In the following a brief summary of these events is given, including references for further information.