A rule-based approach to proactive exception handling in business processes

Effectively handling exceptions in business process is an important capability of enterprises in the current global market environment, since their business processes are becoming more complex. Effective exception handling requires systematic support for the entire scope of exception handling: from exception prediction to exception prevention, and from exception detection to exception resolution. Most existing research approaches to exception handling in business process management and workflow areas have focused on reactive exception handling which resolves exceptions only after their occurrences. Therefore, a proactive exception handling approach is required to predict and prevent business process exceptions as early as possible before they occur, and detect and resolve exceptions as soon as possible after they occur. This paper presents comprehensive behavioral, functional, and informational requirements for proactive exception handling from the lifecycle perspective. Then, it proposes a rule language for proactive exception handling based on the requirements. The proposed rule language will enable effective and flexible exception handling by providing the information required for the entire scope of exception handling, especially, for exception prediction and prevention. Finally, the paper illustrates and validates the rule language with an example of exception prevention and a prototype system.     

Advanced exception handling mechanisms

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, real-time, 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     

异常处理技术在C++中的编程实现

异常处理是C＋＋语言的重要语言机制,正确地处理异常对程序的可靠性、健壮性是十分重要的.本文回顾了异常处理技术的概念和思想,介绍了C＋＋异常处理技术中涉及到的常见问题,对异常处理的性能与代价进行了分析,以便更好地在面向对象程序设计中正确使用异常处理技术进行编程实现.     

On the modularization and reuse of exception handling with aspects

This paper presents an in‐depth study of the adequacy of the AspectJ language for modularizing and reusing exception‐handling code. The study consisted of refactoring existing applications so that the code responsible for implementing error‐handling strategies was moved to newly created exception handler aspects. We have performed quantitative assessments of five systems—four object‐oriented and one aspect‐oriented—based on four key quality attributes, namely separation of concerns, coupling, cohesion, and conciseness. Our investigation also included a multi‐perspective analysis of the refactored systems, including (i) the extent to which error‐handling aspects can be reused, (ii) the beneficial and harmful aspectization scenarios for exception handling, and (iii) the scalability of AOP to support the modularization of exception handling in the presence of other aspects. Copyright © 2009 John Wiley & Sons, Ltd.     

Unveiling and taming liabilities of aspects in the presence of exceptions: A static analysis based approach

As aspects extend or replace existing functionality at specific join points in the code, their behavior may raise new exceptions, which can flow through the program execution in unexpected ways. Assuring the reliability of exception handling code in aspect-oriented (AO) systems is a challenging task. Testing the exception handling code is inherently difficult, since it is tricky to provoke all exceptions during tests, and the large number of different exceptions that can happen in a system may lead to the test-case explosion problem. Moreover, we have observed that some properties of AO programming (e.g., quantification, obliviousness) may conflict with characteristics of exception handling mechanisms, exacerbating existing problems (e.g., uncaught exceptions). The lack of verification approaches for exception handling code in AO systems stimulated the present work. This work presents a verification approach based on a static analysis tool, called SAFE, to check the reliability of exception handling code in AspectJ programs. We evaluated the effectiveness and feasibility of our approach in two complementary ways (i) by investigating if the SAFE tool is precise enough to uncover exception flow information and (ii) by applying the approach to three medium-sized ApectJ systems from different application domains.     

基于程序分析的代码查询技术

策略描述语言是策略驱动的面向服务流程异常处理方法的基础和前提。针对目前已有策略语言在描述面向服务流程异常处理逻辑方面的不足,提出了一种新的面向服务流程异常处理的策略描述语言WS-Policy4BPEH。它在Web服务策略框架的基础上,扩展了ECA对规则执行影响的描述,定义了多种面向服务流程的异常处理动作模式,能够详细、准确地描述异常及异常处理方式、返回方式和传播方式。WS-Policy4BPEH采用XML作为元语言,因此具有良好的可扩展性。     

Analysis and testing of programs with exception handling constructs

Analysis techniques, such as control flow, data flow, and control dependence, are used for a variety of software engineering tasks, including structural and regression testing, dynamic execution profiling, static and dynamic slicing, and program understanding. To be applicable to programs in languages such as Java and C++, these analysis techniques must account for the effects of exception occurrences and exception handling constructs; failure to do so can cause the analysis techniques to compute incorrect results and, thus, limit the usefulness of the applications that use them. This paper discusses the effects of exception handling constructs on several analysis techniques. The paper presents techniques to construct representations for programs with explicit exception occurrences-exceptions that are raised explicitly through throw statements-and exception handling constructs. The paper presents algorithms that use these representations to perform the desired analyses. The paper also discusses several software engineering applications that use these analyses. Finally, the paper describes empirical results pertaining to the occurrence of exception handling constructs in Java programs and their effect on some analysis tasks     

Extended event–condition–action rules and fuzzy Petri nets based exception handling for workflow management

Exception handling plays a key role in dynamic workflow management that enables streamlined business processes. Handling application-specific exceptions is a knowledge-intensive process involving different decision-making strategies and a variety of knowledge, especially much fuzzy knowledge. Current efforts in workflow exception management are not adequate to support the knowledge-based exception handling. This paper proposes a hybrid exception handling approach based on two extended knowledge models, i.e., generalized fuzzy event–condition–action (GFECA) rule and typed fuzzy Petri net extended by process knowledge (TFPN-PK). The approach realizes integrated representation and reasoning of fuzzy and non-fuzzy knowledge as well as specific application domain knowledge and workflow process knowledge. In addition, it supports two handling strategies, i.e., direct decision and analysis-based decision, during exception management. The approach fills in the gaps in existing related researches, i.e., only providing the capability of direct exception handling and neglecting fuzzy knowledge. Based on TFPN-PK, a weighted fuzzy reasoning algorithm is designed to address the reasoning problem of uncertain goal propositions and known goal concepts by combining forward reasoning with backward reasoning and therefore to facilitate cause analysis and handling of workflow exceptions. A prototype system is developed to implement the proposed approach.     

浮点数学函数异常处理方法

异常会造成程序错误,实现完全没有异常的浮点计算软件也很艰难,因此,实现有效的异常处理方法很重要.但现有的异常处理并不针对浮点运算,并且研究重点都集中在整数溢出错误上,而浮点类型运算降低了整数溢出存在的可能.针对上述现象,面向基于汇编实现的数学函数,提出了一种针对浮点运算的分段式异常处理方法.通过将异常类型映射为64位浮点数,以核心运算为中心,将异常处理过程分为3个阶段:输入参数检测(处理INV异常)、特定代码检测(处理DZE异常和INF异常)以及输出结果检测(处理FPF异常和DNO异常),并从数学运算的角度对该方法采用分段式处理的原因进行了证明.实验将该方法应用于Mlib浮点函数库,对库中600多个面向不同平台的浮点函数进行了测试.测试结果表明:该方法能够将出现浮点异常即中断的函数个数从90%降到0%.同时,实验结果验证了该方法的高效性.     

Schedulability-analyzable exception handling for fault-tolerant real-time languages

Exceptions add a significant element of robustness and fault-tolerance to an application. In real-time systems, however, we require not only semantic correctness, robustness, and fault-tolerance, but also timely behavior. For restricted languages, schedulability analysis can be made efficient through use of polynomial-time analyses and transformations. In this paper, we show how a reasonable level of exception handling can be added to such a language. Specifically, we present an exception mechanism which reasonably provides for (1) guaranteed schedulability, (2) fine granularity of exception handling, (3) possibility of non-termination of the process that raises the exception, (4) reuse of exception handlers within the program, (5) information hiding in exception handlers, (6) exceptions as first-class objects, (7) casting or binding of exceptions, and (8) deadline modification. Furthermore, the mechanism allows for easy specification of multi-mode operation, and permits program component assignment using expected behavior while enabling schedulability analysis of worst-case (often exceptional) behavior. While adding features to exception handler semantics can create new analysis problems while solving expressivity problems, we show that the exception handling features described above are desirable, that the complexity of static schedulability analysis in the presence of these features is manageable, and that existing language provides all these desirable features.Marlowe is visiting the Real-Time Computing Laboratory from the Department of Mathematics and Computer Science, Seton Hall University, South Orange, NJ 07079 USA.At the time of the paper, Masticola was with the Department of Computer Science, Rutgers University.     

Active Oberon for .NET: An Exercise in Object Model Mapping

Active Oberon is a substantial evolution of the programming language Oberon. It distinguishes itself by a novel object model and by its integration into the .NET language interoperability framework.The three concepts characterizing Active Oberon are: (a) active object types, (b) a single and unifying notion of abstraction called definition, and (c) a static module construct. These concepts are in fact powerful combinations of concepts: Active objects integrate active behavior with reactive message handling, definitions unify the units of usage, implementation and inheritance, and modules represent both package and static object. The rigid concept of class hierarchy has been sacrificed in Active Oberon to a more flexible concept of aggregation that is based on a generalized IMPLEMENTS relation. The relations IMPORTS and REFINES are used to specify static module dependencies and to derive new definitions from existing ones respectively.This article is a report on a work in progress. We divide our presentation into three parts: (a) A short recall of the history of programming languages developed at the ETH, (b) an extensive conceptual overview of Active Oberon's object model called the Active Object System (AOS), (c) a discussion of the mapping of the AOS into the Common Type System (CTS) exposed by .NET.     

Extending conventional languages by distributed/concurrent exception resolution

The state of art in handling and resolving concurrent exceptions is discussed and a brief outline of all research in this area is given. Our intention is to demonstrate that exception resolution is a very useful concept which facilitates joint forward error recovery in concurrent and distributed systems. To do this, several new arguments are considered. We understand resolution as reaching an agreement among cooperating participants of an atomic action. It is provided by the underlying system to make it unified and less error prone, which is important for forward error recovery, complex by nature. We classify atomic action schemes into asynchronous and synchronous ones and discuss exception handling for schemes of both kinds. The paper also deals with introducing atomic action schemes based on exception resolution into existing concurrent and distributed languages, which usually have only local exceptions. We outline the basic approach and demonstrate its applicability by showing how exception resolution can be used in Ada 83, Ada 95 (for both concurrent and distributed systems) and Java. A discussion of ways to make this concept more object-oriented and, with the help of reflection, more flexible and useful, concludes the paper.     

Exception handling in the spreadsheet paradigm

Exception handling is widely regarded as a necessity in programming languages today and almost every programming language currently used for professional software development supports some form of it. However, spreadsheet systems, which may be the most widely used type of “programming language” today in terms of number of users using it to create “programs” (spreadsheets), have traditionally had only extremely limited support for exception handling. Spreadsheet system users range from end users to professional programmers and this wide range suggests that an approach to exception handling for spreadsheet systems needs to be compatible with the equational reasoning model of spreadsheet formulas, yet feature expressive power comparable to that found in other programming languages. We present an approach to exception handling for spreadsheet system users that is aimed at this goal. Some of the features of the approach are new; others are not new, but their effects on the programming language properties of spreadsheet systems have not been discussed before in the literature. We explore these properties, offer our solutions to problems that arise with these properties, and compare the functionality of the approach with that of exception handling approaches in other languages     

一种策略驱动的BPEL流程异常处理框架

如何提高BPEL流程异常处理的开发效率是策略驱动的BPEL流程异常处理方法亟待解决的关键问题之一.首先分析了基于策略的BPEL流程异常处理机制,设计了一种新的BPEL流程异常处理策略描述语言BPEH/PDL,然后结合BPEH/PDL异常处理策略,给出了一种新的BPEL流程异常处理框架BPEH/F,它具有一定的应用意义.     

A layered approach to automating the verification of real-timesystems

A layered approach to the specification and verification of real-time systems is described. Application processes are specified in the CSR Application Language, which includes high-level language constructs such as timeouts, deadlines, periodic processes, interrupts, and exception handling. A configuration schema is used to map the processes to system resources, and to specify the communication links between them. The authors automatically translate the result of the mapping into the CCSR process algebra, which characterizes CSR's resource-based computation model by a prioritized transition system. For the purposes of verification, a reachability analyzer based on the CCSR semantics has been implemented. This tool mechanically evaluates the correctness of the CSR specification by checking whether an exception state can be reached in its corresponding CCSR term. The effectiveness of this technique is illustrated by a multisensor robot example     

Implementation of blocking coordinated atomic actions based on forward error recovery

The coordinated atomic action concept was proposed as a means for providing fault tolerance in complex objectoriented systems that incorporate both cooperative and competitive concurrency. This paper has two purposes: to discuss a particular implementation of this concept and to address a number of the implementation issues that are common to any experiments with this concept. Our implementation relies on a detailed set of programming conventions for the standard Ada 95 language and uses a scheme of forward error recovery incorporating concurrent exception handling and resolution. Ada 95 has a number of unique features which make it a particularly good choice for our experiments. We believe that our approach is practical and useful for many critical applications with high dependability requirements.     

一种策略驱动的BPEL流程异常处理描述方法

针对如何提高BPEL流程的异常处理描述能力的问题,提出了一种策略驱动的BPEL流程异常处理描述方法。首先设计了一种新型的BPEL流程异常处理策略描述语言BPEH/PDL,并基于着色Petri网提出了BPEH/PDL异常处理策略的形式化描述方法。最后结合制造执行系统领域的汽车装配流水线管理系统,讨论了基于BPEH/PDL的BPEL流程异常处理策略的应用过程,以供参考。