Results 1 - 10
of
92
Rover: A Toolkit for Mobile Information Access
, 1995
"... The Rover toolkit combines relocatable dynamic objects and queued remote procedure calls to provide unique services for "roving" mobile applications. A relocatable dynamic object is an object with a well-defined interface that can be dynamically loaded into a client computer from a server computer ( ..."
Abstract
-
Cited by 176 (4 self)
- Add to MetaCart
The Rover toolkit combines relocatable dynamic objects and queued remote procedure calls to provide unique services for "roving" mobile applications. A relocatable dynamic object is an object with a well-defined interface that can be dynamically loaded into a client computer from a server computer (or vice versa) to reduce clientserver communication requirements. Queued remote procedure call is a communication system that permits applications to continue to make non-blocking remote procedure call requests even when a host is disconnected, with requests and responses being exchanged upon network reconnection. The challenges of mobile environments include intermittent connectivity, limited bandwidth, and channeluse optimization. Experimental results from a Rover-based mail reader, calendar program, and two non-blocking versions of WorldWide Web browsers show that Rover's services are a good match to these challenges. The Rover toolkit also offers advantages for workstation applications by providing a uniform distributed object architecture for code shipping, object caching, and asynchronous object invocation.
The Polylith Software Bus
- ACM Transactions on Programming Languages and Systems
, 1991
"... We describe a system called Polylith that helps programmers prepare and interconnect mixed-language software components for execution in heterogeneous environments. Polylith's principal benefit is that programmers are free to implement functional requirements separately from their treatment of inter ..."
Abstract
-
Cited by 171 (18 self)
- Add to MetaCart
We describe a system called Polylith that helps programmers prepare and interconnect mixed-language software components for execution in heterogeneous environments. Polylith's principal benefit is that programmers are free to implement functional requirements separately from their treatment of interfacing requirements; this means that once an application has been developed for use in one execution environment (such as a distributed network) it can be adapted for reuse in other environments (such as a shared-memory multiprocessor) by automatic techniques. This flexibility is provided without loss of performance. We accomplish this by creating a new run-time organization for software. An abstract decoupling agent, called the software bus, is introduced between the system components. Heterogeneity in language and architecture is accommodated since program units are prepared to interface directly to the bus, not to other program units. Programmers specify application structure in terms of ...
Mobile computing with the Rover toolkit
- IEEE Transactions on Computers
, 1997
"... Rover is a software toolkit that supports the construction of both mobile-transparent and mobile-aware appli-cations. The objective of the mobile-transparent approach istodevelop proxies for system services that hide the mobile characteristics of the environment from applications. Since applications ..."
Abstract
-
Cited by 150 (2 self)
- Add to MetaCart
Rover is a software toolkit that supports the construction of both mobile-transparent and mobile-aware appli-cations. The objective of the mobile-transparent approach istodevelop proxies for system services that hide the mobile characteristics of the environment from applications. Since applications can be run without alteration, the mobile-transparent approach is appealing. However, to excel, applications operating in the harsh conditions of a mobile environment must often be aware of and take an active part in mitigating those conditions. The Rover toolkit supports a set of programming and communication abstractions that enable the construction of both mobile-transparent and mobile-aware applications. Using the Rover abstractions, applications obtain increased availability, concurrency, resource allocation e ciency, fault tolerance, consistency, and adaptation. Experimental evaluation of a suite of mobile applications built with the toolkit demonstrates that such application-level control can be obtained with relatively little programming overhead and allows correct operation, increases interactive performance, and dramatically reduces network utilization under intermittently connected conditions. I.
Active Object -- An Object Behavioral Pattern for . . .
, 1996
"... This paper describes the Active Object pattern, which decouples method execution from method invocation in order to simplify synchronized access to an object that resides in its own thread of control. The Active Object pattern allows one or more independent threads of execution to interleave their a ..."
Abstract
-
Cited by 121 (41 self)
- Add to MetaCart
This paper describes the Active Object pattern, which decouples method execution from method invocation in order to simplify synchronized access to an object that resides in its own thread of control. The Active Object pattern allows one or more independent threads of execution to interleave their access to data modeled as a single object. A broad class of producer/consumer and reader/writer applications are wellsuited to this model of concurrency. This pattern is commonly used in distributed systems requiring multi-threaded servers. In addition, client applications, such as windowing systems and network browsers, employ active objects to simplify concurrent, asynchronous network operations.
Adding Group Communication and Fault-Tolerance to CORBA
, 1995
"... Groupware and fault-tolerant distributed systems stimulate the need for structuring activities around objectgroups and reliable multicast communication. The objectgroup abstraction permits to treat a collection of networkobjects as if they were a single object# clients can invoke operations on objec ..."
Abstract
-
Cited by 102 (7 self)
- Add to MetaCart
Groupware and fault-tolerant distributed systems stimulate the need for structuring activities around objectgroups and reliable multicast communication. The objectgroup abstraction permits to treat a collection of networkobjects as if they were a single object# clients can invoke operations on object-groups without needing to know the exact membership of the group. Object-groups mainly serve to increase reliability through replication, performance through parallelism, or to distribute data from one sender to a large number of receivers efficiently. This paper describes how object-groups and reliable multicast communication can be added to a CORBA compliant Object Request Broker. It also presents ELECTRA --- a CORBA Object Request Broker whose architecture is pervaded by the group concept.
Concurrent Programming in ERLANG
, 1993
"... Syntax Notation One (ASN.1), Recommendation X.208, Geneva, Switzerland. [13] CCITT Specification of Basic Encoding Rules (BER for Abstract Syntax One (ASN.1), Recommendation X.209, Geneva, Switzerland. [14] Gray, Jim and Reuter, Andreas Transaction Processing Concepts and Techniques, Morgan Kaufmann ..."
Abstract
-
Cited by 87 (0 self)
- Add to MetaCart
Syntax Notation One (ASN.1), Recommendation X.208, Geneva, Switzerland. [13] CCITT Specification of Basic Encoding Rules (BER for Abstract Syntax One (ASN.1), Recommendation X.209, Geneva, Switzerland. [14] Gray, Jim and Reuter, Andreas Transaction Processing Concepts and Techniques, Morgan Kaufmann Publishers, 1993. 143 144 Bibliography ...
Safe futures for Java
- In Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2005). ACM
, 2005
"... A future is a simple and elegant abstraction that allows concurrency to be expressed often through a relatively small rewrite of a sequential program. In the absence of side-effects, futures serve as benign annotations that mark potentially concurrent regions of code. Unfortunately, when computation ..."
Abstract
-
Cited by 59 (7 self)
- Add to MetaCart
A future is a simple and elegant abstraction that allows concurrency to be expressed often through a relatively small rewrite of a sequential program. In the absence of side-effects, futures serve as benign annotations that mark potentially concurrent regions of code. Unfortunately, when computation relies heavily on mutation as is the case in Java, its meaning is less clear, and much of its intended simplicity lost. This paper explores the definition and implementation of safe futures for Java. One can think of safe futures as truly transparent annotations on method calls, which designate opportunities for concurrency. Serial programs can be made concurrent simply by replacing standard method calls with future invocations. Most significantly, even though some parts of the program are executed concurrently and may indeed operate on shared data, the semblance of serial execution is nonetheless preserved. Thus, program reasoning is simplified since data dependencies present in a sequential program are not violated in a version augmented with safe futures. Besides presenting a programming model and API for safe futures, we formalize the safety conditions that must be satisfied to ensure equivalence between a sequential Java program and its futureannotated counterpart. A detailed implementation study is also provided. Our implementation exploits techniques such as object versioning and task revocation to guarantee necessary safety conditions. We also present an extensive experimental evaluation of our implementation to quantify overheads and limitations. Our experiments indicate that for programs with modest mutation rates on shared data, applications can use futures to profitably exploit parallelism, without sacrificing safety.
On objects and events
- in Proceedings of the 16th ACM Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA 2001
, 2001
"... This paper presents linguistic primitives for publish/subscribe programming using events and objects. We integrate our primitives into a strongly typed objectoriented language through four mechanisms: (1) serialization, (2) multiple subtyping, (3) closures, and (4) deferred code evaluation. We illus ..."
Abstract
-
Cited by 47 (7 self)
- Add to MetaCart
This paper presents linguistic primitives for publish/subscribe programming using events and objects. We integrate our primitives into a strongly typed objectoriented language through four mechanisms: (1) serialization, (2) multiple subtyping, (3) closures, and (4) deferred code evaluation. We illustrate our primitives through Java, showing how we have overcome its respective lacks. A precompiler transforms statements based on our publish/subscribe primitives into calls to specifically generated typed adapters, which resemble the typed stubs and skeletons generated by the rmic precompiler for remote method invocations in Java.
Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control
, 2006
"... Permission is hereby granted to make and distribute verbatim copies of this document without royalty or fee. Permission is granted to quote excerpts from this documented provided the original source is properly cited. ii When separately written programs are composed so that they may cooperate, they ..."
Abstract
-
Cited by 43 (5 self)
- Add to MetaCart
Permission is hereby granted to make and distribute verbatim copies of this document without royalty or fee. Permission is granted to quote excerpts from this documented provided the original source is properly cited. ii When separately written programs are composed so that they may cooperate, they may instead destructively interfere in unanticipated ways. These hazards limit the scale and functionality of the software systems we can successfully compose. This dissertation presents a framework for enabling those interactions between components needed for the cooperation we intend, while minimizing the hazards of destructive interference. Great progress on the composition problem has been made within the object paradigm, chiefly in the context of sequential, single-machine programming among benign components. We show how to extend this success to support robust composition of concurrent and potentially malicious components distributed over potentially malicious machines. We present E, a distributed, persistent, secure programming language, and CapDesk, a virus-safe desktop built in E, as embodiments of the techniques we explain.
An Asynchronous Remote Method Invocation (ARMI) Mechanism for Java
- In ACM 1997 Workshop on Java for Science and Engineering Computation
"... In recent past, Java has emerged as a powerful and an easy to use language for net-centric computing. Simplicity, object oriented features, a presence of threads and architecture independence are main reasons for the popularity of Java. Despite of the built-in threads in the language, the bare Java ..."
Abstract
-
Cited by 39 (2 self)
- Add to MetaCart
In recent past, Java has emerged as a powerful and an easy to use language for net-centric computing. Simplicity, object oriented features, a presence of threads and architecture independence are main reasons for the popularity of Java. Despite of the built-in threads in the language, the bare Java execution model does not support remote object invocations. RMI (Remote Method Invocation) is an interface specified by Sun Microsystems for the purpose of native Java-client and Java-server communication. Although, RMI is simple to use, it is not desirable in many applications due to its synchronous nature. In this paper, we describe ARMI (Asynchronous RMI), a mechanism which is built on top of RMI and allows concurrent execution of local and remote computations. This article presents the salient features and implementational details of ARMI. A few experiments performed with ARMI along with performance comparisons to RMI are also explained. Keywords: RMI, RPC, Asynchronous, ARMI, Client, Server, Stub, Skeleton, Mailbox. 1

