Reasoning About Exception Flow at the Architectural Level

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.

[1]  Carl F. Schaefer,et al.  Static analysis of exception handling in Ada , 1993, Softw. Pract. Exp..

[2]  Cecília M. F. Rubira,et al.  Verification of coordinated exception handling , 2006, SAC '06.

[3]  Gregory D. Abowd,et al.  Formalizing style to understand descriptions of software architecture , 1995, TSEM.

[4]  George C. Necula,et al.  Finding and preventing run-time error handling mistakes , 2004, OOPSLA.

[5]  Hermann Kopetz,et al.  Fault tolerance, principles and practice , 1990 .

[6]  Gustavo Alonso,et al.  Exception Handling in , 2000 .

[7]  Philippe Kruchten,et al.  Architecture blueprints—the “4+1” view model of software architecture , 1995, TRI-Ada '95.

[8]  Motoshi Saeki,et al.  Evaluating software architectures by coloured petri nets , 2002, SEKE '02.

[9]  Paul Clements,et al.  Software architecture in practice , 1999, SEI series in software engineering.

[10]  Cecília M. F. Rubira,et al.  A comparative study of exception handling mechanisms for building dependable object-oriented software , 2001, J. Syst. Softw..

[11]  Baowen Xu,et al.  An approach to analyzing exception propagation , 2004, IASTED Conf. on Software Engineering and Applications.

[12]  Kwangkeun Yi,et al.  Interprocedural exception analysis for Java , 2001, SAC.

[13]  Richard N. Taylor,et al.  A framework for classifying and comparing architecture description languages , 1997, ESEC '97/FSE-5.

[14]  Flaviu Cristian,et al.  Exception Handling , 1989 .

[15]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[16]  Naranker Dulay,et al.  Specifying Distributed Software Architectures , 1995, ESEC.

[17]  Cecília M. F. Rubira,et al.  An Architectural-Level Exception-Handling System for Component-Based Applications , 2003, LADC.

[18]  Thomas Anderson Dependability of resilient computers , 1989 .

[19]  David C. Luckham,et al.  An Event-Based Architecture Definition Language , 1995, IEEE Trans. Software Eng..

[20]  Ian J. Hayes,et al.  FM 2005: Formal Methods, International Symposium of Formal Methods Europe, Newcastle, UK, July 18-22, 2005, Proceedings , 2005, FM.

[21]  Rogério de Lemos,et al.  Exception handling in the software lifecycle , 2001, Comput. Syst. Sci. Eng..

[22]  Cecilia Mary Fischer Rubira,et al.  Exception handling in the development of dependable component-based systems , 2005 .

[23]  Nenad Medvidovic,et al.  Composing architectural styles from architectural primitives , 2003, ESEC/FSE-11.

[24]  Jeffrey S. Foster,et al.  Tracking down Exceptions in Standard ML Programs , 1998 .

[25]  Kwangkeun Yi,et al.  An Abstract Interpretation for Estimating Uncaught Exceptions in Standard ML Programs , 1998, Sci. Comput. Program..

[26]  Paul Clements,et al.  Software Architecture: An Executive Overview , 1996 .

[27]  David Garlan,et al.  A formal basis for architectural connection , 1997, TSEM.

[28]  Andreas Reuter,et al.  Transaction Processing: Concepts and Techniques , 1992 .

[29]  M. H. Hamza Proceedings of the eighth IASTED International Conference on Software Engineering and Applications, November 9-11, 2004, MIT, Cambridge, USA , 2004 .

[30]  Martin P. Robillard,et al.  Static analysis to support the evolution of exception structure in object-oriented systems , 2003, TSEM.

[31]  David Garlan,et al.  Acme: architectural description of component-based systems , 2000 .

[32]  Jean-Raymond Abrial,et al.  The B-book - assigning programs to meanings , 1996 .

[33]  Fernando Castor Filho,et al.  Specification of exception flow in software architectures , 2006, J. Syst. Softw..

[34]  Philippe Kruchten,et al.  The 4+1 View Model of Architecture , 1995, IEEE Softw..

[35]  Luca Cardelli,et al.  ECOOP 2003 – Object-Oriented Programming , 2003, Lecture Notes in Computer Science.

[36]  Mary Shaw,et al.  Software architecture - perspectives on an emerging discipline , 1996 .

[37]  Morris Sloman,et al.  Distributed systems and computer networks , 1987, Prentice Hall International series in computer science.