multimedia @ VU
The language DLP is a distributed object-oriented extension of Prolog [EliŽns (1992)]. It supports multiple inheritance,
non-logical instance variables and multi-threaded objects (to allow for distributed backtracking). Object methods are
collections of clauses. Method invocation is dealt with as communication by rendez-vous, for which synchronization
conditions may be specified in so-called accept statements. The current implementation of DLP is built on top of Java.
May be replaced by:
DLP is an extension of Prolog.
For clauses and goals it uses standard Prolog (Edinburgh) syntax.
In addition it provides a number of built-in primitives
to support objects that may have
so-called non-logical instance variables,
to record the state of an object.
There are explicit primitives to set or get the values
of these non-logical instance variables.
Also, the semantics of familiar operators like ==/2 and is/2
are extended to allow them to handle non-logical instance
variables, as well as plain Prolog logical variables and
Objects are defined by their non-logical variables and
a collection of clauses that act as the methods of an object.
A method call is simply the invocation of a goal, which is
resolved using the clauses defined for the object.
Encapsulation of the state of the object, as recorded
in the non-logical instance variables, is enforced by
allowing only clauses defined within the object to access
the non-logical instance variables.
that is objects may inherit collections of clauses from
multiple objects that are defined as their ancestor(s).
Objects in DLP are multithreaded.
Each object has a thread that executes the own activity
of the object, defined in the constructor for the object.
In addition for each method call a new thread is started.
The creation of a new thread is needed to allow
for independent backtracking when multiple methods are
activated. Mutual exclusion, that is protection against
other method calls, is guarantueed until the first answer
has been delivered to the caller.
This limited form of protection requires that any updates
of non-logical instance variables must take place
while producing the first answer.
DLP supports communication by rendez-vous.
The acceptance of a method call is determined by
a synchronization or accept statement in the
(active) body of the object, as defined in the
constructor of the object.
The accept statement allows for the unification
of argument parameters, as well as conditions
involving the state of the object.
DLP allows for truly distributed objects, that is
objects residing on different nodes in a computer network.
As the only language of its kind, it supports
distributed backtracking, the generation of (multiple) answers
in a sequential fashion
when backtracking occurs on the callers side.