Publications of the University of Bremen Database Systems Group

[Akehurst et al., 2008]

Dave Akehurst, Martin Gogolla, and Steffen Zschaler, editors. Proc. OCL4ALL - Modelling Systems with OCL, http://eceasst.cs.tu-berlin.de/index.php/eceasst/issue/archive, 2008. Electronic Communications of the EASST, Vol. 9. Satellite Events at the MoDELS'2007 Conference.

The requirements that the modelling community wants to see supported by OCL now go far beyond its initial requirements. When OCL was conceived it was designed as a language for supporting precise modelling. The advent of the MDA (Model Driven Architecture) vision and the rapid acceptance of MDE (Model Driven Engineering) approaches emphasize new application domains (like Domain Specific Languages or Semantic Web). This increase in new modelling languages causes a need for new OCL-like languages for systems modelling, frequently developed as extensions to the original. As this year's special focus, the OCL workshop recognised that OCL is used as a basis for many text-based navigation languages. The workshop brought together the community that defines these extensions in order to consolidate the experiences, successes and failures involved in doing so. The workshop discussed the potential for redesigning or at least restructuring the OCL standard definition in order to better facilitate and support third-party extensions to the language. The workshop aimed to look specifically at how to apply the key software engineering principles of modularity and reuse to the definition of OCL. The workshop was organized as a part of the MoDELS 2007 Conference in Nashville, Tennesee, USA. It continued the series of OCL workshops held at previous UML/MoDELS conferences in York (2000), Toronto (2001), San Francisco (2003), Lisbon (2004), Montego Bay (2005) and Genova (2006). This EC-EASST volume contains improved papers of the papers already published on-line. The workshop organizers are grateful to authors for their effort to polish their papers. Last but not least, we are grateful to the members of the Program Committee, the additional referees, all participants of the workshop and to the EC-EASST editors for their support.

[Büttner et al., 2008]

Fabian Büttner, Mirco Kuhlmann, Martin Gogolla, Jens Dietrich, Frank, Andre Pankratz, Alina Stosiek, and Alexander Salomon. MDA Employed in a Joint eGovernment Strategy: An Experience Report. In Terry Bailey, editor, Proc. 3rd ECMDA Workshop ``From Code Centric To Model Centric Software Engineering'' (2008), http://www.esi.es/modelplex/c2m/program.php, 2008. European Software Institute.

DOL (Deutschland OnLine, Germany online) is a joint eGovernment strategy in Germany. Its objectives include the development of standards for electronic data exchange between public authorities. To achieve this goal, DOL projects are employing UML models, profiles, and tools: A cross-project conceptual model and a profile for common core components are used to harmonize the different domain specific models, and a further DOL specific UML profile has been developed to attach data transmission details to the domain specific models. The automated creation of data exchange specifications from these platform-specific models is realised by an MDA tool developed in DOL: The XGenerator allows the validation of UML models against applied profiles by checking OCL constraints, and the XGenerator supports a flexible, MDA based generation of XML Schema definitions, DocBook based documentation, and WSDL descriptions. This paper reports on how UML profiles and formal MDA techniques have been assembled into a reusable architecture for the development of data exchange specifications.

(13 pages, gzipped PostScript: 289kb via HTTP, FTP, uncompressed PostScript: 711kb via HTTP, FTP)

[Dang, 2008]

Duc-Hanh Dang. Triple Graph Grammars and OCL for Validating System Behavior. In Hartmut Ehrig, Reiko Heckel, Grzegorz Rozenberg, and Gabriele Taentzer, editors, Proc. 4th Int. Conf. Graph Transformations (ICGT'2008). Springer, Berlin, LNCS, 2008.

We propose an approach based on the integration of Triple Graph Grammars (TGGs) and the Object Constraint Language (OCL) for checking the conformance between use case and design models.

(3 pages, gzipped PostScript: 52kb via HTTP, FTP, uncompressed PostScript: 106kb via HTTP, FTP)

[Gogolla et al., 2008a]

Martin Gogolla, Fabian Büttner, and Duc-Hanh Dang. From Graph Transformation to OCL using USE. In Andy Schürr, Manfred Nagl, and Albert Zündorf, editors, Proc. 3rd Int. Workshop Applications of Graph Transformation with Industrial Relevance (AGTIVE '07). Springer, Berlin, LNCS 5088, 2008.

With the tool USE, UML class diagrams with additional OCL constraints can be validated and properties can be formally checked. Constraints may be class invariants and operation pre- and postconditions. USE builds system states with object diagrams and expresses system evolution with operations employing basic state manipulations by creating and destroying objects (nodes) and links (edges) and by modifying attributes. A graph transformation system is expressed in USE by modeling the working graph with an object diagram and by expressing the graph transformation rules with operations modifying the working graph. These operations encapsulate an executable sequence of basic state manipulations and are additionally characterized by pre- and postconditions in which application conditions of the graph transformation rules can be expressed. The graph transformation rules are formulated in a special language permitting to describe left and right hand side of rules as well as their application conditions. This language is automatically translated into USE command sequences and OCL pre- and postconditions. The rules may be executed interactively through operation calls. The current working graph and its properties may be inspected on a graphical user interface and through evaluation of OCL expressions, e.g., for determining the rule redexes in the current working graph. Additionally, OCL invariants may be used to restrict the permitted working graphs.

(2 pages, gzipped PostScript: 104kb via HTTP, FTP, uncompressed PostScript: 1693kb via HTTP, FTP)

[Gogolla et al., 2008b]

Martin Gogolla, Fabian Büttner, and Mirco Kuhlmann. System Modeling with USE (UML-based Specification Environment). Genie Logiciel (French Software Engineering Journal), 2008. ISSN 0295-6322.

The Unified Modeling Language (UML) is accepted today as an important standard for developing software. UML tools however provide little support for validating and checking models in early development phases. There is also nearly no substantial support for the Object Constraint Language (OCL). Therefore, our group works on an approach for the validation of UML models and OCL constraints based on animation and certification. The USE tool (UML-based Specification Environment) supports analysts, designers and developers in executing UML models and checking OCL constraints and thus enables them to employ model-driven techniques for software production. Our group also applies OCL and USE in concrete projects. OCL and USE are employed in DOL, a joint eGovernment strategy in Germany. The objectives of DOL include standardisation of electronic data exchange between public agencies. DOL is employing UML models, profiles, and tools: Reusable conceptual models are provided, the UN/CEFACT profile for CoreComponents is used to ensure correct derivation of models in concrete projects, and a further UML profile (the XOEV profile) has been developed to attach data transmission details to the conceptual models. The automated creation of data exchange specifications is supported by the MDA tool XGenerator: It allows the validation of UML models against their applied profiles using OCL constraints, and it supports a flexible, MDA-based generation of XML Schema definitions, DocBook-based documentation, and WSDL descriptions.

(3 pages, gzipped PostScript: 175kb via HTTP, FTP, uncompressed PostScript: 528kb via HTTP, FTP)

[Kuhlmann and Gogolla, 2008a]

Mirco Kuhlmann and Martin Gogolla. Analyzing Semantic Properties of OCL Operations by Uncovering Interoperational Relationships. Electronic Communications of the EASST, http://eceasst.cs.tu-berlin.de/index.php/eceasst, 9, 2008. UML/MoDELS Workshop on OCL (OCL4ALL'2007), 17 Pages.

The OCL (Object Constraint Language) as part of the UML (Unified Modeling Language) is a rich language with different collection kinds (sets, multi-sets, sequences) and a large variety of operations defined thereon. Without negating the strong correlation between both fields we can say that these operations have their origin partly in logic (like the operations forAll and exists) and partly in computer science, in particular database systems (like the operation select). Some of these operations may be expressed in terms of other operations. This paper presents a systematic study of relationships which hold between OCL features like the mentioned operations. Apart from presenting the relationships between operations in a conceptual way, the relationships are described by a formal metamodel allowing systematic and computer supported access to the operation relationships by querying an underlying formal description.

(18 pages, gzipped PostScript: 744kb via HTTP, FTP, uncompressed PostScript: 4735kb via HTTP, FTP)

[Kuhlmann and Gogolla, 2008b]

Mirco Kuhlmann and Martin Gogolla. Modeling and Validating Mondex Scenarios Described in UML and OCL with USE. Formal Aspects of Computing, 20(1):79-100, 2008.

This paper describes the Mondex case study with UML class diagrams and restricting OCL constraints. The constraints have been formulated either as OCL class invariants or as OCL pre- and postconditions. The proposed two models include UML class diagrams and OCL constraints which have been checked by the UML and OCL tool USE (UML-based Specification Environment). USE allows validation of a model by testing it with scenarios. The Mondex case study has been validated by positive and negative test cases. The test cases allow the validity of the various constraints to be traced and checked. Validation results are presented as textual protocols or as UML sequence diagrams where starting, intermediate, and resulting system states are represented by UML object diagrams. UML sequence diagrams, UML object diagrams, and textual protocols are shown with varying degrees of detail for the attributes, constraints, and executed commands.

(25 pages, gzipped PostScript: 726kb via HTTP, FTP, uncompressed PostScript: 28464kb via HTTP, FTP)

[Kuske et al., 2008]

Sabine Kuske, Martin Gogolla, Hans-Jorg Kreowski, and Paul Ziemann. Towards an Integrated Graph-Based Semantics for UML. Journal on Software and System Modeling, 2008.

This paper shows how a central part of the Unified Modeling Language UML can be integrated into a single visual semanticmodel. It discusses UML models composed of class, object, state, sequence and collaboration diagrams and presents an integrated semantics of these models. As formal basis the theoretically well-founded area of graph transformation is employed which supports a visual and rule-based transformation of UML model states. For the translation of a UML model into a graph transformation system the operations in class diagrams and the transitions in state diagrams are associatedwith graph transformation rules that are then combined into one system in order to obtain a single coherent semantic description. Operation calls in sequence and collaboration diagrams can be associated with applications of graph transformation rules in the constructed graph transformation system so that valid sequence and collaboration diagrams correspond to derivations, i.e., to sequences of graph transformation rule applications. The main aim of this paper is to provide a formal framework that supports visual simulation of integrated UML specifications in which system states and state changes are modeled in a straighforward way.

(19 pages, gzipped PostScript: 6533kb via HTTP, FTP, uncompressed PostScript: 10475kb via HTTP, FTP)

[Sohr et al., 2008]

Karsten Sohr, Michael Drouineaud, Gail-Joon Ahn, and Martin Gogolla. Analysing and Managing Role-Based Access Control Policies. IEEE Transactions on Knowledge and Data Engineering, 2008. Published online 13 March 2008. DOI 10.1109/TKDE.2008.28.

Today more and more security-relevant data is stored on computer systems; security-critical business processes are mapped to their digital counterparts. This situation applies to various domains such as health care industry, digital government, and financial service institutes requiring that different security requirements must be fulfilled. Authorisation constraints can help the policy architect design and express higher-level organisational rules. Although the importance of authorisation constraints has been addressed in the literature, there does not exist a systematic way to verify and validate authorisation constraints. In this paper, we specify both non-temporal and history-based authorisation constraints in the Object Constraint Language (OCL) and first-order linear temporal logic (LTL). Based upon these specifications, we attempt to formally verify role-based access control policies with the help of a theorem prover and to validate policies with the USE system, a validation tool for OCL constraints. We also describe an authorisation engine, which supports the enforcement of authorisation constraints.

(14 pages, gzipped PostScript: 5437kb via HTTP, FTP, uncompressed PostScript: 24166kb via HTTP, FTP)

[Varro et al., 2008]

Daniel Varro, Mark Asztalos, Denes Bisztray, Artur Boronat, Duc-Hanh Dang, Rubino Geiss, Joel Greenyer, Pieter Van Gorp, Ole Kniemeyer, Anantha Narayanan, Edgars Rencis, and Erhard Weinell. Transformation of UML Models to CSP: A Case Study for Graph Transformation Tools. In Andy Schürr, Manfred Nagl, and Albert Zündorf, editors, Proc. 3rd Int. Workshop Applications of Graph Transformation with Industrial Relevance (AGTIVE '07). Springer, Berlin, LNCS 5088, 2008.

Graph transformation provides an intuitive mechanism for capturing model transformations. In the current paper, we investigate and compare various graph transformation tools using a compact practical model transformation case study carried out as part of the AGTIVE 2007 Tool Contest. The aim of this case study is to generate formal CSP processes from high-level UML activity diagrams, which enables to carry out mathematical analysis of the system under design.

(26 pages, gzipped PostScript: 1011kb via HTTP, FTP, uncompressed PostScript: 17896kb via HTTP, FTP)

[Akehurst et al., 2007]

Dave Akehurst, Martin Gogolla, and Steffen Zschaler. OCL4ALL - Modelling Systems with OCL. In Holger Giese, editor, Satellite Events at the MoDELS'2007 Conference, pages 176-181. Springer, Berlin, LNCS 5002, 2007.

This year's OCL workshop at the MODELS conference looked out to usages of OCL outside the direct context of UML or beyond the capabilities of standard OCL. It was a very interesting and successful workshop, which apart from the presentation of 10 papers a lively discussion on various topics surround current usage of OCL was held. Six main topics recurred throughout the discussions: (1) Means and uses of transformation to other languages, (2) Support for side-effects and executability, (3) Continuing need for OCL, (4) Providing extensions to the standard, (5) Platform independence of the language, (6) Formality of the language. This summary report presents the results of the workshop and the discussions.

(6 pages, gzipped PostScript: 79kb via HTTP, FTP, uncompressed PostScript: 157kb via HTTP, FTP)

[Dang, 2007]

Duc-Hanh Dang. Validation of System Behavior from an Integrated Semantics of Use Case and Design Models. In Claudia Pons, editor, Proc. Doctoral Symposium ACM/IEEE 10th Int. Conf. Model-Driven Engineering Languages and Systems , http://ftp.informatik.rwth-aachen.de/Publications/CEUR-WS/, 2007. CEUR Workshop Proceedings, Vol. 262. 5 pages.

This paper summarizes an approach how to specify use cases and how to solve the problem of validating the conformance between the use case model and the design model. An integrated semantics of the two models is proposed. We employ UML- and OCL-based techniques as well as ideas from graph transformation. This research contributes to model transformation within the area of Model Driven Development (MDD).

(5 pages, gzipped PostScript: 86kb via HTTP, FTP, uncompressed PostScript: 181kb via HTTP, FTP)

[Gogolla, 2007]

Martin Gogolla. Model Development in the UML-based Specification Environment (USE). In Ed Brinksma, David Harel, Angelika Mader, Perdita Stevens, and Roel Wieringa, editors, Methods for Modelling Software Systems (MMOSS). IBFI, Schloss Dagstuhl, Germany, 2007. Dagstuhl Seminar Proceedings 06351. 3 pages.

The tool USE (UML-based Specification Environment) supports analysts, designers, and developers in executing UML models and checking OCL constraints and thus enables them to employ model-driven techniques for software production. USE has been developed since 1998 at the University of Bremen. This paper will shortly discuss to what extent and how USE relates to the selected questions and topics (like model quality or modelling method) raised for this seminar.

(3 pages, gzipped PostScript: 60kb via HTTP, FTP, uncompressed PostScript: 122kb via HTTP, FTP)

[Gogolla et al., 2007]

Martin Gogolla, Fabian Büttner, and Mark Richters. USE: A UML-Based Specification Environment for Validating UML and OCL. Science of Computer Programming, 69:27-34, 2007.

The Unified Modeling Language (UML) is accepted today as an important standard for developing software. UML tools however provide little support for validating and checking models in early development phases. There is also no substantial support for the Object Constraint Language (OCL). We present an approach for the validation of UML models and OCL constraints based on animation and certification. The USE tool (UML-based Specification Environment) supports analysts, designers and developers in executing UML models and checking OCL constraints and thus enables them to employ model-driven techniques for software production.

(12 pages, gzipped PostScript: 196kb via HTTP, FTP, uncompressed PostScript: 3118kb via HTTP, FTP)

[Bezivin et al., 2006]

Jean Bezivin, Fabian Büttner, Martin Gogolla, Frederic Jouault, Ivan Kurtev, and Arne Lindow. Model Transformations? Transformation Models! In Oscar Nierstrasz, Jon Whittle, David Harel, and Gianna Reggio, editors, Proc. 9th Int. Conf. Model Driven Engineering Languages and Systems (MoDELS'2006). LNCS 4199, Springer, Berlin, 2006.

Much of the current work on model transformations seems essentially operational and executable in nature. Executable descriptions are necessary from the point of view of implementation. But from a conceptual point of view, transformations can also be viewed as descriptive models by stating only the properties a transformation has to fulfill and by omitting execution details. This contribution discusses the view that model transformations can be abstracted as being transformation models. As a simple example for a transformation model, the well-known transformation from the Entity-Relationship model to the Relational model is shown. A transformation model in this contribution is nothing more than an ordinary, simple model, i.e., a UML/MOF class diagram together with OCL constraints. A transformation model may transport syntax and semantics of the described domain. The contribution thus covers two views on transformations: An operational model transformation view and a descriptive transformation model view.

(15 pages, gzipped PostScript: 330kb via HTTP, FTP, uncompressed PostScript: 7278kb via HTTP, FTP)

[Büttner and Bauerdick, 2006]

Fabian Büttner and Hanna Bauerdick. Realizing UML Model Transformations with USE. In Dan Chiorean, Birgit Demuth, Martin Gogolla, and Jos Warmer, editors, UML/MoDELS Workshop on OCL (OCLApps'2006), pages 96-110. Technical University of Dresden, Technical Report TUD-FI06, 2006.

The USE (UML-based Specification Environment) tool has been successfully applied for model validation in the past. In our current work, we are enriching the USE specification language with imperative elements. We employ this extension as an assembler to realize UML model (class diagram) transformations with USE in a flexible way: UML transformations are described using a custom abstract language based on object diagram-like patterns. These descriptions are automatically translated into the imperative USE extensions. Our approach aims to provide a flexible instrument to experiment with different transformations and transformation formalisms.

(16 pages, gzipped PostScript: 131kb via HTTP, FTP, uncompressed PostScript: 421kb via HTTP, FTP)

[Büttner and Gogolla, 2006]

Fabian Büttner and Martin Gogolla. Realizing Graph Transformations by Pre- and Postconditions and Command Sequences. In Andrea Corradini, Hartmut Ehrig, Ugo Montanari, Leila Ribeiro, and Gregorz Rozenberg, editors, Proc. 3rd Int. Conf. Graph Transformations (ICGT'2006), pages 398-412. LNCS 4178, Springer, Berlin, 2006.

This paper studies two realizations of graph transformations which are based on a UML class diagram. The first realization achieves a representation in terms of descriptive pre- and postconditions. The second one yields an operationally executable command sequence in terms of basic commands for object and link creation, attribute modification, and object and link destruction. Our aim for realizing graph transformations in terms of target languages offering different views, i.e., descriptive or operational, is to take advantage of both views and to utilize the benefits which both views provide.

(15 pages, gzipped PostScript: 200kb via HTTP, FTP, uncompressed PostScript: 2004kb via HTTP, FTP)

[Chiorean et al., 2006a]

Dan Chiorean, Birgit Demuth, Martin Gogolla, and Jos Warmer. OCL for (Meta-)Models in Multiple Application Domains. In Thomas Kühne, editor, Satellite Events at the MoDELS'2006 Conference, pages 152-158. Springer, Berlin, LNCS 4364, 2006.

The workshop OCLApps 2006 was organized as a part of MoDELS/UML Conference in Genova, Italy. It continues the series of five OCL (Object Constraint Language) workshops held at previous UML/MoDELS conferences between 2000-2005. Similar to its predecessors, the workshop addressed both people from academia and industry. The advent of the MDA (Model Driven Architecture) vision and the rapid acceptance of MDE (Model Driven Engineering) approaches emphasize new application domains (like Semantic Web or Domain Specific Languages) and call for new OCL functionalities. In this context, the OCLApps 2006 Workshop, was conceived as a forum enabling researchers and industry experts to present and debate how the OCL could support these new requirements.

(6 pages, gzipped PostScript: 90kb via HTTP, FTP, uncompressed PostScript: 185kb via HTTP, FTP)

[Chiorean et al., 2006b]

Dan Chiorean, Birgit Demuth, Martin Gogolla, and Jos Warmer, editors. Proc. OCL for (Meta-)Models in Multiple Application Domains, http://eceasst.cs.tu-berlin.de/index.php/eceasst/issue/archive, 2006. Electronic Communications of the EASST, Vol. 5. Satellite Events at the MoDELS'2006 Conference.

Conceived as a formalism meant to support unambiguous and detailed modeling using UML (Unified Modeling Language), OCL (Object Constraint Language) needs adaptation to changes expressed in the modeling community. The requirements that the modelers want to see supported today by OCL go far beyond its initial requirements. The advent of the MDA (Model Driven Architecture) vision and the rapid acceptance of MDE (Model Driven Engineering) approaches emphasize new application domains (like Semantic Web or Domain Specific Languages) and call for new OCL functionalities. Apart from the requirements asked by application domains, technologies, visions and paradigms used in modeling, the formalisms and techniques currently used have to support development of large scale applications. Therefore, efficiency represents another important feature that tools supporting OCL must provide. The OCL is required to ensure a fine balance between the use of language in specifying models realized in early life-cycle phases and the rigor asked by the strong relationship with formal languages. Fixing ambiguities reported from the OCL specification without affecting the above mentioned balance is also important. Today, promoting OCL needs a conjoint support from both the research community and the industry. The main target of the OCLApps 2006 Workshop was to organize a debate forum joining people from research and industry able to present an updated state of the art in this domain, to contribute to the OCL dissemination and use. The workshop was organized as a part of MoDELS/UML 2006 Conference in Genova - Italy, continuing the series of OCL workshops held at previous UML/MoDELS conferences in: York (2000), Toronto (2001), San Francisco (2003), Lisbon (2004) and Montego Bay (2005).

[Hölscher et al., 2006]

Karsten Hölscher, Paul Ziemann, and Martin Gogolla. On Translating UML Models into Graph Transformation Systems. Journal of Visual Languages and Computing, 17(1):78-105, 2006.

In this paper we present a concept of a rigorous approach that provides a formal semantics for a fundamental subset of UML. This semantics is derived by translating a given UML model into a graph transformation system, allowing modelers to actually execute their UML model. The graph transformation system comprises graph transformation rules and a working graph which represents the current state of the modeled system. In order to support UML models which use OCL, we introduce a specific graph transformation approach that incorporates full OCL in the common UML fashion. The considered UML subset is defined by means of a metamodel similar to the UML 1.5 metamodel. The concept of a system state that represents the state of the system at a specific point in time during execution is likewise introduced by means of a metamodel. The simulated system run is performed by applying graph transformation rules on the working graph. The approach has been implemented in a research prototype which allows the modeler to execute the specified model and to validate the basic aspects of the model in an early software development phase.

(30 pages, gzipped PostScript: 528kb via HTTP, FTP, uncompressed PostScript: 4842kb via HTTP, FTP)

[Mwatawala et al., 2006]

Maulid W. Mwatawala, Arne Lindow, Martin Gogolla, and Marc De Meyer. Employing the Unified Modeling Language (UML) and Relational Modeling Concepts for the Development of a Schema for Fruit Flies. In Eyas El-Qawasmeh, editor, Proc. 4th Int. Multiconference on Computer Science and Information Technology (CSIT'2006). Applied Science University (ASU), Amman, Jordan, 2006.

This paper is about the analysis, conceptual design, and implementation of a fruit fly database containing information about fruit flies of Morogoro Tanzania, their description, host range, infestation levels in different fruits and the proposed management techniques. The analysis and design of the database is described with Unified Modeling Language, Entity Relationship diagrams, Extended Entity Relationship diagrams and tabular views of relational model. So this paper is an example of a practical and useful application of Information and Communication Technology in solving a pest problem in a developing country, whose economy is largely dependent on agriculture.

(12 pages, gzipped PostScript: 482kb via HTTP, FTP, uncompressed PostScript: 2505kb via HTTP, FTP)

[Vidacs et al., 2006]

Laszlo Vidacs, Martin Gogolla, and Rudolf Ferenc. From C++ Refactorings to Graph Transformations. In Jean-Marie Favre, Reiko Heckel, and Tom Mens, editors, Proc. ICGT'2006 Workshop Software Evolution and Transformation (SETRA'2006), pages 127-141. Electronic Communications of EASST (European Association of Software Science and Technology), 2006.

In this paper, we study a metamodel for the C++ programming language. We work out refactorings on the C++ metamodel and present the essentials as graph transformations. The refactorings are demonstrated in terms of the C++ source code and the C++ target code as well. Graph transformations allow to capture refactoring details on a conceptual and easy to understand, but also very precise level. Using this approach we managed to formalize two major aspects of refactorings: the structural changes and the preconditions.

(15 pages, gzipped PostScript: 1644kb via HTTP, FTP, uncompressed PostScript: 12636kb via HTTP, FTP)

[Baar et al., 2005]

Thomas Baar, Dan Chiorean, Alexandre Correa, Martin Gogolla, Heinrich Hußmann, Octavian Patrascoiu, Peter H. Schmitt, and Jos Warmer. Tool Support for OCL and Related Formalisms - Needs and Trends. In Jean-Michel Bruel, editor, Satellite Events at the MoDELS'2005 Conference, pages 1-9. Springer, Berlin, LNCS 3844, 2005.

The recent trend in software engineering to model-centered methodologies is an excellent opportunity for OCL to become a widely used specification language. If the focus of the development activities is shifted from implementation code to more abstract models then software developers need a formalism to provide a complete, unambiguous and consistent model at a very detailed level. OCL is currently the only language that can bring this level of detail to UML models. The purpose of the workshop was to identify future challenges for OCL and to discuss how OCL and its current tool support can be improved to meet these challenges. The workshop gathered numerous experts from academia and industry to report on success stories, to formulate wishes to the next generation of OCL tools, and to identify weaknesses in the language, which make OCL sometimes cumbersome to use. The workshop could also attract numerous people whose aim was to get an overview on the state of the art of OCL tool support and on how OCL can efficiently be applied in practice.

(9 pages, gzipped PostScript: 112kb via HTTP, FTP, uncompressed PostScript: 227kb via HTTP, FTP)

[Büttner, 2005]

Fabian Büttner. Transformation-Based Structure Model Evolution. In Jean-Michel Bruel, editor, Satellite Events at the MoDELS'2005 Conference, pages 339-340. Springer, Berlin, LNCS 3844, 2005.

This paper summarizes an approach to support evolution of software models by means of a transformation catalogue. These transformations treat UML class diagram models, OCL constraints, and existing states of the models in a coherent and consistent way. By implementing the catalogue in the UML tool USE, we effectively support developers in an iterative and incremental process for model development.

(5 pages, gzipped PostScript: 19kb via HTTP, FTP, uncompressed PostScript: 67kb via HTTP, FTP)

[Büttner et al., 2005]

Fabian Büttner, Hanna Bauerdick, and Martin Gogolla. Towards Transformation of Integrity Constraints and Database States. In Danielle C. Martin, editor, Proc. Dexa'2005 Workshop Logical Aspects and Applications of Integrity Constraints (LAAIC'2005), pages 823-828. IEEE, Los Alamitos, 2005.

This paper discusses integrity constraint evolution, from two perspectives: From the perspective of changing the constraint, and from the perspective of consequently changing an existing database state. The paper concentrates on structural models provided by UML class diagrams and OCL invariant constraints. We discuss how changes in association multiplicities can be extended to further integrity constraints attached to a class diagram and how these changes interact with given database states.

(6 pages, gzipped PostScript: 57kb via HTTP, FTP, uncompressed PostScript: 190kb via HTTP, FTP)

[Czarnecki et al., 2005]

Krzysztof Czarnecki, Jean-Marie Favre, Martin Gogolla, and Tom Mens. Essentials of the 4th UML/MoDELS Workshop in Software Model Engineering (WiSME'2005). In Jean-Michel Bruel, editor, Satellite Events at the MoDELS'2005 Conference, pages 151-159. Springer, Berlin, LNCS 3844, 2005.

Model-Driven Engineering is a form of generative engineering, by which all or at least central parts of a software application are generated from models. Model Driven Engineering should be seen as an integrative approach combining existing software engineering techniques (e.g., testing and refinement) and technical spaces (e.g., 'ModelWare', 'XmlWare') that have usually been studied in separation. The goal of the workshop is to improve common understanding of these techniques across technical spaces and create bridges and increase the synergies among the spaces. This year's WiSME workshop will concentrate on two complementing themes: Bridging Technical Spaces and Model-Driven Evolution. This paper reports on a workshop held at the 8th UML/MoDELS conference. It describes motivation and aims, organisational issues, and abstracts of the accepted papers.

(9 pages, gzipped PostScript: 39kb via HTTP, FTP, uncompressed PostScript: 95kb via HTTP, FTP)

[Ermel et al., 2005]

Claudia Ermel, Karsten Hölscher, Sabine Kuske, and Paul Ziemann. Animated Simulation of Integrated UML Behavioral Models Based on Graph Transformation. In IEEE, editor, Proc. IEEE Symposium Visual Languages and Human-Centric Computing (VL/HCC'05), pages 125-133, 2005.

This paper shows how integrated UML models combining class, object, use-case, collaboration and state diagrams can be animated in a domain-specific layout. The presented approach is based on graph transformation, i.e. UML model diagrams are translated to a graph transformation system and the behavior of the integrated model is simulated by applications of graph transformation rules. For model validation, users may prefer to see the behavior of selected model aspects as scenarios presented in the layout of the application domain. We propose to integrate animation views with the model.s graph transformation system. A prototypical validation system has been implemented recently supporting the automatic translation of a UML model into a graph transformation system, and the interactive execution and simulation of the model behavior. We sketch the tool interconnection to GenGED, a visual language environment which allows to enrich graph transformation systems for model simulation by features for animation.

(9 pages, gzipped PostScript: 374kb via HTTP, FTP, uncompressed PostScript: 948kb via HTTP, FTP)

[Gogolla, 2005a]

Martin Gogolla. Exploring ER and RE Syntax and Semantics with Metamodel Object Diagrams. In Peter J. Nürnberg, editor, ACM Int. Conf. Proceeding Series (Vol. 214), Proc. Metainformatics Symposium (MIS'2005). ACM Press, New York, 2005. ACM Digital Library, 12 pages.

This paper explains how a metamodel transformation between two well-known database models work: Entity-Relationship (ER) database schemas are transformed into Relational (RE) database schemas hand in hand with the transformation of ER states into Relational states. The schemas determine the syntax of the datamodels, and the set of associated states fix the semantics of the datamodels. Often, when database models are considered, one formally only treats syntactical aspects, i.e., schemas, and handles the semantics, i.e., states, merely informally. Our approach formally handles syntax and semantics of database models and their transformation within a single, uniform framework. The approach thus precisely describes properties of the datamodels and properties of the transformation. Our metamodel transformations do not simply convert ER schemas into Relational schemas, but they respect the semantics in a formal way and they can also be used the other way round in order to transfrom Relational schemas into ER ones. This opens the approach for re-engineering as well.

(12 pages, gzipped PostScript: 223kb via HTTP, FTP, uncompressed PostScript: 1000kb via HTTP, FTP)

[Gogolla, 2005b]

Martin Gogolla. Tales of ER and RE Syntax and Semantics. In James R. Cordy, Ralf Lämmel, and Andreas Winter, editors, Transformation Techniques in Software Engineering. IBFI, Schloss Dagstuhl, Germany, 2005. Dagstuhl Seminar Proceedings 05161. 51 pages.

This paper explains how four model transformations between database models work: (1) An ER (Entity-Relationship) database schema is transformed into a collection of ER database states, (2) a RE (Relational) database schema into a collection of RE database states, (3) an ER database schema into a RE database schema, and (4) a collection of ER database states into a collection of RE database states. These four separate transformations may be viewed as a single transformation between the ER datamodel and the RE datamodel. The schemas are regarded as determining the syntax of the datamodels, and the set of associated states is regarded as being the semantics of the datamodels, because the states associate meaning with the schemas. When one usually considers database models, one formally only treats syntactical aspects, i.e., schemas, and handles the semantics merely informally. Our approach allows to formally handle syntax and semantics of database models and their transformation within a single and uniform framework. The approach thus allows to precisely describe properties of the datamodels and properties of the transformation. The method behind our approach is to divide a language into a syntax and semantics part and to describe a transformation between two languages as a direction-neutral affair. Formal properties of the languages to be transformed and formal properties of the transformation are described uniformly. Transformation properties can be properties regarding syntax and semantics. The method can be applied not only to database languages but to transformations between common computer science languages.

(51 pages, gzipped PostScript: 339kb via HTTP, FTP, uncompressed PostScript: 1582kb via HTTP, FTP)

[Gogolla et al., 2005a]

Martin Gogolla, Jörn Bohling, and Mark Richters. Validating UML and OCL Models in USE by Automatic Snapshot Generation. Journal on Software and System Modeling, 4(4):386-398, 2005.

The paper studies the testing and certification of UML and OCL models as supported by the validation tool USE. We extend the available USE features by introducing a language for defining properties of desired snapshots and by showing how such snapshots are generated. Within the approach, it is possible to treat test cases and validation cases. Test cases show that snapshots having desired properties can be constructed. Validation cases show that given properties are consequences of the original UML and OCL model. We sketch the underlying language features and indicate how to give a formal interpretation for them.

(24 pages, gzipped PostScript: 249kb via HTTP, FTP, uncompressed PostScript: 731kb via HTTP, FTP)

[Gogolla et al., 2005b]

Martin Gogolla, Jean-Marie Favre, and Fabian Büttner. On Squeezing M0, M1, M2, and M3 into a Single Object Diagram. In Thomas Baar, Dan Chiorean, Alexandre Correa, Martin Gogolla, Heinrich Hußmann, Octavian Patrascoiu, Peter H. Schmitt, and Jos Warmer, editors, Proc. MoDELS'2005 Workshop Tool Support for OCL and Related Formalisms. In: Satellite Events at MoDELS'2005 Conference. Jean-Michel Bruel (Ed.). Springer, LNCS 3844. Long Version: EPFL (Switzerland), Technical Report LGL-REPORT-2005-001, 2005.

We propose an approach for the integrated description of a metamodel and its formal relationship to its models and the model instantiations. The central idea is to use so-called layered graphs permitting to describe type graphs and instance graphs. A type graph can describe a collection of types and their relationships whereas an instance graph can represent instances belonging to the types and respecting the relationships required by the type graph. Type graphs and instance graphs are used iteratively, i.e., an instance graph on one layer can be regarded as a type graph of the next lower layer. Our approach models layered graphs with a UML class diagram, and operations and invariants are formally characterized with OCL and are validated with the USE tool. Metamodeling properties like strictness or well-typedness and features like potency can be formulated as OCL constraints and operations. We are providing easily understandable definitions for several metamodeling notions which are currently used in a loose way by modelers. Such properties and features can then be discussed on a rigorous, formal ground. This issue is also the main purpose of the paper, namely, to provide a basis for discussing metamodeling topics.

(14 pages, gzipped PostScript: 206kb via HTTP, FTP, uncompressed PostScript: 4894kb via HTTP, FTP)

[Sohr et al., 2005]

Karsten Sohr, Gail-Joon Ahn, Martin Gogolla, and Lars Migge. Specification and Validation of Authorization Constraints using UML and OCL. In Sabrina DeCapitani, Paul F. Syverson, and Dieter Gollmann, editors, Proc. 10th European Symp. Research in Computer Security (ESORICS'2005), pages 64-79. LNCS 3679, Springer, Berlin, 2005.

Authorisation constraints can help the policy architect design and express higher-level security policies for organisations such as financial institutes or governmental agencies. Although the importance of constraints has been addressed in the literature, there does not exist a systematic way to validate and test authorisation constraints. In this paper, we attempt to specify non-temporal constraints and historybased constraints in Object Constraint Language (OCL) which is a constraint specification language of Unified Modeling Language (UML) and describe how we can facilitate the USE tool to validate and test such policies. We also discuss the issues of identification of conflicting constraints and missing constraints.

(16 pages, gzipped PostScript: 791kb via HTTP, FTP, uncompressed PostScript: 6131kb via HTTP, FTP)

[Bauerdick et al., 2004]

Hanna Bauerdick, Martin Gogolla, and Fabian Gutsche. Detecting OCL Traps in the UML 2.0 Superstructure: An Experience Report. In Thomas Baar, Alfred Strohmeier, Ana Moreira, and Stephen J. Mellor, editors, Proc. 7th Int. Conf. Unified Modeling Language (UML'2004), pages 188-197. Springer, Berlin, LNCS 3273, 2004.

Currently, the OMG is developing a new version of the Unified Modeling Language (UML), UML 2.0, which involves major innovations in its metamodel. As for previous versions of the UML, the Object Constraint Language (OCL) is employed to give restrictions on the use of UML and for the formulation of additional operations. It seems that the OCL expressions in the current version of the UML 2.0 Superstructure have not been checked with a tool. In this paper we report on an experiment in checking and validating the well-formedness rules and operation definitions of the UML 2.0 Superstructure w.r.t. syntax and type checking by using our tool USE (UML-based Specification Environment). For this purpose we classify the errors detected by USE in appropriate error categories. We develop statistical information on error frequencies w.r.t. package location and error category. All errors detected by USE and their detailed description are made available in a separate EXCEL file.

(10 pages, gzipped PostScript: 52kb via HTTP, FTP, uncompressed PostScript: 131kb via HTTP, FTP)

[Bezivin et al., 2004]

Jean Bezivin, Thomas Baar, Tracy Gardner, Martin Gogolla, Reiner Hähnle, Heinrich Hußmann, Octavian Patrascoiu, Peter H. Schmitt, and Jos Warmer. OCL and Model Driven Engineering Workshop Report. In Nuno Jardim Nunes, Bran Selic, Alberto Rodrigues da Silva, and Ambrosio Toval Alvarez, editors, UML'2004 Modeling Languages and Applications. UML'2004 Satellite Activities. Revised Selected Papers, pages 67-75. Springer, Berlin, LNCS 3297, 2004.

This paper reports on a workshop held at the 7th UML conference. It describes motivation, objectives, abstracts of the presented papers, questions raised during discussion, and a workshop conclusion.

(9 pages, gzipped PostScript: 31kb via HTTP, FTP, uncompressed PostScript: 158kb via HTTP, FTP)

[Bisanz et al., 2004]

Stefan Bisanz, Paul Ziemann, and Arne Lindow. Integrated Specification, Validation and Verification with HybridUML and OCL Applied to the BART Case Study. In E. Schnieder and G. Tarnai, editors, Proc. Conf. Formal Methods for Automation and Safety in Railway and Automotive Systems (FORMS/FORMAT'2004), 2004.

This article proposes the integration of the HybridUML specification formalism and the USE approach for validation of invariant constraints and verification of system states. The benefit is an executable real-time simulation with an integrated verification/validation component, which combines the advantages of the previously separate approaches by providing an accurate, (partially) time-continuous model that can be checked for consistency between static invariants and dynamical behavior in terms of a complete UML model. The integration is illustrated by means of a train system specification -- the BART case study.

(13 pages, gzipped PostScript: 2325kb via HTTP, FTP, uncompressed PostScript: 5587kb via HTTP, FTP)

[Büttner and Gogolla, 2004a]

Fabian Büttner and Martin Gogolla. On Generalization and Overriding in UML 2.0. In Jean Bezivin, Thomas Baar, Tracy Gardner, Martin Gogolla, Reiner Hähnle, Heinrich Hußmann, Octavian Patrascoiu, Peter H. Schmitt, and Jos Warmer, editors, Proc. UML'2004 Workshop OCL and Model Driven Engineering, pages 69-69. In: UML - Modeling Languages and Applications. Nuno Jardim Nunes, Bran Selic, Alberto Rodrigues da Silva, Ambrosio Toval Alvarez (Eds). LNCS 3297, Springer Verlag. Long version: University of Kent, http://www.cs.kent.ac.uk/projects/ocl/oclmdewsuml04/, 2004.

In the upcoming Unified Modeling Language specification (UML 2.0), subclassing (i.e., generalization between classes) has a much more precise meaning with respect to overriding than it had in earlier UML versions. Although it is not expressed explicitly, UML 2.0 has a covariant overriding rule for methods, attributes, and associations. In this paper, we first precisely explain how overriding is defined in UML 2.0. We relate the UML approach to the way types are formalized in programming languages and we discuss which consequences arise when implementing UML models in programming languages. Second, weaknesses of the UML 2.0 metamodel and the textual explanations are addressed and solutions, which could be incorporated with minor efforts are proposed. Despite of these weaknesses we generally agree with the UML 2.0 way of overriding and provide supporting arguments for it.

(15 pages, gzipped PostScript: 155kb via HTTP, FTP, uncompressed PostScript: 362kb via HTTP, FTP)

[Büttner and Gogolla, 2004b]

Fabian Büttner and Martin Gogolla. Realizing UML Metamodel Transformations with AGG. In Reiko Heckel, editor, Proc. ETAPS Workshop Graph Transformation and Visual Modeling Techniques (GT-VMT'2004). Electronic Notes in Theoretical Computer Science (ENTCS), Elsevier, 2004.

In this paper, we work out equivalence transformations on the UML metamodel as concrete graph transformations implemented in the AGG tool. We consider two examples for manipulating the static structure of a UML model, namely the transformation of an association class into a ternary association and the transformation of a ternary association into three binary associations. We discuss technical details and pros and cons of the presented approach and shortly put out work into the context of the MDA.

(12 pages, gzipped PostScript: 560kb via HTTP, FTP, uncompressed PostScript: 8829kb via HTTP, FTP)

[Büttner et al., 2004]

Fabian Büttner, Oliver Radfelder, Arne Lindow, and Martin Gogolla. Digging into the Visitor Pattern. In Frank Maurer and Günther Ruhe, editors, Proc. IEEE 16th Int. Conf. Software Engineering and Knowlege Engineering (SEKE'2004). IEEE, Los Alamitos, 2004.

In this paper we present an alternative to the visitor pattern, dynamic dispatcher, that can be applied to extend existing software in a nonintrusive way, and which simulates covariant overriding of visit methods. It allows to express polymorphic operations through visitor classes in a more natural way than the original visitor pattern. Our solution dynamic dispatcher can be applied without touching existing domain classes. Therefore, it is especially useful to extend frameworks and libraries. We have implemented dynamic dispatcher as a small framework in Java and conducted performance measurements which show that the overhead should be acceptable in many real world scenarios.

(7 pages, gzipped PostScript: 48kb via HTTP, FTP, uncompressed PostScript: 168kb via HTTP, FTP)

[Gogolla, 2004a]

Martin Gogolla. (An Example for) Metamodeling Syntax and Semantics of Two Languages, their Transformation, and a Correctness Criterion. In Jean Bezivin and Reiko Heckel, editors, Proc. Dagstuhl Seminar on Language Engineering for Model-Driven Software Development. Schloss Dagstuhl Int. Conf. and Research Center for Computer Science, http://www.dagstuhl.de/04101/, 2004.

We study a metamodel for the Entity Relationship (ER) and the Relational data model. We do this by describing the syntax of the ER data model by introducing classes for ER schemata, entities, and relationships. We also describe the semantics of the ER data model by introducing classes for ER states, instances, and links. The connection between syntax and semantics is established by associations explaining that syntactical objects are interpreted by corresponding semantical objects. Analogously we do this for the Relational data model. Finally, we give a metamodel for the transformation of ER schemata into Relational database schemata. By characterizing the syntax and semantics of the languages to be transformed and also the transformation itself within the same (meta-)modeling language we are able to include equivalence criteria on the syntactical and on the semantical level for the transformation. In particular, we show that the semantical equivalence criterion requires that the ER states and the corresponding Relational states bear the same information.

(10 pages, gzipped PostScript: 134kb via HTTP, FTP, uncompressed PostScript: 877kb via HTTP, FTP)

[Gogolla, 2004b]

Martin Gogolla. Benefits and Problems of Formal Methods. In Albert Llamosi and Alfred Strohmeier, editors, Proc. 9th Int. Conf. Reliable Software Technologies Ada-Europe (RST'2004), pages 1-15. Springer, Berlin, LNCS 3063, 2004.

Formal methods for software development have been discussed for decades. This paper will try to explain when and under what circumstances formal methods and languages in general and the Object Constraint Language (OCL) in particular can be employed in a beneficial way. The success of using a formal approach is highly influenced by the expectations and pre-requisite knowledge of the developers, the role the formal support in the development process is given, and of course by the used tools.

(15 pages, gzipped PostScript: 83kb via HTTP, FTP, uncompressed PostScript: 288kb via HTTP, FTP)

[Gogolla and Ziemann, 2004]

Martin Gogolla and Paul Ziemann. Checking BART Test Scenarios with UML's Object Constraint Language. Formal Methods for Embedded Distributed Systems - How to master the complexity. Fabrice Kordon, Michel Lemoine (Eds.), Kluwer, Boston. pages 133-170, 2004.

The Object Constraint Language (OCL) is part of the Unified Modelling Language (UML). Within software engineering, UML is regarded today as an important step towards development of high-quality object-oriented systems. OCL allows to sharpen UML diagrams through invariants and pre- and postconditions. This chapter explains the functionality of the UML Specification Environment USE, which allows to validate and verify UML and OCL descriptions. The paper shows that central safety properties of the BART system can be expressed with OCL. Test cases embodying central aspects of the BART system can be formulated within the USE system. It can be shown that the safety properties are satisfied by the test cases examined.

(38 pages, gzipped PostScript: 193kb via HTTP, FTP, uncompressed PostScript: 1089kb via HTTP, FTP)

[Gogolla et al., 2004a]

Martin Gogolla, Mark Richters, Jörn Bohling, Arne Lindow, Fabian Büttner, and Paul Ziemann. Werkzeugunterstützung für die Validierung von UML- und OCL-Modellen durch automatische Snapshot-Generierung. In Bernhard Rumpe and Wolfgang Hesse, editors, Proc. Modellierung'2004, pages 281-282. Gesellschaft für Informatik, Lecture Notes in Informatics 45, 2004.

Diese Arbeit gibt einen kurzen, aktuellen Überblick zu Bremischen Aktivitäten im Bereich Werkzeugunterstützung für UML und OCL.

(2 pages, gzipped PostScript: 11kb via HTTP, FTP, uncompressed PostScript: 25kb via HTTP, FTP)

[Gogolla et al., 2004b]

Martin Gogolla, Paul Sammut, and Jon Whittle. Essentials of the 3rd UML Workshop in Software Model Engineering (WiSME'2004). In Nuno Jardim Nunes, Bran Selic, Alberto Rodrigues da Silva, and Ambrosio Toval Alvarez, editors, UML'2004 Modeling Languages and Applications. UML'2004 Satellite Activities. Revised Selected Papers, pages 43-51. Springer, Berlin, LNCS 3297, 2004.

This paper reports on a workshop held at the 7th UML conference. It describes motivation and aims, organisational issues, abstracts of the accepted papers, and questions raised during discussion.

(10 pages, gzipped PostScript: 42kb via HTTP, FTP, uncompressed PostScript: 102kb via HTTP, FTP)

[Krieg-Brückner et al., 2004]

Bernd Krieg-Brückner, Arne Lindow, Christoph Lüth, Achim Mahnke, and George Russell. Semantic Interrelation of Documents via an Ontology. In Gregor Engels and Silke Seehusen, editors, Proc. 2. Deutsche e-Learning Fachtagung Informatik (DeLFI'2004), pages 271-282. Gesellschaft für Informatik, Lecture Notes in Informatics 52, 2004.

This paper describes how to use an ontology for extensive semantic interrelation of documents in order to achieve sustainable development, i.e. continuous long-term usability of the contents. The ontology is structured via packages (corresponding to whole documents). Packages are related by import such that semantic interrelation becomes possible not only within a document but also between different documents. Coherence and consistency are enhanced by change management in a repository, including version control and configuration management. Semantic interrelation is realized by particular LaTeX commands for the declaration and definition of classes, objects and relations, and references to them, such that they can be used in standard LaTeX documents, in particular, with a new LaTeX style for educational material (slides, handouts, annotated courses, assignments, and so on).

[Lindow and Gogolla, 2004]

Arne Lindow and Martin Gogolla. Eine multimediale Erweiterung eines UML-Tools für Lehrzwecke. In Gregor Engels and Silke Seehusen, editors, Proc. 2. Deutsche e-Learning Fachtagung Informatik (DeLFI'2004), pages 393-394. Gesellschaft für Informatik, Lecture Notes in Informatics 52, 2004.

In this paper we discuss possible extensions for an UML/OCL tool so far used in the area of formal methods to expand it to an educational teaching and learning system. So we will show a way to develop USE from a well known tool for practical work in the area of formal methods into an educational multimedia teaching and learning environment, which can be used in lectures and for the creation of lecture material. We clarify, how authors could benefit of a new import-function for the standard interchange format of UML-models. We show how we think, authors of multimedia material for lectures can benefit of easy to create graphical or animated presentations of UML models or new diagram combinations. We suggest an extension for a learner model, which can help the students easily access examples of concepts of UML, which they want to learn. A new annotation mechanism for presentation is suggested and an easy to understand, very detailed visualization of the evaluation of OCL-expressions is explained.

(2 pages, gzipped PostScript: 10kb via HTTP, FTP, uncompressed PostScript: 24kb via HTTP, FTP)

[Ziemann et al., 2004a]

Paul Ziemann, Karsten Hölscher, and Martin Gogolla. Coherently Explaining UML Statechart and Collaboration Diagrams by Graph Transformations. In Arnaldo Moura and Alexandre Mota, editors, Proc. Brazilian Symposium on Formal Methods (SBMF'2004). Electronic Notes in Theoretical Computer Science (ENTCS), Elsevier, 2004.

In this paper we continue our work on the formalization and validation of UML models by means of graph transformation systems. We here concentrate on statechart and collaboration diagrams albeit our approach covers use case, class, object, and sequence diagrams as well. The statechart and collaboration diagrams describe the operations of the underlying class diagram and include OCL expressions as guards and parts of message expressions. We illustrate in detail the generation of graph transformation rules for the statechart and collaboration diagrams.

(15 pages, gzipped PostScript: 178kb via HTTP, FTP, uncompressed PostScript: 549kb via HTTP, FTP)

[Ziemann et al., 2004b]

Paul Ziemann, Karsten Hölscher, and Martin Gogolla. From UML Models to Graph Transformation Systems. In Mark Minas, editor, Proc. Workshop Visual Languages and Formal Methods (VLFM'2004). Electronic Notes in Theoretical Computer Science (ENTCS), Elsevier, 2004.

In this paper we present an approach that allows to validate properties of UML models. The approach is based on an integrated semantics for central parts of the UML. We formally cover UML use case, class, object, statechart, collaboration, and sequence diagrams. Additionally full OCL is supported in the common UML fashion. Our semantics is based on the translation of a UML model into a graph transformation system consisting of graph transformation rules and a working graph that represents the system state. By applying the rules on the working graph, the evolution of the modeled system is simulated.

(16 pages, gzipped PostScript: 267kb via HTTP, FTP, uncompressed PostScript: 808kb via HTTP, FTP)

[Bezivin and Gogolla, 2003]

Jean Bezivin and Martin Gogolla, editors. Proc. 2nd UML Workshop in Software Model Engineering (WiSME'2003). www.metamodel.com, 2003. http://www.metamodel.com/wisme-2003/.

Model Driven Architecture (MDA) is an OMG initiative that attempts to separate business functionality specification from the implementation of that functionality on specific middleware technological platforms (CORBA, C#/DotNet, Java/EJB, XML/SOAP, etc.). This new approach is intended to play a key role in the fields of information system and software engineering. The stage is thus set but the efforts to move from the present situation to the idyllic automatic generation of executable models for various platforms remains huge. We need to mobilize the creative energies of a very broad category of contributors, from tool builders to theoretical specialists in the fields of language compilers, graph rewriting, model checking, ontology engineering, etc. The workshop brings together young researchers planning to invest in this emerging new area as well as more experienced professional having previous experience in areas related to automatic code generation, transformational and generative approaches, model checking, etc.

[Gogolla and Lindow, 2003]

Martin Gogolla and Arne Lindow. Transforming Data Models with UML. In Borys Omelayenko and Michel Klein, editors, Knowledge Transformation for the Semantic Web, pages 18-33. IOS Press, Amsterdam, 2003.

This chapter studies an approach to establish a formal connection between data models, in particular between conceptual data models and implementation data models. We use metamodeling techniques based on the Meta Object Facility MOF. MOF may be regarded as a subset of the Unified Modeling Language UML. As prominent example data models, we formally describe and thereby analyze the Entity-Relationship and the Relational data model. In addition, we represent the transformation between these data models by MOF language features. Thus we describe the data models and their transformation within a single framework. All results are formally represented and validated by a MOF compliant tool. The approach presented is general enough so that it can used for other data models being important for the Semantic Web, e.g., the object-oriented data model or semi-structured data models like XML-based models.

(15 pages, gzipped PostScript: 124kb via HTTP, FTP, uncompressed PostScript: 1519kb via HTTP, FTP)

[Gogolla et al., 2003a]

Martin Gogolla, Jörn Bohling, and Mark Richters. Validation of UML and OCL Models by Automatic Snapshot Generation. In Grady Booch, Perdita Stevens, and Jonathan Whittle, editors, Proc. 6th Int. Conf. Unified Modeling Language (UML'2003), pages 265-279. Springer, Berlin, LNCS 2863, 2003.

We study the testing and certification of UML and OCL models as supported by the validation tool USE. We extend the available USE features by introducing a language for defining properties of desired snapshots and by showing how such snapshots are generated. Within the approach, it is possible to treat test cases and validation cases. Test cases show that snapshots having desired properties can be constructed. Validation cases show that given properties are consequences of the original UML and OCL model.

(15 pages, gzipped PostScript: 113kb via HTTP, FTP, uncompressed PostScript: 462kb via HTTP, FTP)

[Gogolla et al., 2003b]

Martin Gogolla, Mark Richters, and Jörn Bohling. Tool Support for Validating UML and OCL Models through Automatic Snapshot Generation. In Jarr Eloff, Andries Engelbrecht, Paula Kotze, and Mariki Eloff, editors, Proc. Annual Research Conf. South African Institute of Computer Scientists and Information Technologists on Enablement through Technology (SAICSIT'2003), pages 248-257. ACM International Conference Proceedings Series, 2003.

This paper studies tool support for the testing and certification of UML and OCL models as supported by the validation tool USE. We describe the features available in the UML/OCL tool USE and extend its features by introducing a language for defining properties of desired snapshots and by showing how such snapshots are generated. We explain the functionality offered by the USE tool. In particular, we demonstrate how the diverse windows, e.g., object diagram, class invariant, class extent, or OCL expression evaluation window, support the development process in early phases of software development.

(10 pages, gzipped PostScript: 202kb via HTTP, FTP, uncompressed PostScript: 2858kb via HTTP, FTP)

[Kollmann, 2003]

Ralf Kollmann. Design Recovery Techniques for Object-Oriented Software Systems. PhD thesis, Universität Bremen, Fachbereich Mathematik und Informatik, 2003.

Reverse engineering techniques have been applied successfully in software maintenance, reengineering, as well as traditional software engineering processes for many years. With the establishment of the UML as a standard for modeling of object-oriented software systems, many new opportunities but also challenges have opened up in the new field of UML-based reverse engineering. In this dissertation thesis, techniques for application of the UML in static design recovery as well as metric-based static software analysis are presented, with a focus on programs written in Java. To address the problem of uniquely representing aspects of existing programs in UML diagrams, a metamodel for the Java language has been developed. It serves as a foundation for a standardized metamodel-level translation scheme between Java and the UML. Based on this scheme, techniques for recovering the abstract design of a software system from the implementation model are introduced. The focus of these is on design recovery strategies for recognition of advanced UML class diagram features. When reverse engineering non-trivial software systems, the resulting amount of information is often huge. One of the central problems of UML diagrams is the tradeoff between detailed rendering and lack of space and readability: Even for programs of average size, the resulting diagrams tend to become quickly too large for comfortable viewing. In addition to metricbased analysis techniques, which help to understand the software by integrating metrics and UML diagrams, we present a metric-based approach for identification of logical substructures in a software architecture, which helps to partition the system and thus make it easier comprehensible. The techniques presented in this dissertation have been implemented in the reverse engineering tool IDEA, a system for static analysis of Java programs. IDEA supports generation of both UML class as well as activity diagrams from source code. Concerning its primary functionality, static design recovery, it is possible to recognize many of UML s advanced notational features in an interactive process. Furthermore, the calculation of metrics is supported and used both for integration in extended UML class diagrams, as well as for metric-based analyses. The approaches presented in this dissertation thesis contribute to the research field of reverse engineering, by showing novel ways to redocument and analyse object-oriented software systems using the graphical UML notation. Thereby, they help to improve a general understanding of how to apply the UML in reverse engineering and static program analysis.

[Krieg-Brückner et al., 2003]

Bernd Krieg-Brückner, Dieter Hutter, Arne Lindow, Christoph Lüth, Achim Mahnke, Erica Melis, Philipp Meier, Arnd Poetzsch-Heffter, Markus Roggenbach, George Russell, Jan-Georg Smaus, and Martin Wirsing. MultiMedia Instruction in Safe and Secure Systems. In Martin Wirsing, Dirk Pattinson, and Rolf Hennicker, editors, Proc. 16th Int. Workshop Abstract Data Types (WADT'02), pages 82-117. Springer, LNCS 2755, 2003.

The aim of the MMiSS project is the construction of a multimedia Internet-based adaptive educational system. Its content will initially cover a curriculum in the area of Safe and Secure Systems. Traditional teaching materials (slides, handouts, annotated course material, assignments, and so on) are to be converted into a new hypermedia format, integrated with tool interactions for formally developing correct software; they will be suitable for learning on campus and distance learning, as well as interactive, supervised, or cooperative self-study. To ensure sustainable development, i.e. continuous long-term usability of the contents, coherence and consistency are especially emphasised, through extensive semantic linking of teaching elements and a particular version and configuration management, based on experience in formal software development and associated support tools.

(38 pages, gzipped PostScript: 1452kb via HTTP, FTP, uncompressed PostScript: 8909kb via HTTP, FTP)

[Radfelder, 2003]

Oliver Radfelder. Dreidimensionale, interaktive und animierte Softwarevisualisierung zur Unterstützung im Softwareentwicklungsprozess. PhD thesis, Universität Bremen, Fachbereich Mathematik und Informatik, 2003.

In Kapitel 1 werden bestehende Ansätze zur Visualisierung untersucht. Dabei werden speziell dreidimensionale und animierte Techniken und Systeme beleuchtet. Weiterhin werden Taxonimien und Evaluierungen der Softwarevisualisierung untersucht, um am Ende einen Kriterienkatalog für effektive Softwarevisualisierung zu entwickeln. In Kapitel 2 wird die UML am exemplarisch im Einsatz eines Softwareentwurfs gezeigt und Kritikpunkte gesammelt und am Ende diskutiert. In Kapitel 3 wird zunächst der Einsatz dreidimensionaler und animierter Softwarevisualisierung statischer Strukturen diskutiert. Während dessen stelle ich die relevanten Teile der zu diesem Zweck entwickelte Software Uvis vor. Kapitel 4 behandelt die Visualisierung dynamischer Vorgänge ebenfalls im Kontext von Uvis. In Kapitel 5 werden die dynamische und die statische Sicht zusammengeführt, wodurch es möglich wird, eine konzeptionelle Gesamtsicht auf ein Modell zu erhalten. Zusätzlich wird in dem Kapitel diskutiert, wie die Integration zweier ansonsten getrennter Sichtweisen durch die dreidimensionale, interaktive und animierte Visualisierung möglich wird: Die Einbettung der Oberflächen-orientierten Sichtweise des zukünftigen Benutzers in die Spezifikations-orientierte Sicht des Modellierers. In Kapitel 6 wird noch einmal die Arbeit zusammengefasst und diskutiert, sowie ein Ausblick auf mögliche weitere Arbeit zu diesem Thema gegeben.

[Richters and Gogolla, 2003]

Mark Richters and Martin Gogolla. Aspect-Oriented Monitoring of UML and OCL Constraints. In Omar Aldawud, Mohamed Kande, Grady Booch, Bill Harrison, Dominik Stein, Jeff Gray, Siobhan Clarke, Aida Zakaria, Peri Tarr, and Faisal Akkawi, editors, Proc. UML'2003 Workshop Aspect-Oriented Software Development with UML. Illinois Institute of Technology, Department of Computer Science, http://www.cs.iit.edu/ oaldawud/AOM/index.htm, 2003.

We present an approach utilizing aspect-oriented programming (AOP) techniques for mapping between di erent abstraction levels of software. The goal is to facilitate validation and testing of a software implementation against constraints specified on an associated UML model. We use AOP techniques for defining a monitor that observes the behavior of an implementation and maps it to model behavior. The model behavior is then validated against constraints with an existing tool. Constraint violations can thus be identified and traced to a specification of the model.

(7 pages, gzipped PostScript: 191kb via HTTP, FTP, uncompressed PostScript: 884kb via HTTP, FTP)

[Ziemann and Gogolla, 2003a]

Paul Ziemann and Martin Gogolla. An OCL Extension for Formulating Temporal Constraints. Research Report 1/03, Universität Bremen, 2003.

UML class diagrams are widely used to model the static structure of object-oriented software systems. The textual language OCL, which is part of the UML, is used for formulating constraints that can not be modeled by the diagrams. In this paper, we extend OCL with elements of linear temporal logic. With this extended OCL, which we call TOCL, we want to give software engineers a user-friendly means to specify constraints on the temporal evolution of the system structure as well as on the system behavior by stating temporal invariants and pre- and postconditions. We formally define syntax and semantics of the extended OCL.

(20 pages, gzipped PostScript: 179kb via HTTP, FTP, uncompressed PostScript: 444kb via HTTP, FTP)

[Ziemann and Gogolla, 2003b]

Paul Ziemann and Martin Gogolla. OCL Extended with Temporal Logic. In Manfred Broy and Alexandre Zamulin, editors, 5th Int. Conf. Perspectives of System Informatics (PSI'2003), pages 351-357. Springer, Berlin, LNCS 2890, 2003.

UML class diagrams have become a standard for modeling the static structure of object-oriented software systems. OCL can be used for formulating additional constraints that can not be expressed with the diagrams. In this paper, we extend OCL with temporal operators to formulate temporal constraints.

(7 pages, gzipped PostScript: 110kb via HTTP, FTP, uncompressed PostScript: 231kb via HTTP, FTP)

[Ziemann and Gogolla, 2003c]

Paul Ziemann and Martin Gogolla. Validating OCL Specifications with the USE Tool - An Example Based on the BART Case Study. In Thomas Arts and Wan Fokkink, editors, Proc. 8th Int. Workshop Formal Methods for Industrial Critical Systems (FMICS'2003). Electronic Notes in Theoretical Computer Science (ENTCS), Vol. 80, Elsevier, 2003.

The Object Constraint Language (OCL) is part of the Unified Modeling Language (UML). Within software engineering, UML is regarded today as an important step towards development of high-quality object-oriented systems. OCL allows to sharpen UML diagrams through invariants as well as pre- and postconditions. This paper explains the functionality of the UML Specification Environment USE which allows to validate UML and OCL descriptions. The paper shows that central safety properties of the train system described in the well-known BART case study can be expressed with OCL. Test cases embodying central aspects of this train system can be formulated within the USE system. It can be shown that the safety properties are satisfied by the test cases examined.

(13 pages, gzipped PostScript: 188kb via HTTP, FTP, uncompressed PostScript: 695kb via HTTP, FTP)

[Gogolla, 2002]

Martin Gogolla. Editorial for the Special Issue on the UML 2001 Conference. Software and System Modeling (SoSyM), 1(2):83-85, 2002.

This paper is the editorial for the special issue of the journal on Software and Systems Modeling dedicated to the UML 2001 Conference (UML'2001)

[Gogolla and Henderson-Sellers, 2002]

Martin Gogolla and Brian Henderson-Sellers. Formal Analysis of UML Stereotypes within the UML Metamodel. In Steve Cook, Heinrich Hussmann, and Jean-Marc Jezequel, editors, Proc. 5th Int. Conf. Unified Modeling Language (UML'2002). Springer, Berlin, LNCS, 2002.

Stereotypes are a powerful and potentially expressive extension mechanism in the Unified Modeling Language UML. However, it seems that stereotypes are difficult to handle because using stereotypes needs an understanding of the UML metamodel and in particular an understanding of OCL constraints. Stereotypes are often applied in a wrong or at least sloppy way without proper declaration. There are also differences between the various versions of UML with respect to subtle details in the stereotype part. A graphical syntax for stereotypes including examples has been introduced only late in UML 1.4. Other difficulties are that constraints are used in the stereotype context in two completely different ways and that no full support of stereotypes is offered by tools yet. The paper points out these difficulties in detail, analyses the UML metamodel part dealing with stereotypes, and makes various suggestions to improve the definition and use of stereotypes.

(15 pages, gzipped PostScript: 235kb via HTTP, FTP, uncompressed PostScript: 3535kb via HTTP, FTP)

[Gogolla and Richters, 2002]

Martin Gogolla and Mark Richters. Development of UML Descriptions with USE. In Hassan Shafazand and A Min Tjoa, editors, Proc. 1st Eurasian Conf. Information and Communication Technology (EURASIA'2002), pages 228-238. Springer, Berlin, LNCS 2510, 2002.

The Object Constraint Language OCL is part of the Unified Modeling Language UML. Within software engineering, UML is regarded today as an important step towards development of high-quality object-oriented systems. OCL allows to describe system structure by invariants and system behavior by pre- and postconditions. This paper explains the functionality of the UML Specification Environment USE which allows to validate and verify UML and OCL descriptions. The paper also uses a new approach to handle UML statecharts by OCL pre- and postconditions.

(12 pages, gzipped PostScript: 196kb via HTTP, FTP, uncompressed PostScript: 5467kb via HTTP, FTP)

[Gogolla et al., 2002a]

Martin Gogolla, Arne Lindow, Mark Richters, and Paul Ziemann. Metamodel Transformation of Data Models. In Jean Bezivin and Robert France, editors, Proc. UML'2002 Workshop in Software Model Engineering (WiSME 2002). http://www.metamodel.com/wisme-2002, 2002.

This paper studies syntax and semantics of the Entity-Relationship (ER) and Relational data model and their transformation. The ER model may be regarded as a platform independent model and the Relational model as a prototypical platform specific model. The paper studies the transformation between these models and proposes to express that transformation again as a model.

(8 pages, gzipped PostScript: 124kb via HTTP, FTP, uncompressed PostScript: 947kb via HTTP, FTP)

[Gogolla et al., 2002b]

Martin Gogolla, Paul Ziemann, and Sabine Kuske. Towards an Integrated Graph Based Semantics for UML. In Paolo Bottoni and Mark Minas, editors, Proc. ICGT Workshop Graph Transformation and Visual Modeling Techniques (GT-VMT'2002). Electronic Notes in Theoretical Computer Science (ENTCS), Vol. 72, No. 3, Elsevier, 2002.

Recently, we proposed an integrated formal semantics based on graph transformation for central aspects of UML class, object and state diagrams. In this paper, we explain the basic ideas of that approach and show how two more UML diagram types, sequence and collaboration diagrams, can be captured. For UML models consisting of a class diagram and particular state diagrams, a graph transformation system can be defined. Its graphs are associated with system states and its rules with operations in the class diagram and transitions in the state diagrams. Sequence and collaboration diagrams then characterize sequences of operation applications and therefore sequences of transformation rule applications. Thus valid sequence and collaboration diagrams correspond to derivations induced by the graph transformation system. Proceeding this way, it can be checked for example whether such an operation application sequence may be applied in a specific system state.

(16 pages, gzipped PostScript: 95kb via HTTP, FTP, uncompressed PostScript: 328kb via HTTP, FTP)

[Kollmann and Gogolla, 2002]

Ralf Kollmann and Martin Gogolla. Metric-Based Selective Representation of UML Diagrams. In Tibor Gyimóthy and Fernando Brito e Abreu, editors, Proc. 6th European Conf. Software Maintenance and Reengineering (CSMR'02). IEEE, Los Alamitos, 2002.

UML diagrams are widely employed for modeling of object-oriented software systems. In addition to their application in forward engineering, it is also possible to use them for the redocumentation of existing programs. However, the inherent structure of UML diagrams, which consists of graphical as well as textual information, makes it difficult to read and oversee large diagrams generated from complex systems. The view on such diagrams can be compared with taking a look at a detailed map: the reader has to decide whether to read the fine details or to view the whole structure. We present approaches to overcome this problem by using object-oriented metrics for program analysis and location of submodules in diagrams that belong together in terms of coupling. The shown techniques have been implemented into our reverse engineering tool Idea, which allows interactive selection and isolation of coherent regions of class diagrams.

(10 pages, gzipped PostScript: 295kb via HTTP, FTP, uncompressed PostScript: 1929kb via HTTP, FTP)

[Kollmann et al., 2002]

Ralf Kollmann, Petri Selonen, Eleni Stroulia, Tarja Systä, and Albert Zündorf. A Study on the Current State of the Art in Tool-Supported UML-Based Static Reverse Engineering. In Elizabeth Burd and Arie van Deursen, editors, Proc. 9th Working Conf. Reverse Engineering (WCRE'02). IEEE, Los Alamitos, 2002.

Today, software-engineering research and industry alike recognize the need for practical tools to support reverse-engineering activities. Most of the well-known CASE-tools nowadays support reverse engineering in some way. But although the Unified Modeling Language (UML) has emerged as the de facto standard for the abstract graphical representation of object-oriented software systems, there does not yet exist a standard scheme for representing the reverse engineered models of software systems. Due to the differences in understanding and application of the UML notation and the proprietary extensions that different tools adopt, it is often difficult to ensure that model semantics remains unambiguous when working with different tools at the same time. In this paper, we examine the capabilities of the two most successful industrial-strength CASE-tools in reverse engineering the static structure of software systems and compare them to the results produced by two academic prototypes. The comparisons are carried out both manually and automatically using a research prototype for manipulating and comparing UML models.

(11 pages, gzipped PostScript: 48kb via HTTP, FTP, uncompressed PostScript: 391kb via HTTP, FTP)

[Kuske et al., 2002]

Sabine Kuske, Martin Gogolla, Ralf Kollmann, and Hans-Jörg Kreowski. An Integrated Semantics for UML Class, Object, and State Diagrams based on Graph Transformation. In Michael Butler and Kaisa Sere, editors, 3rd Int. Conf. Integrated Formal Methods (IFM'02). Springer, Berlin, LNCS, 2002.

This paper studies the semantics of a central part of the Unified Modeling Language UML. It discusses UML class, object and state diagrams and presents a new integrated semantics for both on the basis of graph transformation. Graph transformation is a formal technique having some common ideas with the UML. Graph transformation rules are associated with the operations in class diagrams and with the transitions in state diagrams. The resulting graph transformations are combined into one system in order to obtain a single coherent semantic description.

(19 pages, gzipped PostScript: 109kb via HTTP, FTP, uncompressed PostScript: 494kb via HTTP, FTP)

[Richters, 2002]

Mark Richters. A Precise Approach to Validating UML Models and OCL Constraints. PhD thesis, Universität Bremen, Fachbereich Mathematik und Informatik, Logos Verlag, Berlin, BISS Monographs, No. 14, 2002.

We present a precise approach that allows an analysis and validation of UML models and OCL constraints. We focus on models and constraints specified in the analysis and early design stage of a software development process. For this purpose, a suitable subset of UML corresponding to information that is usually represented in class diagrams is identified and formally defined. This basic modeling language provides a context for all OCL constraints. We define a formal syntax and semantics of OCL types, operations, expressions, invariants, and pre-/postconditions. We also give solutions for problems with the current OCL definition and discuss possible extensions. A metamodel for OCL is introduced that defines the abstract syntax of OCL expressions and the structure of types and values. The metamodel approach allows a seamless integration with the UML metamodeling architecture and makes the benefits of a precise OCL definition easier accessible. The OCL metamodel also allows to define context-sensitive conditions for well-formed OCL expressions more precisely. These conditions can now be specified with OCL whereas they previously were specified only informally. % In order to demonstrate the practical applicability of our work, we have realized substantial parts of it in a tool supporting the validation of models and constraints. Design specifications can be ``executed'' and animated thus providing early feedback in an iterative development process. Our approach offers novel ways for checking user data against specifications, for automating test procedures, and for checking CASE tools for standards conformance. Therefore, this work contributes to the goal of improving the overall quality of software systems by combining theoretical and practical techniques.

[Wang et al., 2002]

Rui-Jin Wang, Hui-Chuan Duan, and Martin Gogolla. Unified Modeling Language and Its Application to Modeling. Application Research of Computers, 19(8):80-84, 2002. ISSN 1001-3695.

In the present paper we introduced briefly the main concepts of the Unified Modeling Language (UML), concentrating on the nine kinds of diagrams. In order to show a clue to the application of the UML, we built a simple model for the sales management system in a supermarket using the UML.

( pages, gzipped PostScript: 1269kb via HTTP, FTP, uncompressed PostScript: 3558kb via HTTP, FTP)

[Ziemann and Gogolla, 2002]

Paul Ziemann and Martin Gogolla. An Extension of OCL with Temporal Logic. In Jan Jürjens, editor, Proc. UML'2002 Workshop Critical System Development (CSD 2002). Technical Report, Technical University of Munich, 2002.

UML class diagrams are widely used to model the static structure of object-oriented software systems. As a supplement, OCL becomes more and more popular for formulating constraints that can not be modeled by the diagrams. In this paper, we extend OCL with elements of temporal logic. With this extension, constraints on the temporal development of the system structure as well as on the system behavior can be stated in terms of temporal invariants and pre- and postconditions.

(10 pages, gzipped PostScript: 139kb via HTTP, FTP, uncompressed PostScript: 295kb via HTTP, FTP)

[Barbier et al., 2001]

Franck Barbier, Brian Henderson-Sellers, Andreas Opdahl, and Martin Gogolla. The Whole-Part Relationship in Object-Oriented Modeling. In Keng Siau and Terry Halpin, editors, Unified Modeling Language: Systems Analysis, Design, and Development Issues, pages 186-209. Idea Group Publishing, Hershey (PA), USA, 2001.

This study of the semantics of the Whole-Part relationship in OO modelling is based on previous detailed analysis of the semantics of UML's Aggregation and Composition (white and black diamonds). Although UML is nowadays a standard and an intensively used OO modelling language, the way the Whole-Part is formalised is unsatisfactory. In this respect, we provide a complete specification by using OCL (Object Constraint Language). This is based on a separation between primary characteristics assigned to the "Whole-Part" metatype, considered as necessary in the metamodel of UML, and secondary features possessed by subtypes of this metatype. This UML-compliant style of specification, based on the use of OCL as well as metamodelling, allows us to directly incorporate our results into the metamodel, in particular to revise UML's definition of Composition.

(20 pages, gzipped PostScript: 414kb via HTTP, FTP, uncompressed PostScript: 1058kb via HTTP, FTP)

[Gogolla, 2001a]

Martin Gogolla. Formal Methods versus UML's OCL. In Stefan Jähnichen, Jeff Kramer, Michel Lemoine, and Martin Wirsing, editors, Can Formal Methods Cope with Software-Intensive Systems, pages 19-20. Dagstuhl-Seminar-Report 308, 2001.

The talk explains the connection between the Unified Modeling Language UML and its Object Constraint Language OCL. It shows OCL features by considering the BART case study and giving a small abstract specification for it. This specification is animated by means of the UML Specification Environment USE developed at University of Bremen. Finally the talk discusses to what extent OCL is different from existing formal specification languages.

(2 pages, gzipped PostScript: 60kb via HTTP, FTP, uncompressed PostScript: 1314kb via HTTP, FTP)

[Gogolla, 2001b]

Martin Gogolla. Using OCL for Defining Precise, Domain-Specific UML Stereotypes. In Aybuke Aurum and Ross Jeffery, editors, Proc. 6th Australian Workshop on Requirements Engineering (AWRE'2001), pages 51-60. Centre for Advanced Software Engineering Research (CAESER), University of New South Wales, Sydney, 2001.

This paper studies the extension mechanisms of the Unified Modeling Language UML. It introduces a new appproach for defining UML stereotypes and shows its usefulness by considering domain-specific requirements for databases. The stereotypes introduced possess a precise meaning by translating them into expressions formulated in the Object Constraint Language OCL. Apart from proposing a general framework for stereotype definition, this work is also one step in the development of a domain-specific requirements language for information systems.

(10 pages, gzipped PostScript: 98kb via HTTP, FTP, uncompressed PostScript: 349kb via HTTP, FTP)

[Gogolla and Kobryn, 2001]

Martin Gogolla and Cris Kobryn, editors. Proc. 4th Int. Conf. Unified Modeling Language (UML'2001). Springer, LNCS 2185, 2001.

This book contains the papers accepted for the 4th International Conference on the Unified Modeling Language (UML'2001).

[Gogolla and Richters, 2001]

Martin Gogolla and Mark Richters. Expressing UML Class Diagrams Properties with OCL. In Tony Clark and Jos Warmer, editors, Advances in Object Modelling with the OCL, pages 86-115. Springer, Berlin, LNCS 2263, 2001.

The Unified Modeling Language UML is a complex language offering many modeling features. Especially the description of static structures with class diagrams is supported by a rich set of primitives. This paper shows how to transfrom UML class diagrams involving cardinality constraints, qualifiers, association classes, aggregations, compositions, and generalizations into equivalent UML class diagrams employing only binary associations and OCL constraints. Thus we provide a better understanding of UML features. By reducing more complex features in terms of basic ones, we suggest an easy way users can gradually extend the set of UML elements they commonly apply in the modeling process.

(29 pages, gzipped PostScript: 96kb via HTTP, FTP, uncompressed PostScript: 747kb via HTTP, FTP)

[Kollmann and Gogolla, 2001a]

Ralf Kollmann and Martin Gogolla. Application of the UML Associations and Their Adornments in Design Recovery. In Peter Aiken and Elizabeth Burd, editors, Proc. 8th Working Conference on Reverse Engineering (WCRE'2001). IEEE, Los Alamitos, 2001.

Many CASE tools support reverse engineering and UML. However, it can be observed that usually, only a subset of the UML notation is supported, namely those parts with a more or less direct code representation. Although a lot of research is done in this field, the more advanced features of UML notations are not commonly supported in reverse engineering. In this paper, we show approaches to discover patterns in program code that can be represented by means of advanced notational features of UML class diagrams. We obtain the necessary information by reverse engineering Java programs with different methods. These have been implemented in a prototypical implementation.

(10 pages, gz