Research and practice of JAVA virtual machine exception handling mechanism testing technology

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.

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.

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.

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

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.

Workflow management systems (WfMSs) are being increasingly deployed to deliver e-business transactions across organizational boundaries. To ensure a high service quality in such transactions, exception-handling schemes for conflict resolution are needed. The conflicts primarily arise due to failure of a task in workflow execution because of underlying application, or controlling WfMS component failures or insufficient user input. So far, little progress has been reported in addressing conflict resolution in cross-organizational business processes, though its importance has been recognized. In this paper, we identify the exception handling techniques that support conflict resolution in cross-organizational settings. In particular, we propose a novel, “bundled” exception-handling approach, which supports (1) exception knowledge sharing--sharing exception specifications and handling experiences, (2) coordinated exception handling, and (3) intelligent problem solving--using case based reasoning to reuse exception handing experiences. A prototype of this exception handling mechanism is developed and integrated as a part of the METEOR Workflow Management System. An evaluation of our approach is also presented through some sample workflow applications.

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>

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.

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

Java Card is a version of Java developed to run on devices with severe storage and processing restrictions. The applets that run on these devices are frequently intended for use in critical, highly distributed, mobile conditions. This requires runtime verification approach based on Design by Contract to improve the safety of Java Card applications. However handling contract violation in Java Card applications is challenging due to their communication structure and platform restrictions. Additionally the Java Card exception handling mechanism requires that developers understand the source of an exception, the place where it is handled, and everything in between. As system development evolves, exceptional control flows become less well-understood, with negative consequences for the program maintainability and robustness. In this paper, we claim that such problem can be addressed by implementing an innovative exception handling model which provides abstractions to explicitly describe global views of exceptional control flows.