An object-oriented programming language for distributed systems: Heraklit
Authors: Hindel B. 
Published: November 2005

The increasing complexity of technical processes asks for large software systems to control them. A large software system can only be developed and managed if there are efficient and reliable tools.
This paper gives an introduction to the high level programming language HERAKLIT, which claims to be such a tool. HERAKLIT is a general purpose object oriented programming language with a hierarchic type concept. It is designed for efficient development and maintenance of software for distributed systems. Some ideas of SIMULA, CLU and SMALLTALK are combined in HERAKLIT. The syntax of HERAKLIT is close to MODULA-2. A special feature of HERAKLIT is the ability to exchange modules (objects) at runtime without stopping the entire program.
A HERAKLIT object can be used for data and program abstraction. An object can contain data entries and algorithms that allow to refer and alter these entries. The data entries and algorithms of an object are both called its components. We distinguish public and private components. Private components are only for object internal representations and duties, while the public components can also be used by other objects.
In addition to the components an object can also have an algorithm whose execution is called the object activity. An object can be activated by a synchronous or asynchronous object call. A synchronous object call (remote procedure call) blocks the activity of the caller until the activity of the called object is finished. An asynchronous object call leads to independent activities of the caller and the called object. Each call starts by checking the execution conditions, which are part of any algorithm. There are three kinds of execution conditions: Non blocking condition, non compatible condition and priority.
Each object belongs to a type. The type of an object determines the number and kind of the object components, the object activity and its execution conditions. A type is defined by its type interface and type body. The type interface describes the public components. The type body contains the private components, the description of the object activity and the execution conditions.
The following relation on the set of all types defines a hierarchy on them: A type T1 is a subtype of T2, if the set of the public components of T2 is a subset of the set of the public components of T1.

The type
ANY
stands on top of the hierarchy. Its public components are object assignment and identifier binding. These are the only operations for objects of type
ANY
. Identifier binding is a statement like
x:-y
. Its execution causes the identifier
x
to refer to the same object as
y
. An object assignment is a statement like
x:=y
. Its execution creates a copy of the object referred by y and binds
x
to it.

The keyword
SUBTYPE
allows to construct subtypes of already defined types. Example 1 shows
robottype 1
declared as a subtype of
ANY
. The new type inherits identifier binding and object assignment from
ANY
and has
moveleft
and
moveright
as additional components. The keyword
REF
says that the following components are only identifiers (without initial object) able to refer to an object of the given type. The meaning of
METHOD
is similar to that of
PROCEDURE
in Modula-2.