Software Fault Tolerance and the Ada Programming Language
P. Rogers, 2003
Transparent system support for software fault tolerance reduces performance in general and precludes application-specific optimizations in particular. In contrast, explicit support â especially at the language level â allows application-specific tailoring such as object-specific checkpointing. However, current techniques that extend languages to support software fault tolerance lead to interwoven code addressing functional and non-functional requirements. This reduced separation of concerns in turn leads to increased complexity and, thereby, reduced robustness. Inheritance does not achieve the desired separation of concerns and, moreover, programmers can only work within the framework provided by the system-defined base classes. Reflection, on the other hand, promises both significant separation of concerns and a malleability allowing the user to customize the language toward the optimum point in a language design space. Compile-time reflection supports this customization while retaining performance and a natural style of programming.
The major contribution of this thesis is an increased understanding of the application of compile-time reflection to software fault tolerance when using a uniquely powerful programming language. Reflection has not been applied to a language with the features integrated within Ada. Furthermore, such a language has not been used to address software fault tolerance with reflective programming even though Ada is especially appropriate for systems in which reliability is critical.
The basis for our thesis evaluation is a comparison of common software fault tolerance scenarios implemented in standard and reflective Ada. To that end we implement a compiletime reflective programming facility for Ada and apply it to scenarios not otherwise explored by the fault tolerance community. Specifically, in addition to backward error recovery and recovery blocks, we explore the application of reflection to atomic actions and conversations. Having implemented the scenarios using both standard and reflective Ada, we then compare the implementations in terms of flexibility, expressive power, portability, and performance.
BibTex Entry
@phdthesis{T:Rogers:2003,
author = {P. Rogers},
link = {https://www.cs.york.ac.uk/ftpdir/reports/2003/YCST/10/YCST-2003-10.pdf},
month = {October},
school = {University of York},
title = {Software Fault Tolerance and the Ada Programming Language},
year = {2003}
}