Reasoning About Exception Flow at the Architectural Level

  • Fernando Castor Filho
  • Patrick Henrique da S. Brito
  • Cecília Mary F. Rubira
Part of the Lecture Notes in Computer Science book series (LNCS, volume 4157)


An important challenge faced by the developers of fault- tolerant systems is to build reliable fault tolerance mechanisms. To achieve the desired levels of reliability, mechanisms for detecting and handling errors should be designed since early phases of software development, preferably using a rigorous or formal methodology. In recent years, many researchers have been advocating the idea that exception handling-related issues should be addressed at the architectural level, as a complement to implementation-level exception handling. However, few works in the literature have addressed the problem of describing how exceptions flow amongst architectural elements. This work proposes a solution to this problem to support the early detection of mismatches between architectural elements due to exceptions. Moreover, it makes it possible to validate whether the architecture satisfies some properties of interest regarding exception flow before the system is actually built. Our solution proposes a model for describing the architectural flow of exceptions which is precise and automatically analyzable by means of a tool.


Software Architecture Exception Handling Architectural Element Architectural Level Alloy Analyzer 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.


Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.


  1. 1.
    Abrial, J.R.: The B-Book Assigning Programs to Meanings. Cambridge U. Press, Cambridge (1995)Google Scholar
  2. 2.
    Allen, R., Garlan, D.: A formal basis for architectural connection. ACM Transactions on Software Engineering and Methodology 6(3), 213–249 (1997)CrossRefGoogle Scholar
  3. 3.
    Anderson, T., Lee, P.A.: Fault Tolerance: Principles and Practice, 2nd edn. Springer, Heidelberg (1990)MATHGoogle Scholar
  4. 4.
    Bass, L., et al.: Air traffic control: A case study in designing for high availability. In: Software Architecture in Practice, ch. 6, 2nd edn. Addison-Wesley, Reading (2003)Google Scholar
  5. 5.
    Bass, L., et al.: Software Architecture in Practice, 2nd edn. Addison-Wesley, Reading (2003)Google Scholar
  6. 6.
    Filho, F.C., de Guerra, P.A.C., Rubira, C.M.F.: An architectural-level exception-handling system for component-based applications. In: de Lemos, R., Weber, T.S., Camargo Jr., J.B. (eds.) LADC 2003. LNCS, vol. 2847, pp. 321–340. Springer, Heidelberg (2003)CrossRefGoogle Scholar
  7. 7.
    Castor Filho, F., et al.: Modeling and analysis of architectural exceptions. In: Fitzgerald, J.S., Hayes, I.J., Tarlecki, A. (eds.) FM 2005. LNCS, vol. 3582, pp. 112–121. Springer, Heidelberg (2005)Google Scholar
  8. 8.
    Castor Filho, F., et al.: Specification of exception flow in software architectures. Journal of Systems and Software (2006)Google Scholar
  9. 9.
    Castor Filho, F., et al.: Verification of coordinated exception handling. In: Proceedings of the 21st ACM Symposium on Applied Computing, pp. 680–685 (April 2006)Google Scholar
  10. 10.
    Chang, B.-M., et al.: Interprocedural exception analysis for java. In: Proceedings of the 16th ACM Symposium on Applied Computing (2001)Google Scholar
  11. 11.
    Clements, P.C., et al.: Evaluating Software Architectures. Addison-Wesley, Reading (2003)Google Scholar
  12. 12.
    Clements, P.C., Northrop, L.: Software architecture: An executive overview. Technical Report CMU/SEI-96-TR-003, SEI/CMU (February 1996)Google Scholar
  13. 13.
    Cristian, F.: Exception handling. In: Anderson, T. (ed.) Dependability of Resilient Computers, pp. 68–97. Blackwell Scientific Publications, Malden (1989)Google Scholar
  14. 14.
    Fahndrich, M., et al.: Tracking down exceptions in standard ml. Technical Report CSD-98-996, University of California, Berkeley (1998)Google Scholar
  15. 15.
    Garcia, A., et al.: A comparative study of exception handling mechanisms for building dependable object-oriented software. Journal of Systems and Software 59(2), 197–222 (2001)CrossRefGoogle Scholar
  16. 16.
    Garlan, D., et al.: Acme: Architectural description of component-based systems. In: Foundations of Component-Based Systems, ch. 3. Cambridge U. Press, Cambridge (2000)Google Scholar
  17. 17.
    Gray, J., Reuter, A.: Transaction Processing: Concepts and Techniques. Morgan Kaufmann, San Francisco (1993)MATHGoogle Scholar
  18. 18.
    Jackson, D.: Alloy: A lightweight object modeling notation. ACM Transactions on Software Engineering and Methodology 11(2), 256–290 (2002)CrossRefGoogle Scholar
  19. 19.
    Jackson, D.: Alloy home page (March 2006), available at:
  20. 20.
    Jiang, S., et al.: An approach to analyzing exception propagation. In: Proceedings of the 8th IASTED International Conference on Software Engineering and Applications, Cambridge, USA (November 2004)Google Scholar
  21. 21.
    Krüchten, P.: The 4+1 view model of software architecture. In: IEEE Software, pp. 42–50 (November 1995)Google Scholar
  22. 22.
    Luckham, D., Vera, J.: An event-based architecture definition language. IEEE Transactions on Software Engineering 21(9), 717–734 (1995)CrossRefGoogle Scholar
  23. 23.
    Medvidovic, N., Taylor, R.N.: A framework for classifying and comparing architecture description languages. In: Proceedings of Joint 5th ACM SIGSOFT FSE/6th ESEC, pp. 60–76 (September 1997)Google Scholar
  24. 24.
    Mehta, N.R., Medvidovic, N.: Composing architectural styles from architectural primitives. In: Proceedings of Joint 9th ESEC/11th ACM SIGSOFT FSE, pp. 347–350 (September 2003)Google Scholar
  25. 25.
    Reimer, D., Srinivasan, H.: Analyzing exception usage in large java applications. In: Cardelli, L. (ed.) ECOOP 2003. LNCS, vol. 2743. Springer, Heidelberg (2003)Google Scholar
  26. 26.
    Robillard, M.P., Murphy, G.C.: Static analysis to support the evolution of exception structure in object-oriented systems. ACM Transactions on Software Engineering and Methodology 12(2), 191–221 (2003)CrossRefGoogle Scholar
  27. 27.
    Rubira, C.M.F., et al.: Exception handling in the development of dependable component-based systems. Software – Practice and Experience 35(5), 195–236 (2005)CrossRefGoogle Scholar
  28. 28.
    Schaefer, C.F., Bundy, G.N.: Static analysis of exception handling in ada. Software: Practice and Experience 23(10), 1157–1174 (1993)CrossRefGoogle Scholar
  29. 29.
    Shaw, M., Garlan, D.: Software Architecture: Perspectives on an Emerging Discipline. Addison-Wesley, Reading (1996)MATHGoogle Scholar
  30. 30.
    Sloman, M., Kramer, J.: Distributed Systems and Computer Networks. Prentice-Hall, Englewood Cliffs (1987)Google Scholar
  31. 31.
    Weimer, W., Necula, G.: Finding and preventing run-time error handling mistakes. In: Proceedings of OOPSLA 2004, pp. 419–433 (October 2004)Google Scholar
  32. 32.
    Yi, K.: An abstract interpretation for estimating uncaught exceptions in standard ml programs. Science of Computer Programming 31(1), 147–173 (1998)MATHCrossRefMathSciNetGoogle Scholar

Copyright information

© Springer-Verlag Berlin Heidelberg 2006

Authors and Affiliations

  • Fernando Castor Filho
    • 1
  • Patrick Henrique da S. Brito
    • 1
  • Cecília Mary F. Rubira
    • 1
  1. 1.Instituto de ComputaçãoUniversidade Estadual de CampinasCampinas

Personalised recommendations