# 1 Introduction

Fueled by the explosive development of the Internet, distributed programming is becoming more and more popular. The Internet provides the first steps towards a global infrastructure for distributed applications: a global namespace (URLs) and a global communications protocol (TCP/IP). Both platforms based on the Java language and on the CORBA standard take advantage of this infrastructure and have become widely-used. On first glance, one might think that distributed programming has become a solved problem. But this is far from the case. Writing efficient, open, and robust distributed applications remains much harder than writing centralized applications. Making them secure increases the difficulty by another quantum leap. The abstractions offered by Java and CORBA, for example the notion of distributed object, provide only rudimentary help. The programmer must still keep distribution and fault-tolerance strongly in mind.

The Mozart platform is the result of three years of research into distributed programming and ten years of research into concurrent constraint programming. The driving goal is to separate the fundamental aspects of programming a distributed system: application functionality, distribution structure, fault tolerance, security, and open computing.

The current Mozart release completely separates application functionality from distribution structure, and provides primitives for fault-tolerance, open computing, and partial support for security. Current research is focused on completing the separation for fault tolerance and open computing, which will be offered in upcoming releases. Future research will focus on security and other issues.

This tutorial presents many examples of practical programs and techniques of distributed programming and fault-tolerant programming. The tutorial also gives many examples of useful abstractions, such as cached objects, stationary objects, fault-tolerant stationary objects, mobile agents, and fault-tolerant mobile agents, and shows how easy it is to develop new abstractions in the Mozart platform.

Essentially all the distribution abilities of Mozart are given by four modules:

- The module `Connection` provides the basic mechanism (known as tickets) for active applications to connect with each other.

- The module `Remote` allows an active application to create a new site (local or remote operating system process) and connect with it. The site may be on the same machine or a remote machine.

- The module `Pickle` allows an application to store and retrieve arbitrary stateless data from files and URLs.

- The module `DP` gives the basic primitives for configuring the distribution of entities, and fault detection and handling.

The first three modules, `Connection`, `Remote`, and `Pickle`, are extremely simple to use. In each case, there are just a few basic operations. For example, `Connection` has just two basic operations: offering a ticket and taking a ticket.

The fourth module, `DP`, is the base on which fault-tolerant abstractions are built. The current module provides complete fault-detection ability for both site and network failures and has hooks that allow to build efficient fault-tolerant abstractions within the Oz language. The underlying model of that module is a both simplified and improved version of the former module `Fault`.

This tutorial gives an informal but precise specification of both the distribution model and the failure model. The tutorial carefully indicates where the current release is incomplete with respect to the specification (this is called a limitation) or has a different behavior (this is called a modification). All limitations and modifications are explained where they occur and they are also listed together at the end of the tutorial (see Chapter 6).

We say two or more applications are connected if they share a reference to a language entity that allows them to exchange information. For example, let Application 1 and Application 2 reference the same object. Then either application can call the object. All low-level data transfer between the two applications is automatic; from the viewpoint of the system, it's just one big concurrent program where one object is being called from more than one thread. There is never any explicit message passing or encoding of data.

The Mozart platform provides much functionality in addition to distribution. It provides an interactive development environment with incremental compiler, many tools including a browser, debugger, and parser-generator, a C++ interface for developing dynamically-linked libraries, and state-of-the-art constraint and logic programming support. We refer the reader to the other tutorials and the extensive system documentation.