Sabine Sachweh

Differences between Model-Driven Development of Service-Oriented and Microservice Architecture

Microservice Architecture (MSA) denotes a novel service-based architectural style with a strong focus on highly cohesive, loosely coupled services. A Microservice realizes a distinct architectural capability and exhibits a high degree of independence regarding development and operation. An alternative to MSA is the Service-oriented Architecture (SOA) style, which also leverages services as building blocks of distributed software systems. While MSA research is still formative, theoretical and practical aspects of SOA are being studied for more than a decade. Hence the question arises, in which areas and to what extent MSA research can draw on findings of SOA research. In this paper we address this question in the area of Model-driven Development (MDD), which has been intensively studied for SOA. Therefore, we identify conceptual and practical differences between SOA and MSA, and classify them on the basis of a hierarchical scheme. Starting from the identified differences we deduce implications on MDD of MSA and discuss them with respect to the existing body of knowledge of MDD of SOA. Hence, we provide an initial overview of differences between SOA and MSA, as well as implications in certain areas of MDD to consider when adapting service-oriented MDD to MSA.

Large Scale Rule-Based Reasoning Using a Laptop

Although recent developments have shown that it is possible to reason over large RDF datasets with billions of triples in a scalable way, the reasoning process can still be a challenging task with respect to the growing amount of available semantic data. By now, reasoner implementations that are able to process large scale datasets usually use a MapReduce based implementation that runs on a cluster of computing nodes. In this paper we address this circumstance by identifying the resource consuming parts of a reasoner process and providing a solution for a more efficient implementation in terms of memory consumption. As a basis we use a rule-based reasoner concept from our previous work. In detail, we are going to introduce an approach for a memory efficient RETE algorithm implementation. Furthermore, we introduce a compressed triple-index structure that can be used to identify duplicate triples and only needs a few bytes to represent a triple. Based on these concepts we show that it is possible to apply all RDFS rules to more than 1 billion triples on a single laptop reaching a throughput, that is comparable or even higher than state of the art MapReduce based reasoner. Thus, we show that the resources needed for large scale lightweight reasoning can massively be reduced.

Scaling Parallel Rule-Based Reasoning

Using semantic technologies the materialization of implicit given facts that can be derived from a dataset is an important task performed by a reasoner. With respect to the answering time for queries and the growing amount of available data, scaleable solutions that are able to process large datasets are needed. In previous work we described a rule-based reasoner implementation that uses massively parallel hardware to derive new facts based on a given set of rules. This implementation was limited by the size of processable input data as well as on the number of used parallel hardware devices. In this paper we introduce further concepts for a workload partitioning and distribution to overcome this limitations. Based on the introduced concepts, additional levels of parallelization can be proposed that benefit from the use of multiple parallel devices. Furthermore, we introduce a concept to reduce the amount of invalid triple derivations like duplicates. We evaluate our concepts by applying different rulesets to the real-world DBPedia dataset as well as to the synthetic Lehigh University benchmark ontology (LUBM) with up to 1.1 billion triples. The evaluation shows that our implementation scales in a linear way and outperforms current state of the art reasoner with respect to the throughput achieved on a single computing node.

Domain Independent Architecture and Behavior Modeling for Pervasive Computing Environments

Although pervasive computing and ambient intelligence are emerging disciplines, domain independent middleware for those scenarios are rare. In this paper we propose act-mobile as a domain independent middleware for pervasive computing environments that consists of a central service platform and locally integrated gateways, building the bridge between sensors and actuators and the act-mobile server. Through the use of a centralized server we are able to connect to controlled environments over the internet and use different clients like mobile applications for monitoring and controlling. One key feature in achieving the domain independence is the way we define the behavior of the whole system and abstract from technical details to easily provide domain dependent functionality. The used state chart-based behavior modeling is also introduced in this paper. We show how we first build properties and composed properties to achieve a higher abstraction of sensor data and apply that abstraction to actuators, too. Finally, the rules are defined based on state charts using composed properties and activities.

Configuration of mechatronic multi product lines

For the development of variable systems, software product lines (SPL) are an established way to handle the variability by using feature models. Nevertheless, the configuration of an SPL can be complex, especially if a product line consists of a large number of features. The problem of handling the complexity becomes even more sophisticated if not only software, but also mechatronic systems containing software and hardware components are configured. Besides modeling the software, within a mechatronic system dependencies and associations between software and hardware features need to be considered which further increases the complexity. To handle this complexity in product lines for mechatronic systems, we propose a multi product line (MPL) approach which allows to distinguish between software and hardware by using different feature models for each. In addition we introduce a level of abstraction to complex product lines consisting of multiple feature models by establishing a feature model mapping. In this paper we present details to the mapping to provide an abstract configuration view as well as the introduced associations for our MPL approach.

Including Metadata into an Ontology Based Pervasive Computing Architecture

Ontologies are a common way to describe knowledge in a smart environment. They can be used to define different concepts as well as their properties and relationships and thereby define the domain knowledge of an application. Due to this characteristic, ontologies are one key feature in making applications domain independent. Nevertheless, this flexibility has some drawbacks concerning the interfaces to that knowledge. Interfaces, which for example can be consumed by mobile clients to display information about a smart environment, need to be clearly defined and have to include a static basis of properties that tell the client the semantic meaning of the data. For this purpose we propose a metadata ontology which represents the static parts in a domain independent architecture and is used in conjunction with domain ontologies. Based on the additional semantic information clearly defined interfaces can be build that not only provide the actual data, but also information about how to use that data.

MAGMA: build management-based generation of microservice infrastructures

Microservice architectures typically integrate a variety of loosely coupled infrastructure components. Due to technology heterogeneity, configuring them to provide the basis for a runnable service system might be time-consuming. Therefore, this paper presents MAGMA, a tool based on the Maven build management system that aims at accelerating the development of Microservice architectures by generating pre-configured, runnable systems. MAGMA enables the selective generation of infrastructure components like API Gateways and Service Discoveries, as well as the extension of existing Microservice architectures with customizable service templates and basic functional services.

On Hardware Variability and the Relation to Software Variability

In mechatronic and embedded systems, variability stretches from customer-visible features to implementation features, which manifest in software, hardware, and mechanical parts. A good example are automotive systems, which are usually implemented as product lines. There are close connections between hardware and software during the development of such product lines. For example, software usually needs to be heavily tuned towards processors characteristics or optimized for a specific memory size. The problem is that different lifecycles of hardware and software make it difficult to maintain all variability in a single model. In this paper, the notion of hardware variability is discussed. We suggest that software and hardware variability should be kept in separate models. We argue that hardware variability and software variability models should only be loosely coupled. This allows an easier exchange of hardware platforms and variants as well as a test during the configuration whether hardware and software fit to each other. To address this, we propose an approach that distinguishes between software and hardware variants by using separate variability models. Therefore, we introduce a hardware variability model, which has a strong focus on the description of hardware properties. Furthermore, we introduce a concept for modeling the dependencies between hardware and software variants to combine them during the configuration.

Performance Considerations in Ontology Based Ambient Intelligence Architectures

One limitation that still exists for the use of ontologies in pervasive and ambient intelligence environments is the performance of the reasoning task, which can slow down the use of an application and make a solution inappropriate for some scenarios. In this paper we first present the results of a user evaluation that substantiates the amount of time, that is acceptable (from the point of view of a user) as a delay resulting from the reasoning process in ontology based scenarios. Based on this results we introduce an experimental setup to test the performance of an ontology based architecture. This test shall demonstrate the performance of the state of the art technology without specific performance optimizations and provide concrete measurements for such a setup.

Towards a UML Profile for Domain-Driven Design of Microservice Architectures

Domain-driven Design (DDD) is a model-driven approach to software development that focuses on capturing the application domain, its concepts and relationships in the form of domain models for architecture design. Among others, DDD provides modeling means for decomposing a domain into Bounded Contexts and expressing the relationships between them. With the recent emergence of Microservice Architecture (MSA), DDD again gains broad attention because a Bounded Context naturally maps to a Microservice, which enables the application of DDD for MSA design.