Domain-driven Design (DDD) is a model-based software design methodology, which focuses on close collaboration of domain experts and software engineers. It promotes to capture relevant domain concepts in domain models in order to define a ubiquitous language, whose terms are well understood by stakeholders and consistently used throughout the software engineering process. DDD is considered particularly useful in Microservice Architecture (MSA) engineering, because it specifies patterns to structure modeled domain concepts in isolated contexts. These contexts determine concepts' applicability and validity, and make relationships between domain concepts beyond context boundaries explicit. Consequently, DDD contexts may be used to prescribe microservices' granularities and interaction relationships. However, domain models are usually underspecified, which facilitates communication with domain experts, but hampers the derivation of microservice code.In this paper, we present a model-driven methodology towards deriving microservice code from underspecified domain models. It relies on a set of viewpoint-based MSA modeling languages, which respect the concerns of DevOps teams, and a set of automatic model transformations, which decrease modeling effort and systematize source code derivation. We validate the applicability of our methodology by means of two case studies.

Microservice Architecture (MSA) is a novel approach for the development and deployment of service-based software systems. MSA puts a strong emphasis on loose coupling and high cohesion of services. This increases service-specific independence, which is considered to result in a better scalability, adaptability, and quality of software architectures. Another perceived benefit of adopting MSA is technology heterogeneity. Microservice teams are free to employ the technologies they deem to be most appropriate for service implementation and operation. However, technology heterogeneity increases the number of technologies in a microservice architecture with the risk to introduce technical debt and steeper learning curves for team members. In this paper, we present an approach to streamline the usage of different technologies in MSA-based software systems. It employs Aspect-oriented Modeling to make technology decisions in microservice architectures explicit and enable reasoning about them. Therefore, a set of languages for model-driven microservice development is extended with means to define, modularize, and apply MSA technology aspects. The usage and characteristics of our approach are shown and discussed in the context of a case study from the mobility domain.

For safety critical systems it is desirable to be able to prove system correctness. If your system is based e.g. on statecharts or finite automata you may use model checking techniques as provided e.g. by Spin. If your system uses dynamic object models you may use tools like Alloy or graph based tools like Groove, Henshin, or SDMLib. Unfortunately, most of theses approaches use proprietary languages for the specification of models and model transformations. This has the drawback that in order to verify system properties one has to recode the system and its operations within the specific language of the used verification tool. This is tedious and error prone. After a successful verification within the specific tool, you still do not know whether your actual implementation works correct. To overcome these limitations, this paper outlines our new EMFeR (EMF Engine for Reachability) tool. EMFeR provides complete testing and model checking capabilities for EMF based models. Unlike most other systems, EMFeR uses directly the code of the system under test. You just hand your implementation of the employed model operations to EMFeR as lambda expressions. In addition, you provide some model queries to retrieve model elements to be operated on. Thus, you may implement your system’s model operation in plain Java, in Kotlin, in Groovy or whatever and than you may use EMFeR to model check your actual system implementation.

While debugging is one of the most time consuming tasks software developers perform, the tool support, especially for distributed applications, is lacking according to many professional developers. The Visual Debugger is an approach to provide an easy-to-use tool which gives software developers an abstract view on the current state of their application in debugging sessions. While similar tools for non distributed applications already exist, the Visual Debugger addresses the more complex debugging scenarios in distributed applications. Therefore, several views with different levels of abstraction of the current state of an application are provided. Although the approach may be adapted to other object oriented programming languages, the current target of the Visual Debugger is languages running on the Java Virtual Machine with the focus on Java.

The Rational Unified Process lacks practical guidance for the development of object oriented applications. Model Driven Software Development (MDD) proposes to do most of these development steps at the model level of abstraction. This tutorial takes the MDD idea and examplifies such a development process. The tutorial guides the user from textual requirements descriptions through UML scenario modeling to the derivation of test case specifications, class diagrams and UML behavior models and finally to the implementation of the desired system. The tutorial employs a running example that allows to illustrate the modeling activities for each development phase and the guidelines for each modeling step. We discuss how existing CASE tools may be used in such an approach and how the Fujaba environment supports our development process.

Following the success of the "First Workshop on Scenarios and State Machines: Models, Algorithms, and Tools" held at ICSE 2002 in Orlando [1], this workshop aims at bringing together researchers and practitioners to build a shared understanding on the relation between scenarios and state machines and to gain insight into techniques and tools that may leverage the combination of these approaches to enhance our means for behavior modeling.

How do you organize an "industrial strength" one semester educational programming project for up to 200 second year students? This paper reports on four years of experience with such projects at the University of Paderborn and the University of Braunschweig. Key properties of our project design are: starting with an existing large application, regular hard deadlines with peer reviews and presentations to a large audience, working in groups, applying project and configuration management tools, a standard system architecture with interchangeable components and competing software agents, quality assurance and standard conformance testing through final overall system integration spanning all groups, and exposure to real-world project threats.

No abstract available.

The Rational Unified Process lacks technical guidance for the development of object-oriented applications. This tutorial fills this gap. We first use UML scenario diagrams to analyze use-cases. Next, we show a method to analyze scenarios and to derive UML class diagrams and UML behavior modeling for active classes and methods. We show how to choose and embed design patterns in a design and how to employ different architectural styles. From such a precise design, smart CASE tools generate fully functional implementations. We explain state-of-the-art code generation concepts for UML and assess current CASE tools for their code generation capabilities and for their support through all software development phases more generally.

This paper proposes to use SDL block diagrams, UML class diagrams, and UML behavior diagrams like collaboration diagrams, activity diagrams, and statecharts as a visual programming language. We describe a modeling approach for flexible, autonomous production agents, which are used for the decentralization of production control systems. In order to generate a (Java) implementation of a production control system from its specification, we define a precise semantics for the diagrams and we define how different (kinds of) diagrams are combined to a complete executable specification.

it turns collaboration diagrams in a powerfull and easy-to-read visual programming construct. However, a single collaboration diagram is usually not expressive enough to model complex operations performing several modifications at different parts of the overall object structure. Such series of modifications need several collaboration diagrams to be modeled. In addition, there may be different situations where certain collaboration diagrams Figure 1 The Fujaba Environment Concepts \t \t \t <

No abstract available.

Object-oriented technology has become mature enough to satisfy many new requirements coming from areas like computer-aided design (CAD), computer-integrated manufacturing (CIM) or software engineering (SE). However, a competitive information management infrastructure often demands the merging of data from CAD, CIM or SE systems with business data stored in a relational system. In addition, complex dependencies between those data stored in the different systems might exist and should be maintained. One approach for seamless integration of object-oriented and relational systems is to migrate the data (and the corresponding schema) from a relational to an object-oriented system. In this paper, we describe an integrated design environment that supports the migration process and overcomes the major drawbacks of comparable approaches.