Microservice Architecture (MSA) is a popular approach to designing, implementing, and deploying complex software systems. However, MSA introduces inherent challenges associated with distributed systems—one of them is the detection and mitigation of security smells. This paper draws on recent works that identified and categorized security smells in MSAs to propose a novel end-to-end approach for resolving security smells in existing MSAs. To this end, the presented approach extends a modeling ecosystem for MSAs with (i) reconstruction capabilities that automatically map MSA source code to viewpoint-specific architecture models; (ii) validations that detect security smells from reconstructed models; and (iii) model refactorings that support the interactive resolution of security smells and solutions’ reflection back to source code. Our approach allows for (i) uncovering security smells, which originate from the combination of different places in source code with possibly heterogeneous purposes, technologies, and software languages; as well as (ii) clustering, reifying, and fixing smells using a level of abstraction that is directed towards MSA stakeholders. The applicability and effectiveness of our approach are evaluated utilizing a standard case study from MSA research.

Data privacy and protection are essential in today’s digital landscape, with software developers’ playing a critical role in addressing these challenges. This paper presents a comprehensive study of the challenges and issues faced by software developers’ in the context of data privacy and protection. Our analysis is based on a dataset of questions posted on popular online platforms, such as Stack Overflow, Information Security Stack Exchange, and Software Engineering Stack Exchange.

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.

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.

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.