Exception Handling for Conflict Resolution in Cross-Organizational Workflows

Exception handling mechanisms have been introduced into programming languages in an effort to help deal with runtime irregularities. These mechanisms aim to improve code reliability by providing constructs for sectioning code into exception scopes (e.g. Java try blocks) and exception handlers (e.g. Java catch blocks). Whilst exception handling mechanisms have been the focus of much research over the past years, empirical studies have only focused on characterising exception handling code of Java and C# programs. There exists little empirical evidence on how exception handling mechanisms are used to develop software with other programming languages. Moreover, to date there exists no empirical study which has examined the structure of exception scopes across software projects. We address these shortcomings by examining the commonalities and differences of both exception scopes and handlers implemented with a wider range of languages. To this end, we analysed 50 software projects, containing code developed in C++, JavaScript, PHP, Java and C#. More than 9 million lines of code and over 20,000 exceptional code blocks were analysed. Our findings revealed significant differences in the frequency, structure and length of exception scopes and exception handlers across languages. This finding suggests that certain exception handling mechanisms are less explored by programmers using certain programming languages. However, regardless of language, exception handlers remained simplistic and in general only ever one handler was associated with each scope. Finally, our analysis confirms the existing belief that developers often pay little attention to developing exception scoping and handling behaviour.

Exception handling mechanisms are intended to help developers build robust systems. Although an exception handling mechanism provides a basis for structuring source code dealing with unusual situations, little information is available to help guide a developer in the appropriate application of the mechanism. In our experience, this lack of guidance leads to complex exception structures. In this paper, we reflect upon our experiences using the Java exception handling mechanism. Based on these experiences, we discuss two issues we believe underlie the difficulties encountered: exceptions are a global design problem, and exception sources are often difficult to predict in advance. We then describe a design approach, based on work by Litke for Ada programs, which we have used to simplify exception structure in existing Java programs.

In this paper, JAVA virtual machine is discussed through the description of the relevant content, the common classification of exception handling mechanism, and the design of the test system of exception handling mechanism. The key points of design include application of SOOT tool, selection of test algorithm, introduction of JIMPLE technology, abnormal code injection, reasonable selection of different virtual machines and so on. Through the establishment of reliable experiments, the practical value of the test system is evaluated. The purpose is to improve the timeliness of abnormal problem discovery and control the negative impact within a reasonable range.

A Hoare-like verification system for a language with an exception handling mechanism

A comparative study of exception handling mechanisms for building dependable object-oriented software

We provide a rigorous framework for language and platform independent design and analysis of exception handling mechanisms in modern programming languages and their implementations. To illustrate the practicality of the method we develop it for the exception handling mechanism of Java and show that its implementation on the Java Virtual Machine (JVM) Is correct. For this purpose we define precise abstract models for exception handling in Java and in the JVM and define a compilation scheme of Java to JVM code which allows us to prove that, in corresponding runs, Java and the JVM throw the same exceptions and with equivalent effect. Thus, the compilation scheme can, with reasonable confidence, be used as a standard reference for Java exception handling compilation.

For programs to be reliable and fault tolerant, each program module must be defined to behave reasonably under a wide variety of circumstances. An exception handling mechanism supports the construction of such modules. This paper descnbes an exception handling mechanism developed as part of the CLU programming language. The CLU mechanism is based on a simple model of exception handling that leads to well-structured programs. It is engineered for ease of use and enhanced program readability. This paper discusses the various models of exception handUlng, the syntax and semantics of the CLU mechanism, and methods of implementing the mechanism and integrating it in debugging and production environments.

Even though exception handling mechanisms have been proposed as a means to improve software robustness, empirical evidence suggests that exception handling code is still poorly implemented in industrial systems. Moreover, it is often claimed that the poor quality of exception handling code can be a source of faults in a software system. However, there is still a gap in the literature in terms of better understanding exceptional faults, i.e., faults whose causes regard to exception handling. In particular, there is still little empirical knowledge about what are the specific causes of exceptional faults in software systems. In this paper we start to fill this gap by presenting a categorization of the causes of exceptional faults observed in two mainstream open source projects. We observed ten different categories of exceptional faults, most of which were never reported before in the literature. Our results pinpoint that current verification and validation mechanisms for exception handling code are still not properly addressing these categories of exceptional faults.

Along with rapid development of workflow technology, on the market, there are a lot of workflow products. Workflow exception handling study in the exception of workflow, through the appropriate method to deal effectively with the exception to ensure the implementation of the workflow. Most existing research on workflow management systems (WFMS) has been focused on workflow based on well structured and well-behaved business processes. But it is devoid of the advisement of flexibility and uncertainty. This paper proposes an Agents group based approach for exception handling. Agents group is dispatched to find out the status of running processes in the system to keep track and troubleshoot them when necessary. This model describes the classification of workflow exception, and the corresponding design of different type of exception handing agents and their cooperation.

In this paper, we focus on the exception handling mechanism of CA-CCML (Context-aware Cooperative Composition Modeling Language). First, according to level of exception generation, we divide Web service exceptions into three broad categories by levels of exception generation, which are Service invocation level exception, Syntax level exception and Semantic level exception. Then we make detail classification according the cause of exception. After that, we add exception handling module into CA-CCML language interpreter, using auxiliary structure such as exception type database and configuration format file, to handle three broad categories of exceptions respectively, which improves robustness of the language interpreter. Finally, we introduce some application cases to show the exception handling mechanism of CA-CCML is valid.

A short description of the concept of an exception is given. A method is proposed for exception handling in C++ without language extension. The method proposed is possible due to the clean-up action (so-called destructors) in the process of stack unwinding at the time when an exception is raised. The method has been implemented and tested on several compilers and on various platforms, including Zortech C++ (MS-DOS), Borland C++ (MS-DOS) and AT&T C++ (SunOS). Finally, the limitations of the proposed method are addressed. A comparison of this method with the exception handling mechanism used in AT&T C++ version 2.1 is given to show why language extension is the preferable approach to handle exceptions. The program given is a good example for learning C++, since nearly all important C++ features (such as inheritance, operator overloading, virtual functions, etc.) are utilized in the program in an innovative manner.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The ability of the Ada programming language to support a software-engineering approach to building fault-tolerant applications systems by distributed redundant abstract data types (ADTs) is discussed. It is shown that the package, the separation of the specification from the implementation parts, the typing and exception handling mechanisms, and the nondeterministic rendezvous of the Ada language contribute to the fault-tolerance of systems constructed in this fashion. >

Failures are unavoidable in many circumstances. For example, an agent may fail at some point to perform a task in a dynamic environment. Robust systems typically have mechanisms to handle such failures. Temporal logic is a widely used representation language for reasoning about the behaviour of systems, although dealing with failures is not part of the language. In this paper, it is investigated how interval temporal logic can be extended with an operator describing failure. This logic has a close relationship to exception handling mechanisms in programming languages, which provides an elegant mechanism for modelling and handling failures. The approach is motivated from the context of specification of systems that have to operate in highly dynamic environments. A case study of the formal modelling and verification of the treatment of diabetes mellitus type 2 illustrates the practical usefulness of the approach.

The Hoare-like verification system for a language with an exception handling mechanism

Management theory increasingly recognizes the importance of knowledge as an additional production factor besides the classical factors (Gutenberg 1965) of labor, equipment and materials (Grant 1996; Kogut & Zander 1992; Nelson 1991; Drucker 1998). In the transition towards a knowledge based economy, information technology plays a crucial role. Thus many fiirms and institutions are currently reengineering their knowledge-intensive processes and are building IT-based knowledge infrastructures. Functional organization structures are being replaced by process-oriented structures. Processes are not only being shortened by reducing transfer times but also by parallelizing previously sequential tasks. Access to information and decision-making authority is being decentralized (while establishing centralized monitoring and exception handling mechanisms). In many cases, the concept of ‘product’ has been refocused around knowledge-intensive services. Moreover, many efforts are targeting the collection and organization of knowledge. Consulting companies, for example, are pioneering knowledge bases which organize and replicate knowledge about best practices (for an overview see Prusak 1998).