Abstract
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. However, current techniques that extend languages to support software fault tolerance lead to interwoven code addressing functional and non-functional requirements. Reflection 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. To explore this potential we compare common software fault tolerance scenarios implemented in both standard and reflective Ada. Specifically, in addition to backward error recovery and recovery blocks, we explore the application of reflection to atomic actions and conversations. We then compare the implementations in terms of expressive power, portability, and performance.
This is a preview of subscription content, log in via an institution to check access.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Preview
Unable to display preview. Download preview PDF.
References
Airlines Electronic Engineering Committee, Avionics Application Software Standard Interface, ARINC Specification 653-1: Aeronautical Radio, Inc. (2003)
Chiba, S.: A Metaobject Protocol for C++. In: Proc. Object-Oriented Programming Systems Languages and Applications (OOPSLA 1995), Austin, Texas, pp. 285–299 (1995)
Kiczales, G., des Rivières, J., Bobrow, D.: The Art of the Metaobject Protocol. MIT Press, Cambridge (1991)
Leveson, N.: Software Safety: Why, What and How. ACM Computing Surveys 18(2), 125–163 (1986)
Lyu, M. (ed.): Software Fault Tolerance, in Trends In Software, vol. 3. John Wiley & Sons, Chichester (1995)
Maes, P.: Concepts and Experiments In Computational Reflection. ACM SIGPLAN Notices 22(12), 147–155 (1987)
Rogers, P.: Software Fault Tolerance, Reflection, and the Ada Programming Language (YCST 2003/10), in Department of Computer Science: University of York (2003)
Rogers, P., Wellings, A.J.: An Incremental Recovery Cache Supporting Software Fault Tolerance Mechanisms. Journal of Computer Systems: Science and Engineering 15(1), 33–48 (2000)
Rogers, P., Wellings, A.J.: OpenAda: Compile-time reflection for ada 95. In: Llamosí, A., Strohmeier, A. (eds.) Ada-Europe 2004. LNCS, vol. 3063, pp. 166–177. Springer, Heidelberg (2004)
Romanovsky, A., Strigini, L.: Backward Error Recovery via Conversations In Ada. Software Engineering Journal 10(8), 219–232 (1995)
Smith, B.C.: Reflection and Semantics in Lisp. In: Proc. 11th ACM Symposium on Principles of Programming Languages, pp. 23–35 (1984)
Wellings, J., Burns, A.: Implementing Atomic Actions In Ada 95. IEEE Transactions On Software Engineering 23(2), 107–123 (1997)
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2005 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Rogers, P., Wellings, A.J. (2005). The Application of Compile-Time Reflection to Software Fault Tolerance Using Ada 95. In: Vardanega, T., Wellings, A. (eds) Reliable Software Technology – Ada-Europe 2005. Ada-Europe 2005. Lecture Notes in Computer Science, vol 3555. Springer, Berlin, Heidelberg. https://doi.org/10.1007/11499909_19
Download citation
DOI: https://doi.org/10.1007/11499909_19
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-26286-2
Online ISBN: 978-3-540-31666-4
eBook Packages: Computer ScienceComputer Science (R0)