Fault Injection for Dependability Validation: A Methodology and Some Applications
IEEE Transactions on Software Engineering
Models and languages for parallel computation
ACM Computing Surveys (CSUR)
A study on exception detection and handling using aspect-oriented programming
Proceedings of the 22nd international conference on Software engineering
Eliminating Exception Handling Errors with Dependability Cases: A Comparative, Empirical Study
IEEE Transactions on Software Engineering
Exception handling: issues and a proposed notation
Communications of the ACM
AspectC++: an aspect-oriented extension to the C++ programming language
CRPIT '02 Proceedings of the Fortieth International Conference on Tools Pacific: Objects for internet, mobile and embedded applications
ACM SIGAda Ada Letters - Exception handling for a 21st century programming language proceedings
Transaction Processing: Concepts and Techniques
Transaction Processing: Concepts and Techniques
Xception: A Technique for the Experimental Evaluation of Dependability in Modern Computers
IEEE Transactions on Software Engineering
An Automated Approach to Increasing the Robustness of C Libraries
DSN '02 Proceedings of the 2002 International Conference on Dependable Systems and Networks
GOOFI: Generic Object-Oriented Fault Injection Tool
DSN '01 Proceedings of the 2001 International Conference on Dependable Systems and Networks (formerly: FTCS)
Automated Robustness Testing of Off-the-Shelf Software Components
FTCS '98 Proceedings of the The Twenty-Eighth Annual International Symposium on Fault-Tolerant Computing
Software reliability: The role of programmed exception handling
Proceedings of an ACM conference on Language design for reliable software
Building dependable COTS microkernel-based systems using MAFALDA
PRDC '00 Proceedings of the 2000 Pacific Rim International Symposium on Dependable Computing
Language support for lightweight transactions
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
Exceptions and aspects: the devil is in the details
Proceedings of the 14th ACM SIGSOFT international symposium on Foundations of software engineering
Science of Computer Programming - Special issue: Synchronization and concurrency in object-oriented languages
Testing object-oriented industrial software without precise oracles or results
Communications of the ACM
Bridging Java and AspectJ through explicit join points
Proceedings of the 5th international symposium on Principles and practice of programming in Java
EJFlow: taming exceptional control flows in aspect-oriented programming
Proceedings of the 7th international conference on Aspect-oriented software development
Transactions are back---but are they the same?
ACM SIGACT News
Enforcing authorization policies using transactional memory introspection
Proceedings of the 15th ACM conference on Computer and communications security
Cooperative aspect-oriented programming
Science of Computer Programming
On the modularization and reuse of exception handling with aspects
Software—Practice & Experience
Exception handlers for healing component-based systems
ACM Transactions on Software Engineering and Methodology (TOSEM) - Testing, debugging, and error handling, formal methods, lifecycle concerns, evolution and maintenance
| Hi-index | 0.02 |
The development of robust software is a difficult undertaking and is becoming increasingly more important as applications grow larger and more complex. Although modern programming languages such as C++ and Java provide sophisticated exception handling mechanisms to detect and correct runtime error conditions, exception handling code must still be programmed with care to preserve application consistency. In particular, exception handling is only effective if the premature termination of a method due to an exception does not leave an object in an inconsistent state. We address this issue by introducing the notion of failure atomicity in the context of exceptions. We propose practical techniques to automatically detect and mask the nonatomic exception handling situations encountered during program execution. These techniques can be applied to applications written in various programming languages that support exceptions. We perform experimental evaluation on both C++ and Java applications to demonstrate the effectiveness of our techniques and measure the overhead that they introduce.