Keywords:
Astract: In this paper, we discuss how to make a generic model versioning system language-specific by using various adaptation techniques. In particular, we recap some lessons learned during the AMOR project and outline some open challenges for adaptable model versioning systems.

Keywords:

Keywords: Domain-specific language, DSL, REA, Resource Event Agent ontology, Business model
Astract: Accounting Information Systems (AIS) are essential for companies not only to record and track what events are happening or what events have happened in the past, they are also one of the most important tools for management to predict the financial future of a firm and take according actions. To enable an AIS to precisely record economic data and apply reasoning on them, it is crucial that the data structure of an AIS is built upon the economic phenomenas of a company's business.
Accordingly, it is already important to have a detailed understanding of the company's economic actions at the design time of an AIS.
Like in most software development projects, the dilemma during design time of an IT product is the language barrier between the domain expert, providing vital input for defining the requirements, and the IT professional, designing and developing the IT product. In most cases the domain expert is not capable of understanding IT specific terms, and the IT professional is not capable of completely understanding the specific area of the domain expert. Nevertheless, to successfully complete an IT product, these two groups still need to unambiguously communicate with each other by using a common language.
When designing an AIS, the domain at hand is the accounting/business domain. Thus, a business modeling language describing economic phenomenas of a company can be used as such a common language to define requirements. One powerful business modeling language today is the Resource-Event-Agent ontology (REA). It not only allows describing events of the present and the past, it also allows specification of commitments made for future events. Consequently, it perfectly fits our requirement to capture the economic phenomenas of an AIS. However, REA is somewhat vague in the definition of its concepts and the current representation is merely IT related, which makes it hard to be understood by business experts. Accordingly, REA still cannot be used as a common communication language for the AIS design phase.
Given these limitations, in this thesis we have taken upon the challenge to develop an unambiguous and intuitive graphical domain-specific representation for the REA ontology called the REA-DSL. First, we formalize the REA ontology by providing a REA-DSL meta-model incorporating the REA concepts resources, events, agents, commitments, and types as well as concepts known from database modeling.
Subsequently, we create a graphical notation for the REA-DSL using different shapes for different REA concepts. Additionally, to reduce the complexity of the models, we split the REA-DSL into five interlinked views. A serialization format for the REA-DSL is provided by the REA-XML language. Furthermore, we specify a mapping between the conceptual REA-DSL and a database description language. This enables the semi-automatic generation of database structures for an AIS.
The presented REA-DSL serves as an unambiguous and powerful business modeling language which can be used by IT and business experts for faster designing a robust AIS.

Keywords: Model versioning, conflict resolution, Model-Driven Engineering
Astract: In most engineering disciplines, models are built as pragmatic, yet precise abstractions of huge systems. The model building process requires multiple people jointly elaborating on artifacts, which are analyzed, used to communicate among stakeholders, and act finally as construction plan for realizing the modeled system. In the field of software engineering, modeling languages such as the Unified Modeling Language (UML) provide multiple diagrams to describe various viewpoints of a system in a concrete graphical notation. While the code-centric software engineering discipline adopted those models as visual language for describing the system under study, the increasing complexity of modern software systems accompanied by ever shorter time to market constraints has asked for new techniques. The upcoming Model-Driven Engineering (MDE) approach aims at additionally exploiting models to automatically generate executable code. This paradigm shift lifts models to first-class citizens within the whole engineering process, effectively shaping the primary artifact of change undergoing the collaborative refinement from informal sketches to blueprints. This upgrowth intrinsically demands tool support for managing the models' history including merging of parallel evolved models. Optimistic versioning systems, which are already successfully applied for the management of source code, handle both issues. However, applying those systems to models fails due to the models' graph-based structure. Consequently, first dedicated model versioning systems emerged. Although current model versioning systems provide decent conflict detection facilities, they (1) ignore the graphical representation of the models, and (2) neglect conflict resolution by totally shifting the responsibility to the user.
Yet, the central role of models unifying the human-centric, collaborative abstraction and design process with the computation-centric process of generating executable systems, demands proper mechanisms to foster validity and quality of the merged model.
In this thesis, we first analyze specifics of model versioning and elaborate on the notion of conflict to improve conflict resolution respecting the central role of models. To cope with the human-centric aspect, we present a conflict aware merge strategy to calculate a tentatively merged conflict diagram as accelerator for conflict resolution retaining the graphical representation of the model. The conflict diagram unifies non-conflicting changes and materializes merge conflicts in form of annotations, rendering a coherent picture of the model's evolution. To further support the conflict resolution process, we elaborate on a conflict resolution recommender system on top of the conflict diagram, which recommends automatically executable conflict resolution patterns. Finally, to satisfy validity conditions of the computation-centric aspect, we establish a formal framework based on graph transformation theory, to showcase the feasibility of our approach.

Keywords: model-driven, modeling, versioning, model transformation, demonstration-based, software development
Astract: Model-driven engineering (MDE) is evermore adopted in academia and industry. In MDE, software models constitute the central artifacts in the software engineering process.
Developing a large software system entails the need for a large number of collaborating developers. Unfortunately, collaborative development of models is currently not sufficiently supported. Traditional versioning systems for code fail for models, because they neglect the graph-based nature of models.
A few dedicated model versioning approaches have been proposed. However, these approaches suffer from four major deficiencies. First, they either support only one modeling language or, if they are generic, they do not consider important specifics of a modeling language. Second, they do not allow the specification of composite operations such as refactorings and thus, third, they neglect the importance of respecting the original intention behind composite operations for detecting conflicts and constructing a merged model. Fourth, the types of detectable conflicts is insufficient and not extensible by users.
To tackle these deficiencies, we present an adaptable model versioning framework, which offers out-of-the-box support for all modeling languages, but also allows to be adapted for for specific modeling languages. For easily specifying language-specific composite operations, we propose a novel technique called model transformation by demonstration. These operation specifications constitute the adaptation artifacts for enabling the detection of applications of specified composite operations. Furthermore, we introduce techniques for detecting additional types of conflicts caused by concurrently applied composite operations as well as for revealing potentially unfavorable merge results.

Keywords: Answer Set Programming, Design, Analysis, Support, Graph, VIDEAS, design-first
Astract: In the last decade, logic programming experienced new impetus by the growth of Answer Set Programming (ASP) as one of the key drivers in the academic world. However, ASP could not attract the same interest as other declarative programming languages in practice so far. This lack of interest in ASP may be explained by the absence of a sufficiently supported software engineering methodology resulting in a difficulty of designing and developing ASP programs. No tools supporting the development of ASP programs are available. So far, no modeling environment has been introduced in the context of software development based on the ASP paradigm, which offers valuable abstraction and visualization support during the development process.
This thesis aims at establishing a novel method for visually designing and analyzing ASP programs. Therefore, a graphical approach for the visualization of ASP is proposed, which is based on concepts presented in literature for other declarative approaches. Moreover, concepts of model engineering are combined with the field of logic programming.
Following an Model Driven Engineering approach, an ASP-specific modeling language is established which is able to visualize important facets of ASP. The modeling language is applied within a graphical editor for the model creation. The resulting models are transformed to textual ASP programs by a code generator. The model engineering approaches are used to define the metamodel, a graphical editor, and to generate the ASP program code from models. Therefore, the link between the formalism of ASP and the graphical representation has to be established. Due to the close connection between ASP and deductive databases-databases with logical reasoning capabilities-the widely used Entity Relationship diagram is applied as initial visualization method for ASP programs.

Keywords: UML, fUML, Model Execution, Model Debugging, Model Testing, Activity Diagram
Astract: Over the past years Model-Driven Development (MDD) gained significant popularity. With the usage of this paradigm the software engineering process becomes more model-centric and less code-centric.
This means that models become the main artifact in the software development process and therewith the whole software development process relies on these models and their correctness. For this reason the need for executable models that can be tested and validated arose. The de facto standard for modeling software systems is OMG's Unified Modeling Language (UML). The problem is that UML models are not executable because UML has no precise and completely specified semantics. Its semantics is defined informally in English prose and this definition is scattered throughout the standard with about 1000 pages. Because of this situation, ambiguities arise and models can be interpreted and executed in different ways. This also led to the development of execution tools that are not interoperable because they implement different execution semantics.
OMG has recognized the need for executable models in an unambiguous way, and has developed a new standard called Semantics of a Foundational Subset of Executable UML Models or foundational UML (fUML) that was released in February 2011. This standard defines the precise execution semantics of a subset of UML 2, the so-called foundational UML subset.
The research question of this thesis is as follows. Is the semantics definition of the fUML standard sound and applicable for building tools that enable the execution of UML activity diagrams? To answer this question, a prototype of a model interpreter has been developed in this thesis that is able to execute and debug UML models according to the execution semantics defined in the fUML standard. This model interpreter prototype focuses on executing activity diagrams that model the manipulation of objects and links in a system. Furthermore, the prototype provides reasonable debugging functionality similar to the functionality offered for debugging code like the step-wise execution and the displaying of the debugging progress. The experiences gained during the implementation of the model interpreter prototype led to the following conclusion. The fUML standard is applicable for implementing tools that support the execution of UML activity diagrams, however, high efforts are necessary to develop a user-friendly and efficiently usable tool supporting features like the debugging of models or the execution of incomplete models.

Keywords: ATL, UML profiles, transformation language extension
Astract: The software engineering process has significantly changed over the last decade. Whereas in the past models were only used for communication and brainstorming purposes, this philosophy has shifted drastically. Model-Driven Engineering (MDE) is the keyword that is guiding the current engineering direction. Models are the key artifact and all development steps are aligned to these models. Sophisticated modeling techniques have been invented to ensure a consistent and comprehensive technological basis. The Unified Modeling Language (UML) was introduced by the Object Management Group (OMG) to standardize and support different modeling aspects like structural, behavioral, and architectural models. The huge success of UML is not only due to the versatility of the language but also because of the highly-developed language extension mechanism in form of UML profiles. UML profiles may be defined for tailoring UML to specific domains and technological platforms.
Apart from modeling languages, the technique of model transformation plays a crucial role for the model-driven approach. Model transformations aim at transforming an existing source model into some desired target model. Different model transformation languages were invented that support various kinds of model transformations. One of them is the ATLAS Transformation Language (ATL), which is currently one of the most widely used transformation languages. While modeling languages defined by metamodels are directly supported in an ATL transformation, the use of UML profiles demands for a complex work-around. It would be desirable, however, to simplify the handling of UML profiles in such a way that profiles are, like metamodels, represented as language definitions.
The contribution of this master's thesis is to extend ATL for a native UML profile support. New language constructs are integrated into the abstract and concrete syntax of ATL to ease the use of profile-specific information within a model transformation. Apart from the extension of the ATL syntax, also an operational semantics for the new constructs is defined by translating the extended ATL to standard ATL. The goal of this work is to enrich the ATL language with new language-inherent constructs and keywords. During the implementation phase several technological possibilities as well as limitations were encountered and discussed. This collection of lessons learned can be seen as a guideline for future extensions of ATL, and as a starting point for a critical discussion about the extensibility of ATL.

Keywords: graph transformation, model-driven development, model transformation
Astract: Software engineering has come a long way in its short history.
With the recent advent of model-driven development, which places models at the center of all development efforts, some of the existing deficiencies of traditional, code-centric software development approaches have been addressed. However, at the same time new problems arose, which require, for example, techniques to describe, control and verify the evolution of models. Drawing from past experiences and findings in the field of code-centric software evolution is only partly feasible due to the inherent graph-based nature of models, which renders the adoption and porting of previously developed solutions for text-based software development impractical.
The graph-based nature of models suggests the application of graph transformation-theoretic concepts to models, in order to formally describe their manipulation by means of graph-rewriting rules. Though the concepts and techniques provided by the theory of graph transformation may seem intuitive, the specification of accurate rewriting rules is a non-trivial and time-consuming task, which requires adequate tool support and thorough knowledge of the underlying theory.
Unfortunately, due to the heterogeneity of the employed approaches, a tool's capability to specify graph rewriting rules and the degree of assistance offered for this task is hard to determine without prior investigation. Thus, a survey of existing tools was conducted, which revealed the Operation Recorder as a suitable tooling environment. In contrast to all other surveyed tools, it offers a by-demonstration environment, which allows to showcase the intended transformation instead of requiring its manual construction by means of dedicated transformation languages.
The Operation Recorder, however, lacks a concise, formal basis which prevents the verification of its transformations. Therefore, a framework to describe attributed graphs with inheritance, composition and multiplicities is presented with the aim to embed the Operation Recorder into this framework. For this purpose, a conceptual alignment is pursued which demonstrates the equivalence and interchangeability of the concepts provided by the Operation Recorder and those provided by the theory of graph transformation.

Keywords: Eclipse, Modelling, CDO
Astract: The high complexity of modern software makes it unavoidable to develop software with the help of graphical, model based editors.
Software models serve not only as documentation or as a rough system overview. They are also the fundament to generate a executable system.
The larger the application the more persons are involved in the design and development process. Simultaneous changes on a model are very common. With these concurrent changes conflicts can occur. There is a need of interpersonal communication to solve appearing questions and avoid misunderstandings. Specially in the early stage of software development diversities in interpretation can occur easily because the semantics of models can be interpreted different. To avoid such problems the communication channels within the team should be supported as much as possible. With good communication it should be possible to conclude a consolidated solution of the problem in a collaborative way. Within this thesis ways and means are sought to enable interactive model-driven software development with the Eclipse Modeling Framework. It turned out that there are already several approach for this interactive development method. These budding candidates where reviewed and analyzed.
Unfortunately each of the tested systems had some disadvantages or they were not mainly designed for model-driven software development. When the analysis of various existing approaches was finished, a list of requirements was created. The search for a tool that matches the requirements as good as possible and that can be extended easily was started and finished with an acceptable result. Therefore the implementation part consists of a extension of a existing tool. The chosen tool is CDO, "Connected Data Objects", a plugin for Eclipse. CDO was selected because it is the best match to our requirements. We think we found the optimal candidate to develop a sustainable solution.