The concept of distributed logic programming
Distributed logic programming (DLP)
may be characterized by the pseudo-equation
[] DLP = LP + OO +
stating that distributed logic programming
combines logic programming (LP),
object oriented programming (OO) and
parallelism ().
\nop{
The nature of the features supported by DLP will be introduced in the next section
and further explained in chapter \ref{des/ext}.
Here a brief characterization will be given of the distinct paradigms
of computing that form the foundation of DLP.
}
Logic Programming
has originally been used only in the context of Artificial Intelligence.
Its most popular representative is Prolog.
Because of its logical basis it allows to solve problems in a declarative way,
that is by providing a logical description of the problem to be solved. See [Ko79], [Bratko].
However, usually such specifications must be refined to become
efficiently executable. C.f. [Ho87].
Prolog is a very suitable language for prototyping small systems.
In software engineering practice, logic programming and in particular Prolog
has been recognized as a potential aid in requirements engineering and design specification.
See [Webster].
Object Oriented Programming
has rapidly grown into a popular paradigm for developing complex systems.
Objects integrate data and methods that operate on these data
in a protected way.
This allows to organize a program as a collection of objects,
representing the conceptual
structure of the problem.
Part of the popularity of object oriented languages
is due to the
facilities for code sharing as offered by
the inheritance mechanism. See [We87].
Object oriented programming allows to model problems in a very natural way.
Its major promise for software engineering practice is in my opinion that it
offers the opportunity of a close link between the various phases of the
software life cycle, the engineering of requirements in the analysis phase and
the design and implementation phases. C.f. [WWW90], [Meyer88].
Parallelism
is somehow of independent interest.
Most of the developments in parallel logic programming
are based on exploiting the parallelism inherent in the
computation model of logic programming languages.
Parallelism in DLP is achieved by extending the notion of object
to that of a process,
in a similar fashion as the approach taken for POOL [Am87].
DLP, however, also supports multi-threaded objects,
that have autonomous activity and may simultaneously evaluate method calls.
As [Booch86] observes, objects provide a natural way to introduce concurrency,
by associating (possibly multiple) processes with objects.
Despite the fact that parallelism is often inherently part of the problem domain,
not many design specification formalisms support concurrency. See [Webster].
A design goal in developing DLP was to provide a syntactically
elegant language with a clear semantics that allows to express
the conceptual structure of a program in a straightforward way
and that may serve as a vehicle for prototyping.
The next section summarizes the main ingredients of the language DLP.
Readers not familiar with the language Prolog may wish to consult section \ref{des:lp}
first.