WSO (Web-Services Orchestration) addresses a broad set of failure scenarios that become relevant when web-service implementations encapsulate multiple web-service calls to other systems. Network timeouts introduce uncertainty about the success or failure of a given API call: in certain scenarios, simply retrying the operation may make the situation worse. In order to guarantee pseudo-atomicity of a web-service call sequence, the failure of one API call implies that other, successfully completed, API calls may have to compensated for before retrying the original set of web-service calls. Even if no failure occurs, orchestration of a web-service to deal with edge-cases (such as expiration of credentials) can be difficult to implement correctly. In this paper we describe an approach to solving such scenarios which we have implemented in our WSO project. To facilitate use of WSO, the programming model is designed to wrap existing code rather than requiring rewriting code. We show the benefits of WSO in the context of a motivating scenario and also present a before/after comparison.

To meet the demand for rapid Web-service development, developers seek to efficiently consume existing data from multiple sources into a form that can be used by the new service. In this paper, we discuss our SAKURA prototype in which we created two services to facilitate such data consumption. The first, a “resource-aggregation” service, gives developers a “composed object” abstraction across multiple Web-services. The second, a “business object” caching service, improves the performance of accessing existing Web-services from the new application. We describe these two services and illustrate their benefits in the context of an extended scenario.

Large enterprises have built very large "on-premise" data-sets that are critical to many business functions. With the availability of cloud-based storage, many of these enterprises are considering whether and how to make some of this data available on the cloud. One motivation is to offload the processing of new mobile application workloads from the on-premise system to the cloud. Another motivation is to improve the performance of these mobile applications. However, because of the importance of this data, and because of regulatory constraints, many enterprises are unwilling to simply move their data from an on-premise environment to the cloud. Instead, they prefer to keep the "master" version of the data on-premise, while projecting a subset of the data to the cloud. Several challenges face these enterprises. First, how can large data-sets be efficiently made available on the cloud with minimal disruption to the ongoing on-premise business function? Second, how can this data be represented in a way that will be useful to cloud developers? Typically, cloud developers want data represented in a way that is easily consumable by REST APIs, but the on-premise representation may not be amenable to such usage. Our INTEGRATOR project addresses these challenges by providing an integrated cloud/on-premise data-service. Importantly, the INTEGRATOR architecture is broadly applicable across various back-end systems. In this paper we describe the INTEGRATOR architecture and a prototype implementation for a specific on-premise system. We examine alternative architectures - "table based" and "business object based" - and explain why we chose the business object approach.

We examine the lifecycle requirements of intermittently connected web-applications (ICWAs) and investigate whether such applications can be developed as an "always connected" web-application combined with middleware that address ICWA requirements. We show that this is difficult to do because ICWAs require application-specific logic that is not easily combined with a middleware API. We therefore propose the use of "middleware components" in the areas of data-provisioning and change-set propagation. Combined with application-specific logic, these components make it easier to develop an ICWA by reducing the amount of required developer code. We show how our prototype UNTETHER system implements these components and reduces the burden on the application developer.

Application-caching occurs when applications assume control for data caching rather then relying on middleware to manage their data. This paradigm is a good fit for"main-memory caching" in which data storage and retrieval issues are relatively straight-forward. However, the caching requirements of certain workloads exceed even modern main-memory capacity. Although disk-offload offers the potential to overcome this capacity constraint, it poses a problem for the application-caching paradigm since application data may now be resident in either main-memory or on disk. In this paper, we therefore examine how disk-offload middleware can best support the application-caching paradigm for data-centric web-services. We present two disk-offload caching architectures, evaluate their performance, and draw conclusions as to their relative effectiveness.

Developers of situational applications - applications created by a small group of users/developers to satisfy the specific needs of the group - require two things from their software stack. First, they require support for their rapidly changing designs; second, they require semantics that are close to their own domain of expertise. For example, developers of situational applications prefer to use scripting languages because the "duck typing" style of programming language allows them to ignore issues related to class inheritance or interface implementation. In comparison to strongly-typed languages, developers can begin programming more quickly, and can modify their program more rapidly in response to changing requirements. In this paper we explore whether middleware services can similarly provide developers of situational applications with these desired software characteristics. Specifically, we present EDS, an Extensible Data-Service designed to support applications whose design changes rapidly and with semantics that are closer to the domain expertise of situational application developers. We present the features of EDS, contrast it to other data services and APIs, and discuss the EDS implementation.

One benefit of Software-as-a-Service (SaaS) is the ability to rapidly deploy iterative improvements without requiring users to upgrade the application on their machine. However, the need to rapidly "develop and test" different versions of an application implies that developers need branch isolation to protect the system from local changes to both data and meta-data in the same way that they traditionally use branch-isolation to protect the system from source-code changes. Providing branch-isolation for source-code changes has well-known solutions, but these solutions do not extend well to providing isolation for changes to data and meta-data. EVERETT provides developers the ability to safely - and concurrently - change database values with new business logic or evolve data schema in various ways while sharing the same database.

Many web-applications can be characterized as relational. In this paper we introduce and evaluate WebRB, a visualdomain-specific language for building such applications. WebRB addresses the limitations of the conventional imperative-embedding approach typically used to build relational web-applications. We describe the WebRB language, present extended examples of its use, and discuss the WebRB visual editor, libraries, and runtime. We then evaluate WebRB by comparing it to alternative approaches, and demonstrate its effectiveness in building relational web-applications.

Many Web-applications can be characterized as "relational". In this paper we show that developers can greatly benefit from relational blocks, a visual, domain-specific, dataflow language that is designed to facilitate the construction of such web-applications. We define the relational blocks visual language, discuss our WebRB implementation, and show how WebRB is used to construct non-trivial web-pages.

Abstract We present the design of an Enterprise JavaBeans (EJBs) caching architecture, and show that EJB caching can greatly improve application throughput in clustered environments. Throughput is improved because data serving is offloaded from the database server to the cache‐enabled application server. EJB caching is successful because it exploits the low‐latency connections between the database server and application servers that exist in a clustered environment. An important feature of our architecture is that the caching function is transparent to applications that use it. The cache‐enabled application server uses the same (EJB) programming model, and the same transactional semantics, as provided by non‐caching architectures. Copyright © 2005 John Wiley & Sons, Ltd.

We present the design of an Enterprise JavaBeans (EJBs) caching architecture, and show that EJB caching can greatly improve application throughput. Throughput is improved because data serving is offloaded from the database server to the cache-enabled application server. An important feature of our architecture is that the caching function is transparent to applications that use it. The cache-enabled application server uses the same (EJB) programming model, and the same transactional semantics, as provided by non-caching architectures.

The Model/View/Controller design pattern is very useful for architecting interactive software systems. This design pattern is partition-independent, because it is expressed in terms of an interactive application running in a single address space. Applying the Model/View/Controller design pattern to web-applications is therefore complicated by the fact that current technologies encourage developers to partition the application as early as in the design phase. Subsequent changes to that partitioning require considerable changes to the application's implementation-despite the fact that the application logic has not changed. This paper introduces the concept of Flexible Web-Application Partitioning, a programming model and implementation infrastructure, that allows developers to apply the Model/View/Controller design pattern in a partition-independent manner Applications are developed and tested in a single address-space; they can then be deployed to various client/server architectures without changing the application's source code. In addition, partitioning decisions can be changed without modifying the application.

The possibility of fast access to the main memory of remote sites has been advanced as a potential performance improvement in distributed systems. Even if a page is not available in local memory, sites need not do a disk access. Instead, the sites can use efficient mechanisms that support rapid request/response exchanges in order to access pages that are currently buffered at a remote site. Hardware and software support in such a remote caching architecture must also include algorithms that determine which pages should be buffered at what sites. When each site uses the classic LRU replacement algorithm, performance can be much worse than optimal in many system configurations. Because sites do not coordinate individual decisions, overall system buffering/caching decisions yield very inefficient global configurations. This paper proposes an easily implementable modification of the LRU replacement algorithm for LAN environments that reduces replication. The algorithm substantially improves hit-ratios-and thus performance-over a wide range of parameters. The relatively simple LAN topology implies that much less state information need be available for good replacement decisions compared to general network topologies. Two implications of two variations of the algorithm are explored. In an environment where the network is not a performance bottleneck, and where performance is memory-limited, performance of the proposed replacement algorithm is shown to be close to optimal.

This paper describes a rapid protocol development approach that enables protocol verification through the design and development stages. Feedback from verification analysis can be very useful to protocol designers, but it is often difficult to stay current with the protocol's development. Our approach facilitates quick turnaround in the development and verification process-even before the protocol is stable. American National Standards Committee X3T9.3 has chartered the development of Fibre Channel (FC), a proposed standard for serial I/O channel capable of supporting a wide range of zipper layer protocols. Despite the complexity of FC, we have used our approach to both verify it and to produce a software and hardware implementation of the protocol. We describe features that enable rapid turnaround in response to revisions of the standard and maintenance of a stable suite of test cases for the standard. The approach has also been applied to other protocols.>

In this paper, we examine a set of load sharing strategies that are robust to the unreliable state information that is often present in a distributed database system. In this environment, sites must solve the problem of how alternative sites should be selected to process incoming transactions, given that the information on which the decision is based exhibits varying degrees of obsolescence. A set of regression-based adaptive strategies is examined in which a feedback mechanism is used to compensate for obsolete information. Transaction response time under the different adaptive strategies is evaluated, and the reasons for these performance differences discussed. The key characteristic of the best regression strategy is that transaction site affinity is taken into consideration when adjusting for the effect of information obsolescence.>

As the differences between channels and networks narrow, the services and capabilities of channels need to be examined relative to those of networks. A comparison is made between the Fibre Channel protocol and networking protocols. Specific features of the Fibre Channel protocol are compared with those of the Fiber Distributed Data Interface (FDDI) LAN protocol and 802.2-type media access controllers (MACs). Fibre Channel may, in the future, fill a role where it serves as a single communication medium providing both channel and network services.

The design of a simulator that is being used to verify Fibre Channel (a proposed standard for a serial I/O channel) is discussed. The complexity and incomplete state of the standard make verification through simulation both important and difficult. The simulator is also intended for subsequent use as a tool for Fibre Channel development. The need to meet the requirements of both verification and development has important implications of the simulator's design. These implications are described, together with some of the resulting tradeoffs.

Studies the cache performance in a remote caching architecture. The authors develop a set of distributed object replication policies that are designed to implement different optimization goals. Each site is responsible for local cache decisions, and modifies cache contents in response to decisions made by other sites. The authors use the optimal and greedy policies as upper and lower bounds, respectively, for performance in this environment. Critical system parameters are identified, and their effect on system performance studied. Performance of the distributed algorithms is found to be close to optimal, while that of the greedy algorithms is far from optimal.>

A set of strategies that address the problem which unreliable state information poses to useful load sharing in a distributed database system is examined. In this environment, sites must solve the problem of how alternative sites should be selected to process incoming transactions, given that the information on which the decision is based exhibits varying degrees of obsolescence. A set of regression-based adaptive strategies in which a feedback mechanism is used to compensate for obsolete information is presented. Transaction response time under the different adaptive strategies is analyzed, and the reasons for the performance differences are discussed.>

For LAN environments, a simple modification of the LRU replacement algorithm is proposed. By limiting the number of object replicas, the algorithm can substantially improve LRU performance over a wide range of parameters. The relatively simple LAN topology implies that much less state information need be available for good replacement decisions, compared to general network topologies.>

Article Free Access Share on Replica control in distributed systems: as asynchronous approach Authors: Calton Pu Department of Computer Science, Columbia University, New York, NY Department of Computer Science, Columbia University, New York, NYView Profile , Avraham Leff Department of Computer Science, Columbia University, New York, NY Department of Computer Science, Columbia University, New York, NYView Profile Authors Info & Claims SIGMOD '91: Proceedings of the 1991 ACM SIGMOD international conference on Management of dataApril 1991 Pages 377–386https://doi.org/10.1145/115790.115856Published:01 April 1991Publication History 153citation1,037DownloadsMetricsTotal Citations153Total Downloads1,037Last 12 Months45Last 6 weeks6 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

In this paper we examine the issue of robust transaction routing in a locally distributed database environment where transaction characteristics such as reference locality imply that certain processing systems can be identified as being more suitable than others for a given transaction class. A response time based routing strategy can strike a balance between indiscriminate sharing of the load and routing based only on transaction affinity. Since response time estimates depend on workload and system parameters that may not be readily available, it is important to examine the robustness of routing decisions to information accuracy. We find that a strategy which strictly tries to minimize the response time of incoming transactions is sensitive to the accuracy of certain parameter values. On the other hand, naive strategies, that simply ignore the parameters in making routing decisions, have even worse performance. Three alternative strategies are therefore examined: threshold, discriminatory, and adaptive. Instead of just optimizing an incoming transaction's response time, the first two strategies pursue a strategy that is somewhat more oriented towards global optimization. This is achieved by being more restrictive on either the condition or the candidate for balancing the load. The third strategy, while trying to minimize the response time of individual incoming transactions, employs a feedback process to adaptively adjust future response time estimates. It monitors the discrepancy between the actual and estimated response times and introduces a correction factor based on regression analysis. All three strategies are shown to be robust with respect to the accuracy of workload and system parameters used in the response time estimation.

The issue of transaction routing in a heterogeneous database environment is examined where transaction characteristics like reference locality implies that certain processing systems can be identified as being, in general, more suitable than others for a given transaction class. Routing which ignores these distinctions in an attempt to balance system load can degrade system performance. An adaptive routing strategy is considered which: (1) estimates the response time based on a steady-state analysis; (2) monitors how well actual response time conforms to the estimate; and (3) adaptively adjusts future estimates through a feedback control based on (2). It is found that the adaptive strategy greatly enhances performance robustness as compared to the results of the strategy without feedback. The feedback process used alleviates the sensitivity to accurate estimations of workload and system parameters. Various simulation studies are used to illustrate the adaptive strategy's robustness.>

The authors outline a formal model of topological navigation in one-dimensional spaces such as single roads. They formally define the concepts of direction giving and of custom map, as well as some specifications for feature detector models, including the idea of sensor synchronicity. The representations necessary to model and make use of differences between the world itself, the world as perceived by the map maker, and the world as experienced by the navigator are discussed. The difficulty of giving precise meaning to what is meant by a 'good' map is shown, and an operational definition of what is meant by a 'landmark' is given: regardless of starting position, any custom map can attain a landmark with but a single direction. It is shown that even in the simplest case, NP-complete problems arise in the efficient selection and sequencing of sensor modalities, even while attempting to navigate from one single object to another. A heuristic is provided that appears reasonable for map creation, and examples are given of several very different maps, each of which is optimal under eight reasonable criteria.>