IoT systems are becoming an increasingly important component of the civil and industrial infrastructure. With the growth of these IoT ecosystems, their complexity is also growing exponentially. In this paper we explore the problem of testing and evaluating large scale IoT systems at design time. To this end we employ simulated sensors with the physical and geographical characteristics of real sensors. Moreover, we propose Sensyml, a simulation environment that is capable of generating big data from cyber-physical models and real-world data. To the best of our knowledge it is the first approach to use a hybrid integration of real and simulated sensor data, that is also capable of being integrated into existing IoT systems. Sensyml is a cloud based Infrastructure-as-a-Service (IaaS) system that enables users to test both functionality and scalability of their IoT applications.

Although Model-Based Software Engineering (MBE) is a widely accepted Software Engineering (SE) discipline, no agreed-upon core set of concepts and practices (i.e., a Body of Knowledge) has been defined for it yet. With the goals of characterizing the contents of the MBE discipline, promoting a global consistent view of it, clarifying its scope with regard to other SE disciplines, and defining a foundation for the development of educational curricula on MBE, this paper proposes the contents for a Body of Knowledge for MBE. We also describe the methodology that we have used to come up with the proposed list of contents, as well as the results of a survey study that we conducted to sound out the opinion of the community on the importance of the proposed topics and their level of coverage in the existing SE curricula.

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.

\n Recent efforts to standardize a deployment modeling language for\n cloud applications resulted in TOSCA. At the same time, the software\n modeling standard UML supports architecture modeling from different\n viewpoints. Combining these standards from cloud computing and\n software engineering would allow engineers to refine UML\n architectural models into TOSCA deployment models that enable\n automatic provisioning of cloud applications. However, this\n refinement task is currently carried out manually by recreating\n TOSCA models from UML models because a conceptual mapping between\n the two languages as basis for an automated translation is missing.\n In this paper, we exploit cloud modeling extensions to UML called\n CAML as the basis for our approach CAML2TOSCA, which aims at\n bridging UML and TOSCA. The validation of our approach shows that\n UML models can directly be injected into a TOSCA-based provisioning\n process. As current UML modeling tools lack cloud-based refinement\n support for deployment models, the added value of CAML2TOSCA is\n emphasized because it provides the glue between architecture\n modeling and application provisioning.\n

Model transformations play a vital role in Model-Driven Engineering. Due to their increasing complexity, proper means for ensuring their quality are needed. Although numerous approaches for testing of model transformations have been proposed, their focus is rather on formal verification than on execution-based testing. Additionally, existing approaches do not consider the actual transformation definition, rarely provide hints for debugging in case of an error and are specific to a certain transformation language. Therefore we propose TETRA Box as a generic framework for execution-based white-box testing of transformation languages. For this, we base on symbolic execution of model transformations. Additionally, by employing our Pattern-based Modeling Language for Model Transformations (PaMoMo), we are able to provide dedicated failure traces that are aligned to the actual transformation definition as a hint for debugging.

As every software artifact, also software models are subject to continuous evolution. The operations applied between two successive versions of a model are crucial for understanding its evolution. Generic approaches for detecting operations a posteriori identify atomic operations, but neglect composite operations, such as refactorings, which leads to cluttered difference reports. To tackle this limitation, we present an orthogonal extension of existing atomic operation detection approaches for detecting also composite operations. Our approach searches for occurrences of composite operations within a set of detected atomic operations in a post-processing manner. One major benefit is the reuse of specifications available for executing composite operations also for detecting applications of them. We evaluate the accuracy of the approach in a real-world case study and investigate the scalability of our implementation in an experiment.

Model-Driven Engineering places models as first-class artifacts throughout the software lifecycle requiring the availability of proper model transformation languages. Although numerous languages are available, they lack convenient facilities for debugging and supporting understanding of the transformation logic. This is not least because the underlying transformation engines operate on a low level of abstraction, hiding the operational semantics of a high-level language. Consequently, low-level debugging information is available only, e.g., variable values. To tackle these limitations, we propose a DSL on top of Colored Petri Nets (CPNs) - called Transformation Nets (TNs) - for the execution and debugging of model transformations. By integrating all artifacts of a transformation, i.e., metamodel elements, model elements, and transformation logic, a runtime model for model transformations is provided, making the afore hidden operational semantics explicit. Based on this runtime model we present various means for debugging by means of an example showing how a QVT-Relations (QVT-R) specification may be debugged using TNs.

Model transformations play a key role in the vision of Model-Driven Engineering. Thereby, the resolution of structural heterogeneities between metamodels (MMs) represents the key challenge. For this task, current approaches require the definition of partly tricky, low-level recurring transformation logic but neglect to offer reusable components. Moreover, little attention has been paid to heterogeneities caused by the concept of inheritance, although extensively used in MMs. Therefore, we propose to specify model transformations in a plug & and play manner by a set of pre-defined mapping operators (MOps) representing a DSL to resolve structural heterogeneities. For coping with inheritance in MMs, we introduce an inheritance mechanism between MOps allowing to reuse parts of the mapping definitions. Moreover, dedicated MOps for resolving heterogeneities when one MM comprises inheritance hierarchies whereas the other one does not are presented, which are well-known problems in object-relational transformations and object-oriented refactorings.

In the Model-Driven Architecture (MDA) paradigm the Query/View/Transformation (QVT) standard plays a vital role for model transformations. Especially the high-level declarative QVT Relations language, however, has not yet gained widespread use in practice. This is not least due to missing tool support in general and inadequate debugging support in particular. Transformation engines interpreting QVT Relations operate on a low level of abstraction, hide the operational semantics of a transformation and scatter metamodels, models, QVT code, and trace information across different artifacts. We therefore propose a model-based debugger representing QVT Relations on bases of TROPIC, a model transformation language utilizing a variant of Colored Petri Nets (CPNs). As a prerequisite for convenient debugging, TROPIC provides a homogeneous view on all artifacts of a transformation on basis of a single formalism. Besides that, this formalism also provides a runtime model, thus making the afore hidden operational semantics of the transformation explicit. Using an explicit runtime model allows to employ model-based techniques for debugging, e.g., using the Object Constraint Language (OCL) for simply defining breakpoints and querying the execution state of a transformation.

to automatically react to occurred events. Aside from proprietary approaches for enriching XML with active behavior, the W3C standardized the Document Object Model (DOM) Event Module for the detection of events in XML documents. When using any of these approaches, however, it is often impossible to decide which event to react upon because not a single event but a combination of multiple events, i.e., a composite event determines a situation to react upon. The paper presents the first approach for detecting composite events in XML documents by addressing the peculiarities of XML events which are caused by their hierarchical order in addition to their temporal order. It also provides for the detection of satisfied multiplicity constraints defined by XML schemas. Thereby the approach enables applications operating on XML documents to react to composite events which have richer semantics.

Abstract Object‐oriented database systems are designed to meet the requirements of advanced database applications such as computer‐integrated manufacturing. These requirements may evolve in the course of time and may require the migration of the database application from one object‐oriented database system to another. Traditional migration approaches for relational database systems fail when applied to object‐oriented database systems. The goal of this paper is to fill this gap. The paper describes a framework for the migration of object‐oriented database applications. Our approach is based on a detailed analysis of the involved database systems, of the application's database requirements, and of the resources available for the database migration. We illustrate our framework by means of a case study, which is migrating an electronic planning board system from the object‐oriented database system ONTOS to ObjectStore.

Properly structured software libraries are crucial for the success of software reuse. Specifically, the structure of the software library ought to reflect the functional similarity of the stored software components in order to facilitate the retrieval process. We propose the application of artificial neural network technology to achieve such a structured library. In more detail, we utilize an artificial neural network adhering to the unsupervised learning paradigm. The distinctive feature of this very model is to make the semantic relationship between the stored software components geographically explicit. Thus, the actual user of the software library gets a notion of the semantic relationship between the components in terms of their geographical closeness.>

A novel diagram technique is presented to depict the structure as well as the behavior of objects. One of its distinguishing characteristics is its strict adherence to the object-oriented paradigm. A first prototype of an editor for object/behavior diagrams has been developed and is running on SUN-workstations. To assist the user the editor provides hypertext style facilities for navigating through different diagrams. For example, by clicking on an activity in a life cycle diagram one moves to the activity specification diagram of that activity.>