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.