Announcement: Obliq paper

[Luca Cardelli]

Obliq is a distributed scripting language. It is based on Modula-3
Network Objects, and was designed to be embedded in Modula-3
applications.

It has now evolved into a self-contained language, whose direct ties
to Modula-3 are limited to the network objects run-time, and to a
rich collection of libraries.

The following paper can be obtained via ftp; instructions are at
the bottom. The Obliq software distribution (matching the paper)
will be part Modula-3 v3.2. The current distribution of Modula-3
v3.1 includes a slightly older version of Obliq. All these are or
will be available from gatekeeper.pa.dec.com

Obliq: A Language with Distributed Scope

Luca Cardelli
Digital, Systems Research Center

Abstract

Obliq is a lexically-scoped untyped language that supports distributed
object-oriented computation. An Obliq computation may involve multiple
threads of control within an address space, multiple address spaces
on a machine, heterogeneous machines over a local network, and multiple

networks over the Internet. Objects are local to a site, while
computations
can roam over the network.

The most novel feature of Obliq is its combination of distributed
computation and lexical scoping. In lexically scoped languages, the
binding location of every identifier is determined by simple analysis
of the program text. Therefore, one can be sure of the meaning of
program identifiers, and can much more easily reason about the behavior

of programs. In a distributed language like Obliq, lexical scoping
assumes a further role. It ensures that computations have a precise
meaning even when they migrate over the network: a meaning that is
determined by the original binding location and network site of
identifiers,
and not by their execution sites.

Network-wide scoping becomes an issue in presence of higher-order
distributed computation, as in the situation of remote sites accepting
procedures for execution; the typical case being compute servers.
The question is what happens to the free identifiers of such
network-transmitted procedures. Obliq takes the view that such
identifiers
are bound to their original locations, as prescribed by lexical
scoping,
even when these locations belong to different network sites.

Distributed computation interacts well with the notion of objects.
For example, network services normally accept a variety of messages;
it is then natural to see each service as a network object (or, more
neutrally, as a network interface). Obliq supports objects in this
spirit, relying for its implementation on Modula-3's network objects.

The Obliq object primitives are designed to be simple and powerful;
a main trait of the language is the relation between local and
distributed
semantics of these primitives. Obliq objects are collections of named
fields, with four basic operations: selection/invocation,
update/override,
cloning, and delegation. Every object is potentially and transparently
a network object. An object may become accessible over the network
either by the mediation of a name server, or simply by being used
as the argument or result of a remote method.

In addition to the distribution of objects, the distribution of
computations
must be designed carefully. It is clearly desirable to be able transmit

agents for remote execution. However, in general, one should not
be satisfied with transmitting just the program text of such agents.
Program text cannot carry with it live connections to its originating
site, nor to any data or service at any other site. Hence the process
of transmitting program text over the network implies a complete
network disconnect from the currently running distributed computation.
In addition, unpredictable dynamic scoping results from transmitting
and then running program text containing free identifiers.

Obliq computations, in the form of procedures or methods, can be
freely transmitted over the network. Actual computations (i.e.
closures,
not source text) are transmitted; lexically scoped free identifiers
retain their bindings to the originating sites. Through these free
identifiers, migrating computations can maintain connections to objects

and locations residing at various sites. Disconnected agents can still
be represented as procedures with no free identifiers.

>From the point of view of a server executing a foreign agent, distributed
lexical scoping and strong run-time typing together provide a safety
and security guarantee. Namely, the foreign agent has access only
to the data that it carries with it via lexical bindings, or that
it explicitly receives in the form of parameters.

Contents

1. Introduction
1.1 Language Overview
1.2 Distributed Semantics
2. Local Objects
2.1 Objects and their Fields
2.2 Object Operations
2.3 Simple Examples
3. Remote Objects
3.1 State
3.2 Transmission
3.3 Distributed Computation
3.4 Self-inflicted Operations
3.5 Protected Objects
3.6 Serialized Objects
3.7 Name Servers
3.8 Execution Engines
4. Local Techniques
4.1 Recursion and Iteration
4.2 The Object-Oriented Numerals
4.3 The Prime Numbers Sieve
4.4 A Calculator
4.5 Surrogates
5. Distributed Techniques
5.1 A Serialized Queue
5.2 A Compute Server
5.3 Remote Agents
5.4 Agent Migration
5.5 Object Migration
6. Conclusions
6.1 Future Work
6.2 Acknowledgments
7. Syntax overview
A. Language Reference
A.1 Syntactic Structures
A.1.1 Identifiers
A.1.2 Definitions
A.1.3 Terms
A.1.4 Term Sequences
A.1.5 Built-In Operators
A.1.6 Operator Precedence
A.2 Data Structures
A.2.1 Value Identity
A.2.2 Constants
A.2.3 Operators
A.2.4 Arrays
A.2.5 Options
A.2.6 Objects
A.2.7 Protection and Serialization
A.2.8 Object and Engine Servers
A.3 Control Structures
A.3.1 Definitions
A.3.2 Assignment
A.3.3 Sequencing
A.3.4 Procedures
A.3.5 Conditionals
A.3.6 Case
A.3.7 Iteration
A.3.8 Concurrency
A.3.9 Exceptions
A.3.10 Errors
A.4 Methodology
A.4.1 Type Comments
A.5 Lexicon
A.6 Syntax
B. System Reference
B.1 The Executables
B.2 The Top-Level
B.3 Program Files
B.4 Modules
B.5 The Network Objects Daemon
B.6 Built-in Modules
B.6.1 Sys
B.6.2 Bool
B.6.3 Int
B.6.4 Real
B.6.5 Math
B.6.6 Ascii
B.6.7 Text
B.6.8 Array
B.6.9 Net
B.6.10 Thread
B.6.11 Rd
B.6.12 Wr
B.6.13 Pickle
B.6.14 Lex
B.6.15 Fmt
B.6.16 Process
B.6.17 Color
B.6.18 Form
C. Programming Reference
C.1 The Package Hierarchy
C.2 The Interfaces
C.3 The Libraries
C.4 Embedding Obliq
C.5 Extending Obliq
C.6 Extending Obliq with new Packages
C.7 Building a Customized Obliq Interpreter
References
Index

------------------------------------------------

ftp gatekeeper.pa.dec.com
anonymous
<your email address>
cd pub/DEC/SRC/personal/luca
binary
get ObliqPaper.ps.Z
quit

uncompress ObliqPaper.ps.Z

Print Obliq.ps on Apple or HP postscript printers, for best results.
Online postscript viewers do not necessarily work properly on this
file (although it is legal postscript).

Luca