Modularity by Design for Safety-Critical Software Systems

"Simplicity is about subtracting the obvious and adding the meaningful." - John Maeda A sentence which describes exactly the goal of this work. But why is simplicity a desirable goal in the first place? To understand this, we investigate how Consumer-Grade Software Systems (CGSS) have evolved over the past decades in terms of complexity. A subsequent comparison with Safety-Critical Software Systems (SCSS) shows that these lag behind the CGSS by about 5-10 years. The complexity of these systems increases to such an extent that they are no longer controllable with the previous methods, languages and tools and therefore new methods, languages and tools were invented to master this complexity again. Hereby, simplicity is the groundbreaking goal and in most cases this simplicity is achieved by abstraction and encapsulation. Therefore, in this thesis we show how to build on the observed developments in CGSS to bring about improvements for SCSS. We use an oppinionated approach which already specifies the methods, languages and tools to use in order to provide a better overall workflow and developer experience. We show how to start with a semantically well-defined modeling language to generate standardcompliant high-level language code for SCSS. Thereby, reducing the time spent for recurring and error-prone tasks regarding the writing of timing-, structure-, and communication-related code. The only task a programmer then is left with, is the writing of business logic which corresponds exactly to the aforementioned quote about simplicity. Subsequently, we add modularity by design on top of the aforementioned approach in order to provide better maintainability of the generated systems. This is achieved by reusing an existing modularity framework on top of the chosen high-level language. Thereby, enabling a developer to also use additional benefits of this framework, like predefined, modular services and a well-defined lifecycle that can be reused to achieve even more abstract goals, like mapping modes of the modeling language to runtime reconfigurable modules in code. Finally, we complement the existing approaches with additional compile- and runtime checks in order to enable a developer of a SCSS to easily show semantic equivalence of exchanged or newly added modules to existing modules in a generated system. All approaches are evaluated via a qualitative and quantitative evaluation. The qualitative evaluation uses a running example based on a real-world quadrocopter autopilot, whereby the quantitative evaluation makes heavy use of Java Microbenchmark Harness (JMH) benchmarks in order to compare our approaches with a handwritten solution as well as comparing the approaches among themselves