Results 1 - 10
of
35
Static analysis to support the evolution of exception structure in object-oriented systems
- ACM Transactions on Software Engineering and Methodology (TOSEM
, 2003
"... Exception-handling mechanisms in modern programming languages provide a means to help software developers build robust applications by separating the normal control flow of a program from the control flow of the program under exceptional situations. Separating the exceptional structure from the code ..."
Abstract
-
Cited by 47 (0 self)
- Add to MetaCart
Exception-handling mechanisms in modern programming languages provide a means to help software developers build robust applications by separating the normal control flow of a program from the control flow of the program under exceptional situations. Separating the exceptional structure from the code associated with normal operations bears some consequences. One consequence is that developers wishing to improve the robustness of a program must figure out which exceptions, if any, can flow to a point in the program. Unfortunately, in large programs, this exceptional control flow can be difficult, if not impossible, to determine. In this article, we present a model that encapsulates the minimal concepts necessary for a developer to determine exception flow for object-oriented languages that define exceptions as objects. Using these concepts, we describe why exception-flow information is needed to build and evolve robust programs. We then describe Jex, a static analysis tool we have developed to provide exception-flow information for Java systems based on this model. The Jex tool provides a view of the actual exception types that might arise at different program points and of the handlers that are present. Use of this tool on a collection of Java library and application source code demonstrates that the approach can be helpful to support both local and global improvements to the
Combining the Robustness of Checked Exceptions with the Flexibility of Unchecked Exceptions using Anchored Exception Declarations
, 2005
"... Ever since their invention 30 years ago, checked exceptions have been a point of much discussion. On the one hand, they increase the robustness of soft ware by preventing the manifestation of unanticipated checked exceptions at run-time. On the other hand, they decrease the adaptability of software ..."
Abstract
-
Cited by 13 (4 self)
- Add to MetaCart
Ever since their invention 30 years ago, checked exceptions have been a point of much discussion. On the one hand, they increase the robustness of soft ware by preventing the manifestation of unanticipated checked exceptions at run-time. On the other hand, they decrease the adaptability of software bec ause they must be propagated explicitly, and must often be handled even if they cannot be signalled. We show that these problems are caused by a conflict between the exceptional interface of a method and the principle of abstraction. We then solve this conflict by introducing anchored exception declarations, which allow the exceptional behaviour of a method to be declared relative to that of others. We present their formal semantics, along with the necessary rules for ensuring compile-time safety, and give a proof of correctness. We show that ancho red exception declarations do not violate the principle of information hiding when used properly, and provide a guideline for when to use them. We have implemented anchored exception declarations as an extension to the ClassicJava programming language, called Cappuccino.
Action-Oriented Exception Handling in Cooperative and Competitive Concurrent Object-Oriented Systems
- ADVANCES IN EXCEPTION HANDLING TECHNIQUES
"... The chief aim of this survey is to discuss exception handling models which have been developed for concurrent object systems. In conducting this discussion we rely on the following fundamental principles: exception handling should be associated with structuring techniques; concurrent systems requ ..."
Abstract
-
Cited by 10 (3 self)
- Add to MetaCart
The chief aim of this survey is to discuss exception handling models which have been developed for concurrent object systems. In conducting this discussion we rely on the following fundamental principles: exception handling should be associated with structuring techniques; concurrent systems require exception handling which is different from that used in sequential systems; concurrent systems are best structured out of (nested) actions; atomicity of actions is crucial for developing complex systems. In this survey we adhere to the wellknown classification of concurrent systems, developed in the 70s by C.A.R. Hoare, J.J. Horning and B. Randell, into cooperative, competitive and disjoint ones. Competitive systems are structured using atomic transactions. Atomic actions are used for structuring cooperative systems. Complex systems in which components can compete and cooperate are structured using Coordinated Atomic actions. The focus of the survey is on outlining models and schemes which combine these action-based structuring approaches with exception handling. In conclusion we emphasise that exception handling models should be adequate to the system development paradigm and structuring approaches used.
Robust software -- No more excuses
, 2002
"... Software developers identify two main reasons why software systems are not made robust: performance and practicality. This work demonstrates the effectiveness of general techniques to improve robustness that are practical and yield high performance. We present data from treating three systems to imp ..."
Abstract
-
Cited by 9 (0 self)
- Add to MetaCart
Software developers identify two main reasons why software systems are not made robust: performance and practicality. This work demonstrates the effectiveness of general techniques to improve robustness that are practical and yield high performance. We present data from treating three systems to improve robustness by a factor of 5 or more, with a measured performance penalty of under 5 % in nearly every case, and usually under 2%. We identify a third possible reason why software systems are not made robust: developer awareness. A case study on three professional development groups evaluated their ability to estimate the robustness of their software. Two groups were able to estimate their software’s robustness to some extent, while one group had more divergent results. Although we can overcome the technical challenges,
Managing Exceptions in the Medical Workflow Systems
- In Proceeding of the 28th international conference on Software engineering
, 2006
"... Over the years, medical informatics researchers have studied how to use software technologies to provide decision support for using evidence-based medical procedures. Software professionals have investigated how to support hospital administration, therapy and laboratory workflows. For many of these ..."
Abstract
-
Cited by 8 (0 self)
- Add to MetaCart
(Show Context)
Over the years, medical informatics researchers have studied how to use software technologies to provide decision support for using evidence-based medical procedures. Software professionals have investigated how to support hospital administration, therapy and laboratory workflows. For many of these efforts, managing the exceptions in the workflows is a key issue since the medical workflows must cope with a wide variety of patient medical situations as well as those of the healthcare environments. This paper presents an analysis of past research in managing medical workflow exceptions, and proposes future research that would benefit the medical applications. The paper is focused on three topics: representing, handling and analyzing exceptions. Based upon our analysis, we believe that techniques for verifying exception management models and for handling dynamic exceptions should be useful and possibly essential for developing large scale, practical medical workflow systems.
An Approach to Improving the Structure of Error-Handling Code in the Linux Kernel
"... The C language does not provide any abstractions for exception handling or other forms of error handling, leaving programmers to devise their own conventions for detecting and handling errors. The Linux coding style guidelines suggest placing error handling code at the end of each function, where it ..."
Abstract
-
Cited by 7 (1 self)
- Add to MetaCart
(Show Context)
The C language does not provide any abstractions for exception handling or other forms of error handling, leaving programmers to devise their own conventions for detecting and handling errors. The Linux coding style guidelines suggest placing error handling code at the end of each function, where it can be reached by gotos whenever an error is detected. This coding style has the advantage of putting all of the error-handling code in one place, which eases understanding and maintenance, and reduces code duplication. Nevertheless, this coding style is not always applied. In this paper, we propose an automatic program transformation that transforms error-handling code into this style. We have applied our transformation to the Linux 2.6.34 kernel source code, on which it reorganizes the error handling code of over 1800 functions, in about 25 minutes.
High Performance Robust Computer Systems
, 2001
"... Although our society increasingly relies on computing systems for smooth, efficient operation; computer "errors" that interrupt our lives are commonplace. Better error and exception handling seems to be correlated with more reliable software systems[shelton00][koopman99]. Unfortunately, ro ..."
Abstract
-
Cited by 6 (1 self)
- Add to MetaCart
Although our society increasingly relies on computing systems for smooth, efficient operation; computer "errors" that interrupt our lives are commonplace. Better error and exception handling seems to be correlated with more reliable software systems[shelton00][koopman99]. Unfortunately, robust handling of exceptional conditions is a rarity in modern software systems, and there are no signs that the situation is improving. This dissertation examines the central issues surrounding the reasons why software systems are, in general, not robust, and presents methods of resolving each issue. Although it is commonly held that building robust code is too impractical, we present methods of addressing common robustness failures in a simple, generic fashion. We develop uncomplicated checking mechanisms that can be used to detect and handle exceptional conditions before they can affect process or system state (preemptive detection). This gives a software system the information it needs to gracefully recover from the exceptional condition without the need for task restarts. The perception that computing systems can be either robust or fast (but not both) is a myth perpetuated by not only a dearth of quantitative data, but also an abundance of conventional wisdom whose truth is rooted in an era before modern superscalar processors. The advanced microarchitectural features of such processors are the key to building and understanding systems that are both fast and robust. This research provides an objective, quantitative analysis of the performance cost associated with making a software system highly robust. It develops methods by which the systems studied can be made robust for less than 5% performance overhead for nearly every case, and often much less. Studies indicate that most prog...
The JCilk Multithreaded Language
, 2005
"... JCilk is a Java-based multithreaded programming language which extends Java to provide a dynamic threading model. Specifically, JCilk imports Cilk’s fork-join primitives spawn and sync into Java to provide procedure-call semantics for concurrent subcomputations. More importantly, JCilk integrates ex ..."
Abstract
-
Cited by 6 (0 self)
- Add to MetaCart
(Show Context)
JCilk is a Java-based multithreaded programming language which extends Java to provide a dynamic threading model. Specifically, JCilk imports Cilk’s fork-join primitives spawn and sync into Java to provide procedure-call semantics for concurrent subcomputations. More importantly, JCilk integrates exception handling with multithreading by defining semantics consistent with Java’s existing semantics of exception handling. JCilk’s strategy of integrating multithreading with Java’s exception semantics yields some surprising semantic synergies. In particular, JCilk extends Java’s exception semantics to allow exceptions to be passed from a spawned method to its parent in a natural way that obviates the need for Cilk’s inlet and abort constructs. This extension is “faithful ” in that it obeys Java’s ordinary serial semantics when executed on a single processor. When executed in parallel, however, an exception thrown by a JCilk computation signals its sibling computations to abort, yielding a clean semantics in which only a single exception from the enclosing try block is handled.
A Novel General Framework for Automatic and Cost-Effective Handling of Recoverable Temporal Violations in Scientific Workflow Systems
- Journal of Systems and Software
, 2011
"... Due to the complex nature of scientific workflow environments, temporal violations often take place and may severely reduce the timeliness of the execution’s results. To handle temporal violations in an automatic and cost-effective fashion, two interdependent fundamental issues viz. the definition o ..."
Abstract
-
Cited by 4 (2 self)
- Add to MetaCart
(Show Context)
Due to the complex nature of scientific workflow environments, temporal violations often take place and may severely reduce the timeliness of the execution’s results. To handle temporal violations in an automatic and cost-effective fashion, two interdependent fundamental issues viz. the definition of fine-grained recoverable temporal violations and the design of light-weight effective exception handling strategies need to be resolved. However, most existing works study them separately without defining a comprehensive framework. To address such a problem, with the probability based temporal consistency model which defines the range of recoverable temporal violations, a novel general automatic and cost-effective exception handling framework is proposed in this paper where fine-grained temporal violations are defined based on the empirical function for the capability lower bounds of the exception handling strategies. To serve as a representative case study, a concrete example exception handling framework which consists of three levels of fine-grained temporal violations and their corresponding exception handling strategies is presented. The effectiveness of the example framework is evaluated by large scale simulation experiments conducted in the SwinDeW-G scientific grid workflow system. The experimental results demonstrate that the example framework can significantly reduce the overall average violation rates of local temporal constraints and global temporal constraints to 0.127% and 0.167 % respectively.
Preventing Temporal Violations in Scientific Workflows: Where and How
- IEEE Transactions on Software Engineering
, 2011
"... Abstract—Due to the dynamic nature of the underlying high-performance infrastructures for scientific workflows such as grid and cloud computing, failures of timely completion of important scientific activities, namely, temporal violations, often take place. Unlike conventional exception handling on ..."
Abstract
-
Cited by 4 (2 self)
- Add to MetaCart
(Show Context)
Abstract—Due to the dynamic nature of the underlying high-performance infrastructures for scientific workflows such as grid and cloud computing, failures of timely completion of important scientific activities, namely, temporal violations, often take place. Unlike conventional exception handling on functional failures, nonfunctional QoS failures such as temporal violations cannot be passively recovered. They need to be proactively prevented through dynamically monitoring and adjusting the temporal consistency states of scientific workflows at runtime. However, current research on workflow temporal verification mainly focuses on runtime monitoring, while the adjusting strategy for temporal consistency states, namely, temporal adjustment, has so far not been thoroughly investigated. For this issue, two fundamental problems of temporal adjustment, namely, where and how, are systematically analyzed and addressed in this paper. Specifically, a novel minimum probability time redundancy-based necessary and sufficient adjustment point selection strategy is proposed to address the problem of where and an innovative genetic-algorithm-based effective and efficient local rescheduling strategy is proposed to tackle the problem of how. The results of large-scale simulation experiments with generic workflows and specific real-world applications demonstrate that our temporal adjustment strategy can remarkably prevent the violations of both local and global temporal constraints in scientific workflows. Index Terms—Workflow management, exception handling, reliability, software verification, statistical methods. Ç 1
