This paper aims at providing confluence and determinism properties in concurrent processes, more specifically within the paradigm of object-oriented systems. Such results should allow one to program parallel and distributed applications that behave in a deterministic manner, even if they are distributed over local or wide area networks. For that purpose, an object calculus is proposed. Its key characteristics are asynchronous communications with futures, and sequential execution within each process. While

Distributed language features form an important part of modern objectoriented programming. In spite of their prominence in today's computing environments, the formal semantics of distributed primitives for object-oriented languages have not been well-understood, in contrast to their sequential part. This makes it difficult to perform rigorous analysis of their behaviour and develop formally founded safety methodologies. As a first step to rectify this situation, we present an operational semantics and typing system for a Java-like core language with primitives for distribution. The language captures the crucial but often hidden concerns involved in distributed objects, including object serialisation, dynamic class downloading and remote method invocation. We propose several invariant properties that describe important correctness conditions for distributed runtime behaviour. These invariants also play a fundamental role in establishing type safety, and help bound the design space for extensions to the language. The semantics of the language are constructed modularly, allowing straightforward extension, and this is exploited by adding primitives for direct code distribution to the language: thunk passing. Typing rules for the new primitives are developed using the invariants as an analysis tool, with type soundness ensuring that their inclusion does not violate safety guarantees.

Abstract. Existing web services and mashups exemplify the need for flexible construction of distributed applications. How to do so securely remains a topic of current research. We present TAPIDO, a programming model to address Trust and Authorization concerns via Provenance and Integrity in systems of Distributed Objects. Creation of TAPIDO objects requires (static) authorization checks and their communication provides fine-grain control of their embedded authorization effects. TAPIDO programs constrain such delegation of rights by using provenance information. A type-and-effect system with effect polymorphism provides static support for the programmer to reason about security policies. We illustrate the programming model and static analysis with example programs and policies. 1

This paper presents a Java-like core language with primitives for object-oriented distribution and explicit code mobility. We apply our formulation to prove the correctness of several optimisations for distributed programs. Our language captures crucial but often hidden aspects of distributed object-oriented programming, including object serialisation, dynamic class downloading and remote method invocation. It is defined in terms of an operational semantics that concisely models the behaviour of distributed programs using machinery from calculi of mobile processes. Type safety is established using invariant properties for distributed runtime configurations. We argue that primitives for explicit code mobility offer a programmer fine-grained control of type-safe code distribution, which is crucial for improving the performance and safety of distributed object-oriented applications.

Abstract- Real world objects can be classified into two kinds according to their behavior (1)autonomous objects (2)dependent objects. An object can behave both ways as well. Dependent objects are those objects which are of no use unless exploited by an external entity. Once they are created or instantiated, they keep waiting for the driver class to invoke theirs functions for their utilization. Example of dependent objects include a car, a calculator, a word processing application etc. Autonomous Objects are those objects which when created or instantiate, then they know by their self what they are supposed to do and then they readily start performing their task (set of methods) with possibly no external interaction or invocation. We emphasize that autonomy of object intuitively needs to have these two properties (1)Object runs its method(s) itself as soon as it is created. (2)More than one copy of object can be running simultaneously. Example of autonomous objects include a clock, a car set at cruise control, an Operating system kernel that always keeps active, a virus scan utility that always keeps active, Graphical Actors(simulation of humans) in game programming, an automatic robot, etc. We have established object calculus of autonomous object definition & object creation which incorporates the intuitive properties of autonomous objects as well. Our proposed calculus is based on the same structures as that of Abadi & Cardelli [1].