Keywords: Java annotations, UML profiles, Model-based software engineering, Forward engineering, Reverse engineering
Astract: The capability of UML profiles to serve as annotation mechanism has been recognized in both research and industry. Today’s modeling tools offer profiles specific to platforms, such as Java, as they facilitate model-based engineering approaches. However, considering the large number of possible annotations in Java, manually developing the corresponding profiles would only be achievable by huge development and maintenance efforts. Thus, leveraging annotation-based modeling requires an automated approach capable of generating platform-specific profiles from Java libraries. To address this challenge, we present the fully automated transformation chain realized by Jump, thereby continuing existing mapping efforts between Java and UML by emphasizing on annotations and profiles. The evaluation of Jump shows that it scales for large Java libraries and generates profiles of equal or even improved quality compared to profiles currently used in practice. Furthermore, we demonstrate the practical value of Jump by contributing profiles that facilitate reverse engineering and forward engineering processes for the Java platform by applying it to a modernization scenario.

Keywords:

Keywords:
Astract: Modern cloud computing environments support a relatively high degree of automation in service provisioning, which allows cloud service customers (CSC) to dynamically acquire services required for deploying cloud applications. Cloud modeling languages (CMLs) have been proposed to address the diversity of features provided by cloud computing environments and support different application scenarios, e.g., migrating existing applications to the cloud, developing new cloud applications, or optimizing them. There is, however, still much debate in the research community on what a CML is and what aspects of a cloud application and its target cloud computing environment should be modeled by a CML. Furthermore, the distinction between CMLs on a fine-grained level exposing their modeling concepts is rarely made. In this article, we investigate the diverse features currently provided by existing CMLs. We classify and compare them according to a common framework with the goal to support CSCs in selecting the CML which fits the needs of their application scenario and setting. As a result, not only features of existing CMLs are pointed out for which extensive support is already provided but also in which existing CMLs are deficient, thereby suggesting a research agenda.

Keywords: Graphical Models, Diagrams, Model Review, Visualizations for Model Reviews
Astract: Code reviews are used today in several software projects to check changes before they are merged. The aim of code reviews is to identify and prevent mistakes introduced by changed artifacts before they are merged into the actual software project. Therefore, several tools exist to support developers with the reviewing process. Such tools usually allow to mark, comment and discuss parts of the code that are considered to be problematic, as well as track the history of the reviewed changes. Of course they also support approval and rejection of changes. As source code is usually text based, these tools focus on source code or text-based artifacts. However, like almost every artifact in a software development project, models also change over time. This also includes diagrams, or models with a graphical syntax, which may not necessarily have a textual representation that is understandable by the average user. Papyrus Unified Modeling Language (UML) Diagrams are an example for such models. Therefore the techniques and visualizations of existing tools are usually considered to be unsatisfactory for such models by developers. So developers have to combine the code review tool with comparison tools that support the given model types, but do not support the review process. However, this adds additional overhead and complexity that may affect the review negatively. This thesis provides visualizations and interaction techniques that support developers who need to handle diagrams as well as models with a graphical syntax during the review process. These visualizations and techniques are obtained by analyzing existing methods for model comparison, code review and related techniques that might support the review process. A case study is presented using a prototype implementation utilizing frameworks based on the Eclipse Modeling Framework to prove the value of the proposed visualizations and techniques.

Keywords: model-driven engineering, executable models, functional properties, testing, UML, fUML, activity diagrams
Astract: Software industry is constantly looking for ways to improve the productivity of the software development process, as well as the quality and durability of the developed software product. A significant factor behind the difficulty of developing complex software is the wide conceptual gap between the problem and the implementation domain of a developed solution. Model Driven Software Engineering (MDSE) is an approach to software development whose aim is the automation of the development process through the specification of models containing domain specific knowledge of the system under development, and transformation of such models into the implementation of the system. Based on the premise that the implementation code is not the main result of the development process, but rather the system knowledge encoded inside the models, starting point in MDSE are the conceptual and implementation independent models of the domain knowledge which are then transformed, according to some formal rules, into implementations on selected target environments. One of the important issues when using the MDSE approach is that once the implementation artifacts are produced from the models, any existing defects at the model level get transferred to the implementation level, where it is more expensive, in terms of time and effort, to detect and correct them. To improve the development process when using a model driven approach, adequate means for detecting and correcting defects already on the model level are necessary. One of the most popular modeling languages in MDSE is the Unified Modeling Language (UML), a standard by the Object Management Group (OMG). UML is composed of thirteen diagram types, which can be used for specifying structural and behavioral aspects of a software system. In order to support the execution of models defined with UML, OMG introduced a standard called Semantics of a Foundational Subset for Executable UML Models (fUML), which defines the operational semantics for a subset of UML. Furthermore, a reference implementation of an interpreter that can execute fUML compliant models exists. The goal of this thesis is to utilize this precise and standardized specification of the semantics and the interpreter of fUML in order to address the lack of testing facilities for fUML models,