Present-day software systems have to fulfill an increasing number of requirements, which makes them more and more complex. Many systems need to anticipate changing contexts or need to adapt to changing business rules or requirements. The challenge of 21th-century software development will be to cope with these aspects. We believe that the role concept offers a simple way to adapt an object-oriented program to its changing context. In a role-based application, an object plays multiple roles during its lifetime. If the contexts are represented as first-class entities, they provide dynamic views to the object-oriented program, and if a context changes, the dynamic views can be switched easily, and the software system adapts automatically. However, the concepts of roles and dynamic contexts have been discussed for a long time in many areas of computer science. So far, their employment in an existing object-oriented language requires a specific runtime environment. Also, classical object-oriented languages and their runtime systems are not able to cope with essential role-specific features, such as true delegation or dynamic binding of roles. In addition to that, contexts and views seem to be important in software development. The traditional code-oriented approach to software engineering becomes less and less satisfactory. The support for multiple views of a software system scales much better to the needs of todays systems. However, it relies on programming languages to provide roles for the construction of views. As a solution, this thesis presents an implementation pattern for role-playing objects that does not require a specific runtime system, the SCala ROles Language (SCROLL). Via this library approach, roles are embedded in a statically typed base language as dynamically evolving objects. The approach is pure in the sense that there is no need for an additional compiler or tooling. The implementation pattern is demonstrated on the basis of the Scala language. As technical support from Scala, the pattern requires dynamic mixins, compiler-translated function calls, and implicit conversions. The details how roles are implemented are hidden in a Scala library and therefore transparent to SCROLL programmers. The SCROLL library supports roles embedded in structured contexts. Additionally, a four-dimensional, context-aware dispatch at runtime is presented. It overcomes the subtle ambiguities introduced with the rich semantics of role-playing objects. SCROLL is written in Scala, which blends a modern object-oriented with a functional programming language. The size of the library is below 1400 lines of code so that it can be considered to have minimalistic design and to be easy to maintain. Our approach solves several practical problems arising in the area of dynamical extensibility and adaptation.

Although originally designed as an extension for the Unifi ed Modeling Language (UML), today, the Object Constraint Language (OCL) has been broadly adopted in the context of both UML and other modeling and domain-specifi c languages. However, appropriate tooling, supporting modelers and software developers on using OCL is still scarce and lacks important features such as debugging support. As OCL constraints are likely to become rather complex for real world examples, it is hard to comprehend the in uence of single OCL expressions and subexpressions on the result of a completely evaluated OCL constraint in the context of speci fic constrained objects. Therefore, debugging is of topmost importance for both constraint comprehension and maintenance. Thus, the major task of this work is to develop a graphical debugger integrated into Dresden OCL and the Eclipse Integrated Development Environment (IDE) to fill this gap.

Der Große Beleg dokumentiert die Entwicklung eines Java Code-Generators für Dresden OCL2 for Eclipse. Schwerpunkt der Arbeit liegt dabei auf der Abbildung der Object Constraint Language auf die Programmiersprache Java mit Hilfe von AspectJ.

Diese Arbeit präsentiert 9 Entwurfsmuster in einer Darstellung durch das Compartment Role Object Model(CROM). Dabei wird dessen graphische Notation für rollenbasierte Modelle mit verschiedenen Möglichkeiten zur Darstellung von Bedingungen des Entwurfsmusters benutzt. Über eine Evaluationsoll ermittelt werden, ob das CROM dazu geeignet ist, die Bedingungen von Entwurfsmustern verständlich und schnell erfassbar darzustellen. Dabei soll die graphische Dokumentation dieser helfen. Das kann positive E ekte auf die Entwicklung von Software haben, wie bessere Codequalität, verkürzte Entwicklungszeiten und die Vereinfachung der Kommunikation zwischen Entwicklern.