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ÐFault tolerance is a key requirement in Process Support Systems (PSS), a class of distributed computing middleware encompassing applications such as workflow management systems and process centered software engineering environments. A PSS controls the flow of work between programs and users in networked environments based on a ªmetaprogramº (the process). The resulting applications are characterized by a high degree of distribution and a high degree of heterogeneity (properties that make fault tolerance both highly desirable and difficult to achieve.) In this paper, we present a solution for implementing more reliable processes by using exception handling, as it is used in programming languages, and atomicity, as it is known from the transaction concept in database management systems. The paper describes the mechanism incorporating both transactions and exceptions and presents a validation technique allowing to assess the correctness of process specifications. Index TermsÐDependability, exception handling, workflow management, process support systems. 1

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.

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....

The paper presents a discussion and a specification of an exception handling system dedicated to object-oriented programming. We show how a full object-oriented representation of exceptions and of protocols to handle them, using meta-classes, makes the system powerful as well as extendible and solves many classical exception handling issues. We explain the interest for object-oriented programming of handlers attached to classes and to expressions. We propose an original algorithm for propagating exceptions along the invocation chain which takes into account, at each stack level, both kind of handlers. Any class can control which exceptions will be propagated out of its methods; any method can provide context-dependant answers to exceptional events. The whole specification and some keys of our Smalltalk implementation are presented in the paper. Keywords: exception handling, fault-tolerance, classhandlers, expression-handlers, exception propagation algorithm, modularity, reusability, kn...

It is no longer possible to consider exception handling as a secondary issue in language design, or even worse, a mechanism added after the fact via a library approach. Exception handling is a primary feature in language design and must be integrated with other major features, including advanced control flow, objects, coroutines, concurrency, realtime and polymorphism. Integration is crucial as there are both obvious and subtle interactions between exception handling and other language features. Unfortunately, many exception handling mechanisms work only with a subset of the features and in the sequential domain. A framework for a comprehensive, easy to use, and extensible exception handling mechanism is presented for a concurrent, object-oriented environment. The environment includes language constructs with separate execution stacks, e.g., coroutines and tasks, so the exception environment is significantly more complex than the normal single-stack situation. The pros and cons of various exception features are examined, along with feature interaction with other language mechanisms. Both exception termination and resumption models are examined in this environment, and previous criticisms of the resumption model, a feature commonly missing in modern languages, are addressed. Index Terms---Exception handling, robustness, termination, resumption, concurrent, interrupts, object-oriented. 1

this article differentiate the exception-handling needs of CB-RTS as compared to other software paradigms and can serve as a driving force for future research into exception-handling technology.

The aim of this paper 1 is to show and to explain how the object-oriented formalism can improve the expressive power of an exception handling system and how it can simplify its implementation and its utilization. Object-oriented design allows implementors to solve easily many classical exception handling issues such as creating user-defined exceptions, passing arguments from signalers to handlers, etc. Besides, new capabilities arise, such as defining generic protocols for handling exceptions, organizing them into a hierarchy leading to an inheritance of these protocols, signaling and handling multiples exceptions. The proposed system (implemented and used) is powerful, user-friendly, extendible and reusable without any code duplication. This paper can interest the non specialist of object-oriented programming concerned with the problem of exception handling. I. Introduction Exception handling techniques [3] [9] [12] [13] became an important issue because of their implications in s...

Exception handling resolves inconsistency by backward or forward error recovery methods or both in Business-to-Business (B2B) process collaboration. To avoid committing irrevocable tasks followed by exceptions, B2B processes, which guarantee the atomicity sphere property, are attractive. While atomicity sphere ensures its outcomes to be either all or nothing, conflicting local recoveries may lead to global B2B inconsistencies. Existing (global) analysis techniques however mandate every process unveiling all individual tasks. Such an analysis is infeasible when some business parties refuse to disclose their process details for privacy or business reasons. To address this problem, we propose a process algebraic technique to prove, construct, and check atomicity-equivalent public views from B2B processes. By checking atomicity spheres in the composition of these public views, business parties can identify suitable services that respect their individual and overall atomicity requirements. An example based on a real-life multilateral supply chain process is included.

this paper we have presented a system to check certain safety and progress properties of concurrent programs in execution. We have developed sentry algorithms that observe local and global properties during program execution, while ensuring finite storage and mutual exclusion, and without introducing new synchronization constraints on the program. We have also extended the sentry to check logical properties involving large data structures without prohibitive overhead. We have discussed the annotation language with which the programmer defines the properties to be checked, and have described a prototype to generate the appropriate sentry and program modifications automatically from annotated C source programs. Finally, we have presented some encouraging experimental results