A Peer-to-Peer Middleware Framework for Resilient Persistent Programming

The persistent programming systems of the 1980s offered a programming model that integrated computation and long-term storage. In these systems, reliable applications could be engineered without requiring the programmer to write translation code to manage the transfer of data to and from non-volatile storage. More importantly, it simplified the programmer's conceptual model of an application, and avoided the many coherency problems that result from multiple cached copies of the same information. Although technically innovative, persistent languages were not widely adopted, perhaps due in part to their closed-world model. Each persistent store was located on a single host, and there were no flexible mechanisms for communication or transfer of data between separate stores. Here we re-open the work on persistence and combine it with modern peer-to-peer techniques in order to provide support for orthogonal persistence in resilient and potentially long-running distributed applications. Our vision is of an infrastructure within which an application can be developed and distributed with minimal modification, whereupon the application becomes resilient to certain failure modes. If a node, or the connection to it, fails during execution of the application, the objects are re-instantiated from distributed replicas, without their reference holders being aware of the failure. Furthermore, we believe that this can be achieved within a spectrum of application programmer intervention, ranging from minimal to totally prescriptive, as desired. The same mechanisms encompass an orthogonally persistent programming model. We outline our approach to implementing this vision, and describe current progress.Comment: Submitted to EuroSys 200

Unification of Transactions and Replication in Three-Tier Architectures Based on CORBA

In this paper, we describe a software infrastructure that unifies transactions and replication in three-tier architectures and provides data consistency and high availability for enterprise applications. The infrastructure uses transactions based on the CORBA object transaction service to protect the application data in databases on stable storage, using a roll-backward recovery strategy, and replication based on the fault tolerant CORBA standard to protect the middle-tier servers, using a roll-forward recovery strategy. The infrastructure replicates the middle-tier servers to protect the application business logic processing. In addition, it replicates the transaction coordinator, which renders the two-phase commit protocol nonblocking and, thus, avoids potentially long service disruptions caused by failure of the coordinator. The infrastructure handles the interactions between the replicated middle-tier servers and the database servers through replicated gateways that prevent duplicate requests from reaching the database servers. It implements automatic client-side failover mechanisms, which guarantee that clients know the outcome of the requests that they have made, and retries aborted transactions automatically on behalf of the clients

Implementing Session Centered Calculi

Recently, specific attention has been devoted to the development of service oriented process calculi. Besides the foundational aspects, it is also interesting to have prototype implementations for them in order to assess usability and to minimize the gap between theory and practice. Typically, these implementations are done in Java taking advantage of its mechanisms supporting network applications. However, most of the recurrent features of service oriented applications are re-implemented from scratch. In this paper we show how to implement a service oriented calculus, CaSPiS (Calculus of Services with Pipelines and Sessions) using the Java framework IMC, where recurrent mechanisms for network applications are already provided. By using the session oriented and pattern matching communication mechanisms provided by IMC, it is relatively simple to implement in Java all CaSPiS abstractions and thus to easily write the implementation in Java of a CaSPiS process

Incrementally developing parallel applications with AspectJ

This paper presents a methodology to develop more modular parallel applications, based on aspect oriented programming. Traditional object oriented mechanisms implement application core functionality and parallelisation concerns are plugged by aspect oriented mechanisms. Parallelisation concerns are separated into four categories: functional or/and data partition, concurrency, distribution and optimisation. Modularising these categories into separate modules using aspect oriented programming enables (un)pluggability of parallelisation concerns. This approach leads to more incremental application development, easier debugging and increased reuse of core functionality and parallel code, when compared with traditional object oriented approaches. A detailed analysis of a simple parallel application - a prime number sieve - illustrates the methodology and shows how to accomplish these gains.Fundo Europeu de Desenvolvimento Regional (FEDER) - PPC-VM project POSI/CHS/47158/2002.Fundação para a Ciência e a Tecnologia (FCT) - PPC-VM project POSI/CHS/47158/2002

Unifying Internet Services Using Distributed Shared Objects

Developing wide area applications such as those for sharing data across the Internet is unnecessarily difficult. The main problem is the widespread use of a communication paradigm that is too low level. We will show how wide area application development can be made easier when using distributed shared objects instead of a communication-oriented model. An object in our model is physically distributed, with multiple copies of its state on different machines. All implementation aspects such as replication, distribution, and migration of state, are hidden from users through an object's interface. In this paper, we concentrate on the application of distributed shared objects, by providing an outline of a middleware solution that permits integration of the Internet services for e-mail, News, file transfer, and Web documents. vrije Universiteit Faculty of Mathematics and Computer Science 1 Introduction Constructing wide area applications, such as those for sharing data across the Internet,..

An implementation of active objects in Java

Active objects are a form of multitasking for computer systems. Active objects manipulate their own execution thread instead of using the execution thread of the object that created them. When a method is invoked on an active object, the call returns immediately and the caller continues execution. Thus, active objects can be utilized to develop parallel applications; Active object model can be implemented in a number of different ways: with patterns, external libraries or extending the language. The solution proposed by this thesis is to implement active objects by extending the Java language with new keywords. We have modified Sun\u27s open-source Java Compiler to accept the added keywords and to translate them into regular Java syntax; An \u27active\u27 modifier was introduced to mark active objects; active objects can be created on remote machines and communication with them is done using RMI; active object\u27s methods can be executed asynchronously and the results obtained later using a new \u27waitfor\u27 statement