We present an exception handling facility suitable for languages used to implement database-intensive Information Systems. Such a mechanism facilitates the development and maintenance of more flexible software systems by supporting the abstraction of details concerning special or abnormal occurrences. We consider the type constraints imposed by the schema as well as various semantic integrity assertions to be normalcy conditions, and the key contribution of this work is to allow exceptions to these constraints to persist. To achieve this, we propose solutions to a range of problems, including sharing and computing with exceptional information, exception handling by users, the logic of constraints with exceptions, and implementation issues. We also illustrate the use of exception handling in dealing with null values, estimates, and measurements. Keywords and phrases: semantic integrity, violations of type constraints, exception handling, accommodating exceptions, conceptual models CR ...

Abstract: This paper describes the Chimera II Real-time Operating System, which has been developed for advanced sensor-based control applications. It has been designed as a local operating system, to be used in conjunction with a global operating system. It executes on one or more single board computers in a VMEbus-based system. Advanced sensor-based control systems are both statically and dynamically reconfigurable. As a result, they require many special features, which are currently not found in commercial real-time operating systems. In this paper, we present several design issues for such systems, and we also present the features we have developed and implemented as part of Chimera II. These features include a real-time kernel with dynamic scheduling, global error handling, user signals, and two levels of device drivers; an enhanced collection of interprocessor communication mechanisms, including global shared memory, spin-locks, remote semaphores, priority message passing, global state variable tables, multiprocessor servo task control, and host workstation integration; and several support utilities, including a UNIX C and math libraries, a matrix library, a command interpreter library, and a configuration file library. Chimera II is currently being used with a variety of systems, including the CMU Direct Drive Arm II, the CMU Reconfigurable Modular Manipulator System, the Troikabot System for Rapid Assembly, and the Self-Mobile Space Manipulator. I.

It is di#cult to write programs that behave correctly in the presence of run-time errors. Existing programming language features often provide poor support for executing clean-up code and for restoring invariants in such exceptional situations. We present a dataflow analysis for finding a certain class of error-handling mistakes: those that arise from a failure to release resources or to clean up properly along all paths. Many real-world programs violate such resource safety policies because of incorrect error handling. Our flow-sensitive analysis keeps track of outstanding obligations along program paths and does a precise modeling of control flow in the presence of exceptions. Using it, we have found over 800 error handling mistakes almost 4 million lines of Java code. The analysis is unsound and produces false positives, but a few simple filtering rules su#ce to remove them in practice. The remaining mistakes were manually verified. These mistakes cause sockets, files and database handles to be leaked along some paths. We present a characterization of the most common causes of those errors and discuss the limitations of exception handling, finalizers and destructors in addressing them. Based on those errors, we propose a programming language feature that keeps track of obligations at run time and ensures that they are discharged. Finally, we present case studies to demonstrate that this feature is natural, e#cient, and can improve reliability; for example, retrofitting a 34kLOC program with it resulted in a 0.5% code size decrease, a surprising 17% speed increase (from correctly deallocating resources in the presence of exceptions) , and more consistent behavior.

The growing interest in Electronic Commerce practices has lead to a wide variety of models trying to capture the subtleties and complexities of the electronic marketplace. In this paper, we discuss a model based on trading communities, virtual business processes and virtual enterprises. These concepts are at the heart of the WISE (Workflow based Internet SErvices) project, where we have used them to drive the design and implementation of software tools for business to business electronic commerce. The paper briefly describes the model and shows how it is being used in practice as part of the WISE research effort. 1 Introduction Electronic commerce is a long established practice among companies which use information and communication technology to drive their everyday business transactions. In fact, some decades old retail chains are the direct result of electronic commerce practices. In spite of this proven success, electronic commerce has not been widely adopted until very rece...

The goals of exception handling mechanisms are to make programs more reliable and robust. The integration of exception handling mechanisms with object-oriented languages raises some unique issues. The requirements of exception handling often conflict with some of the goals of object-oriented designs, such as supporting design evolution, functional specialization, and abstraction for implementation transparency. This paper demonstrates these conflicts, illustrates that the use of exception handling in object-oriented systems poses potential pitfalls, and suggests that their resolution is one of the first steps necessary to make exception handling robust in object-oriented designs and languages.

The first part of this paper provides rigorous definitions for several basic concepts underlying the design of dependable programs, such as specification, program semantics, exception, program correctness, robustness, failure, fault, and error. The second part investigates what it means to handle exceptions in modular programs structured as hierarchies of data abstractions. The problems to be solved at each abstraction level, such as exception detection and propagation, consistent state recovery and masking are examined in detail. Both programmed exception handling and default exception handling (such as embodied for example in recovery blocks or database transactions) are considered. An assessment of the adequacy of backward recovery in providing tolerance of software design faults is made. An earlier version of this paper was published in "Dependability of Resilient Computers", T. Anderson, Editor, BSP Professional Books, Blackwell Scientific Publications, UK, 1989, pp. 68-97 INTRO...

Atomic actions are an important dynamic structuring technique that aid the construction of fault-tolerant concurrent systems. Although they were developed some years ago, none of the well-known commerciallyavailable programming languages directly support their use. This paper illustrates how to program atomic action using the facilities of Ada 95. In particular, it shows how packages, protected objects, requeue, exceptions, asynchronous transfer of control, tagged types and controlled types can be used as building block from which to construct atomic actions with forward and backward error recovery and which are resilient to deserter tasks and task abortion. Distributed execution of atomic actions is also discussed. Keywords: Software fault tolerance, Atomic actions, Ada 95, Exception handling, Recover blocks, Conversations 1 Introduction Software fault tolerance is often classified according to whether it is static (masking) or dynamic. With static redundancy, several versions of a ...

Extending database-like techniques to semi-structured and Web data sources is becoming a prominent research field. These data sources are essentially collections of textual documents. Hence, in this context, one of the key tasks consists in wrapping documents to build database abstractions of their content that can be manipulated using high-level tools. However, the degree of heterogeneity and the lack of structure make standard grammar parsers excessively rigid, and often unable to capture the richness of constructs in these documents. This paper presents Minerva, a formalism for writing wrappers around Web sites and other textual data sources. The key feature of Minerva is the attempt to couple the benefits of a declarative, grammar-based approach, with the flexibility of procedural programming. This is done by enriching regular grammars with an explicit exception-handling mechanism. Contributions of the paper stand in the definition of the formalism, and in the description of its i...

Exceptions are one of the most pervasive problems in process support systems. In installations expected to handle a large number of processes, having exceptions is bound to be a normal occurrence. Any programming tool intended for large, complex applications has to face this problem. However, current process support systems, despite their orientation towards complex, distributed, and heterogeneous applications, provide almost no support for exception handling. This paper shows how flexible mechanisms for failure handling are incorporated into the OPERA process support system using a combination of programming language concepts and transaction processing techniques. The resulting mechanisms allow the construction of fault-tolerant workflow processes in a transparent and flexible way while ensuring reusability of workflow components. 1 Introduction A process can be defined as a sequence of program invocations and data exchanges between distributed and heterogeneous stand-alone systems....

. Exception handling mechanisms provided by programming languages are intended to ease the difficulty of developing robust software systems. Using these mechanisms, a software developer can describe the exceptional conditions a module might raise, and the response of the module to exceptional conditions that may occur as it is executing. Creating a robust system from such a localized view requires a developer to reason about the flow of exceptions across modules. The use of unchecked exceptions, and in object-oriented languages, subsumption, makes it difficult for a software developer to perform this reasoning manually. In this paper, we describe a tool called Jex that analyzes the flow of exceptions in Java code to produce views of the exception structure. We demonstrate how Jex can help a developer identify program points where exceptions are caught accidentally, where there is an opportunity to add finer-grained recovery code, and where error-handling policies are not being followed...