Publications of the University of Bremen Database Systems Group

[Büttner and Kuhlmann, 2009]

Fabian Büttner and Mirco Kuhlmann. Shortcomings of the Embedding of OCL into QVT ImperativeOCL. In Michel R.V. Chaudron, editor, Workshops and Symposia at 11th Int. Conf. Model Driven Engineering Languages and Systems (MODELS'2008), pages 263-272. Springer, Berlin, LNCS 5421, 2009.

MOF QVT introduces ImperativeOCL as an imperative language for operational descriptions of model transformations (QVT operational mappings). ImperativeOCL extends conventional OCL by expressions with side-effects. A couple of semantical problems arise from the way OCL is embedded into ImperativeOCL - imperative expressions are modelled as a subtype of OCL expressions. This paper points out these semantical problems and proposes a change to the operational mappings language of QVT that resolves these problems, following an approach that reuses OCL by composition rather than by inheritance in the abstract syntax of ImperativeOCL. The proposed change reduces the complexity of the imperative language, removes undefinedness, and leaves OCL conformant to its original definition.

(10 pages, gzipped PostScript: 550kb via HTTP, FTP, uncompressed PostScript: 10798kb via HTTP, FTP)

[Cabot et al., 2009]

Jordi Cabot, Martin Gogolla, and Pieter Van Gorp. Eighth International Workshop on OCL Concepts and Tools. In Michel R.V. Chaudron, editor, Workshops and Symposia at 11th Int. Conf. Model Driven Engineering Languages and Systems (MODELS'2008), pages 257-262. Springer, Berlin, LNCS 5421, 2009.

This paper reports on the 8th OCL workshop held at the MODELS conference in 2008. The workshop focussed on how to evaluate, compare and select the right OCL tools for a given purpose and how to deal with the expressiveness and complexity of OCL. The workshop included sessions with paper presentations as well as a special tool demo session.

(6 pages, gzipped PostScript: 118kb via HTTP, FTP, uncompressed PostScript: 286kb via HTTP, FTP)

[Dang and Gogolla, 2009a]

Duc-Hanh Dang and Martin Gogolla. On Integrating OCL and Triple Graph Grammars. In Michel R.V. Chaudron, editor, Workshops and Symposia at 11th Int. Conf. Model Driven Engineering Languages and Systems (MODELS'2008), pages 124-137. LNCS 5421, Springer, Berlin, 2009.

Triple Graph Grammars (TGGs) tend to be a promising approach for explaining relationships between models in general, and model co-evolution and model consistency within model-driven development in particular. Declarative TGG descriptions can be translated into operational scenarios for model integration, model synchronization, and model transformation. To realize such scenarios, restrictions formulated with the Object Constraint Language (OCL) are an important factor. How to integrate TGGs and OCL is a topic of ongoing research activities. There are strong similarities between the result of such an integration and the Queries, Views and Transformations (QVT) standard of the Object Management Group (OMG). We propose a language for this integration: One part of this language has a one-one mapping to TGGs and the remaining part covers OCL concepts. The language is realized in our tool UML-based Specification Environment (USE) by taking two views on operations derived from TGG rules: Declarative OCL pre- and postconditions are employed as operation contracts, and imperative command sequences are taken as an operational realization. USE offers full OCL support for restricting models and metamodels with invariants, for checking pre- and postconditions of operations as well as for validating and animating transformation operations. Our approach covers a complete realization of TGGs incorporating OCL within our tool USE.

(13 pages, gzipped PostScript: 5555kb via HTTP, FTP, uncompressed PostScript: 21481kb via HTTP, FTP)

[Dang and Gogolla, 2009b]

Duc-Hanh Dang and Martin Gogolla. Precise Model-Driven Transformations Based on Graphs and Metamodels. In Dang Van Hung and Padmanabhan Krishnan, editors, Proc. 7th IEEE Int. Conf. Software Engineering and Formal Methods (SEFM 2009). IEEE, 2009.

Presenting precisely models and supporting automatic manipulation of models are at the heart of model-centric software development. A formal foundation for these tasks is a necessity as well as a challenge. We present a model-driven approach based on the integration of two light-weight formal methods, the Object Constraint Language (OCL) and Triple Graph Grammars (TGGs). OCL together with metamodeling allows us to present precisely models. With TGGs we can carry out model manipulations, especially model transformations. We focus on explaining the tool which realizes our approach. This tool is developed as an extension of the UML-based Specification Environment (USE), which offers full OCL support. A case study showing the transformation between statecharts and extended hierarchical automata explains our approach.

(10 pages, gzipped PostScript: 497kb via HTTP, FTP, uncompressed PostScript: 2639kb via HTTP, FTP)

[France and Gogolla, 2009]

Robert France and Martin Gogolla. Educators' Symposium at MODELS 2009. In Andy Schürr and Bran Selic, editors, Proc. 11th Int. Conf. Model Driven Engineering Languages and Systems (MoDELS'2008), pages 753-754. Springer, Berlin, LNCS 5795, 2009.

The Educator's Symposium at the MODELS conference, the premier conference devoted to the topic of model-driven engineering of software-based systems, is intended as a forum in which educators and trainers can meet to discuss pedagogy, use of technology in the classroom, and share their experience pertaining to teaching modeling techniques and model-driven development.

(2 pages, gzipped PostScript: 33kb via HTTP, FTP, uncompressed PostScript: 76kb via HTTP, FTP)

[Gogolla et al., 2009]

Martin Gogolla, Mirco Kuhlmann, and Lars Hamann. Consistency, Independence and Consequences in UML and OCL Models. In Catherine Dubois, editor, Proc. 3rd Int. Conf. Test and Proof (TAP'2009), pages 90-104. Springer, Berlin, LNCS 5668, 2009.

Properties in UML models are frequently formulated as OCL invariants or OCL pre- and postconditions. The UML-based Specification Environment (USE) supports validation and to a certain degree verification of such properties. USE allows the developer to prove the consistency and independence of invariants by building automatically generated test cases. USE also assists the developer in checking consequences and making deductions from invariants by automatically constructing a set of test cases in form of model scenarios. Suspected deductions are either falsified by a counter test case or are shown to be valid in a fixed finite search space.

(16 pages, gzipped PostScript: 206kb via HTTP, FTP, uncompressed PostScript: 2441kb via HTTP, FTP)

[Kuske et al., 2009]

Sabine Kuske, Martin Gogolla, Hans-Jorg Kreowski, and Paul Ziemann. Towards an Integrated Graph-Based Semantics for UML. Journal on Software and System Modeling, 8(3):403-422, 2009.

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)

[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 Steimke, 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, 2008a]

Martin Gogolla. On Horizontal and Vertical Relationships between Models. In Uwe Asmann, Jean Bézivin, Richard Paige, Bernhard Rumpe, and Douglas C. Schmidt, editors, Perspectives Workshop: Model Engineering of Complex Systems (MECS). IBFI, Schloss Dagstuhl, Germany, 2008. Dagstuhl Seminar Proceedings 08331. 4 pages.

Detecting, modeling and managing relationships between models are central tasks within model-driven engineering. By taking a simple view on software development, we distinguish in a vertical dimension between domain-specific models, core models, and executable models. A typical example for a vertical relationship is the refinement relationship beween a core model and an executable model. In the horizontal dimension, there may be several so-called property models which have the task to validate or verify particular properties of the core model. Software development coincides in our view with model development, and therefore finding the right models and their relationships is a crucial task.

(4 pages, gzipped PostScript: 107kb via HTTP, FTP, uncompressed PostScript: 1544kb via HTTP, FTP)

[Gogolla, 2008b]

Martin Gogolla. Teaching Touchy Transformations. In Michal Smialek, editor, MODELS Educators' Symposium (EDUSYMP'2008), pages 13-25. Warsaw University, ISBN 83-916444-8-0, 2008.

This paper reports on a teaching unit on model development and model transformation. One example model is first developed and considered as the source of various possible transformations. These transformations are explained implicitly afterwards by showing the different target models obtained by the transformations. The source model and the target models each emphasize a particular aspect, and an appropriate teaching method is chosen in order to communicate central ideas in a well-understandable way. The chosen teaching methods stress active student participation in the development of models and transformations.

(13 pages, gzipped PostScript: 167kb via HTTP, FTP, uncompressed PostScript: 2235kb 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), pages 585-586. 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), 85:57-58, 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)

[Gogolla et al., 2008c]

Martin Gogolla, Mirco Kuhlmann, and Fabian Büttner. A Benchmark for OCL Engine Accuracy, Determinateness, and Efficiency. In Krzysztof Czarnecki, editor, Proc. 11th Int. Conf. Model Driven Engineering Languages and Systems (MoDELS'2008), pages 446-459. LNCS 5301, Springer, Berlin, 2008.

The Object Constraint Language (OCL) is a central element in modeling and transformation languages like UML, MOF, and QVT. Consequently approaches for MDE (Model-Driven Engineering) depend on OCL. However, OCL is present not only in these areas influenced by the OMG but also in the Eclipse Modeling Framework (EMF). Thus the quality of OCL and its realization in tools seems to be crucial for the success of model-driven development. Surprisingly, up to now a benchmark for OCL to measure quality properties has not been proposed. This paper puts forward in the first part the concepts of a comprehensive OCL benchmark. Our benchmark covers (A) OCL engine accuracy (e.g., for the undefined value and the use of variables), (B) OCL engine determinateness properties (e.g., for the collection operations any and flatten), and (C) OCL engine efficiency (for data type and user-defined operations). In the second part, this paper empirically evaluates the proposed benchmark concepts by examining a number of OCL tools. The paper discusses several differences in handling particular OCL language features and underspecifications in the OCL standard.

(15 pages, gzipped PostScript: 160kb via HTTP, FTP, uncompressed PostScript: 423kb 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)

[Mustafa et al., 2008]

Tanveer Mustafa, Karsten Sohr, Duc-Hanh Dang, Michael Drouineaud, and Stefan Kowski. Implementing Advanced RBAC Administration Functionality with USE. Electronic Communications of the EASST, http://eceasst.cs.tu-berlin.de/index.php/eceasst, 15, 2008. MoDELS Workshop on OCL (OCL Concepts and Tools 2008), 19 Pages.

Role-based access control (RBAC) is a powerful means for laying out and developing higher-level organizational policies such as separation of duty, and for simplifying the security management process. One of the important aspects of RBAC is authorization constraints that express such organizational policies. While RBAC has generated a great interest in the security community, organizations still seek a flexible and effective approach to impose role-based authorization constraints in their security-critical applications. In particular, today often only basic RBAC concepts have found their way into commercial RBAC products; specifically, authorization constraints are not widely supported. In this paper, we present an RBAC administration tool that can enforce certain kinds of role-based authorization constraints such as separation of duty constraints. The authorization constraint functionality is based upon the OCL validation tool USE. We also describe our practical experience that we gained on integrating OCL functionality into a prototype of an RBAC administration tool that shall be extended to a product in the future.

(19 pages, gzipped PostScript: 790kb via HTTP, FTP, uncompressed PostScript: 1980kb 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, gzipped PostScript: 53kb via HTTP, FTP, uncompressed PostScript: 163kb via HTTP, FTP)

[Kollmann and Gogolla, 2001b]

Ralf Kollmann and Martin Gogolla. Capturing Dynamic Program Behaviour with UML Collaboration Diagrams. In Pedro Sousa and Jürgen Ebert, editors, Proc. 5th European Conf. Software Maintenance and Reengineering (CSMR'01), pages 58-67. IEEE, Los Alamitos, 2001.

The UML provides means to specify both static and dynamic aspects of object-oriented software systems and can be used to assist in all phases of a software development process. With growing support by CASE tools, its applications become more and more widespread. In addition to the automatic generation of class code from diagrams, the recovery of static structure from source code has become common, too. In this paper however, we focus on the extraction of behavioural information from program code. We introduce a restricted meta model for Java code and present a new approach to extract the required data, which will then be rendered as UML collaboration diagrams.

(10 pages, gzipped PostScript: 37kb via HTTP, FTP, uncompressed PostScript: 137kb via HTTP, FTP)

[Kollmann and Gogolla, 2001c]

Ralf Kollmann and Martin Gogolla. Selektive Darstellung von Programmstrukturen mit UML. In Jürgen Ebert and Franz Lehner, editors, Proc. 3. Workshop Software-Reengineering. Universität Koblenz, Technischer Bericht, http://www.uni-koblenz.de/ ist/WSR2001, 2001.

Das Papier beschreibt, wie verschiedene Ansätze zur Selektion und Transformation von durch Reverse Engineering gesammelten Informationen dazu beitragen können, die Menge der durch Programmcode gegebenen Informationen in komprimierter Weise darzustellen, um Lesbarkeit und Verständnis zu erleichtern. Wir unterscheiden zwischen Abstraktion, wobei komplexere Elemente der UML Notation von Klassendiagrammen zum Einsatz kommen, und selektiver Darstellung, wobei die Transformation der Daten mit einer manuellen Selektion kombiniert wird. Beim Einsatz dieser Techniken hat sich gezeigt, daß durch die kombinierte Herangehensweise bessere Ergebnisse erreicht werden können.

(6 pages, gzipped PostScript: 54kb via HTTP, FTP, uncompressed PostScript: 133kb via HTTP, FTP)

[Lindow et al., 2001]

Arne Lindow, Martin Gogolla, and Mark Richters. Ein formal validiertes Metamodell für die Transformation von Schemata in Informationssystemen. In K. Bauknecht, W. Brauer, and T. Mück, editors, Proc. GI Jahrestagung (GI'2001), Band 1, Workshop Integrating Diagrammatic and Formal Specification Techniques, pages 662-669. Austrian Computer Society, Wien, 2001.

Dieses Papier stellt eine Verbindung von klassischen Datenmodellen wie dem Entity-Relationship-Modell und dem relationalen Modell mit dem Metamodellierungsansatz der Meta-Object-Facility her. Es wird eine Modellierung sowohl für das ER-Modell als auch für das relationale Modell vorgestellt. Ergänzend wird die Transformation von Entity-Relationship-Schemata in relationale Schemata diskutiert. Alle drei Ebenen werden formal spezifiziert und mit einem Werkzeug validiert.

(8 pages, gzipped PostScript: 111kb via HTTP, FTP, uncompressed PostScript: 3854kb via HTTP, FTP)

[Richters and Gogolla, 2001]

Mark Richters and Martin Gogolla. OCL - Syntax, Semantics and Tools. In Tony Clark and Jos Warmer, editors, Advances in Object Modelling with the OCL, pages 43-69. Springer, Berlin, LNCS 2263, 2001.

The Object Constraint Language OCL allows to formally specify constraints on a UML model. We present a formal syntax and semantics for OCL based on set theory including expressions, invariants and pre- and postconditions. A formal foundation for OCL makes the meaning of constraints precise and helps to eliminate ambiguities and inconsistencies. A precise language de nition is also a prerequisite for implementing CASE tools providing enhanced support for UML models and OCL constraints. We give a survey of some OCL tools and discuss one of the tools in some more detail. The design and implementation of the USE tool supporting the validation of UML models and OCL constraints is based on the formal approach presented in this paper.

(27 pages, gzipped PostScript: 135kb via HTTP, FTP, uncompressed PostScript: 524kb via HTTP, FTP)

[Warmer et al., 2001]

Jos Warmer, Anneke Kleppe, Tony Clark, Anders Ivner, Jonas Högström, Martin Gogolla, Mark Richters, Heinrich Hussmann, Steffen Zschaler, Simon Johnston, David S. Frankel, and Conrad Bock. Object Constraint Language 2.0. Technical report, Submission to the OMG, 2001.

This paper is a submission in response to the UML 2.0 OCL request for proposals. It proposes syntax and semantics of a new version of the Object Constraint Language OCL.

(155 pages, gzipped PostScript: 889kb via HTTP, FTP, uncompressed PostScript: 4317kb via HTTP, FTP)

[Gärtner, 2000]

Heino Gärtner. Schematransformationen in objektorientierten Informationssystemen. PhD thesis, Universität Bremen, Fachbereich Mathematik und Informatik, Shaker Verlag, Aachen, 2000.

Die vorliegende Arbeit konzentriert sich auf die Untersuchung der vertikalen Schemaevolution und geht dabei wie folgt vor: Nachdem im folgenden Abschnitt die benötigten Grundbegriffe aus dem Bereich der konzeptionellen Modellierung und der Schemaevolution geklärt worden sind, folgt zunächst die Präsentation eines einfachen Objektmodells, das im wesentlichen die Konzepte des ER-Modells umfaßt. Danach werden die Grundlagen von Schematransformation diskutiert und eine formal begründete Notation zur Beschreibung von atomaren Schemaänderungsoperationen, Schematransformationsprimitiven, vorgestellt. Mit Hilfe dieser Notation werden zunächst Transformationen auf den Konstrukten des einfachen Objektmodells beschrieben. Danach wird das einfache Objektmodell schrittweise um weitergehende Konzepte erweitert und deren Transformationsmöglichkeiten in dem präsentierten Rahmen diskutiert. Im darauf folgenden Abschnitt werden schließlich Transformationen von Spezifikationsanteilen, die über die Modellierung struktureller Information hinausgehen, am Beispiel von Objektlebensläufen erläutert. Im vorletzten Abschnitt wird die Perspektive der Spezifikation verlassen und erörtert, wie sich der vorgestellte Ansatz in den Softwareentwicklungsprozeß integrieren läßt. Eine Einordnung in die bisherige Forschung und ein Ausblick auf künftige Entwicklungsmöglichkeiten beschließt die Arbeit.

[Gogolla, 2000]

Martin Gogolla. Graph Transformations on the UML Metamodel. In Jose D.P. Rolim, Andrei Z. Broder, Andrea Corradini, Roberto Gorrieri, Reiko Heckel, Juraj Hromkovic, Ugo Vaccaro, and Joe B. Wells, editors, Proc. ICALP Workshop Graph Transformations and Visual Modeling Techniques (GTVMT'2000), pages 359-371. Carleton Scientific, Waterloo, Ontario, Canada, 2000.

The Unified Modeling Language UML is a rich language so that it seems not feasible to give a single semantics for the complete language in one step. In order to define the semantics, we propose to translate as many UML language features as possible into UML itself. The part of UML which cannot be treated in this way is called the UML core. The semantics of the non-core language features is given by a translation into the core, whereas a different semantics (for example a set-theoretic one or a semantics on the basis of graphs) must be given to the UML core. It turns out that for the first step, namely the translation of UML language features into the UML core, graph transformations are an ideal language for expressing the required manipulations and the UML metamodel gives the necessary fundamental vocabulary and notions.

(13 pages, gzipped PostScript: 91kb via HTTP, FTP, uncompressed PostScript: 371kb via HTTP, FTP)

[Gogolla and Kollmann, 2000]

Martin Gogolla and Ralf Kollmann. Re-Documentation of Java with UML Class Diagrams. In Eliot Chikofsky, editor, Proc. 7th Reengineering Forum, Reengineering Week 2000 Zürich, pages REF 41-REF 48. Reengineering Forum, Burlington, Massachusetts, 2000.

This paper describes the generation of class diagrams characterizing the static data and class structure of Java source code. To achieve such a diagrammatic representation, translation rules are defined that transform Java syntax into UML notation. Attention is paid especially to implicit and advanced properties of associations. First, an implementation view class diagram of the Java source code is generated that reflects program-specific details of the source code. In a second, more involved step, we try to create a design view from the source code and also represent certain patterns as ODMG language features. The focus of our approach is on minimizing the resulting UML diagrams (minimal with respect to the number of elements in the diagrams) by recognizing certain patterns in the source code and transforming certain low-level syntactic constructs into high-level semantic UML features.

(9 pages, gzipped PostScript: 67kb via HTTP, FTP, uncompressed PostScript: 199kb via HTTP, FTP)

[Gogolla and Richters, 2000]

Martin Gogolla and Mark Richters. Definition von UML mit UML und OCL: Ein Überblick zum Stand der Technik. In Mario Jeckle, Bernhard Rumpe, Andy Schürr, and Andreas Winter, editors, Proc. 7. GROOM-Workshop ``UML - Erweiterungen (Profile) und Konzepte der Metamodellierung''. Universität Koblenz-Landau, Fachbereich Informatik, 2000. Auch: Softwaretechnik-Trends, 20:2, 2000, ISSN 0720-8928.

Das Ziel dieser Arbeit ist es, einen Überblick zum Einsatz der Object Constraint Language OCL zum einen bei der Beschreibung von Modellen mit der Unified Modeling Language UML und zum anderen bei der Beschreibung des UML-Metamodells zu vermitteln. Eingang in die Überlegungen finden die Dokumente des UML-Standards, eigene Arbeiten und weitere Papiere anderer Arbeitsgruppen.

(2 pages, gzipped PostScript: 17kb via HTTP, FTP, uncompressed PostScript: 38kb via HTTP, FTP)

[Gogolla et al., 2000]

Martin Gogolla, Oliver Radfelder, Ralf Kollmann, and Mark Richters. Analysing Atomic Dynamic UML Notions by Surfing through the UML Metamodel. In Gianna Reggio, Alexander Knapp, Bernhard Rumpe, Bran Selic, and Roel Wieringa, editors, Proc. UML'00 Workshop Dynamic Behaviour in UML Models, pages 57-62. LMU München, Informatik-Bericht Nr. 0006, 2000.

This paper analyses atomic notions in UML which are fundamental for the understanding of dynamic aspects. The notions considered are: Action, Event, Exception, Message, Method, Signal, Stimulus, Operation, and Reception. We surf through the UML metamodel by combining the different metamodel class diagrams, where these notions are defined, into a single class diagram. Thereby we point out the intent, similarities and differences between these notions. Thus before doing a formalization, we try to make the concepts a bit clearer than they appear in the UML Semantics document.

(6 pages, gzipped PostScript: 44kb via HTTP, FTP, uncompressed PostScript: 153kb via HTTP, FTP)

[Huge, 2000]

Anne Kathrin Huge. Formalisierung objektorientierter Datenbanken auf der Grundlage von ODMG. PhD thesis, Universität Bremen, Fachbereich Mathematik und Informatik, Shaker Verlag, Aachen, 2000.

Die Untersuchung objektorientierter Methoden zeigt, daß die Bereitstellung einer formalen Grundlage ein häufiges Problem ist. Dabei stellt gerade eine formale Grundlage die Basis für ein eingehendes Verständnis der Semantik von Modellierungs- und Spracheigenschaften dar. Ein vergleichender Rückblick auf die generelle Entwicklung von Datenbanken ergibt, daß sich insbesondere das relationale Datenbankmodell auf eine wohldefinierte formale Grundlage stützt und somit den weitreichenden Erfolg relationaler Datenbanksysteme (inklusive SQL) begründet. Ausgehend von diesen Beobachtungen wird in dieser Arbeit eine formale Grundlage für objektorientierte Datenbanken auf der Grundlage des ODMG-Standards vorgestellt. Der ODMG-Standard vereinheitlicht die Konzepte objektorientierter Datenbanken und ermöglicht Portabilität. Um die Lücke zwischen der informellen Beschreibung von ODMG-Sprachkonstrukten und den theoretischen Grundlagen zu schließen, wird in dieser Arbeit ein mengentheoretischer Ansatz zur Beschreibung des ODMG-Objektmodells und der Anfragesprache OQL vorgestellt. Nach einer eher informellen Vorstellung der Konzepte des ODMG-Modells und deren Einbettung in die allgmeinen Konzepte objektorientierter Datenbanken und anschließender vergleichenden Darstellung mit anderen objektorientierten Datenmodellen und Modellierungssprachen wird eine formale Beschreibung des ODMG-Modells und der OQL vorgenommen. Die Formalisierung beruht auf einem Zwei-Schichten-Ansatz, wonach zwischen einer Datenschicht und einer Objektebene differenziert wird. Auf dies Weise erfolgt eine strikte Trennung zwischen unveränderlichen Datentypen und veränderlichen Objekttypen. Um eine konsistente Implementierung einer ODMG-Objektmodell-Spezifikation in einer der Sprachanbindungen (C++, Smalltalk, Java) zu gewährleisten, wird eine Transformation der Konstrukte des ODMG-Modells auf die entsprechenden Konstrukte der Sprachanbindungen vorgestellt.

[Radfelder and Gogolla, 2000]

Oliver Radfelder and Martin Gogolla. On Better Understanding UML Diagrams through Interactive Three-Dimensional Visualization and Animation. In Vito Di Gesu, Stefano Levialdi, and Laura Tarantino, editors, Proc. Advanced Visual Interfaces (AVI'2000), pages 292-295. ACM Press, New York, 2000.

Different approaches support the construction of software by representing certain aspects of a system graphically. Recently, the UML has become common to provide software designers with tools, in which they can create visual representations of software interactively. But the UML is intended to be drawn on two-dimensional surfaces. Our approach extends UML into a third and fourth dimension in a way that we can place both static and dynamic aspects in one single view. By this, we can show behavior in the context of structural aspects, instead of drawing different diagrams for each aspect with only loose relation to each other. We also use the third dimension to emphasize important things and to place less interesting things in the background. Thereby, we direct the viewer's attention to the important things in the foreground. Currently, UML shows dynamic behavior by diagrams which do not change and are therefore static in nature. In sequence diagrams, for example, time elapses from the top of the diagram to the bottom. We point out that behavior is better visualized by animated diagrams where message symbols move from the sender object to the receiver object. Our approach supports the creation of a system as well as the communication of its dynamic processes especially to customers.

(4 pages, gzipped PostScript: 526kb via HTTP, FTP, uncompressed PostScript: 851kb via HTTP, FTP)

[Radfelder et al., 2000]

Oliver Radfelder, Martin Gogolla, and Volker Behr. Entwurf und Implementierung eines Internet-basierten Material-Informationssystems. Interner Bericht, Universität Bremen, Fachbereich 3, 2000.

Das Projekt Material-Informationssystem hatte das Ziel, ein System zu entwickeln, mit dem Personen und Institutionen aus dem Bereich Verbundwerkstoffe auf einen gemeinsamen Produktdatenbestand zugreifen können. Wir haben ein System entwickelt, das den Zugriff über das Internet ermöglicht. Als Benutzungsschnittstelle wird lediglich ein Webbrowser vorausgesetzt anstatt eine vollständige Applikation auf den Rechnern der Teilnehmer zu installieren. Während der ersten Projektphase wurden die Anforderungen an ein solches neues System analysiert und ein Prototyp entworfen und implementiert. In der zweiten Projektphase wurde das System als Server mit Hilfe von SQL und Java implementiert.

(28 pages, gzipped PostScript: 319kb via HTTP, FTP, uncompressed PostScript: 969kb via HTTP, FTP)

[Richters and Gogolla, 2000a]

Mark Richters and Martin Gogolla. Validating UML Models and OCL Constraints. In Andy Evans and Stuart Kent, editors, Proc. 3rd Int. Conf. Unified Modeling Language (UML'2000), pages 265-277. Springer, Berlin, LNCS 1939, 2000.

The UML has been widely accepted as a standard for modeling software systems and is supported by a great number of CASE tools. However, UML tools often provide only little support for validating models early during the design stage. Also, there is generally no substantial support for constraints written in the Object Constraint Language (OCL). We present an approach for the validation of UML models and OCL constraints that is based on animation. The USE tool (UML-based Specification Environment) supports developers in this process. It has an animator for simulating UML models and an OCL interpreter for constraint checking. Snapshots of a running system can be created, inspected, and checked for conformance with the model. As a special case study, we have applied the tool to parts of the UML 1.3 metamodel and its well-formedness rules. The tool enabled a thorough and systematic check of the OCL well-formedness rules in the UML standard.

(13 pages, gzipped PostScript: 90kb via HTTP, FTP, uncompressed PostScript: 377kb via HTTP, FTP)

[Richters and Gogolla, 2000b]

Mark Richters and Martin Gogolla. Validierung von UML-Modellen und OCL-Bedingungen. In Martin Wirsing, Martin Gogolla, Hans-Jörg Kreowski, Tobias Nipkow, and Wolfgang Reif, editors, Proc. GI'2000 Workshop Rigorose Entwicklung software-intensiver Systeme, pages 21-32. LMU München, Informatik-Bericht Nr. 0005, 2000.

Die Unified Modeling Language (UML) ist ein allgemein akzeptierter Standard für die Modellierung von Software-Systemen und wird als solcher von einer großen Anzahl von CASE-Tools unterstützt. Oft weisen UML-Werkzeuge nur wenig Unterstützung für die Validierung von Modellen in frühen Entwurfsphasen auf. Es gibt im allgemeinen auch keine nennenswerte Unterstützung für Integritätsbedingungen, die in der Object Constraint Language (OCL) geschrieben sind. Wir stellen daher einen Ansatz für die Validierung von UML-Modellen und OCL-Bedingungen vor, der diese Unterstützung bereitstellt. Das USE-Werkzeug (UML-based Specification Environment) bietet einen Animator zum Simulieren von UML-Modellen und einen OCL-Interpreter für die überprüfung von Bedingungen. Einzelne Zustände eines laufenden Systems können untersucht und auf übereinstimmung mit dem Modell überprüft werden.

(12 pages, gzipped PostScript: 83kb via HTTP, FTP, uncompressed PostScript: 328kb via HTTP, FTP)

[Astesiano et al., 1999]

Egidio Astesiano, Andy Evans, Robert France, Guy Geniloud, Martin Gogolla, Brian Henderson-Sellers, John Howse, Heinrich Hussmann, Shusaku Iida, Stuart Kent, Alain Le Guennec, Tom Mens, Richard Mitchell, Oliver Radfelder, Gianna Reggio, Mark Richters, Bernhard Rumpe, Perdita Stevens, Klaas van den Berg, Pim van den Broek, and Roel Wieringa. UML Semantics FAQ. In Ana Moreira and Serge Demeyer, editors, ECOOP'99 Workshop Reader, pages 33-56. Springer, Berlin, LNCS 1743, 1999.

This paper reports the results of a workshop held at ECOOP'99. The workshop was set up to find answers to questions fundamental to the definition of a semantics for the Unified Modelling Language. Questions examined the meaning of the term semantics in the context of UML; approaches to defining the semantics, including the feasibility of the meta-modelling approach; whether a single semantics is desirable and, if not, how to set up a framework for defining multiple, interlinked semantics; and some of the outstanding problems for defining a semantics for all of UML.

(25 pages, gzipped PostScript: 952kb via HTTP, FTP, uncompressed PostScript: 5795kb via HTTP, FTP)

[Gogolla, 1999]

Martin Gogolla. Identifying Objects by Declarative Queries. Advances in Object-Oriented Data Modeling. M.P. Papazoglou, S. Spaccapietra, Z. Tari (Eds.), MIT Press. pages 255-277, 1999.

Object identification in data models, especially in semantic, Entity-Relationship, and Object-Oriented data models is studied. Various known approaches to object identification are shown, and an alternative proposal to the topic is put forward. The main new idea is to attach to each object type an arbitrary query, a so-called observation term, in order to observe a unique, identifying property of objects of the corresponding type.

(25 pages, gzipped PostScript: 138kb via HTTP, FTP, uncompressed PostScript: 682kb via HTTP, FTP)

[Gogolla and Richters, 1999]

Martin Gogolla and Mark Richters. Transformation Rules for UML Class Diagrams. In Jean Bezivin and Pierre-Alain Muller, editors, Proc. 1st Int. Workshop Unified Modeling Language (UML'98), pages 92-106. Springer, Berlin, LNCS 1618, 1999.

UML is a complex language with many modeling features. Especially the modeling of static structures with class diagrams is supported by a rich set of description primitives. We show how to transfrom UML class diagrams involving cardinality constraints, qualifiers, association classes, aggregations, compositions, and generalizations into equivalent UML class diagrams employing only n-ary associations and OCL constraints. This provides a better understanding of UML features. By explaining 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.

(15 pages, gzipped PostScript: 87kb via HTTP, FTP, uncompressed PostScript: 431kb via HTTP, FTP)

[Gogolla et al., 1999a]

Martin Gogolla, Oliver Radfelder, and Mark Richters. A UML Semantics FAQ - The View from Bremen. In S.J.H. Kent, A. Evans, and B. Rumpe, editors, Proc. ECOOP'99 Workshop UML Semantics FAQ. University of Brighton, 1999.

This note spells out questions the authors found while studying the material defining the Unified Modeling Language UML. After formulating a preliminary question in Sec. 1, some detailed questions with answers and some detailed questions without answers are given in Sec. 2 and 3, respectively. Sections 4 and 5 just state questions with and without answers but we do not go into details explaining the importance of the questions. Our answers to the `questions with answers' can be found in our recent. In Sec. 6, a short hint to relevant literature ends this note.

(10 pages, gzipped PostScript: 87kb via HTTP, FTP, uncompressed PostScript: 523kb via HTTP, FTP)

[Gogolla et al., 1999b]

Martin Gogolla, Oliver Radfelder, and Mark Richters. Towards Three-Dimensional Representation and Animation of UML Diagrams. In Robert France and Bernhard Rumpe, editors, Proc. 2nd Int. Conf. Unified Modeling Language (UML'99), pages 489-502. Springer, Berlin, LNCS 1723, 1999.

The UML notation is intended to be drawn on two-dimensional surfaces. However, three-dimensional diagram layout and animation may improve comprehension of complex diagrams significantly. The paper concentrates on special UML diagram forms well-suited for advanced visualization. It makes a proposal for representing and animating such UML diagrams in a three-dimensional style.

(14 pages, gzipped PostScript: 558kb via HTTP, FTP, uncompressed PostScript: 1845kb via HTTP, FTP)

[Radfelder et al., 1999]

Oliver Radfelder, Martin Gogolla, and Volker Behr. On Designing and Querying a Material Information System. In M. Türksever, N.Y. Topaloglu, N. Zincir-Heywood, A. Kantarci, C.A. Sürgevil, and Ö. Özmen, editors, Proc. 14th Int. Symposium Computer and Information Science (ISCIS'99), pages 132-142. Ege University, Izmir, 1999.

We present an information system which has been developed in cooperation with a composite material development laboratorium and other industrial partners. The system enables people interested in this field to get knowledge about project participants and their offers. The main purpose of the development was to let all the involved people participate regardless of their technical skills. One precondition to achieve this goal was the development of an easy-to-learn graphical query language. The implementation has been led by the demand for platform independence and the necessity to involve the project participants in the maintenance of the data.

(11 pages, gzipped PostScript: 33kb via HTTP, FTP, uncompressed PostScript: 123kb via HTTP, FTP)

[Richters and Gogolla, 1999a]

Mark Richters and Martin Gogolla. A Metamodel for OCL. In Robert France and Bernhard Rumpe, editors, Proc. 2nd Int. Conf. Unified Modeling Language (UML'99), pages 156-171. Springer, Berlin, LNCS 1723, 1999.

The Object Constraint Language (OCL) allows the extension of UML models with constraints in a formal way. While the UML itself is defined by following a metamodeling approach, there is currently no equivalent definition for the OCL. We propose a metamodel for OCL that fills this gap. The benefit of a metamodel for OCL is that it precisely defines the syntax of all OCL concepts like types, expressions, and values in an abstract way and by means of UML features. Thus, all legal OCL expressions can be systematically derived and instantiated from the metamodel. We also show that our metamodel smoothly integrates with the UML metamodel. The focus of this work lies on the syntax of OCL; the metamodel does not include a definition of the semantics of constraints.

(16 pages, gzipped PostScript: 82kb via HTTP, FTP, uncompressed PostScript: 265kb via HTTP, FTP)

[Richters and Gogolla, 1999b]

Mark Richters and Martin Gogolla. On the Need for a Precise OCL Semantics. In Robert France, Bernhard Rumpe, Brian Henderson-Sellers, Jean-Michel Bruel, and Ana Moreira, editors, Proc. OOPSLA Workshop ``Rigorous Modeling and Analysis with the UML: Challenges and Limitations''. Colorado State University, Fort Collins, Colorado, 1999.

In our view a formalization of the OCL is beneficial for achieving the following goals: (1) Improvement of the OCL itself by pointing out some potential problems with its current definition, (2) a more precise understanding of UML class models and their interpretation, (3) a solid foundation for implementing CASE tools supporting analysis, simulation and validation of UML models. We also feel that there is one aspect of OCL which often gets underrated. OCL expressions cannot only be used to specify constraints, but more generally, one can utilize them to specify queries retrieving non-trivial information about certain objects in a given system state. These queries can then be translated into statements of a query language of the chosen implementation environment. A precise OCL semantics would obviously facilitate a more systematic description of a translation scheme from OCL to e.g. SQL or the ODMG's Object Query Language (OQL).

(3 pages, gzipped PostScript: 36kb via HTTP, FTP, uncompressed PostScript: 84kb via HTTP, FTP)

[Wagner and Gogolla, 1999]

Annika Wagner and Martin Gogolla. Semantics of Object-Oriented Languages. In Hartmut Ehrig, Gregor Engels, Hans-Jörg Kreowski, and Gregorz Rozenberg, editors, Handbook of Graph Grammars and Computing by Graph Transformation, Volume II, Applications, Languages, and Tools, pages 181-211. World Scientific, Singapore, 1999.

Graph transformations can be applied everywhere, where graphs are used as a natural and intuitive description of complex phenomena. One field where this is the case is object modeling. The important role graphs play during object-oriented analysis and design shows their usefulness in the context of object orientation. A main characteristic of graph transformations is its direct operational executability. Combining both observations, it seems to be natural to use graph transformations to specify the operational behavior of objects. In this contribution we follow this idea by providing an operational semantics for the textual object description language TROLL light by means of graph transformations. But this is not the only possible application of graph transformations in the object-oriented field because what we are doing can be used also in combination with the graphical object modeling language UML.

(16 pages, gzipped PostScript: 312kb via HTTP, FTP, uncompressed PostScript: 714kb via HTTP, FTP)

[Cerioli et al., 1998]

Maura Cerioli, Martin Gogolla, Helene Kirchner, Bernd Krieg-Brückner, Zhenyu Qian, and Markus Wolf, editors. Algebraic System Specification and Development - Survey and Annotated Bibliography. Monographs of the Bremen Institute of Safe Systems (BISS). Shaker, Aachen, 1998.

This book is an annotated bibliography that attempts to provide an up-to-date overview of most past and present work on algebraic specification for researchers in algebraic specification and neighbouring fields. It extends the previous annotated bibliography by Bidoit, Kreowski, Lescanne, Orejas and Sannella. A review of the main topics of current and past research is given, with some indication of how the different approaches are related and pointers to relevant papers.

(142 pages, gzipped PostScript: 383kb via HTTP, FTP, uncompressed PostScript: 1535kb via HTTP, FTP)

[Gogolla, 1998]

Martin Gogolla. UML for the Impatient. Research Report 3/98, Universität Bremen, 1998.

By examples we give a short introduction into the nine diagram forms provided by the Unified Modeling Language (UML). The running example we use is a small traffic light system which we first formally describe in an object specification language. Afterwards, central aspects of the specification and the specified system are visualized with UML constructs. As a conclusion, we discuss a classification of the various UML diagram forms.

(23 pages, gzipped PostScript: 140kb via HTTP, FTP, uncompressed PostScript: 886kb via HTTP, FTP)

[Gogolla and Parisi-Presicce, 1998]

Martin Gogolla and Francesco Parisi-Presicce. State Diagrams in UML - A Formal Semantics using Graph Transformation. In Manfred Broy, Derek Coleman, Tom Maibaum, and Bernhard Rumpe, editors, Proc. ICSE'98 Workshop on Precise Semantics of Modeling Techniques (PSMT'98), pages 55-72. Technical University of Munich, Technical Report TUM-I9803, 1998.

We show how to transform UML (Unified Modeling Language) state diagrams into graphs by making explicit the intended semantics of the diagram. The process of state expansion in nested state diagrams is explained by graph transformations in three steps: (1) adding boundary nodes introducing a precise interface for the state to be expanded, (2) expanding the state, and (3)  removing the boundary nodes. The general idea of approaching the semantics of UML diagrams by graph transformations is applicable to other forms of UML diagrams as well. The main advantage of the graph transformation approach is the closeness between the (mathematical) graph representation and the (UML) diagram representation.

(18 pages, gzipped PostScript: 111kb via HTTP, FTP, uncompressed PostScript: 649kb via HTTP, FTP)

[Gogolla and Richters, 1998]

Martin Gogolla and Mark Richters. On Combing Semi-Formal and Formal Object Specification Techniques. In Francesco Parisi-Presicce, editor, Proc. 12th Int. Workshop Abstract Data Types (WADT'97), pages 238-252. Springer, LNCS 1376, 1998.

In the early phases of software development it seems profitable to freely mix semi-formal and formal design techniques. Formal techniques have their strength in their ability to rigorously define desired software qualities like functionality, whereas semi-formal methods are usually said to be easier to understand and to be more human-nature oriented. We propose a new approach in order to combine these two areas by exploiting how constructs of the formal specification language TROLL light are related to the graphical elements of the UML approach.

(16 pages, gzipped PostScript: 77kb via HTTP, FTP, uncompressed PostScript: 353kb via HTTP, FTP)

[Gogolla et al., 1998]

Martin Gogolla, Anne Kathrin Huge, and Bodo Randt. Stepwise Re-Engineering and Development of Object-Oriented Database Schemata. In Roland R. Wagner, editor, Proc. 9th Int. Workshop Database and Expert Systems Applications (DEXA'98). IEEE, Los Alamitos, 1998.

We present a general approach for re-engineering of object-oriented database schemata. The approach consists of four dependent steps: (1) description of the data within the underlying basic data format, (2) application of a powerful semantic data model in order to construct a semantic database schema, (3) translation of the achieved schema into a general object model, and (4) implementation of the object schema in a concrete object-oriented database system. As an instantiation of this general procedure we report on a case study carried out in an industrial context where an Extended Entity-Relationship model was used as the semantic data model and ObjectStore as the implementation platform.

(6 pages, gzipped PostScript: 40kb via HTTP, FTP, uncompressed PostScript: 123kb via HTTP, FTP)

[Richters and Gogolla, 1998]

Mark Richters and Martin Gogolla. On Formalizing the UML Object Constraint Language OCL. In Tok-Wang Ling, Sudha Ram, and Mong Li Lee, editors, Proc. 17th Int. Conf. Conceptual Modeling (ER'98), pages 449-464. Springer, Berlin, LNCS 1507, 1998.

We present a formal semantics for the Object Constraint Language (OCL) which is part of the Unified Modeling Language (UML) -- an emerging standard language and notation for object-oriented analysis and design. In context of information systems modeling, UML class diagrams can be utilized for describing the overall structure, whereas additional integrity constraints and queries are specified with OCL expressions. By using OCL, constraints and queries can be specified in a formal yet comprehensible way. However, the OCL itself is currently defined only in an informal way. Thus the semantics of constraints is in general not precisely defined. Our approach gives precise meaning to OCL concepts and to some central aspects of UML class models. In consequence, a formal semantics facilitates verification, validation and simulation of models improving the quality of models and software design.

(16 pages, gzipped PostScript: 103kb via HTTP, FTP, uncompressed PostScript: 472kb via HTTP, FTP)

[Richters et al., 1998]

Mark Richters, Martin Gogolla, and Heino Gärtner. SIGN - Software Implementierung durch Graphische Notation. Interner Bericht, Universität Bremen, Fachbereich 3, 1998.

Das studentische Projekt SIGN (Software Implementierung durch Graphische Notation) wurde an der Universität Bremen von 1996 bis 1998 durchgeführt. Ziel des Projektes war die Entwicklung einer graphischen Modellierungssprache zur Unterstützung des objektorientierten Systementwurfs. Zur praktischen Umsetzung der Modellierungssprache wurde außerdem eine Entwicklungsumgebung entworfen und implementiert. Sowohl Sprache als auch das Entwicklungssystem wurden durchgehend objektorientiert entwickelt. Dabei wurde im Rahmen der Metamodellierung auch die zu entwerfende Sprache selbst eingesetzt. Dieses Papier faßt die Ziele, Methoden und Ergebnisse des Projektes zusammen.

(9 pages, gzipped PostScript: 82kb via HTTP, FTP, uncompressed PostScript: 480kb via HTTP, FTP)

[Buddrus et al., 1997]

Frank Buddrus, Heino Gärtner, and Sven-Eric Lautemann. First Steps to a Formal Framework for Multilevel Database Modifications. In A. Hameurlain and A Min Tjoa, editors, Proc. 8th Int. Conf. Database and Expert Systems Applications (DEXA'97), pages 240-251. Springer, Berlin, LNCS 1308, 1997.

We propose a formal basis for operations which can be understood as implicitly used in many kinds of schema modifications. Approaches for view definition, schema evolution, and schema versioning all rely on operations which work either on instance, on schema, or on both levels. This paper discusses a basic set of these operations called modification primitives and describes their semantics on the basis of the Extended Entity Relationship (EER) Model in a Hoare-style notation. We focus on the structural part of the schema definition and outline our ideas for arbitrary manipulations of instances.

(13 pages, gzipped PostScript: 82kb via HTTP, FTP, uncompressed PostScript: 383kb via HTTP, FTP)

[Gärtner, 1997]

Heino Gärtner. Perspectives for a Formal Framework for Schema Modification in Object Databases. In D.J. Ram, editor, Proc. 8th Int. Conf. Management of Data (COMAD'97), pages 238-249. Narosa, New Delhi, 1997.

This paper proposes a formal basis for the description of schema modification in object databases. We identify three necessary building blocks for the structural aspect of such a description: (i) basic schema and database objects, (ii) properties of (classes of) schema and database objects, and (iii) schema modifications, i.e. transitions between schemata and transitions between database states. The semantics for the basic schema and database objects is given in a denotational style. Properties of schemata can be described as formulas. For schema modification we introduce a set of schema modification primitives and describe their semantics by means of pre- and postcondition in a Hoare-style notation. We focus on the structural aspects of schema modification and describe some simple properties of our framework.

(12 pages, gzipped PostScript: 96kb via HTTP, FTP, uncompressed PostScript: 476kb via HTTP, FTP)

[Gogolla, 1997]

Martin Gogolla. On Behavioral Model Quality and Transformation. In Stephen W. Liddle, Stephen W. Clyde, and Scott N. Woodfield, editors, Proc. 16th Int. Conf. on Conceptual Modeling (ER'97), Workshop on Behavioral Models and Design Transformations. verb !http://osm7.cs.byu.edu/ER97/workshop4!, 1997.

This statement reflects experience of our group in conceptual modelling with Entity-Relationship and object-oriented approaches. It describes a general view on structural and behavioral aspects of conceptual models, their interrelationships, and their transformations, and sketches a proposal to build integrated models of them.

(4 pages, gzipped PostScript: 54kb via HTTP, FTP, uncompressed PostScript: 279kb via HTTP, FTP)

[Gogolla and Parisi-Presicce, 1997]

Martin Gogolla and Francesco Parisi-Presicce. State Diagrams in UML - A Formal Semantics using Graph Transformation. Rapporto di Ricerca 97/15, University of Rome `La Sapienza', Dipartimento di Scienze dell' Informazione, 1997.

We show how to transform UML (Unified Modeling Language) state diagrams into graphs by making explicit the intended semantics of the diagram. The process of state expansion in nested state diagrams is explained by graph transformations in three steps: (1) adding boundary nodes introducing a precise interface for the state to be expanded, (2) expanding the state, and (3)  removing the boundary nodes. The general idea of approaching the semantics of UML diagrams by graph transformations is applicable to other forms of UML diagrams as well. The main advantage of the graph transformation approach is the closeness between the (mathematical) graph representation and the (UML) diagram representation.

(19 pages, gzipped PostScript: 112kb via HTTP, FTP, uncompressed PostScript: 685kb via HTTP, FTP)

[Gogolla and Richters, 1997a]

Martin Gogolla and Mark Richters. On Constraints and Queries in UML. In Martin Schader and Axel Korthaus, editors, Proc. UML'97 Workshop `The Unified Modeling Language - Technical Aspects and Applications', pages 109-121. Physica-Verlag, Heidelberg, 1997.

The UML has recently been extended by an Object Constraint Language (OCL). This formal language can be used for specifying constraints on a model in order to restrict possible system states. We present some examples for illustrating main concepts of OCL. Problems with the current definition of OCL resulting from imprecise or ambiguous definitions are investigated. A comparison of OCL with a language for specification of queries and integrity constraints in an Extended Entity-Relationship model shows similarities between both approaches. This comparison could lead to a better understanding of OCL.

(14 pages, gzipped PostScript: 86kb via HTTP, FTP, uncompressed PostScript: 456kb via HTTP, FTP)

[Gogolla and Richters, 1997b]

Martin Gogolla and Mark Richters. Web-Based Object Animation. In Hans-Dieter Ehrich, Yulin Feng, and David Kung, editors, Object-Oriented Software Development, pages 16-16. Dagstuhl-Seminar-Report Nr. 174, 1997.

The current activities of our group comprises concrete case studies arising from practical projects: (1) Reengineering of a tram simulation system and (2) development of a material information system. Both projects use object-oriented description techniques on a semi-formal (OMT-like) and formal (TROLL-like) level. Semi-formal techniques are also the topic of a student project (18 students, 2 years). The aim of this student project is the development of an OMT design system. The formal basis for the above activities is the object description language TROLL light. Our group already has experience with implementations of this language on different platforms. The current implementation uses Java. The talk explains the user-interface of the current animation system which is based on HTML documents. Thus any Web browser can be employed for the validation of specifications. For demonstration purposes we use a small description of a car rentals case system.

(1 pages, gzipped PostScript: 15kb via HTTP, FTP, uncompressed PostScript: 86kb via HTTP, FTP)

[Richters, 1997]

Mark Richters. jtrl User Manual. Internal Report, Universität Bremen, 1997.

This manual provides information on using the jtrl system for developing and validating specifications written in the TROLL light language. Such specifications are used for modeling information systems as a set of interacting and communicating objects. With jtrl a model can be validated by direct execution (also called animation) of its specification. The manual presents all steps necessary to work with jtrl. These include instructions on system usage via the various user interfaces: command line, Web interface, and the graph visualization tool daVinci. A complete list of builtin operations and a grammar serve as reference for the language supported by jtrl.

(26 pages, gzipped PostScript: 162kb via HTTP, FTP, uncompressed PostScript: 921kb via HTTP, FTP)

[Richters and Gogolla, 1997a]

Mark Richters and Martin Gogolla. A Web-based Animator for Validating Object Specifications. In Bipin C. Desai and Barry Eaglestone, editors, Proc. Int. Database Engineering and Applications Symposium (IDEAS'97), pages 211-219. IEEE, Los Alamitos, 1997.

One of the central tasks in developing information systems is the specification of desired system properties. We use the object specification language TROLL light to formalize the conceptual model of a system. A TROLL light specification describes structural as well as dynamic characteristics of objects representing real-world entities. For validating specifications, we have developed an animation tool allowing us to reflect structural properties and dynamic behavior. The main concepts of the animator are illustrated by a working example. We present a simple specification of a car rental company and describe some of the steps performed during a typical animation session. The animation allows to check whether desired properties are fulfilled by the given object descriptions. Finally, some design and implementation issues regarding the utilized persistent programming environment and the Web-based user interface are discussed.

(9 pages, gzipped PostScript: 106kb via HTTP, FTP, uncompressed PostScript: 701kb via HTTP, FTP)

[Richters and Gogolla, 1997b]

Mark Richters and Martin Gogolla. A Web User Interface for an Object Specification Language. In Michel Bidoit, editor, Proc. 7th Int. Joint Conf. on Theory and Practice of Software Development (TAPSOFT'97), pages 867-870. Springer, Berlin, LNCS 1214, 1997.

We present an animation tool for the formal specification language TROLL light. The system allows the manipulation and querying of objects and navigation through object hierarchies. A Web-based user interface simplifies the usage of the system.

(5 pages, gzipped PostScript: 69kb via HTTP, FTP, uncompressed PostScript: 436kb via HTTP, FTP)

[Claßen et al., 1996]

Ingo Claßen, Martin Gogolla, and Michael Löwe. Dynamics in Information Systems - An Algebraic Approach to Specification, Construction and Correctness. Forschungsbericht 96/01, Technische Universität Berlin, 1996.

A formal framework based on algebraic graph theory is presented that integrates specification and construction of dynamics in information systems. Specifications are based on temporal logic whose semantics is given by algebras and partial homomorphisms. Constructions are given by graph transformation rules whose operational nature provides a first step towards actual implementations. Both are related by a correctness notion. The formal framework is especially suited as a semantical basis for graphical notations as used in conceptual modeling, thus combining intuitiveness of such notations with precision of formal methods.

(21 pages, gzipped PostScript: 80kb via HTTP, FTP, uncompressed PostScript: 225kb via HTTP, FTP)

[Gärtner and Gogolla, 1996]

Heino Gärtner and Martin Gogolla. LASSY - A System for Analysing Grammatical Dependencies in Latin. In Roland R. Wagner and Helmut Thoma, editors, Proc. 7th Int. Workshop Database and Expert Systems Applications (DEXA'96), pages 275-284. IEEE, Los Alamitos, 1996.

We introduce the Latin analysis system Lassy, a slim system for analyzing Latin sentences. Tools for interacting with a database for morphological features are integrated as well as an interface for defining and applying a grammar database. We also give a small outline of the grammar model used in Lassy which is a pragmatic integration of linguistic theories known from both dependency and phrase structure grammar.

(10 pages, gzipped PostScript: 105kb via HTTP, FTP, uncompressed PostScript: 577kb via HTTP, FTP)

[Gogolla, 1996a]

Martin Gogolla. Parameterizing Object Specifications. In Luigia Aiello, editor, Proc. 4th Int. Symposium Design and Implementation of Symbolic Computation Systems (DISCO'96), pages 126-137. Springer, Berlin, LNCS 1128, 1996.

We present a proposal for parameterized object specifications allowing especially objects sorts in the parameter. These object specifications permit to describe the part of the world to be modeled as an object community of concurrently existing and communicating objects. Our proposal for parameter passing works well on the syntactical level by means of a pushout construction. On the semantic level we use free constructions and corresponding forgetful functors.

(12 pages, gzipped PostScript: 47kb via HTTP, FTP, uncompressed PostScript: 152kb via HTTP, FTP)

[Gogolla, 1996b]

Martin Gogolla. Towards Object Visualization by Conceptual Graphs. In Peter W. Eklund, Gerard Ellis, and Graham Mann, editors, Proc. 4th Int. Conf. Conceptual Structures (ICCS'96), Auxiliary Proceedings, pages 175-188. University of New South Wales, Sydney, 1996.

The specification language TROLL light allows to describe the part of the world to be modeled in the information system design process as a community of concurrently existing and communicating objects. It follows the object paradigm by coherently describing structure as well behavior of conceptual objects. A TROLL light specification is divided into a signature part and an axiom part where formulas over the signature characterizing the object are formulated. Conceptual graphs are employed to visualize object schemata as well as object instances. Thereby, we provide a uniform platform for representing static and dynamic properties of objects and reasoning about them. By giving appropriate graph substitution rules, conceptual structures are capable to express system dynamics as well.

(14 pages, gzipped PostScript: 82kb via HTTP, FTP, uncompressed PostScript: 240kb via HTTP, FTP)

[Gogolla and Richters, 1996]

Martin Gogolla and Mark Richters. An Object Specification Language Implementation with Web User Interface based on Tycoon. In Hartmut Ehrig, Friedrich von Henke, Jose Meseguer, and Martin Wirsing, editors, Specification and Semantics, pages 8-11. Dagstuhl-Seminar-Report Nr. 151, 1996.

We concentrate on the user interface of a TROLL light implementation based on Tycoon. The implementation employs a normal Web browser (Netscape, Mosaic, etc.) for both the exploration of template, i.e. object type, descriptions and objects, i.e. instances of these templates. In particular, objects are represented by HTML documents and object references can be followed simply with the Web browser.

(3 pages, gzipped PostScript: 47kb via HTTP, FTP, uncompressed PostScript: 267kb via HTTP, FTP)

[Meyer et al., 1996]

Bernd Meyer, Gerhard D. Westerman, and Martin Gogolla. Drafting ER and OO Schemas in Prototyping Environments. Data and Knowledge Engineering, 19(3):201-240, 1996.

The system QUEER is a prototype of an information system design tool which directly supports an extended Entity-Relationship model on its front-end and uses a semantically well-founded query and manipulation language based on an Entity-Relationship calculus. The system basically consists of a set of compilers written in PROLOG which translate data specifications, schema definitions, queries, integrity constraints, and data-manipulation statements into PROLOG programs. All features mentioned are implemented in form and extent as described here.

(48 pages, gzipped PostScript: 106kb via HTTP, FTP, uncompressed PostScript: 353kb via HTTP, FTP)

[Wagner and Gogolla, 1996]

Annika Wagner and Martin Gogolla. Defining Operational Behavior of Object Specifications by Attributed Graph Transformations. Fundamenta Informaticae, 3,4:407-431, 1996.

A single pushout approach to the transformation of attributed partial graphs based on categories of partial algebras and partial morphisms is introduced. A sufficient condition for pushouts in these categories is presented. As the synchronization mechanism we use amalgamation of rules and show how synchronization can be minimized. We point out how the results obtained can be employed in order to define an operational semantics for object specification languages.

(25 pages, gzipped PostScript: 93kb via HTTP, FTP, uncompressed PostScript: 348kb via HTTP, FTP)

[Conrad et al., 1995]

Stefan Conrad, Grit Denker, Martin Gogolla, Rudolf Herzig, Nikolaos Vlachantonis, and Hans-Dieter Ehrich. Entwicklung zuverlässiger Informationssysteme. GI EMISA-Forum, 2:25-33, 1995.

Ausgehend von einem einfachen objektorientierten Ansatz zur Modellierung von Objektgesellschaften als Informationssysteme wird insbesondere eine geeignete Entwicklungsumgebung konzipiert, der Bereich Validation von Objektspezifikationen mittels Animation untersucht und ein Beweisunterstützungssystem entworfen, das formale Nachweise von Objekteigenschaften ermöglicht. Ziel ist die Entwicklung von Informationssystemen auf der Grundlage von objektorientierten Datenbanksystemen.

(9 pages, gzipped PostScript: 90kb via HTTP, FTP, uncompressed PostScript: 234kb via HTTP, FTP)

[Gogolla, 1995a]

Martin Gogolla. A Declarative Query Approach to Object Identification. In Mike Papazoglou, editor, Proc. 14th Int. Conf. Object-Oriented and Entity-Relationship Modelling (ER'95), pages 65-76. Springer, Berlin, LNCS 1021, 1995.

Object identification in data models, especially in semantic, Entity-Relationship, and object-oriented data models is studied. Various known approaches to object identification are shown, and an alternative proposal to the topic is put forward. The main new idea is to attach to each object type an arbitrary query in order to observe a unique, identifying property of objects of the corresponding type.

(12 pages, gzipped PostScript: 47kb via HTTP, FTP, uncompressed PostScript: 165kb via HTTP, FTP)

[Gogolla, 1995b]

Martin Gogolla. Identifying Objects by Declarative Queries. In Jan Chomicki, Gunter Saake, and Christina Sernadas, editors, The Role of Logics in Information Systems. Dagstuhl-Seminar-Report Nr. 121, 1995.

In this talk we study object identification in data models, especially in semantic, Entity-Relationship, and object-oriented data models. Various known approaches to object identification are shown, and an alternative proposal to the topic is put forward. The main new idea is to attach to each object type an arbitrary query in order to observe a unique, identifying property of objects of the corresponding type. This proposal seems to be more general than the well-known ``deep equality'' approach. The talk is organized as follows. First we introduce an example schema which will be used throughout the paper, and sketch the interpretation of object schemas in an informal way. Several known and our new proposal (the so-called observation term approach) to object identification are studied afterwards. The advantages of our new proposal are discussed, and its formal definition is mentioned. The talk ends with some concluding remarks.

(1 pages, gzipped PostScript: 16kb via HTTP, FTP, uncompressed PostScript: 89kb via HTTP, FTP)

[Gogolla, 1995c]

Martin Gogolla. Towards Schema Queries for Semantic Data Models. In Norman Revell and A Min Tjoa, editors, Proc. 6th Int. Conf. and Workshop on Database and Expert Systems Applications (DEXA'95), pages 274-283. ONMIPRESS, San Mateo, 1995.

We contribute to metadata management by giving a specification of extended Entity-Relationship schemas with the extended Entity-Relationship model itself. We formulate a number of integrity constraints describing the context-sensitive requirements an extended Entity-Relationship schema has to fulfill. By doing this, a certain class of schema queries can be formulated.

(10 pages, gzipped PostScript: 66kb via HTTP, FTP, uncompressed PostScript: 176kb via HTTP, FTP)

[Gogolla and Cerioli, 1995a]

Martin Gogolla and Maura Cerioli. What is an Abstract Data Type, after all? Technical Report PDISI-95-01, Dipartimento di Informatica e Scienze dell'Informazione, Universita di Genova, 1995.

We look back on ten Workshops on Abstract Data Types. A comprehensive KWIC index of titles of talks held at the workshop, a list of authors referencing their talks and publications, and a bibliography are presented.

(76 pages, gzipped PostScript: 169kb via HTTP, FTP, uncompressed PostScript: 784kb via HTTP, FTP)

[Gogolla and Cerioli, 1995b]

Martin Gogolla and Maura Cerioli. What is an Abstract Data Type, after all? In Egidio Astesiano, Gianna Reggio, and Andrzej Tarlecki, editors, Proc. 10th Int. Workshop Abstract Data Types (WADT'94), pages 499-523. Springer, Berlin, LNCS 906, 1995.

We look back on ten Workshops on Abstract Data Types. Organizers and publications, a list of authors referencing their talks and papers on the workshops, and a workshop bibliography are presented.

(26 pages, gzipped PostScript: 72kb via HTTP, FTP, uncompressed PostScript: 198kb via HTTP, FTP)

[Gogolla and Herzig, 1995a]

Martin Gogolla and Rudolf Herzig. An Algebraic Development Technique for Information Systems. In Vangalur S. Alagar and Maurice Nivat, editors, Proc. 4th Int. Conf. Algebraic Methodology and Software Technology (AMAST'95), pages 446-460. Springer, Berlin, LNCS 936, 1995.

This paper reports on successful application of algebraic ideas to the formal development of software systems, in particular information systems. It describes (1) a formalism, i.e., a language, for the specification of information systems, (2) a method for the construction of specifications in this language, and (3) implemented and planned parts of a specification environment covering important phases of the software development process.

(15 pages, gzipped PostScript: 85kb via HTTP, FTP, uncompressed PostScript: 222kb via HTTP, FTP)

[Gogolla and Herzig, 1995b]

Martin Gogolla and Rudolf Herzig. An Algebraic Semantics for the Object Specification Language TROLL light. In Egidio Astesiano, Gianna Reggio, and Andrzej Tarlecki, editors, Proc. 10th Int. Workshop Abstract Data Types (WADT'94), pages 288-304. Springer, Berlin, LNCS 906, 1995.

Within the KORSO project we have developed the object specification language TROLL light which allows to describe the part of the world to be modeled as a community of concurrently existing and communicating objects. Recently, we have worked out the basic notions of a pure algebraic semantics for our language. The main underlying idea is to present a transition system where the states represent the states of the specified information system, and state transitions are caused by the occurrence of finite sets of events. This semantics is formulated by representing states and state transitions as algebras. The various constructs of TROLL light are unified to general axioms restricting the possible interpretations for TROLL light object descriptions.

(17 pages, gzipped PostScript: 97kb via HTTP, FTP, uncompressed PostScript: 256kb via HTTP, FTP)

[Gogolla et al., 1995a]

Martin Gogolla, Stefan Conrad, Grit Denker, Rudolf Herzig, and Nikolaos Vlachantonis. A Development Environment for an Object Specification Language. IEEE Transactions on Knowledge and Data Engineering, 7(3):505-508, 1995.

Techniques for the development of reliable information systems on the basis of their formal specification are the main concern in our project. Our work focuses on the specification language TROLL light which allows to describe the part of the world to be modeled as a community of concurrently existing and communicating objects. Our specification language comes along with an integrated, open development environment. The task of this environment is to give support for the creation of correct information systems. Two important ingredients of the environment to be described here in more detail are the animator and the proof support system.

(6 pages, gzipped PostScript: 64kb via HTTP, FTP, uncompressed PostScript: 300kb via HTTP, FTP)

[Gogolla et al., 1995b]

Martin Gogolla, Stefan Conrad, Grit Denker, Rudolf Herzig, Nikolaos Vlachantonis, and Hans-Dieter Ehrich. TROLL light - The Language and Its Development Environment. In Manfred Broy and Stefan Jähnichen, editors, KORSO - Methods, Languages, and Tools for the Construction of Correct Software (KORSO'95), pages 204-220. Springer, Berlin, LNCS 1009, 1995.

In our sub-project we are concerned with techniques for the development of reliable information systems on the basis of their formal specification. Our work focuses on the specification language TROLL light which allows to describe the part of the world to be modeled as a community of concurrently existing and communicating objects. Our specification language comes along with an integrated, open development environment. The task of this environment is to give support for the creation of correct information systems. Two important ingredients of the environment to be described here in more detail are the animator and the proof support system.

(16 pages, gzipped PostScript: 84kb via HTTP, FTP, uncompressed PostScript: 229kb via HTTP, FTP)

[Herzig and Gogolla, 1995]

Rudolf Herzig and Martin Gogolla. An Animator for the Object Specification Language TROLL light. In Vangalur S. Alagar and Rokia Missaoui, editors, Proc. Int Colloquium Object Orientation in Databases and Software Engineering (COODBSE'94), pages 156-170. World Scientific, River Edge (NJ), 1995.

In our project we are concerned with techniques for the development of reliable information systems on the basis of their formal specification. Our work focuses on the specification language TROLL light which allows to describe the part of the world to be modeled as a community of concurrently existing and communicating objects. Our specification language comes along with an integrated, open development environment. The task of this environment is to give support for the creation of correct information systems. One important ingredient of the environment to be described here in more detail is the TROLL light animator.

(15 pages, gzipped PostScript: 62kb via HTTP, FTP, uncompressed PostScript: 233kb via HTTP, FTP)

[Herzig et al., 1995]

Rudolf Herzig, Martin Gogolla, and Grit Denker. KORSO Reference Languages: Concepts and Application Domains - TROLL light. In Manfred Broy and Stefan Jähnichen, editors, KORSO - Methods, Languages, and Tools for the Construction of Correct Software (KORSO'95), pages 156-162. Springer, Berlin, LNCS 1009, 1995.

This paper gives an overview of the three KORSO reference languages SPECTRUM, TROLL light, and SPECIAL, exposing their motivation and background, language concepts, and typical application domains. The presentation of the different languages is followed by a discussion to what extent these languages may complement each other in the software development process.

(23 pages, gzipped PostScript: 61kb via HTTP, FTP, uncompressed PostScript: 164kb via HTTP, FTP)

[Conrad et al., 1994]

Stefan Conrad, Martin Gogolla, and Rudolf Herzig. Safe Derivations in Object Hierarchies. In D. Patel, Y. Sun, and S. Patel, editors, Proc. Int. Conf. Object-Oriented Information Systems (OOIS'94), pages 306-319. Springer, London, 1994.

We present a language for specifying structure and behavior of objects in information systems. This language is restricted to a set of core concepts for conceptual modeling. But it includes powerful concepts for specifying constraints and derived data. We present an algorithm for deciding on safe computation of derived information and demonstrate how this algorithm works with an example.

(14 pages, gzipped PostScript: 48kb via HTTP, FTP, uncompressed PostScript: 126kb via HTTP, FTP)

[Denker and Gogolla, 1994]

Grit Denker and Martin Gogolla. Translating TROLL light Concepts to Maude. In Hartmut Ehrig and Fernando Orejas, editors, Proc. 9th Int. Workshop Abstract Data Types (WADT'92), pages 173-187. Springer, Berlin, LNCS 785, 1994.

The specification language TROLL light is designed for the conceptual modeling of information systems. Maude is a logic programming language, which unifies the two paradigms of functional and concurrent object-oriented programming. Because of the very similar features offered by both languages, we present a translation from TROLL light concepts into the Maude language in order to compare the languages. Apart from presenting the translation, the languages are briefly described and illustrated by examples.

(16 pages, gzipped PostScript: 66kb via HTTP, FTP, uncompressed PostScript: 166kb via HTTP, FTP)

[Ehrich et al., 1994]

Hans-Dieter Ehrich, Martin Gogolla, Stefan Conrad, Grit Denker, Rudolf Herzig, and Nikolaos Vlachantonis. Entwicklung zuverlässiger Informationssysteme - Stand der Arbeiten im Januar'94. In Manfred Broy and Stefan Jähnichen, editors, Korrekte Software durch formale Methoden - 6. KORSO-Workshop (KORSO'93), pages 82-94, 1994.

Zwei wichtige Komponenten der TROLL light-Entwicklungsumgebung sind der Animator und das Beweisunterstützungssystem. Der Animator dient dem Prototyping einer mit TROLL light spezifizierten Objektgesellschaft und das Beweisunterstützungssystem hilft beim formalen Nachweis bestimmter Eigenschaften der Spezifikation. Eine andere Komponente ist ein Tool, das den Objektansatz von TROLL light mit der etablierten Entity-Relationship-Modellierungstechnik verbindet.

[Gogolla, 1994a]

Martin Gogolla. An Extended Entity-Relationship Model - Fundamentals and Pragmatics. Springer, Berlin, LNCS 767, 1994.

This text presents a comprehensive introduction to an extended Entity-Relationship model both on a conceptual and on a formal, mathematical level. In addition to the primitives given by the data model the text introduces a language for the formulation of constraints in order to restrict database states to consistent ones. The same language can be used to query databases. The text also explains an implementation of the approach chosen in the logic programming language PROLOG and discusses in this context the computational power of the proposed calculus. Finally, the extended Entity-Relationship calculus is applied in order to define the meaning of the relational query language SQL.

(145 pages, gzipped PostScript: 266kb via HTTP, FTP, uncompressed PostScript: 881kb via HTTP, FTP)

[Gogolla, 1994b]

Martin Gogolla. An Extended Entity-Relationship Model - Fundamentals and Pragmatics. GI EMISA-Forum, 1:80-80, 1994.

This text presents a comprehensive introduction to an extended Entity-Relationship model both on a conceptual and on a formal, mathematical level. In addition to the primitives given by the data model the text introduces a language for the formulation of constraints in order to restrict database states to consistent ones. The same language can be used to query databases. The text also explains an implementation of the approach chosen in the logic programming language PROLOG and discusses in this context the computational power of the proposed calculus. Finally, the extended Entity-Relationship calculus is applied in order to define the meaning of the relational query language SQL.

(1 pages, gzipped PostScript: 17kb via HTTP, FTP, uncompressed PostScript: 89kb via HTTP, FTP)

[Gogolla, 1994c]

Martin Gogolla. An Extended Entity-Relationship Model - Fundamentals and Pragmatics. GI Datenbankrundbrief, 13:86-86, 1994.

This text presents a comprehensive introduction to an extended Entity-Relationship model both on a conceptual and on a formal, mathematical level. In addition to the primitives given by the data model the text introduces a language for the formulation of constraints in order to restrict database states to consistent ones. The same language can be used to query databases. The text also explains an implementation of the approach chosen in the logic programming language PROLOG and discusses in this context the computational power of the proposed calculus. Finally, the extended Entity-Relationship calculus is applied in order to define the meaning of the relational query language SQL.

(1 pages, gzipped PostScript: 17kb via HTTP, FTP, uncompressed PostScript: 89kb via HTTP, FTP)

[Gogolla, 1994d]

Martin Gogolla. Grundlagen von Entity-Relationship-Modellen. Informatik-Skript 33, Technische Universität Braunschweig, 1994.

Nach einer kurzen Motivation in der Datenbanksysteme, Datenmodelle und insbesondere semantische Datenmodelle kurz charakterisiert werden wird das Braunschweiger Erweiterte Entity-Relationship-Modell mit einem zugehörigen Entity-Relationship-Kalkül samt Anwendungen des Kalküls vorgestellt. Es werden anschließend weitere semantische Datenmodelle wie IFO, ERC und OMT auf die Konzepte des vorgenannten Entity-Relationship-Modells zurückgeführt.

(62 pages, gzipped PostScript: 173kb via HTTP, FTP, uncompressed PostScript: 500kb via HTTP, FTP)

[Gogolla, 1994e]

Martin Gogolla. On Formal Semantics of Some Semantic Data Models. In Selahattin Kuru, Ufuk Caglayan, Erol Gelenbe, Levent Akin, and Cem Ersoy, editors, Proc. 9th Int. Symposium Computer and Information Science (ISCIS'94), pages 33-40. Bogazici University Printhouse, Istanbul, 1994.

We explain how different semantic data models like the ER model, the ERC approach and the OMT structural modeling method could be transformed into a semantically well-defined extended Entity-Relationship model and calculus.

(8 pages, gzipped PostScript: 68kb via HTTP, FTP, uncompressed PostScript: 165kb via HTTP, FTP)

[Gogolla et al., 1994a]

Martin Gogolla, Sedat Güler, and Rudolf Herzig. From Object Specification to Enhanced Logic Programming. In Selahattin Kuru, Ufuk Caglayan, Erol Gelenbe, Levent Akin, and Cem Ersoy, editors, Proc. 9th Int. Symposium Computer and Information Science (ISCIS'94), pages 423-430. Bogazici University Printhouse, Istanbul, 1994.

We combine the area of object-oriented specification and object-oriented logic programming by indicating the translation of a specification language into an enhanced logic programming language. The translation shows that in comparison to the programming language the specification language offers richer concepts. The background of our work is the development of rapid prototyping systems for object-oriented specification languages.

(8 pages, gzipped PostScript: 68kb via HTTP, FTP, uncompressed PostScript: 165kb via HTTP, FTP)

[Gogolla et al., 1994b]

Martin Gogolla, Nikolaos Vlachantonis, Rudolf Herzig, Grit Denker, Stefan Conrad, and Hans-Dieter Ehrich. The KORSO Approach to the Development of Reliable Information Systems. Informatik-Bericht 94-06, Technische Universität Braunschweig, 1994.

KORSO was a joint project of fourteen university partners and one industrial partner, sponsored by the German Ministry of Research and Technology (BMFT). The project aimed at the consolidation of existing and the investigation of new methods for the development of correct software. Within this framework the focus of the KORSO group at the Technical University of Braunschweig was on the improvement of techniques for the development of reliable information systems. Our work focused on the specification language TROLL light which allows to describe the part of the world to be modeled as a community of concurrently existing and communicating objects. Our specification language comes along with an integrated, open development environment. The task of this environment is to give support for the creation of correct information systems. This report summarizes the results achieved by the Braunschweig KORSO group.

(59 pages, gzipped PostScript: 172kb via HTTP, FTP, uncompressed PostScript: 468kb via HTTP, FTP)

[Herzig and Gogolla, 1994a]

Rudolf Herzig and Martin Gogolla. A SQL-like Query Calculus for Object-Oriented Database Systems. In Elisa Bertino and Susan Urban, editors, Proc. Int. Symposium Object-Oriented Methodologies and Systems (ISOOMS'94), pages 20-39. Springer, Berlin, LNCS 858, 1994.

Currently much effort is being spent on providing object-oriented databases with ad hoc query facilities. In this paper we present a SQL-like query calculus whose major contribution lies in its inherent orthogonality and rigorous mathematical foundation. The calculus is essentially a calculus of complex values but it is defined independently of any concrete database model. The calculus can be used to formulate queries in value-based and object-based data models. Moreover it provides a general facility for the manipulation of complex values.

(20 pages, gzipped PostScript: 68kb via HTTP, FTP, uncompressed PostScript: 230kb via HTTP, FTP)

[Herzig and Gogolla, 1994b]

Rudolf Herzig and Martin Gogolla. On a Better Formal Basis for Stating SQL-like Queries in Value- And Object-Based Database Systems. Technical Report 9/94, Universität Bremen, 1994.

We present a formalism whose purpose is to serve as a rigid basis for describing SQL-like queries and constraints in context of both value- and object-based data models. The formalism, whose major contribution lies in its inherent orthogonality and rigorous mathematical foundation, is defined independently of any concrete database model. Instead it offers a general facility for the ad-hoc manipulation of structured values. In an improvement to the well-known relational domain or tuple calculi (or their extensions towards extended relational models) the formalism (1) guarantees safe and computable queries in an immanent way, (2) allows to explain duplicates in query results, and (3) supports the composition of queries from subqueries without the need to name intermediate query results. Hence it should be seen closer to concrete SQL than classical query calculi.

(26 pages, gzipped PostScript: 83kb via HTTP, FTP, uncompressed PostScript: 272kb via HTTP, FTP)

[Herzig et al., 1994a]

Rudolf Herzig, Stefan Conrad, and Martin Gogolla. Compositional Description of Object Communities with TROLL light. In Chris Chrisment, editor, Proc. Basque Int. Workshop Information Technology (BIWIT'94), pages 183-194. Cepadues Editions, Toulouse, 1994.

TROLL light is a language for the modeling of information systems. It is designed to describe the Universe of Discourse (UoD) as a system of concurrently existing and interacting objects. TROLL light objects have observable properties modeled by attributes, and the behavior of objects is described by events. Possible object observations may be restricted by constraints, whereas event occurrences may be restricted to specified life cycles. TROLL light objects are organized in an object hierarchy established by subobject relationships. Communication between objects is supported by event calling. Apart from introducing the various possibilities for the syntactical description of objects, we aim to describe how the state of an object community may be changed by event occurrences.

(12 pages, gzipped PostScript: 35kb via HTTP, FTP, uncompressed PostScript: 98kb via HTTP, FTP)

[Herzig et al., 1994b]

Rudolf Herzig, Heiko Fischer, and Martin Gogolla. Zur Gestaltung der Benutzeroberfläche bei der Animation von Objektspezifikationen. GI Datenbankrundbrief, 13:43-45, 1994. Proc. Workshop GI-Fachgruppe Datenbanken.

Im Rahmen des BMFT-Verbundprojekts KORSO beschäftigt sich die Braunschweiger Gruppe mit Aspekten der Entwicklung zuverlässiger Informationssysteme. Der Schwerpunkt liegt dabei auf Fragen der Spezifikation, Analyse und Validierung konzeptioneller Schemata. Zu TROLL light wurde eine Entwicklungsumgebung konzipiert, deren wesentliche, bisher implementierte Bestandteile ein Parser zur syntaktischen Analyse, eine Struktur zur persistenten Ablage, ein Beweisunterstützungssystem zum Nachweis spezieller Eigenschaften und ein Animationssystem zur Validierung von Objektspezifikationen sind. Wir diskutieren einige Anforderungen, die an ein Werkzeug zur Unterstützung der Animation von TROLL light-Objektspezifikationen zu stellen sind, und gehen darauf ein, in welcher Weise diese Anforderungen in der aktuellen Implementierung der Benutzungsschnittstelle des TROLL light-Animationssystems realisiert worden sind.

(4 pages, gzipped PostScript: 77kb via HTTP, FTP, uncompressed PostScript: 279kb via HTTP, FTP)

[Conrad et al., 1993]

Stefan Conrad, Grit Denker, Martin Gogolla, Rudolf Herzig, Nikolaos Vlachantonis, and Hans-Dieter Ehrich. Zur Entwicklung zuverlässiger Informationssysteme in KORSO. In H. Reichel, editor, Proc. 23. GI Jahrestagung (GI'93) - Informatik - Wirtschaft - Gesellschaft, pages 464-469. Springer, Berlin, Informatik Aktuell, 1993.

Innerhalb des KORSO-Projektes verfolgt unsere Gruppe das Ziel, die Entwicklung zuverlässiger Informationssysteme auf der Basis formaler Spezifikationen zu unterstützen. Dazu konzentriert sich unsere Arbeit auf die Spezifikationssprache TROLL light, die es erlaubt, Teile der zu modellierenden Welt als eine Gemeinschaft nebeneinander bestehender und miteinander kommunizierender Objekte zu beschreiben. Auf diese Weise bestimmen wir sowohl die Struktur als auch das Verhalten der konzeptionellen Objekte. Unsere Spezifikationsumgebung für TROLL light erlaubt die Animation von Spezifikationen ebenso wie das Beweisen von Eigenschaften der Spezifikationen unter Verwendung von Theorembeweisern.

(6 pages, gzipped PostScript: 58kb via HTTP, FTP, uncompressed PostScript: 144kb via HTTP, FTP)

[Ehrich et al., 1993a]

Hans-Dieter Ehrich, Martin Gogolla, Stefan Conrad, Grit Denker, Rudolf Herzig, and Nikolaos Vlachantonis. Beiträge zu ``Das BMFT-Verbundprojekt Korrekte Software (KORSO)''. In Manfred Broy and Stefan Jähnichen, editors, Das BMFT-Verbundprojekt Korrekte Software (KORSO), pages 160-161. Informatik - Forschung und Entwicklung, Vol. 8, No. 3, 1993.

Innerhalb des KORSO-Projektes verfolgt unsere Gruppe das Ziel, die Entwicklung zuverlässiger Informationssysteme auf der Basis formaler Spezifikationen zu unterstützen. Dazu konzentriert sich unsere Arbeit auf die Spezifikationssprache TROLL light, die es erlaubt, Teile der zu modellierenden Welt als eine Gemeinschaft nebeneinander bestehender und miteinander kommunizierender Objekte zu beschreiben. Auf diese Weise bestimmen wir sowohl die Struktur als auch das Verhalten der konzeptionellen Objekte. Unsere Spezifikationsumgebung für TROLL light erlaubt die Animation von Spezifikationen ebenso wie das Beweisen von Eigenschaften der Spezifikationen unter Verwendung von Theorembeweisern.

[Ehrich et al., 1993b]

Hans-Dieter Ehrich, Martin Gogolla, Stefan Conrad, Grit Denker, Rudolf Herzig, and Nikolaos Vlachantonis. Entwicklung zuverlässiger Informationssysteme - Stand der Arbeiten im Januar'93. In Manfred Broy and Stefan Jähnichen, editors, Korrekte Software durch formale Methoden - 4. KORSO-Workshop (KORSO'93), pages 50-56, 1993.

Innerhalb des KORSO-Projektes befaßt sich unsere Gruppe damit, die Entwicklung zuverlässiger Informationssysteme auf der Basis formaler Spezifikationen zu unterstützen. Dazu konzentriert sich unsere Arbeit auf die Spezifikationssprache TROLL light, die es erlaubt, Teile der zu modellierenden Welt als eine Gemeinschaft nebeneinander bestehender und miteinander kommunizierender Objekte zu beschreiben. Auf diese Weise bestimmen wir sowohl die Struktur als auch das Verhalten konzeptioneller Objekte. Unsere Spezifikationsumgebung für TROLL light erlaubt die Animation von Spezifikationen ebenso wie das Beweisen von Eigenschaften der Spezifikationen unter Verwendung von Theorembeweisern.

[Gogolla, 1993a]

Martin Gogolla. A Computational Model for TROLL light. In Hartmut Ehrig, Friedrich von Henke, Jose Meseguer, and Martin Wirsing, editors, Specification and Semantics. Dagstuhl-Seminar-Report Nr. 64, 1993.

The object specification language TROLL light is intended to be used for conceptual modeling of information systems. It is designed to describe the Universe of Discourse (UoD) as a system of concurrently existing and interacting objects, i.e., an object community. The first part of the talk introduces the various language concepts offered by TROLL light. The second part of our paper outlines a simplified computational model for TROLL light. After introducing signatures for collections of object types we explain how single states of an object community are constructed. By parallel occurrence of a finite set of events the states of object communities change. The object community itself is regarded as a graph where the nodes are the object community states reachable from an initial state and the edges represent transitions between states.

(1 pages, gzipped PostScript: 20kb via HTTP, FTP, uncompressed PostScript: 118kb via HTTP, FTP)

[Gogolla, 1993b]

Martin Gogolla. Some Examples for TROLL light Templates. In Hans-Dieter Ehrich, editor, Beiträge zu KORSO- und TROLL light-Fallstudien, pages 51-62. Technische Universität Braunschweig, Informatik-Bericht Nr. 93-11, 1993.

We introduce some small examples for templates which are given in the language TROLL light which is intended for the specification of conceptual objects in information systems. The spectrum of our examples ranges however from rather untypical information systems like clocks, counters, or flipflops over stacks and trees to more specific information system applications like libraries.

(68 pages, gzipped PostScript: 191kb via HTTP, FTP, uncompressed PostScript: 517kb via HTTP, FTP)

[Gogolla, 1993c]

Martin Gogolla. TROLL light - A Core Language for Specifying Objects. In Catriel Beeri, Andreas Heuer, Gunter Saake, and Susan Urban, editors, Formal Aspects of Object Base Dynamics. Dagstuhl-Seminar-Report Nr. 62, 1993.

TROLL light is a language for conceptual modeling of information systems. It is designed to describe the Universe of Discourse (UoD) as a system of concurrently existing and interacting objects. As a basis for our language we took the specification language TROLL. However, some details have been added or modified in order to round off TROLL light. This was necessary because we needed a clear and balanced semantic basis for our specification language. In TROLL light classes are understood as composite objects having the class extension as sub-objects. Therefore in contrast to TROLL an extra notion of class is not needed in TROLL light. Over and above that concepts like class attributes, meta-classes, or heterogeneous classes are inherent in TROLL light. Second TROLL light incorporates a query calculus providing a general declarative query facility for object-oriented databases.

(1 pages, gzipped PostScript: 31kb via HTTP, FTP, uncompressed PostScript: 170kb via HTTP, FTP)

[Gogolla and Claßen, 1993]

Martin Gogolla and Ingo Claßen. An Object-Oriented Design for the ACT ONE Environment. In Maurice Nivat, Charles Rattray, Theodor Rus, and Giuseppe Scollo, editors, Proc. 3rd Int. Conf. Algebraic Methodology and Software Technology (AMAST'93), pages 361-368. Springer, London, Workshops in Computing, 1993.

We define a conceptual model, i.e., an information system schema, for the well-established algebraic specification language ACT ONE and its accompanying specification environment. This paper gives a formal description of suitable database support for an environment supporting the interactive development of ACT ONE specifications. The object-oriented data model of TROLL light, a language developed recently within the KORSO project, is used to present the design of such an environment and its dynamic behavior. However, the concepts used are general enough to support other specification and even programming languages as well. Therefore, we feel the design of a conceptual schema for ACT ONE is mainly a case study in employing an object-oriented data model for database support of specification or programming languages. It is therefore a proposal for the consolidation of environments for algebraic specification languages.

(8 pages, gzipped PostScript: 55kb via HTTP, FTP, uncompressed PostScript: 134kb via HTTP, FTP)

[Gogolla et al., 1993a]

Martin Gogolla, Stefan Conrad, and Rudolf Herzig. Sketching Concepts and Computational Model of TROLL light. In Alfonso Miola, editor, Proc. 3rd Int. Symposium Design and Implementation of Symbolic Computation Systems (DISCO'93), pages 17-32. Springer, Berlin, LNCS 722, 1993.

The specification language TROLL light is intended to be used for conceptual modeling of information systems. It is designed to describe a system of concurrently existing and interacting objects. We introduces the various language concepts offered by TROLL light. TROLL light objects have observable properties modeled by attributes, and the behavior of objects is described by events. TROLL light objects are organized in an object hierarchy established by sub-object relationships. Communication among objects is supported by event calling. We outlines a simplified computational model for TROLL light. We explain how single states of an object community are constructed. By parallel occurrence of a finite set of events the states of object communities change. The object community itself is regarded as a graph where the nodes are the object community states reachable from an initial state and the edges represent transitions between states.

(16 pages, gzipped PostScript: 106kb via HTTP, FTP, uncompressed PostScript: 264kb via HTTP, FTP)

[Gogolla et al., 1993b]

Martin Gogolla, Rudolf Herzig, Stefan Conrad, Grit Denker, and Nikolaos Vlachantonis. Integrating the ER Approach in an OO Environment. In Ramez Elmasri, Vram Kouramajian, and Bernhard Thalheim, editors, Proc. 12th Int. Conf. Entity-Relationship Approach (ER'93), pages 376-389. Springer, Berlin, LNCS 823, 1993.

We translate Entity-Relationship (ER) schemas into the object-oriented specification language TROLL light. This language describes the Universe of Discourse (UoD) as a system of concurrently existing and interacting objects, i.e., an object community. Thereby two essential aspects, structure and behavior, are integrated in one formalism. By doing the translation from ER to TROLL light we preserve the visual advantages of the former and receive a formalism through the latter which can be mapped to an adequate object-oriented database system. Proceeding this way we hope our proposal for transforming ER schemas into TROLL light specifications provides a valuable link between structural and dynamic modeling.

(14 pages, gzipped PostScript: 94kb via HTTP, FTP, uncompressed PostScript: 231kb via HTTP, FTP)

[Vlachantonis et al., 1993]

Nikolaos Vlachantonis, Rudolf Herzig, Martin Gogolla, Grit Denker, Stefan Conrad, and Hans-Dieter Ehrich. Towards Reliable Information Systems: The KORSO Approach. In Colette Rolland, Francois Bodart, and Corine Cauvet, editors, Proc. 5th Int. Conf. Advanced Information Systems Engineering (CAiSE'93), pages 463-483. Springer, Berlin, LNCS 685, 1993.

Within the compound project KORSO our team is concerned with the research on techniques and methods for the development of reliable information systems on the basis of formal specifications. Our work focuses on the specification language TROLL light which allows to describe the part of the world which is to be modeled as a community of concurrently existing and communicating objects by determining their structure as well as their behavior. Moreover we develop and implement a computer aided specification environment for TROLL light which permits specification animation as well as the proof of properties of specifications.

(20 pages, gzipped PostScript: 87kb via HTTP, FTP, uncompressed PostScript: 229kb via HTTP, FTP)

[Conrad and Gogolla, 1992]

Stefan Conrad and Martin Gogolla. An Annotated Bibliography on Object-Orientation and Deduction. ACM SIGMOD Record, 21(1):123-132, 1992.

This note tries to briefly survey research activities and results on the integration of object-oriented concepts and deductive database languages.

(10 pages, gzipped PostScript: 61kb via HTTP, FTP, uncompressed PostScript: 150kb via HTTP, FTP)

[Conrad et al., 1992]

Stefan Conrad, Martin Gogolla, and Rudolf Herzig. TROLL light - A Core Language for Specifying Objects. Informatik-Bericht 92-02, Technische Universität Braunschweig, 1992.

TROLL light is a language for conceptual modeling of information systems. It is designed to describe the Universe of Discourse (UoD) as a system of concurrently existing and interacting objects. TROLL light objects have observable properties modeled by attributes, and the behavior of objects is described by events. Possible object observations may be restricted by constraints, whereas event occurrences may be restricted to specified life cycles. TROLL light objects are organized in an object hierarchy established by subobject relationships. Communication among objects is supported by event calling. Apart from introducing the various possibilities for the syntactical description of objects, we aim to describe how the state of an object community may be changed by event occurrences.

(26 pages, gzipped PostScript: 114kb via HTTP, FTP, uncompressed PostScript: 301kb via HTTP, FTP)

[Engels et al., 1992]

Gregor Engels, Martin Gogolla, Uwe Hohenstein, Klaus Hülsmann, Perdita Löhr-Richter, Gunter Saake, and Hans-Dieter Ehrich. Conceptual Modelling of Database Applications Using an Extended ER Model. Data and Knowledge Engineering, 9(2):157-204, 1992.

In this paper, we motivate and present a data model for conceptual design of structural and behavioural aspects of databases. We follow an object centered design paradigm in the spirit of semantic data models. The specification of structural aspects is divided into modelling of object structures and modelling of data types used for describing object properties. The specification of object structures is based on an Extended Entity-Relationship (EER) model. The specification of behavioural aspects is divided into the modelling of admissible database state evolutions by means of temporal integrity constraints and the formulation of database (trans)actions. The central link for integrating these design components is a descriptive logic-based query language for the EER model. The logic part of this language is the basis for static constraints and descriptive action specifications by means of pre- and postconditions.

(58 pages, gzipped PostScript: 163kb via HTTP, FTP, uncompressed PostScript: 484kb via HTTP, FTP)

[Gogolla, 1992a]

Martin Gogolla. Contributions to ``A Framework for Software Development in KORSO''. In Martin Wirsing, editor, A Framework for Software Development in KORSO. Ludwig-Maximilians-Universität München, Institut für Informatik, Bericht 9205, 1992.

This paper reports on the results of the first meeting of the KORSO methods group, held in Munich, January 1992. It presents an outline of a framework for a software development methodology in KORSO. The framework is based on a generic algebraic-axiomatic approach to software development. Goals and requirements for KORSO developments are described. The roles of correctness and verification are discussed.

[Gogolla, 1992b]

Martin Gogolla. Fundamentals and Pragmatics of an Entity-Relationship Approach. Habilitation thesis, Technische Universität Braunschweig, Naturwissenschaftliche Fakultät, 1992. Submitted November 1992, Accepted May 1993.

This text presents a comprehensive introduction to an extended Entity-Relationship model both on a conceptual and on a formal, mathematical level. In addition to the primitives given by the data model the text introduces a language for the formulation of constraints in order to restrict database states to consistent ones. The same language can be used to query databases. The text also explains an implementation of the approach chosen in the logic programming language PROLOG and discusses in this context the computational power of the proposed calculus. Finally, the extended Entity-Relationship calculus is applied in order to define the meaning of the relational query language SQL.

(145 pages, gzipped PostScript: 266kb via HTTP, FTP, uncompressed PostScript: 881kb via HTTP, FTP)

[Herzig and Gogolla, 1992]

Rudolf Herzig and Martin Gogolla. Transforming Conceptual Data Models into an Object Model. In Günter Pernul and A Min Tjoa, editors, Proc. 11th Int. Conf. Entity-Relationship Approach (ER'92), pages 280-298. Springer, Berlin, LNCS 645, 1992.

In this paper a conceptually simple structural object model focusing on object types, attributes and ISA relationships is introduced. The model is derived mainly from an extended Entity-Relationship approach, but concepts from other semantic and object-oriented models have influenced its features. It is shown how high-level conceptual data models can be mapped to this model, and to what extent the object model subsumes classical modeling paradigms.

(19 pages, gzipped PostScript: 108kb via HTTP, FTP, uncompressed PostScript: 278kb via HTTP, FTP)

[Claßen and Gogolla, 1991]

Ingo Claßen and Martin Gogolla. Towards a Conceptual Model for the Environment of the Algebraic Specification Language ACT ONE. Forschungsbericht 91/11, Technische Universität Berlin, 1991.

The paper defines a conceptual model for the algebraic specification language ACT ONE and its accompanying specification environment. But the approach chosen is quite general and can be employed for other specification languages as well. The definition of the database schema including integrity constraints is done by means of an expressive and semantically well-founded extended Entity-Relationship model and a respective calculus. The basic idea is to start with the context free grammar of ACT ONE and to introduce entity types for non-terminal symbols. Productions are modelled by a type construction and appropriate components. Context sensitive conditions are translated into integrity constraints formulated in the calculus. This approach especially allows to describe various degrees of incompleteness of ACT ONE types, for instance whether an ACT ONE type has already been checked syntactically or whether the flat equivalent of the type is available.

(24 pages, gzipped PostScript: 100kb via HTTP, FTP, uncompressed PostScript: 261kb via HTTP, FTP)

[Ehrich et al., 1991]

Hans-Dieter Ehrich, Martin Gogolla, and Amilcar Sernadas. Objects and Their Specification. In Michel Bidoit and Christine Choppy, editors, Proc. 8th Int. Workshop Abstract Data Types (WADT'91), pages 40-65. Springer, Berlin, LNCS 655, 1991.

Object-oriented concepts and constructions are explained in an informal and language-independent way. Various algebraic approaches for dealing with objects and their specification are examined, ADT-based ones as well as process-based ones. The conclusion is that the process view of objects seems to be more appropriate than the data type view.

(26 pages, gzipped PostScript: 97kb via HTTP, FTP, uncompressed PostScript: 255kb via HTTP, FTP)

[Gogolla and Ehrich, 1991]

Martin Gogolla and Hans-Dieter Ehrich. Contributions to ``COMPASS - A Comprehensive Algebraic Approach to System Specification and Development''. In Michel Bidoit, Hans-Jörg Kreowski, Pierre Lescanne, Fernando Orejas, and Don Sannella, editors, COMPASS - A Comprehensive Algebraic Approach to System Specification and Development. Springer, Berlin, LNCS 501, 1991.

This volume arose out of the work of the COMPASS Basic Research Working Group, funded by the European Community under the Basic Research Action programme, ref. no. 3264. The name COMPASS stands for ``a COMPrehensive Algebraic approach to System Specification and development''. An early version of this document was included in the original COMPASS project proposal as a review of the state of the art. The current version is the result of suggestions for improvements from the participants in the COMPASS project, assembled and edited into a more or less coherent form by five editors. Since the COMPASS working group includes most of the leading European experts in algebraic specification, the result should be a relatively comprehensive overview of the main work in the field. In spite of its deficiencies, we hope that it nevertheless represents a useful snapshot of the current state of the art.

[Gogolla and Hohenstein, 1991]

Martin Gogolla and Uwe Hohenstein. Towards a Semantic View of an Extended Entity-Relationship Model. ACM Transactions on Database Systems, 16(3):369-416, 1991.

This paper introduces an extended ER model concentrating nearly all concepts of known so-called semantic data models to a few syntactical constructs. Moreover, we provide our extended ER model with a formal mathematical semantics. On this basis a well-founded calculus is developed taking into account data operations on arbitrary user-defined data types and aggregate functions. We pay special attention to arithmetic operations as well as multivalued terms allowing nested queries in a uniform and consistent manner. We prove our calculus only allows the formulation of safe terms and queries yielding a finite result, and to be (at least) as expressive as the relational calculi.

(48 pages, gzipped PostScript: 5025kb via HTTP, FTP, uncompressed PostScript: 47544kb via HTTP, FTP)

[Gogolla et al., 1991]

Martin Gogolla, Bernd Meyer, and Gerhard D. Westerman. Drafting Extended Entity-Relationship Schemas with QUEER. In Toby Teorey, editor, Proc. 10th Int. Conf. Entity-Relationship Approach (ER'91), pages 561-585. ER Institute, San Mateo, 1991.

The system QUEER is a prototype of an information system design tool which directly supports an extended Entity-Relationship model on its front-end and uses a semantically well-founded query and manipulation language based on an Entity-Relationship calculus. The system basically consists of a set of compilers written in PROLOG which translate data specifications, schema definitions, queries, integrity constraints, and data-manipulation statements into PROLOG programs. All features mentioned are implemented in form and extent as described here.

(25 pages, gzipped PostScript: 111kb via HTTP, FTP, uncompressed PostScript: 290kb via HTTP, FTP)

[Engels et al., 1990]

Gregor Engels, Martin Gogolla, Uwe Hohenstein, Klaus Hülsmann, Perdita Löhr-Richter, Gunter Saake, and Hans-Dieter Ehrich. Conceptual Modelling of Database Applications Using an Extended ER Model. Informatik-Bericht 90-05, Technische Universität Braunschweig, 1990.

In this paper, we motivate and present a data model for conceptual design of structural and behavioural aspects of databases. We follow an object centered design paradigm in the spirit of semantic data models. The specification of structural aspects is divided into modelling of object structures and modelling of data types used for describing object properties. The specification of object structures is based on an Extended Entity-Relationship (EER) model. The specification of behavioural aspects is divided into the modelling of admissible database state evolutions by means of temporal integrity constraints and the formulation of database (trans)actions. The central link for integrating these design components is a descriptive logic-based query language for the EER model. The logic part of this language is the basis for static constraints and descriptive action specifications by means of pre- and postconditions.

(58 pages, gzipped PostScript: 163kb via HTTP, FTP, uncompressed PostScript: 484kb via HTTP, FTP)

[Gogolla, 1990a]

Martin Gogolla. A Note on the Translation of SQL to Tuple Calculus. Bulletin of the EATCS, 40:231-236, 1990.

This note presents a translation of a subset of the relational query language SQL into the well known tuple calculus. Roughly speaking, tuple calculus corresponds to first order predicate calculus. The SQL subset is relationally complete and represents a ``relational core'' of the language. Nevertheless, our translation is simple and elegant. Therefore it is especially well suited as a beginners course into the principles of a formal definition of SQL.

(5 pages, gzipped PostScript: 47kb via HTTP, FTP, uncompressed PostScript: 117kb via HTTP, FTP)

[Gogolla, 1990b]

Martin Gogolla. A Note on the Translation of SQL to Tuple Calculus. ACM SIGMOD Record, 19(1):18-22, 1990.

This note presents a translation of a subset of the relational query language SQL into the well known tuple calculus. Roughly speaking, tuple calculus corresponds to first order predicate calculus. The SQL subset is relationally complete and represents a ``relational core'' of the language. Nevertheless, our translation is simple and elegant. Therefore it is especially well suited as a beginners course into the principles of a formal definition of SQL.

(5 pages, gzipped PostScript: 47kb via HTTP, FTP, uncompressed PostScript: 117kb via HTTP, FTP)

[Gogolla, 1990c]

Martin Gogolla. Datalog - Eine deduktive Datenbanksprache. Informatik-Skript 25, Technische Universität Braunschweig, 1990.

Die vorliegenden Notizen sind Überarbeitungen der Folien, die für eine Vorlesung verwendet wurden. Stoffauswahl und Detailierungsgrad waren wesentlich von dem Umstand bestimmt, daß eine zweistündige Veranstaltung in einem Sommersemester mit 12 Wochen gehalten wurde. Die Struktur der Vorlesung lehnt sich an einen Übersichtsartikel von Ceri, Gottlob und Tanca an. Zusätzliche Definitionen, Sätze, Verfahren und Beispiele stammen aus der angegebenen Literatur. Andere Beispiele wurden in der Veranstaltung entwickelt. Die Hörer der Vorlesung haben durch kritische Fragen und Bemerkungen zur Verbesserung des Materials beigetragen.

[Gogolla and Karge, 1990]

Martin Gogolla and Ulrich Karge. Zur formalen Semantik von SQL. In Udo Walter Lipeck, Stefan Braß, and Gunter Saake, editors, Kurzfassungen 2. Workshop Grundlagen von Datenbanken (GvD'90), pages 27-29. Technische Universität Braunschweig, Informatik-Bericht Nr. 90-02, 1990.

Es wird ein Vorschlag zur Definition der formalen Semantik von SQL auf der Grundlage eines erweiterten Entity-Relationship-Kalküls diskutiert. Dieser zugrunde liegende Kalkül gestattet insbesondere eine semantisch wohl-definierte Verwendung von Aggregierungsfunktionen auf der Grundlage von Multimengen. Damit ist es möglich, sowohl die SQL Gruppierungsmöglichkeiten mittels GROUP BY als auch die (zumindest teilweise) hierauf basierenden SQL Aggregierungen MAX, MIN, AVG, COUNT und SUM präzise zu erklären. Auf dieser Grundlage können so Aussagen u.a. über die Äquivalenz von Anfragen und somit über beweisbare Eigenschaften der Sprache gemacht werden. Auf diesem Weg wird dann auch gezeigt, daß Unteranfragen, die mittels IN, ALL, ANY oder EXISTS gebildet werden, sich durch ein einziges Konstrukt, nämlich COUNT ausdrücken lassen.

[Karge and Gogolla, 1990]

Ulrich Karge and Martin Gogolla. Formal Semantics of SQL Queries. Informatik-Bericht 90-02, Technische Universität Braunschweig, 1990.

A formal semantics of the relational query language SQL (Structured Query Language) is presented by translating SQL into an extended relational calculus. This calculus allows the handling of grouping and aggregation as well as null vallues, and therefore special emphasis is laid on the correct translation of grouping and aggregation of SQL. The translation of an SQL query is performed in eight steps. Some steps can be omitted for most of the queries. Making use of the presented translation, it is possible to prove properties of SQL, e.g. subqueries which are added with IN, ALL, or EXISTS can be replaced equivalently by subqueries using the aggregation function COUNT.

[Meyer et al., 1990]

Bernd Meyer, Gerhard D. Westerman, and Martin Gogolla. QUEER - A Prolog Based Prototype for an Extended ER Approach. Informatik-Bericht 90-03, Technische Universität Braunschweig, 1990.

The combination of logic programming and databases has been given broad attention in recent years. However, mainly the connections between the relational data model and logic programming have been investigated. The application of logic programming languages as a basis for information systems founded on more complex, i.e. conceptual data models has received comparatively less attention. With the system QUEER, we introduce the prototype of a PROLOG-based information system which directly supports an extended Entity-Relationship model on its front-end and uses a semantically well-founded query and manipulation language based on an Entity-Relationship calculus. The system basically consists of a set of compilers written in PROLOG which translate data specifications, schema definitions, queries, and data-manipulation statements into PROLOG programs.

(36 pages, gzipped PostScript: 136kb via HTTP, FTP, uncompressed PostScript: 367kb via HTTP, FTP)

[Ehrich et al., 1989a]

Hans-Dieter Ehrich, Gregor Engels, Martin Gogolla, and Gunter Saake, editors. Abstracts Workshop Grundlagen von Datenbanken (GvD'89). Technische Universität Braunschweig, Informatik-Bericht Nr. 89-02, 1989.

Der vorliegende Bericht faßt die Kurzfassungen der Vorträge zusammen, die für den Workshop Grundlagen von Datenbanken (16.-19.5.89 im Herrenhaus Volkse) angemeldet wurden. Der Workshop hat das Anliegen, die Kommunikation zwischen den deutschsprachigen Arbeitsgruppen zu fördern, die um Bereich der theoretischen, konzeptionellen und methodologischen Grundlagen von Daten- und Wissensbanken arbeiten. Insbesondere den jüngeren Nachwuchswissenschaftlern soll der Workshop Gelegenheit bieten, in zwangloser Umgebung Ideen, Ansätze und Ergebnisse auszutauschen und zu diskutieren. Die Vielfalt der Anmeldungen zeigt, daß für Workshops dieser Art - und dieser Thematik - ein großer Bedarf besteht.

[Ehrich et al., 1989b]

Hans-Dieter Ehrich, Martin Gogolla, and Udo Walter Lipeck. Algebraische Spezifikation Abstrakter Datentypen - Eine Einführung in die Theorie. Leitfäden und Monographien der Informatik. Teubner, Stuttgart, 1989.

Dieses Buch ist aus der Überarbeitung und Erweiterung von Notizen zu Vorlesungen entstanden, die seit 1977 zunächst vom ersten Autor an der Universität Dortmund, seit 1982 dann von allen drei Autoren in wechselnder Folge an der Technischen Universität Braunschweig gehalten wurden. Der Schwerpunkt des Buches liegt bei den theoretischen Grundlagen, jedoch haben die Möglichkeiten und Grenzen praktischer Anwendung die Auswahl und die Gestaltung des Stoffes stark beeinflußt. Das Buch richtet sich vornehmlich an Informatiker, die sich mit Grundlagen des Software-Entwurfs auseinandersetzen wollen, und an Mathematiker, die sich für Anwendungen der universellen Algebra und der Logik in der Informatik interessieren.

[Gogolla, 1989a]

Martin Gogolla. Algebraization and Integrity Constraints for an Extended Entity-Relationship Approach. In Josep Diaz and Fernando Orejas, editors, Proc. 3rd Int. Joint Conf. Theory and Practice of Software Development (TAPSOFT'89), pages 259-274. Springer Berlin, LNCS 351, 1989.

An extended Entity-Relationship model concentrating nearly all concepts of known ``semantic'' data models and especially allowing arbitrary user defined data types is introduced. The semantics of the model is described purely in algebraic terms mainly based on the notions of signature, algebra and extension. On this basis a calculus making intensive use of abstract data types is defined and employed for the formulation of typical integrity constaints like functional restrictions and key specifications.

(16 pages, gzipped PostScript: 70kb via HTTP, FTP, uncompressed PostScript: 186kb via HTTP, FTP)

[Gogolla, 1989b]

Martin Gogolla. Zur Übersetzung eines ER-Kalküls nach Prolog. In Hans-Dieter Ehrich, Gregor Engels, Martin Gogolla, and Gunter Saake, editors, Abstracts Workshop Grundlagen von Datenbanken (GvD'89). Technische Universität Braunschweig, Informatik-Bericht Nr. 89-02, 1989.

Auf der Basis eines erweiterten ER Modells werden sowohl Schemata als auch die zugehörigen Datenbanzustände mittels Prolog-Fakten dargestellt. Es wird ein Verfahren angegeben, das es gestattet, Terme eines auf dem erweiterten ER Modell aufbauenden Kalküls in äquivalente Prolog-Prädikate zu übersetzen. Mit Hilfe dieser Terme bzw. der entsprechenden Prolog-Prädikate lassen sich einerseits Anfragen bzgl. des gegebenen Datenbankzustands formulieren und auswerten. Andererseits dienen diese Terme bzw. die äquivalenten Prolog-Prädikate auch zur Überprüfung (statischer) Integritätsbedingengen im repräsentierten Zustand.

[Gogolla and Ehrich, 1989]

Martin Gogolla and Hans-Dieter Ehrich. Contributions to ``COMPASS - A Comprehensive Algebraic Approach to System Specification and Development''. In Bernd Krieg-Brückner, editor, COMPASS - A Comprehensive Algebraic Approach to System Specification and Development. Universität Bremen, Informatik-Bericht 6/89, 1989.

COMPASS is funded as a Basic Research Workong Group under the ESPRIT Programme of the European Communities. This document contains those three chapters of the original proposal that we believe to be of potential interest to a wider audience. The first chapter states the general objectives of the cooperation in the Working Group. The second chapter gives a summary of the State of the Art for and of our own work as we saw it in June 1988. Thus it is in many ways incomplete with respect to the work of others and does not claim full coverage. We believe, however, that it provides an overview that might be of interest for other researchers in the area of Formal Methods in Computing Science. The third chapter lists the references to work mentioned in the previous chapter. Again, it is by no means complete. Overall, chapter II and III can be regarded as a first approximation of an annotated bibliography of the area of algebraic specification.

[Ehrich et al., 1988]

Hans-Dieter Ehrich, Klaus Drosten, and Martin Gogolla. Towards an Algebraic Semantics for Database Specification. In Robert A. Meersman and Amilcar C. Sernadas, editors, Proc. 2nd IFIP 2.6 Working Conf. Database Semantics (DS-2'86), pages 119-135. North Holland, Amsterdam, 1988.

In the framework of a modal-algebraic approach to database semantics, the specification of abstract object types on the basis of abstract data types is studied. As a semantic framework for determining admissible states and state sequences, a standard universe of ``possible objects'' and their interrelationships has to be associated with a schema specification. This paper gives a construction of such a standard universe from a given key system including certain constraints. There is also an abstract algebraic characterisation of the universe (up to isomorphism) in the terms of final algebras. Within this framework, a general definition of admissible states and state sequences as the semantics of a schema specification is discussed briefly.

[Hohenstein and Gogolla, 1988a]

Uwe Hohenstein and Martin Gogolla. A Calculus for an Extended Entity-Relationship Model Incorporating Arbitrary Data Operations and Aggregate Functions. In Carlo Battini, editor, Proc. 7th Int. Conf. Entity-Relationship Approach (ER'88), pages 129-148. North-Holland, Amsterdam, 1988.

We propose a semantically well-founded Entity-Relationship calculus that takes into account data operations (especially arithmetic operations) on arbitrary defineable data types and aggregate functions, as well as multivalued terms allowing nested queries in a uniform and consistent manner. We define our calculus in a way that only allows the formulation of safe terms and queries (yielding a finite result) and that it is (at least) as powerful as the relational calculi. The calculus is based upon an extended ER model concentrating nearly all concepts of known so-called semantic data models to a few syntactical constructs. Moreover, we provide our extended ER model with a formal semantics, since otherwise the semantics of the calculus cannot be defined mathematically precise.

[Hohenstein and Gogolla, 1988b]

Uwe Hohenstein and Martin Gogolla. Towards a Semantic View of an Extended Entity-Relationship Model. Informatik-Bericht 88-02, Technische Universität Braunschweig, 1988.

This paper introduces an extended ER model concentrating nearly all concepts of known so-called semantic data models to a few syntactical constructs. Moreover, we provide our extended ER model with a formal mathematical semantics. On this basis a well-founded calculus is developed taking into account data operations on arbitrary user-defined data types and aggregate functions. We pay special attention to arithmetic operations as well as multivalued terms allowing nested queries in a uniform and consistent manner. We prove our calculus only allows the formulation of safe terms and queries yielding a finite result, and to be (at least) as expressive as the relational calculus.

[Gogolla, 1987]

Martin Gogolla. On Parametric Algebraic Specifications with Clean Error Handling. In Hartmut Ehrig, Robert Kowalski, and Giorgio Levi, editors, Proc. 2nd Int. Joint Conf. Theory and Practice of Software Development (TAPSOFT'87), pages 81-95. Springer, Berlin, LNCS 249, 1987.

Usual algebraic specification techniques can be extended to treat partially ordered sorts. This allows the introduction of sub- and supersorts as well as overloaded operators, while pleasant features of the equational specification method (e.g. existence of initial algebras and equivalence of algebraic and operational semantics) are preserved. On this basis error and exception handling is studied. For each sort an ok and an error subsort is introduced and clean algebras (i.e. algebras which are ok-error-consistent and ok-error-complete) are considered. This new approach allows to prove an extension lemma for persistent parametric specifications which permit error handling.

[Ehrich et al., 1986]

Hans-Dieter Ehrich, Klaus Drosten, Martin Gogolla, and Udo Walter Lipeck, editors. Abstracts 4th Int. Workshop Abstract Data Types (WADT'86). Technische Universität Braunschweig, Informatik-Bericht Nr. 86-09, 1986.

Here are the abstracts of talks presented at the 4th Workshop on Specification of Abstract Data Types which was held at Burg Warberg near Braunschweig, May 20-23, 1986. About 70 participants attended the workshop, more than ever before in this series of workshops, starting in Langscheid 1982 and going on in Passau 1983 and in Bremen 1984. We all look forward to the next meeting in Edinburgh which is scheduled to take place in fall 1987 and will be organized by Don Sannella.

[Gogolla, 1986a]

Martin Gogolla. Exception Handling and Subsorts. In Hans-Dieter Ehrich, Klaus Drosten, Martin Gogolla, and Udo Walter Lipeck, editors, Abstracts 4th Int. Workshop Abstract Data Types (WADT'86). Technische Universität Braunschweig, Informatik-Bericht Nr. 86-09, 1986.

Usual algebraic specification techniques can be extended to treat partially ordered sorts. This allows the introduction of sub- and supersorts as well as overloaded operators, while pleasant features of the equational specification method (e.g. existence of initial algebras and equivalence of algebraic and operational semantics) are preserved. Partially ordered sorts can also be used as a basis for exception and error handling. We discuss three different, but closey related methods: (1) Ok-subsorts, (2) error-subsorts, and (3) disjoint ok- and error-subsorts. In particular, the three approaches are considered with respect to error introduction, error propagation and error recovery.

[Gogolla, 1986b]

Martin Gogolla. Über Partiell Geordnete Sortenmengen und deren Anwendung zur Fehlerbehandlung in Abstrakten Datentypen. PhD thesis, Technische Universität Braunschweig, Naturwissenschaftliche Fakultät, 1986. Mainly material from the CAAP'84, TCS'84, WADT'84 and TAPSOFT'87 papers.

Algebraische Spezifikationen von Datentypen werden um Ausdrucksmittel zur Darstellung von Halbordnungen auf den Trägern erweitert. Dies ermöglicht insbesondere die Behandlung von Unter- und Obersorten. Neben Gleichungen werden auch Deklarationen in Spezifikationen zugelassen, die es gestatten, einem Term eine neue Sorte zuzuweisen. Als Semantik ergibt sich stets eine initiale Algebra. Auf dieser Basis werden verschiedene Methoden zur Behandlung von Fehlern und Ausnahmen in abstrakten Datentypen vorgestellt, und ein Vorschlag zu deren Parametrisierung wird diskutiert.

[Gogolla, 1985a]

Martin Gogolla. A Final Algebra Semantics for Errors and Exceptions. Informatik-Bericht 85-06, Technische Universität Braunschweig, 1985.

Algebraic specifications allowing equations and inequations are studied. A characterisation of the existence of models and initial algebras as well as a criterion for the existence of final algebras for such specifications are given. As an application it is shown, how the result can be applied to yield maximal error propagation preserving error recovery in abstract data types.

[Gogolla, 1985b]

Martin Gogolla. A Final Algebra Semantics for Errors and Exceptions. In Hans-Jörg Kreowski, editor, Proc. 3rd Int. Workshop Abstract Data Types (WADT'84), pages 89-103. Springer Berlin, Informatik Fachberichte 116, 1985.

Algebraic specifications allowing equations and inequations are studied. A characterisation of the existence of models and initial algebras as well as a criterion for the existence of final algebras for such specifications are given. As an application it is shown, how the result can be applied to yield maximal error propagation preserving error recovery in abstract data types.

[Lipeck et al., 1985]

Udo Walter Lipeck, Hans-Dieter Ehrich, and Martin Gogolla. Specifying Admissibility of Dynamic Database Behaviour Using Temporal Logic. In Amilcar Sernadas, Janis Bubenko, and Antoni Olive, editors, Proc. IFIP Working Conf. Theoretical and Formal Aspects of Information Systems (TFAIS'85), pages 145-157. North Holland, Amsterdam, 1985.

This work uses temporal logic as a calculus for expressing integrity constraints that specify admissibility of dynamic database behaviour. Formulas are interpreted in state sequences representing dynamic behaviour. Our approach incorporates temporal quantifications by ``always'' and ``sometime'', and quantifiers bounded by intervals in state sequences. Moreover, dynamically changing domains of database values are considered. We then use special kinds of formulas as a language for dynamic constraints and give some hints how to specify in typical situations. For such formulas, a frame for monitoring constraints during runtime of a database is discussed which allows to characterize admissibility operationally.

(13 pages, gzipped PostScript: 1606kb via HTTP, FTP, uncompressed PostScript: 20511kb via HTTP, FTP)

[Ehrich et al., 1984]

Hans-Dieter Ehrich, Udo Walter Lipeck, and Martin Gogolla. Specification, Semantics and Enforcement of Dynamic Database Constraints. In Umeshwar Dayal, Gunter Schlageter, and Lim Huat Seng, editors, Proc. 10th Int. Conf. Very Large Data Bases (VLDB'84), pages 310-318. Morgan Kaufmann, San Mateo, 1984.

In order to specify dynamic constraints, we present a simplified version of temporal logic based on the temporal quantifiers ``always'' and ``sometime'' as well as their bounded versions ``always..until'' and ``sometime..before''. We show that, in most practical cases, the bounded temporal quantifiers can be expressed by appropriate formulas with unbounded temporal quantifiers. We then use special kinds of temporal formulas as a language to specify dynamic constraints. The problem of enforcing such constraints is then reduced to the problem of enforcing dynamically changing sets of two kinds of static constraints, called universal and existential constraints. While universal constraints can be enforced strictly in principle, violation of existential constraints cannot be detected in each case at the earliest moment. We give a sufficient criterion for detecting violation of existential constraints.

(8 pages, gzipped PostScript: 1153kb via HTTP, FTP, uncompressed PostScript: 12773kb via HTTP, FTP)

[Gogolla, 1984a]

Martin Gogolla. A Final Algebra Semantics for Errors and Exceptions. In Hans-Jörg Kreowski and Anne Wilharm, editors, Abstracts 3rd Int. Workshop Abstract Data Types (WADT'84). Universität Bremen, Informatik-Bericht 9/84, 1984.

Algebraic specifications allowing equations and inequations are studied. A characterisation of the existence of models and initial algebras as well as a criterion for the existence of final algebras for such specifications are given. As an application it is shown, how the result can be applied to yield maximal error propagation preserving error recovery in abstract data types.

[Gogolla, 1984b]

Martin Gogolla. Partially Ordered Sorts in Algebraic Specifications. In Bruno Courcelle, editor, Proc. 9th Int. Colloquium Trees in Algebra and Programming (CAAP'84), pages 139-153. Cambridge University Press, Cambridge, 1984.

Conventional algebraic specification techniques cannot express relationships between sorts formally. The approach presented here puts more structure into the specification by allowing a partial ordering on the set of sorts to describe that one sort is a subsort of another sort. This concept implies that one function can occur more than one time in the signature with different domains and codomains. The initial algebra semantics of our specifications with a partial ordering on the set of sorts are studied.

( pages, gzipped PostScript: 1584kb via HTTP, FTP, uncompressed PostScript: 20309kb via HTTP, FTP)

[Gogolla et al., 1984]

Martin Gogolla, Klaus Drosten, Udo Lipeck, and Hans-Dieter Ehrich. Algebraic and Operational Semantics of Specifications Allowing Exceptions and Errors. Theoretical Computer Science, 34:289-313, 1984.

The specification of abstract data types requires the possibility to treat exceptions and errors. We present an approach allowing all forms of error handling: error introduction, error propagation and error recovery. The algebraic semantics of our method and a new correctness criterion are given. We also introduce an operational semantics of a subclass of our specifications which coincides with the algebraic semantics.

(25 pages, gzipped PostScript: 1749kb via HTTP, FTP, uncompressed PostScript: 22673kb via HTTP, FTP)

[Gogolla, 1983a]

Martin Gogolla. Algebraic Specification of Subsorts. In Manfred Broy and Martin Wirsing, editors, Abstracts 2nd Int. Workshop Abstract Data Types (WADT'83). Universität Passau, Informatik-Bericht, 1983.

A method for the algebraic specification of subsorts and overloaded operators is presented. In this approach algebras are described by equations and declarations. A declaration is a construct, which assures that an expression has a certain type. It is shown that every specification consisting of equations and declarations has an initial model. Furthermore it is proved that declarations can be expressed only by equations using hidden sorts and functions. An as application it is shown how errors and exceptions in abstract data types can be treated by using declarations. For every sort an ok subsort representing the non error elements is introduced and by the use of declarations the functions are divided into those which may introduce errors and those which return ok values when applied to such ones. By this, error introduction and error propagation as well as error recovery is possible.

[Gogolla, 1983b]

Martin Gogolla. Algebraic Specifications with Partially Ordered Sorts and Declarations. Forschungsbericht 169, Universität Dortmund, Abteilung Informatik, 1983.

Conventional algebraic specification techniques cannot express relationships between sorts formally. The approach presented here puts more structure into the specification by allowing a partial ordering on the set of sorts to describe that one sort is a subsort of another sort. This concept implies that one function can occur more than one time in the signature with different domains and codomains. Apart from equations our specifications allow declarations to type a term of a certain sort to a subsort of the given one. The initial algebra semantics of our specifications with a partial ordering on the set of sorts are studied.

[Gogolla and Ehrich, 1983]

Martin Gogolla and Hans-Dieter Ehrich. Algebraic Specifications with Subsorts Using Declarations. Bulletin of the EATCS, 21:31-38, 1983.

Conventional algebraic specifications describe data types some times only implicit with hidden sorts and functions. A more powerful and elegant technique can be achived by putting more structure into the specification. Our approach distinguishes between basis sorts and subsorts. The subsorts, whose carriers are included in the basis sort carriers, are described by declarations, i.e. a list of terms possibly with variables of basis as well as subsorts. We study the initial algebra semantics of our specifications, which include declarations and equations.

[Drosten et al., 1982]

Klaus Drosten, Martin Gogolla, Hans-Dieter Ehrich, and Udo Lipeck. A Hierarchical Approach to an Operational Semantics for Conditional Algebraic Specifications. Forschungsbericht 144, Universität Dortmund, Abteilung Informatik, 1982.

For the specification of abstract data types, it is most convenient in many cases not only to have pure equations, but conditional ones. We present a hierarchical approach where conditions have to be evaluated on underlying levels. An operational semantics is obtained via term rewriting systems. In order to guarantee its well-definedness, we provide sufficient syntactical criteria for the Church-Rosser property. Moreover, these criteria are sufficient for the termination of the full substitution reduction strategy, as well.

[Gogolla et al., 1982a]

Martin Gogolla, Klaus Drosten, Udo Lipeck, and Hans-Dieter Ehrich. Algebraic and Operational Semantics of Exceptions and Errors. In Armin B. Cremers and Hans-Peter Kriegel, editors, Proc. 6th GI Conf. Theoretical Computer Science, pages 141-151. Springer, Berlin, LNCS 145, 1982.

The specification of abstract data types requires the possibility to treat exceptions and errors. We present an approach allowing all forms of error handling: error introduction, error propagation and error recovery. The algebraic semantics of our method and a new correctness criterion are given. We also introduce an operational semantics of a subclass of our specifications which coincides with the algebraic semantics.

[Gogolla et al., 1982b]

Martin Gogolla, Klaus Drosten, Udo Lipeck, and Hans-Dieter Ehrich. Algebraic and Operational Semantics of Specifications Allowing Exceptions and Errors. Forschungsbericht 140, Universität Dortmund, Abteilung Informatik, 1982.

The specification of abstract data types requires the possibility to treat exceptions and errors. We present an approach allowing all forms of error handling: error introduction, error propagation and error recovery. The algebraic semantics of our method and a new correctness criterion are given. We also introduce an operational semantics of a subclass of our specifications which coincides with the algebraic semantics.

[Gogolla, 1980]

Martin Gogolla. Eine Charakterisierung von nicht-strukturierten Flußdiagrammen. Master's thesis, Universität Dortmund, Abteilung Informatik, 1980.

In dieser Arbeit wird eine Formalisierung der Begriffe Flußdiagramm und Strukturiertheit eines Flußdiagramms angegeben, und es werden nicht-strukturierte Flußdiagramme über bestimmte Teilgraphen beschrieben. Flußdiagramme geben den Kontrollfluß von Programmen wieder, und Analysen des Programmablaufs können unter anderem zur Optimierung in Compilern, Umkehrübersetzung von maschinennahen Programmen und Umwandlung von unstrukturierten Programmen in lesebare Form dienen. Fragestellungen nach der Ursache der Unstrukturiertheit sind sicherlich auch im Hinblick auf die Methodik der Programmierung von Interesse.

[Coy et al., 1979]

Wolfgang Coy, Claudio Moraga, Friedrich Abraham, Angelika Beese, Werner Bielefeld, Magdalena Bonsiepen, Martin Gogolla, Michael Land, and Manfred Siebert. Adaptive und Lernende Systeme - Bericht einer Projektgruppe Wintersemester 1978 - Sommersemester 1979. Interne Berichte und Skripten, Universität Dortmund, Abteilung Informatik, 1979.

In der Projektgruppe ``Adaptive und Lernende Systeme'' wollten die Veranstalter eine Möglichkeit anbieten, das Problem des Lernens im Gebiet der formalen Sprachinferenz zu untersuchen. Nach einer einheitlichen Verarbeitung von Grundbeiträgen aus der Literatur ist die Gruppe in der Lage, sich mit Inferenzalgorithmen zu beschäftigen, einige zu entwickeln, in Form eines Programms zu testen und zu bewerten. Schließlich bietet sich die Möglichkeit, Algorithmen für Inferenz über verschiedenen Sprachen der Chomsky-, Petri- oder Lindenmayer-Sprachfamilien weiter zu untersuchen.

Home|People|Teaching|Publications