In modern enterprises, workflows are essential to automating business processes. During their execution, workflows need to interact with users using a mechanism called dialogs to deliver information and collect input that is required for further decision-making in the workflows. Information delivery and input collection by enterprise workflows is often a time-sensitive matter. Thus, dialogs have to be communicated to users in a timely fashion, which necessitates sending dialogs to user communication endpoints that permit the recipients to quickly, effectively, and conveniently view the information and provide the requested feedback. The proliferation of communication devices and clients among enterprise users implies that the content and rendering of dialogs has to be tailored to a large number of endpoints and preferably by middleware. This customization poses several challenges to developing and maintaining a manageable, extensible, and flexible middleware mechanism for synthesizing dialogs from specific decision points in enterprise workflows. In this paper, we first describe the challenges associated with context-sensitive dialog synthesis. We discuss how we applied templatized model transformation techniques to automatically synthesize dialogs in enterprise workflows. We show how our templatized transformation approach supports the evolution of communication endpoints and system requirements with a minimum of downtime and invasive design changes. We demonstrate our approach in the context of a representative enterprise case study.

Many systems and techniques exist for detecting application failures. However, previously known generic failure detection solutions are only of limited use for Java applications because they do not take into consideration the specifics of the Java language and the Java execution environment. In this article, we present the application-independent Java Application Supervisor (JAS). JAS can automatically detect, log, and resolve a variety of execution problems and failures in Java applications. In most cases, JAS requires neither modifications nor access to the source code of the supervised application. A set of simple user-specified policies guides the failure detection, logging, and recovery process in JAS. A JAS configuration manager automatically generates default policies from the bytecode of an application. The user can modify these default policies as needed. Our experimental studies show that JAS typically incurs little execution time and memory overhead for the target application. We describe an experiment with a Web proxy that exhibits reliability and performance problems under heavy load and demonstrate an increase in the rate of successful requests to the server by almost 33% and a decrease in the average request processing time by approximately 22% when using JAS.

Abstract The Java programming language is increasingly used in the implementation of servers with stringent availability, reliability, and performance requirements. Our Java Application Supervisor (JAS) software system is an attachment to a Java runtime environment that enhances the availability of a target Java program. To this end, JAS automatically detects and resolves certain reliability and performance problems during the execution of the target program. JAS does not require any source or byte code modifications in the target program. Instead, JAS is configured for a target program by supplying simple policies that determine how JAS reacts to problems during the target program execution. JAS typically imposes little execution time and memory overhead on the target program. We describe an experiment with a Web proxy that exhibits reliability and performance problems under heavy load. In this experiment, running the proxy in conjunction with JAS increased the rate of successful requests to the proxy by 33% and decreased the averagerequest processing time by 22%. JAS was also used successfully in two Java servers at Bell Labs to monitor server reliability and performance and ensure long‐term availability. Copyright © 2001 John Wiley & Sons, Ltd.

We present a model for analyzing the reliability of component based software systems. Each software component is described as a finite state machine whose transitions have failure probabilities that reflect the unreliable execution of elementary component operations. Alternatively, we model a component as a finite state machine with an associated reliability figure that expresses the overall reliability of the component. Using our model, we prove that there is no algorithm that can accurately calculate the reliability of a system of finite state machines with known or estimated overall reliabilities or transition failure probabilities. The same negative result holds even if we only want to approximate the system reliability.

Object Persistence is an important feature of Object-oriented languages. The C++ language specification does not include or discuss any method of providing persistence for C++ objects. Several schemes have been developed for adding persistence to C++. Some of them require persistent objects to be allocated and treated differently than non-persistent objects, while some others require the programmer to provide vital parts of the persistence mechanism. It is desirable to make the persistence feature transparent, but the nature of C++ makes it difficult. This paper discusses in detail the various interesting language issues to be considered for adding persistence to C++ and how they lead to the design of the reflective object-checkpointing library, MemberAnalyzer.

Accessing remote sites of the World Wide Web is often a frustrating experience for users because of long Web page retrieval times even over relatively fast Internet connections. Users are more likely to embrace the further expansion of the role of the Web into a major infrastructure for electronic commerce and for information, application, and multimedia delivery if Web accesses can be accelerated. One technique that attempts this is prefetching. We built a client-side Java-implemented prefetching agent, WebCompanion, which employs a novel adaptive, fast, and selective online prefetching strategy based on estimated round-trip times for Web resources. This strategy efficiently hides the access latencies for slow resources while at the same time limiting the network and server overhead and local resource consumption to moderate levels. Our extensive experiments show an average access speedup of greater than 50 percent and an average network byte overhead of less than 150 percent using WebCompanion over a fast Internet connection. We measured a slight acceleration in accessing the Web through WebCompanion even in a pessimistic scenario where the user never requests a prefetched document.