IEEE 802.11p complements the widespread 802.11 standard for use in vehicular environments. Designed for communication between wireless devices in rapidly changing environments, it handles situations where connection and communication must be completed in very short periods of time. Even though this is supposed to be a substantial improvement and essential for real-time applications, latencies have been rarely investigated in existing studies. Based on practical experiments, we evaluate how beneficial 802.11p's changes in comparison to regular 802.11n are and whether the usage of IEEE 802.11p is suitable within environments with real-time constraints. We compare latencies of networks in OCB mode to both networks in IBSS (ad-hoc) and BSS/AP (access point) mode by measuring the initial connection speed and the latency of ICMP packets' round-trip times. Furthermore, the response of the latter to disturbances is measured. The results show OCB to be superior to both BSS/AP and IBSS modes in average latency, maximum latency, and standard deviation under all tested circumstances.

Security is an important and difficult topic in today’s complex computer systems. Cloud-based systems adopting microservice architectures complicate that analysis by introducing additional layers. In the test system analyzed, base layers are combined into three groups (compute provider, encapsulation technology, and deployment) and possible security risks introduced by technologies used in these layers are analyzed. The application layer focuses on security concerns that concern authorization and authentication. The analysis is based on a microservice-based rewritten version of the seat reservation system of the Deutsche Bahn using technologies such as Amazon Web Services, Docker, and Kubernetes. The comparison concludes that the security of communication in the test system could be significantly improved with little effort. If security is not considered as an integral part from the beginning of a project, it can easily be neglected and be expensive

The release of Intel's Software Guard Extensions (SGX) refueled the interest in trusted computing approaches across industry and academia. The corresponding hardware is available, but practical usage patterns and applications are still lacking notable prevalence rates. This paper addresses this gap by approaching trusted computing from the point of view of a software engineer. To help developers in overcoming the initial hurdles of integrating SGX with existing code bases, a small helper library is presented. Furthermore, hardening strategies are identified and applied in a case study based on the simple KISSDB database, demonstrating how SGX can be used in practice.

In contrast to applications relying on specialized and expensive highly-available infrastructure, the basic approach of microservice architectures to achieve fault tolerance - and finally high availability - is to modularize the software system into small, self-contained services that are connected via implementation-independent interfaces. Microservices and all dependencies are deployed into self-contained environments called containers that are executed as multiple redundant instances. If a service fails, other instances will often still work and take over. Due to the possibility of failing infrastructure, these services have to be deployed on several physical systems. This horizontal scaling of redundant service instances can also be used for load-balancing. Decoupling the service communication using asynchronous message queues can increase fault tolerance, too. The Deutsche Bahn AG (German railway company) uses as system called EPA for seat reservations for inter-urban rail services. Despite its high availability, the EPA system in its current state has several disadvantages such as high operational cost, need for special hardware, technological dependencies, and expensive and time-consuming updates. With the help of a prototype, we evaluate the general properties of a microservice architecture and its dependability with reference to the legacy system. We focus on requirements for an equivalent microservice-based system and the migration process; services and data, containerization, communication via message queues; and achieving similar fault tolerance and high availability with the help of replication inside the resulting architecture.

The fault tolerance of complex software systems can be assessed experimentally using fault injection. To become an effective and systematic testing strategy, fault injection requires a realistic and well-defined failure cause model. However, such failure cause models are frequently incomplete, informal, and implicit or application-dependent. In this paper, we present a formal error model tailored for multi-threaded single-node applications. Based on the community-maintained Common Weakness Enumeration (CWE) database of real world software problems, we derive classes of error states which are either static, i.e., detectable from a snapshot of the system, or dynamic, i.e., dependent on the history of previous states. We then show how to implement our error model so that it becomes executable in our fault injection tool, Hovac.

The increasing usage of third-party software and complexity of modern software systems makes dependability, in particular robustness against faulty code, an ever more important concern. To compare and quantitatively assess the dependability of different software systems, dependability benchmarks are needed. We present a configurable tool for dependability benchmarking, Hovac, which uses DLL API hooking to inject faults into third party library calls. Our fault classes are implemented based on the Common Weakness Enumeration (CWE) database, a community maintained source of real life software faults and errors. Using two example applications, we discuss a detailed and systematic approach to benchmarking the dependability of C/C++ applications using our tool.

In modern cloud software systems, the complexity arising from feature interaction, geographical distribution, security and configurability requirements increases the likelihood of faults. Additional influencing factors are the impact of different execution environments as well as human operation or configuration errors. Assuming that any non-trivial cloud software system contains faults, robustness testing is needed to ensure that such faults are discovered as early as possible, and that the overall service is resilient and fault tolerant. To this end, fault injection is a means for disrupting the software in ways that uncover bugs and test the fault tolerance mechanisms. In this paper, we discuss how to experimentally assess software dependability in two steps. First, a model of the software is constructed from different runtime observations and configuration information. Second, this model is used to orchestrate fault injection experiments with the running software system in order to quantify dependability attributes such as service availability. We propose the architecture of a fault injection service within the OpenStack project.

Mobility-as-a-Service (MaaS) describes a class of applications where traditional real-time control systems are enhanced by backbone services accessed via the mobile Internet. In order to implement MaaS, new architectures for multi -stage real-time systems with several layers of control loops have to be implemented. Using approaches such as analytic redundancy, hard real-time control loops are extended with software-defined sensors that deliver data with soft real-time semantics.We describe a real-time control experiment that has been implemented in our Distributed Control Lab with four stages an extended digital Carrera race track (D132), custom built sensor/actuator boards, a control PC, and an outer control loop established via web services and present a timing analysis. Our architecture allows for decoupling of hard real-time processing on embedded control units and soft real-time data acquisition on the outer layers.