Birgit Demuth

OCL as a Specification Language for Business Rules in Database Applications

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

Using UML/OCL constraints for relational database design

Integrating relational databases into object-oriented applications is state of the art in software development practice. In database applications, it is beneficial if constraints like business rules are encoded as part of the database schema and not in the application programs. The Object Constraint Language (OCL) as part of the Unified Modeling Language (UML) provides the posssibility to express constraints in a conceptual model unambiguously. We show how OCL, UML and SQL can be used in database constraint modeling, and discuss their advantages and limitations. Furthermore, we present patterns for mapping OCL expressions to SQL code.

Modular architecture for a toolset supporting OCL

The practical application of the Object Constraint Language, which is part of the UML specification since version 1.1, depends crucially on the existence of adequate tool support. This paper discusses general design issues for OCL tools. It is argued that the nature of OCL will lead to a large variety of tools, applied in combination with a variety of different UML tools. Therefore, a flexible modular architecture for a UML/OCL toolset is proposed. The paper reports on the first results of an ongoing project which aims at the provision of such an OCL toolset for the public domain.

A Framework for Generating Query Language Code from OCL Invariants

The semantical integrity of business data is of great importance for the implementation of business applications. Model-Driven Software Development (MDSD) allows for specifying the relevant domain concepts, their interrelations and their concise semantics using a plethora of modelling languages. Since model transformations enable an automatic mapping of platform independent models (PIMs) to platform specific models (PSMs) and code, it is reasonable to utilise them to derive data schemas and integrity rules for business applications. Most current approaches only focus on transforming structural descriptions of software systems while semantical specifications are neglected. However, to preserve also the semantical integrity rules we propose a Query Code Generation Framework that enables Model-Driven Integrity Engineering. This framework allows for mapping UML models to arbitrary data schemas and for mapping OCL invariants to sentences in corresponding declarative query languages, enforcing semantical data integrity on implementation level. This supersedes the manual translation of integrity constraints and, thus, decreases development costs while increasing software quality.

Model-Level Integration of the OCL Standard Library Using a Pivot Model with Generics Support

OCL 2.0 specifies a standard library of predefined types and associated operations. A model-level representation of the library is required to reference its elements within the abstract syntax model created by an OCL parser. Existing OCL engines build this model in the implementation code which severely limits reusability, flexibility and maintainability. To address these problems, we show how a common pivot model with explicit support for template types can help to externalize the definition of the standard library and integrate it with instances of arbitrary domain-specific modeling languages. We exemplify the feasibility of our approach with a prototypical implementation for the Dresden OCL2 Toolkit and present a tailored EMF editor for modeling the OCL types and operations. We limit our discussion to the model level, i.e., we do not consider an implementation of the standard library for an execution engine.

DropsBox: the Dresden Open Software Toolbox

The Dresden Open Software Toolbox (DropsBox) is a software modelling toolbox consisting of a set of open source tools developed by the Software Technology Group at TU Dresden. The DropsBox is built on top of the Eclipse Platform and the Eclipse Modeling Framework. The DropsBox contributes to the development and application of domain-specific language changes (DSLs) in model-driven software development. It can be customised by tool and language developers to support various activities of a DSL’s life cycle ranging from language design to language application and evolution. In this paper, we provide an overview of the DSL life cycle, the DropsBox tools, and their interaction on a common example. Furthermore, we discuss our experiences in developing and integrating tools for DropsBox in an academic environment.

OCL Tools Report based on the IDE4OCL Feature Model

Previously we have developed the idea of an Integrated Development Environment for OCL (IDE4OCL). Based on the OCL communitys feedback we have also designed and published an IDE4OCL feature model. Here we present a report on selected OCL tools developed by the authors and their teams. Each author gives an overview of their OCL tool, provides a top level architecture, and gives an evaluation of the tool features in a web framework. The framework can also be used by other potential OCL users and tool developers. For users it may serve as an aid to choose a suitable tool for their OCL use scenarios. For tool developers it provides a comparative view for further development of the OCL tools. Our plans are to maintain the collected data and extend this web framework by further OCL tools. Additionally, we would like to encourage sharing of OCL development resources.

An approach for bridging the gap between business rules and the semantic web

Business rules should improve the human communication inside of an enterprise or between business partners and must be therefore independent of implementations in IT systems. As a long-term goal, business rules should be guaranteed by all IT applications of an enterprise. A first step to define and to standardize what business rules are is an OMG initiative to specify a metamodel for business rules and the vocabulary on which business rules are defined. The result of OMGs effort is the SBVR (Semantics of Business Vocabulary and Business Rules) specification that we took as starting point of our investigations to automate business rules. There are multiple ways for transforming business rules. In this paper we show how SBVR based vocabulary and rules can be translated by model transformation chains into Semantic Web Languages. In our approach we use OWL and R2ML (REWERSE Rule Markup Language). Both are languages with a high potential for a broad usage in future rule-based applications.

UML is still inconsistent! How to improve OCL Constraints in the UML 2.3 Superstructure

Since the first OMG specification of the Unified Modeling Language (UML), the Object Constraint Language (OCL) has been used for the definition of well-formedness rules in the UML specification. These rules have been specified within the early OCL years, when no appropriate tooling existed. Thus, they could not be checked for syntactical and static semantics correctness. In this paper we present an analysis of the static correctness of all OCL rules specified in the UML 2.3 superstructure document. We categorise found errors and propose changes for both the UML specification process and the OCL language to improve the UML specification’s correctness in future versions.

How should teaching modeling and programming intertwine

This paper refers to 15 years experience in teaching object-oriented (OO) software development for undergraduate students. Our teaching approach includes modeling with UML and programming with Java. In a first course we introduce the students to OO analysis and OO design including using selected design patterns as well as to OO programming including UML2Java transformation based on small applications. In the subsequent project course students have to implement a mid-size application in a work-sharing software development process. Although the topics of the courses have basically not changed over the years we experimented with two basic didactic approaches in the introductory first course. The underlying issue is how should modeling and programming intertwine to educate both modelers and programmers. In this paper we evaluate both didactic approaches based on statistical results of written exams.