Ambient-Oriented Programming

In AmbientTalk, objects are not instantiated from classes. Rather, they are either created ex-nihilo or by cloning and adapting existing objects, in the spirit of prototype-based programming such as in the SELF programming language. The definition of a prototypical object contains a number of fields and methods that represent the object's state and behaviour respectively.

The following code illustrates the ex-nihilo creation of an object:

def Point := object: { 
  def x := 0;
  def y := 0;
  def init(aX,aY) {
    x := aX;
    y := aY;
  };
  def sumOfSquares() { x*x + y*y };
}

The above code defines an ex-nihilo created point object and binds it to the variable Point. The object itself does not carry a name (i.e. it is “anonymous”). Like all definitions in AmbientTalk, fields and methods are defined using the def keyword. Fields are defined using a def name := value syntax while methods are defined using a def name(parameters) {body} syntax.

In the example above, the state of the point object is composed of x and y fields while its behaviour corresponds to the init and sumOfSquares methods.

In AmbientTalk, computation is expressed in terms of objects sending messages to one another. Messages are used to invoke the fields and methods of the objects.

> Point.x
>>0
> Point.sumOfSquares()
>>0

This code shows two messages sent to the point object defined above. The x message acts as an accessor for the x field. The sumOfSquares message looks up the sumOfSquares method in the object and applies it.

Note that the “prototypical” point object defined above can act as a stand-alone object. This is different from a class in a class-based language, which often requires the use of static fields or methods to be used stand-alone.

As noted above, AmbientTalk objects are created ex-nihilo or by cloning and adapting an existing object. The code below shows the instatiation of a new point object by instantiating the Point prototype:

def anotherPoint := Point.new(2,3)

Every object understands the message new, which creates a clone (a shallow copy) of the receiver object and initializes the clone by invoking its init method with the arguments that were passed to new (aX and aY in the example code). Hence, the init method plays the role of “constructor” for AmbientTalk objects. In the above code, anotherPoint shares its methods with its Point prototype, but it has its own set of fields:

> anotherPoint.x
>> 2
> Point.x
>> 0
> anotherPoint.x := 3
>> nil
> Point.x
>> 0

AmbientTalk also provides a clone: construct which only creates a clone of the receiver object without calling the init method ¹⁾.

def clonedPoint := clone: Point
> clonedPoint.x
>> 0
> clonedPoint.x := 2
>> nil
> Point.x
>> 0

In order to support code reuse and modular extensions between objects, AmbientTalk features delegation (also known as object-based inheritance). By means of delegation, an object can reuse and extend the fields and methods of another object by establishing a so-called “parent-child” or “delegate-delegator” relationship.

Delegation implies that, if a message is sent to an object, but that object has no definition for the message's selector, then the message is delegated to a designated object (often called the parent or delegate). What is important to note here is that “delegating” a message is not the same as simply “forwarding” the message to the other object: delegating a message leaves the self pseudovariable unchanged to the original receiver of the message.

AmbientTalk distinguishes between two kinds of delegation relationships,IS-A and SHARES-A, each denoting a different kind of object extension (the difference between both is explained below).

An IS-A delegation relationship between two objects signifies that the child object “is-a” kind of parent object, with the implicit assumption that such a child object cannot exist without its parent. As an example, consider the following code (don't worry about the meaning of ^ yet):

def Point3D := extend: Point with: {
  def z := 0;
  def sumOfSquares() {
    super^sumOfSquares() + z*z
  };
}

In this example, Point3D delegates any message it does not understand to Point. The extend:with: construct creates a new object whose super slot is automatically set to the given parent object. The delegation relationship is IS-A because a Point3D is a kind of 2D Point, and a z coordinate (conceptually) cannot exist without a corresponding x and y coordinate.

A SHARES-A relationship between two objects signifies that an object only delegates to another object purely for reasons of code sharing. The delegation link has no other semantics, and conceptually both parent and child can exist without one another.

The following code shows how to extend objects with a SHARES-A delegation relationship. It uses the share: with: language construct.

def Collection := share: Enumerable with: {
  def elements := [];
  ...
}

In this code example, the Collection object delegates to Enumerable simply for inheriting useful methods such as inject: or collect: which are of general use to a collection object.

The IS-A and SHARES-A delegation relationships differ in their semantics for cloning child objects. Whereas cloning an IS-A child also clones its parent, a SHARES-A child shares its parent object with the clonee (see the figure below).

This cloning semantics reinforces the semantics of IS-A as promoting a unique link between a parent and a child object. IS-A delegation most closely corresponds to class-based inheritance.

The parent of an object is bound to a field named super. The delegation chain defined by an object and its parent (or chain of parents) determines the scope in which the message is looked up. As any field in AmbientTalk objects, the super field can be dynamically modified.

> def openConnection := object: {...};
> def closedConnection := object: {...};
> def connection := object: {
    def open() {
      super := openConnection.new();
    };
    def close() {
      super := closedConnection.new();
    };
  }

AmbientTalk provides an explicit delegation operator ^ (the “caret” or “hat” symbol). The code below illustrates the use of the ^ operator in the implementation of the init method of the point3D object.

> def point3D := extend: point with: {
    def z := 0;
    def init(aX, aY, aZ) {
      super^init(aX, aY);
      z := aZ;
    };
  }

A message sent to an object using the ^ symbol (e.g. to the parent object in the example above) will start the method lookup in this object (and its parents) and then execute the method body in the lexical scope of the message sender (self is bound to the message sender).

In AmbientTalk, all fields and methods are “public” via selection. Still, a field or method can be made “private” by means of lexical scoping. The following code shows the definition of an object inside the definition of a function. The fields and methods of this object cannot be accessed directly from outside the funuction.

> def makeObject(hidden) {
    object: {
      def foo() { /* use hidden */ }
    }
  }

Due to the encapsulation of this object the following instruction fails:

> makeObject(5).hidden;
>>Lookup failure : selector hidden could not be found in 
  <object:5068254>