We propose the development of a toolkit for automated and user-configurable distributed deployment of a Swift program implementing a web service. The web service is defined as a composition of individual services, via the Apodini internal domain-specific language (DSL) [Sch20]. Our toolkit analyses the web service’s structure as expressed via the DSL, taking into account additional nonfunctional requirements. From this information it determines the deployment strategy which best satisfies these constraints. The resulting distributed system can be deployed to arbitrary target platforms, ranging from conventional web servers to FaaS providers such as AWS Lambda.

Web services offer reusable, well-designed and pretested component solutions for their consumers. Whilst striving for stability and reliability, web services experience numerous evolutive phases due to changes in application domain or changed requirements, and often cause breaking compatibility. This thesis proposes automated generation of migration guides, that encapsulate a generic description on how to migrate breaking changes. Our approach focuses on generating migration guides for web services built on Apodini, a novel internal Domain Specific Language that describes web services declaratively. The applicability of our research is demonstrated on industry projects from telecommunication branch and healthcare industry in cooperation with Mobile Software AG. You can find the open source implementation at https://github.com/Apodini/ApodiniMigrator.

The operation of large amounts of data generated by Internet of Things (IoT) devices is challenging for classic centralized IoT systems. Fog Computing solves this issue by shifting the computing responsibility from a centralized instance to fog devices, thus enables large heterogenous environments with different device types. Moving away from a central approach also allows more dynamic environments with devices entering and leaving the network arbitrarily. In this thesis we present an approach that enables the simultaneous and automatic deployment of a webservice to an heterogeneous IoT environment. Our approach assumes certain IoT typical constraints, such as hardware restrictions on devices, limited access due to private and secure networks, heterogenity of devices and nodes as well as dynamic topology changes. To handle the latter, our approach is able to register changes in the network at runtime and reflect them in the components and services. To showcase our approach, we will present an example using a web service created with the Apodini framework that we deploy in selected scenarios. You can find the open source implementation at https://github.com/Apodini/ApodiniIoTDeploymentProvider.

A fog computing architecture represents a solution for the challenges introduced by modern distributed systems containing countless heterogeneous and interconnected components. Monitoring these fog computing architectures is typically achieved by central cloud monitoring platforms, which result in increased network traffic and static responsibilities of maintenance teams. Decentralized Observability addresses the challenges above by transferring the responsibility of monitoring a system from a central cloud monitoring platform to each of the individual components. In the course of this thesis, we will try to integrate this approach into the declarative component-based Apodini framework and use its Domain-Specific Language (DSL) to automate most of the resulting observability overhead. The thesis contributed to the Apodini open source project: https://github.com/Apodini/Apodini.

The thesis aims to identify and address the challenges faced when using domain-specific languages (DSLs) to declaratively express the interface of a web service based on the service’s structure and the semantics of its implementation. Apodini proposes an internal DSL, with the intention of using a web service’s structure in combination with run-time type introspection to automatically generate, by the means of so-called interface exporters, client-facing interfaces for a variety of different protocols, such as REST, HTTP, WebSockets, or others. The approach of deriving service interfaces dynamically from an implementation presents an interface exporter developer with several new challenges, such as properly mapping the semantics of the service as expressed in Swift to the semantics of the respective protocols. We will conduct an expansive evaluation by adding two new interface exporters to Apodini: gRPC and GraphQL. These two interface exporters will serve as a validation of our general work on Apodini, and will be used to determine the quality, accuracy, and reliability of the API mappings generated by Apodini.

Modern server-side development faces a multitude of challenges. While many of those challenges are solved well by most modern web-frameworks, the following are still subject of active research: Web services often have to use a variety of middlewares to serve a heterogenous set of clients. Moreover, agile development methodologies lead to constant change in regards to both, application logic and middleware. Apodini is a prototypic server-side framework that aims to solve these challenges by providing a declarative and composable syntax for defining a web-service, establishing a full abstraction between the implemented application logic, the web-service’s structure and the middleware in use. This thesis explores different strategies to improve the Apodini framework in terms of maintainability and runtime-performance. The thesis contributed to the Apodini open source project: https://github.com/Apodini/Apodini.

When designing web services, requirements traceability is a challenging task. In the software engineering process, functional and non-functional requirements are defined in the Requirements Elicitation. Those requirements are structured and formalized in the Analysis, System Design and Object Design activities before the developed models are mapped to code. Therefore, tracing requirements through the individual design artifacts to the actual implementation is a challenge for software engineers. Requirements Traceability is essential as it enables us to verify our implementation against the requirements expected from the system. Furthermore, it improves the ability to deal with the change of requirements, yielding an improved iteration speed of the software engineering process. The thesis explores how a tighter coupling between the implementation and software engineering activities can improve traceability and thus verifiability and changeability of requirements. The research is done in the context of requirements typically encountered with web services, including non-functional requirements like security, performance and availability. The Apodini framework is used for the instantiation and validation of requirements. The thesis contributed to the Apodini open source project: https://github.com/Apodini/Apodini.