Separation of concerns for dependable software design

Daniel Jackson, Eunsuk KangFoSER 2010 · DOI

TL;DR

This paper argues that traditional software development practices like process and testing are insufficient for achieving high levels of dependability in critical systems. Instead, it proposes a design-centric approach focused on "separation of concerns" to create smaller, isolated "trusted bases" for critical properties, making dependability arguments more tractable and cost-effective.

What Problem Does This Paper Address?

Achieving high dependability (reliability, safety, security) in software, especially for "mixed-criticality" systems where some functions are safety-critical and others are not, is a major challenge. Current approaches rely heavily on rigorous development processes and extensive testing. However, the authors contend that for the extremely high levels of dependability required in critical applications (e.g., one failure per billion hours), these methods are not enough. The sheer scale of testing required to statistically prove such low failure rates is often infeasible. Furthermore, traditional software design, particularly object-oriented approaches, can lead to "entanglement," where unrelated functionalities are tightly coupled, making it difficult to isolate and verify critical properties without analyzing large portions of the system. This increases the complexity and cost of demonstrating dependability.

Methods

The paper advocates for a "direct approach" to dependability, where developers construct a "dependability case." This case is a formal or semi-formal argument that connects the software's design and implementation to specific critical properties. The core of this approach is the concept of a "trusted base": the minimal set of code and assumptions required to argue that a particular critical property holds.

The key technique proposed is separation of concerns through decoupling mechanisms. This involves designing the system as a collection of independent services with narrow interfaces. This allows for the identification and isolation of smaller trusted bases for critical properties. Decoupling can be achieved through various means, including:

  • Physical isolation: Separate hardware or processes.
  • Virtual isolation: Operating system features like address space separation.
  • Middleware platforms: Providing communication channels with isolation guarantees.
  • Programming language features: Strong typing and namespace access control for encapsulation.

The authors critique object-oriented design for often leading to "entanglement," where a single object hierarchy can encompass many unrelated functionalities, making it hard to factor out code relevant only to a critical property. They suggest that structuring systems as collections of independent services, perhaps using techniques like aspect-oriented programming or problem frames, is a more effective way to achieve the desired decoupling.

Datasets

Not discussed in the paper.

Key Insights and Ideas

  • Testing limitations: Statistical testing, while useful for finding bugs, is practically impossible for proving extremely low failure rates required for critical systems.
  • Dependability Case: A direct, argument-based approach is more promising than relying solely on process and testing.
  • Trusted Base: The concept of a minimal, trusted base for each critical property is crucial for managing complexity.
  • Entanglement vs. Decoupling: Object-oriented design can hinder dependability by creating entanglement. A service-oriented or problem-frame-based approach that emphasizes decoupling is more beneficial.
  • Design is Paramount: Dependability is not an accident; it must be a fundamental aspect of the design process, not an afterthought addressed through analysis or testing alone.

Key Results

The paper does not present quantitative results from experiments or case studies. Its contribution is primarily conceptual and methodological, proposing a new way of thinking about and achieving software dependability. The authors argue that by reducing the size of the trusted base, the cost of constructing a dependability case can be significantly decreased, potentially by factors of 20 or more, which is more impactful than incremental improvements in analysis or language design.

Limitations and Future Work

The authors acknowledge that identifying trusted bases can be tricky, especially when "failure" is not well-defined. They also note that while decoupling mechanisms exist, their effective application requires careful design and analysis. The paper suggests that a more systematic design method that fully exploits separation of concerns is needed. Future work could involve developing such methods and demonstrating their effectiveness through practical case studies. The authors also imply that more research into design strategies that promote decoupling and minimize trusted bases would be valuable.

Summary updated

BibTeX
@inproceedings{jackson2010separation,
  author = {Daniel Jackson and Eunsuk Kang},
  title = {{Separation of concerns for dependable software design}},
  booktitle = {FoSER},
  year = {2010},
  doi = {10.1145/1882362.1882399},
}
Figure