Ellie(ID:1549/ell003)

Distributed OO language 

• Country: dk
  • languages for dk
  • dk/1990
• Began: 1990
  • Languages for 1990
  • 1990s languages
  • Fifth generation
  • Post-Cold War
• Published: 1990
  • 1990
• Type:Prototyping
  • Prototyping
• Sammet:EXP
  • EXP
  • EXP/1990
  • EXP/dk

• Object

Andersen, Birger "Ellie Language Definition Report" view details Abstract: This report defines the parallel object-oriented language Ellie in details by means of informal definitions and examples. The syntax of Ellie is defined by a grammar. Ellie has been designed as a part of my Ph.D. thesis.The goals of Ellie are to achieve machine independent parallel programming and great language flexibility. Machine independent parallel programming is achieved by allowing the programmer to have a huge number of small processes for a virtual distributed memory parallel computer. If an actual distributed parallel computer can not execute the huge number of processes efficiently then a compiler can combine small processes hereby reducing the number of processes.Great language flexibility is achieved by allowing definitions of new types and control structures and by using a non-strict type system. Ellie is meant as an all-purpose programming language that has the flexibility of languages like Smalltalk and Lisp without losing efficiency in numerical calculations etc. DOI Extract: Ellie Objects
Ellie Objects
The object is the single abstraction mechanism for notions of names, data, functions, operations, blocks, control structures, and prototypes. All entities in Ellie are objects from characters and numbers to programs and databases.
An object can either be uninitialized, initializing, or initialized. An uninitialized object may only serve as a prototype for activation of new objects. Initializing and initialized objects may also serve as prototypes. An initializing object is active, i.e., it is initializing or changing its state; it is said to have a process. An initialized object may have had a process and is passive. An object consists of the following:
? A reference, which uniquely identifies the object.
? A representation, which consists of references to other objects.
? An optional interface, which allows other objects in possession of the reference to access the part of the representation defined by the interface; the part is said to be exported.
? An optional process, which is initiated when the object is activated.
The interface of an active object is usually closed, i.e., requests to access the representation are suspended. The interface will be opened when the object becomes inactive and any suspended request will be resumed. An activated object goes through the following phases:
1) It has just been activated. Optionally, it has a process executing that is changing the state of the object, i.e., the representation, and may change states of other objects known by references (the object is active and initializing itself).
2) Its process has terminated (or never existed) and the interface, if any, is opened (the object is passive and initialized). This means that the state now is only accessed and changed by the process of other objects.
3) The last reference to the object has ceased to exist and the object also ceases to exist.
If the representation may change over time then the object is said to be mutable. If the interface does not allow other objects to change the state (only read it), then the object becomes immutable in 2). Immutability simplifies sharing of objects in a distributed environment because immutable objects can be copied.
Parallelism exists beth between objects and within an object. If an object with a future process is activated then parallelism is generated because the process will execute in parallel with the process activating the object. If an object with a non-future process is activated then no parallelism is generated because the process activating the object is suspended, i.e., it will not execute again before the process of the activated object has terminated. Because objects through an interface may activate objects within another object and these objects can have future processes, the number of processes within an object has no limit.
Processes synchronize by opening and closing object interfaces. By using this powerful mechanism, other synchronization primitives may be defined, e.g., condition and semaphore objects.
Extract: Object Definition
Object Definition
An Ellie object is defined by means of an object constructor. Data accessible through the interface, private encapsulated data, input and output parameter, and the process for reading and modifying the state are defined by the object constructor.
The value of an object constructor is a reference to an uninitialized object with the properties defined by the constructor. For example,
[ function <: i :- integer :> i * i ]
defines an object that when passed an integer number as actual parameter in an activation returns the square of the number.
Four kinds of objects can be defined: Objects, future objects, express objects, and future express objects. The process of a normal object can not execute in parallel with the process of the object activating it, whereas the process of an future object can. The process of an express object is given higher execution priority by the processor than the process of a non-express object.
Furthermore, an object can be defined to be a function or an operation. An object defined to be a function must have a functional process, whereas an object defined to be an operation may have an operational process. If a process is operational, it is allowed to have side-effects when active. If a process is functional, it must not have any sideeffect. By side-effects we mean modification of states outside the object itself.
Extract: Object Activation
Object Activation
The only method for communication in Ellie is object activation. New objects are activated by using other objects as prototypes. As an example, let X, R, and S be existing objects where S is accessible by X through the interface of R, The object X may then activate a new object S' within R using S as a prototype. The process of S' may access (and possibly modify) the internal state of R. The object S' (and S) is called a super object of R. The object R is called the subobject of S" (and S). An object can only have one subobject but any number of super objects.
The relations in this example are shown in figure 1.

Figure 1: Object Relations
An object may activate an object within its subobject, sub-subobject, sub-sub-subobject, etc., or within one of its super objects by evaluating an Ellie expression, for example:
target.prototype parameter
The subobject (or super object) is referred to by the name target and an actual parameter by the name parameter. The name prototype refers to the object within target that is used as prototype for the activation. An object may also activate an object within a super object, referred to by the name super, of its subobject (or super object) by evaluating an expression of the following form:
target.super.prototype parameter
This is possible to any depth of super objects as long as the super objects can be accessed through the interface of their subobjects.
If the process of a new object is non-future then the activation is synchronous, i.e., the process of the object evaluating the Ellie expression is suspended. If it is a future process, the activation is asynchronous (a process is forked), i.e., the activating process is not suspended.
The object receives an input parameter in the activation and it returns an output parameter when its non-future process has terminated or immediately (before activation) in case of a future process. Input and output parameters are passed by object reference. The output parameter of a future process is returned as a future result object with an undefined state. Requests to access a future result object will be delayed until the future process has terminated and defined the state of the output parameter. Requests to activate a new future object with a future result object (or an object referenced in its interface) as a prototype will also be delayed but the new future result object will be returned immediately.

      in [SIGPLAN] SIGPLAN Notices 25(11) November 1990 view details

Abadi, Martin and Cardelli, Luca "A Theory of Objects" Springer Monographs in Computer Science, 1996 view details

      in SIGPLAN Notices 29(09) October 1997 (OOPSLA '94) view details