DejaVu
A Distributed Hypermedia Application Framework
A. Eliëns
Vrije Universiteit,
Department of Mathematics and Computer Science
De Boelelaan 1081, 1081 HV Amsterdam
The Netherlands
email: eliens@cs.vu.nl
slide: DejaVu - A Distributed Hypermedia Application Framework
Abstract
The project DejaVu aims at providing a framework for the development of
open heterogeneous distributed object oriented intelligent hypermedia systems.
It serves as a vehicle for research in hypermedia systems,
object oriented programming, distributed logic programming,
intelligent information systems and software engineering.
The DejaVu framework has a number of innovative features.
First of all, we propose to employ inferential links
as a means to traverse information stored in documents.
Inferential links allow navigation on the basis
of contextual knowledge.
Such inferential links may be defined declaratively,
in a rule-based way.
The support for these links is provided by what we consider another
innovative feature of our framework,
a software platform that combines a low-level system implementation
language (Active C++) and a high level logic-based distributed language
DLP in what we call 'linguistic symbiosis'.
An essential part of the (multi-lingual) environment is the
hush (hyper utility shell) library based on Tcl/Tk,
which enables the programmer to integrate (Tcl) script-based applications
with C++ and DLP.
To enable both the user and the developer
of a hypermedia application to employ a script-like language to control
the system, the framework provides an extendible hypermedia command language
that offers the functionality needed to develop and tailor
the user interface and contents of hypermedia systems.
One of our research goals is to arrive at a declarative
specification formalism that provides for both a high-level
definition of the functionality of an application
as well as support for the verification of
invariance and consistency assertions.
As part of the project we will develop some hypermedia applications
to establish the validity of our approach.
Further we intend to undertake a number of theoretical studies addressing
the foundational and semantic issues involved.
Keywords:
hypermedia systems,
object oriented programming,
visual languages,
distributed logic programming,
intelligent information systems,
inferential links,
rule-based information processing,
declarative specifications,
hypermedia command languages,
meta programming
Introduction
With an increasing growth of information, hypermedia
will become more and more important.
Hypermedia must be regarded as a merge between multimedia and hypertext.
Multimedia capture the need of displaying information in a
non-textual form, such as graphics, sound or video animation.
Hypertext technology provides associative information storage and retrieval
by means of machine supported links between pieces of information.
Combined, multimedia and hypertext offer a very powerful technology
for information management, that we call hypermedia.
In order to deal with the mass of information involved, the integration
of expert system technology and hypermedia has been proposed [Parsay et al, 1989].
With reference to our earlier work on distributed logic programming [Eliëns, 1992],
we wish to explore this development towards distributed logic-based hypermedia,
supporting knowledge-based information storage and retrieval.
Hypermedia applications
range from computer-based training,
technical documentation and online encyclopedias to
interactive help systems and information systems that aid
in decision making, as for instance on the occurrence of environmental
disaster.
As prospective business applications one may think of
product catalogs, blueprints and bulletin boards for advertisement.
Electronic publishing is also likely to grow more important.
Another interesting application area of hypermedia technology
lies in the software engineering of complex systems.
Hypermedia may provide the support to monitor the behavior of
a distributed program by means of animation techniques.
Visual programming formalisms (like some CASE tools offer)
may be naturally embedded in a hypermedia environment.
See [Bigelow, 1988], [Meyer, 1990] and [Raeder, 1985].
One of the major challenges of hypermedia systems is to support connectivity,
that is to allow the integration of heterogeneous systems
and to provide the support for a compatible, homogeneous user interface.
We expect that knowledge-based information handling and display
will provide the support for such systems, as an example of which one may
think of future office information systems.
Project aims
The DejaVu project aims at providing a framework for the development
of open, heterogeneous distributed object oriented intelligent hypermedia systems.
The phrase open means here that the framework offered must be extendible
by a user to make it fit his or her own needs.
By heterogeneous is meant that the framework must support the development
of systems consisting of multiple, loosely coupled, components.
Similarly, the framework must support the development of distributed
systems, that are intended to run on a network of computers.
The phrase object oriented clearly reflects a choice for a
particular approach to software development, that is known as object oriented
programming.
Finally, the adjective intelligent indicates our intention
to provide logic-based retrieval and navigation capabilities,
alike those proposed for intelligent information systems.
Our aim is to provide a framework that integrates distributed logic programming
with hypermedia technology, to support the development of distributed knowledge-based
hypermedia systems.
The starting point of our project will be to extend the distributed logic
programming language DLP, as described in [Eliëns, 1992], with hypermedia facilities
and a suitable programming environment.
Since our own expertise lies primarily in software engineering,
computer systems and programming languages,
we will focus our research initially to the development of hypermedia
technology to support
the construction and maintenance of complex software systems.
The description of the background and motivations of the project is written from
this perspective.
It is, however, explicitly not our intention to restrict ourselves
to this application area.
On the contrary, we will look for opportunities to explore other application
areas as well, such as for example environmental monitoring and computer-based training
systems.
In this initial phase, however, the inlooking nature of
our approach seems unavoidable. Cf. [Graham, 1991].
Software engineering
The DejaVu project is meant to serve as a vehicle for
research in hypermedia systems, software reuse,
object oriented programming, distributed logic programming and
intelligent information systems.
Along with the actual realization of the framework we hope that valid insights and
guidelines will emerge, that will contribute to the software engineering theory
concerning heterogeneous distributed hypermedia systems.
Also we expect to have (scientifically valid) spinoff from our accompanying theoretical studies
of the areas mentioned.
DejaVu: background and motivation
Software systems grow increasingly larger and complex, to the extent that
they become unmanageable and a large prize has to be paid for their maintenance.
With respect to program development
there are a number of issues of complexity and size that are specific for
heterogeneous and distributed systems.
However, also on a smaller scale the problem of managing the complexity of a
system and the software development process is not so easily solved as well.
Usually a variety of methods and tools is needed in order to construct
a system and to understand the functionality that it offers.
In the following section we will explore what support hypermedia offers for the development
of complex, heterogeneous distributed systems.
Then we will discuss some of the problems that occur with heterogeneous systems,
and the requirements that are imposed on the environment in which such systems
may be developed.
We will conclude the discussion of the motivation underlying our efforts
with a brief sketch of our earlier work and why we think it is of relevance
in developing a distributed hypermedia application framework.
Distributed hypermedia
Hypermedia technology is increasingly used in programming environments
(such as those found on personal computers).
It is applied to support program development ,
to provide online associative documentation ,
to build multimedia user interfaces ,
to provide the tools for visual programming ,
and to create intelligent information systems that support
computer-based training and the animated display of complex information.
Program development support
For personal computers one can clearly discern
a trend towards
integrated programming environments
that allow the user the simultaneous inspection of source code, dynamic behavior
and supplementary documentation.
Obviously, similar facilities are needed when developing large
heterogeneous distributed systems.
For these systems, however, the integration techniques as used
for personal computers do not apply.
To effect the cooperative behavior of tools one must proceed
from the assumption that not only the source code but also the tools
themselves may be distributed, where, in opposition, tool-integration
on personal computers is often patched into a single executable.
A tool-environment is needed that is adapted to the
intrinsically distributed nature of multimedia systems.
Characteristic for such an environment is the cooperation of tools
by means of explicit protocols of communication and the exchange of
information.
Associative online documentation
An essential ingredient of such an environment is a
(distributed) hypermedia-based online information retrieval
and documentation system that may be used for browsing, annotation
and documentation, both in text and graphic formats and possibly
also in audio and video formats.
Multimedia User Interfaces
Many workstations and personal computers
(for those willing to pay for it) provide multimedia
facilities, including sound and the display
of video signals.
Applications in such environments naturally wish to
to profit from the capabilities offered by these
systems to provide a more appealing interface.
As an example, an online encyclopedia
may include sound examples and (video-based)
animation to give better explanations.
For some applications, such as computer music
systems or 'virtual museums' multimedia
intrinsically belong to the application area.
For many other applications however, multimedia
capabilities provide the opportunity to create
a lively tutorial or demonstration for that applications.
Such computer-based tutorials and demonstrations
will definitely contribute to the acceptance of
that particular application
by a larger (non-specialist) user community.
Intelligent information systems
Information can become arbitrarily complex.
Having stored the information in a computer
does not reduce complexity in itself.
However, tools may be developed to manage
this complexity.
Hypertext technology (that we will also refer to as hypertechnology)
allows to connect pieces of information by means
of associative links that enable a focussed retrieval
of this information.
Hypertechnology supports
structural links between pieces of information,
but also accidental links that are added by the
user for the purpose of navigation and selection.
As an example, in a software documentation system
there must exist links between the requirements
specification and the documents describing
the design and implementation.
To be useful in the development of a software
system, it must be possible to add annotations
and temporary links connecting the relevant
pieces of information, relevant with respect
to a particular problem.
A key issue in the development of intelligent
information systems is to allow the user
to view the information in accordance with his
or her needs and to focus rapidly into
the relevant areas.
Such systems must hence support functionally
powerful links between information
and personal annotations to determine the selection
of material, closely coupled with an interface
that allows associative navigation through the
information stored.
Heterogeneous systems
Given the availability of wide and small area networks,
many of the current systems (such as for instance systems for command and control,
environmental monitoring systems) must be characterized as
heterogeneous and distributed.
For a variety of reasons the (re)design of these systems will only be
partial and incremental,
and hence the original question of how to manage these systems narrows down
to the question of what technology is needed to partition a system in
suitable components and to integrate these components.
Glueing
With regard to the question of how to glue more or less heterogeneous
components together opinions may differ whether such support must be given by
an underlying operating system or whether the programming language
must provide the necessary constructs.
The disadvantage of the former approach clearly is its ad hoc nature.
Extending a programming language (and we assume to have an object oriented
language) has as an advantage that the transition from an object oriented model
of the domain to an implementation may be more easily made.
Since in our opinion the modeling perspective must be regarded as
essential in the object oriented approach, the benefit of modeling
outweights the disadvantage that the required functionality is
harder to obtain in a consistent fashion.
When relying on the operating system, obtaining the required functionality is
not the problem but dealing with it is much more difficult.
Encapsulation
Recently, the object oriented paradigm has been proposed as a means
to handle the complexity of large systems and to structure the
software development process.
Assuming that object orientedness indeed provides a solution
to the problems incurred by the size and complexity of
current systems, we may start to re-design and re-implement
these systems.
However, in practice a complete re-design is most often regarded as infeasible
due the the size of the existing software (which may run into million lines of code),
limitations on the budget or the absence of qualified people.
Instead, a considerable effort is put into maintenance
and only the components requiring new functionality are redesigned
and glued back into the old software.
Obviously, the notion of encapsulation , which may be regarded as one
of the basic ingredients of an object oriented approach, is of relevance here.
Encapsulation provides the means to hide implementation details
to the extent that the functionality of a component may be addressed solely
by means of a well-defined interface, regardless of the size of the component
or the resources needed to perform its function.
Reuse
Apart from budget limitations, there may be other reasons
not to re-implement existing systems or parts thereof.
For instance when a component is used by different groups
it may be impossible to decide how to satisfy all these groups.
Or even there may be an explicit intention to reuse the available
software resources.
This applies in particular to systems that are explicitly designed
as a heterogeneous collection of components.
A fortiori this holds for hypermedia applications.
Object oriented modeling
Having enumerated the diverse problems, their underlying assumptions
and the direction toward their solution, there remains one issue that
must be treated in somewhat more depth.
We have stated that an object oriented approach supports
the glueing technology required to deal with heterogeneous software
but we have not stated what glue we need or prefer.
Two requirements have to be dealt with in this respect.
First of all it is necessary to provide the low level mechanisms
that enable to connect a variety of software and/or hardware
components.
Secondly, we must provide the means to model the constituent
entities and actors in the application domain
in a natural way.
Active objects
A basic assumption here, and from the perspective of distributed systems
a necessary presupposition, is that at least part of these entities
and actors behave intrinsically concurrent.
The extent that this parallel behavior must be directly visible
in the model and the program depends on the application.
Nevertheless, we feel that we must provide the means
to model parallel activity in a form that is compatible with
the modeling facilities offered by the object oriented paradigm.
The opportunity to control dynamically the interface of an active object,
that is its willingness to engage in a rendez-vous, counts in this respect
as an argument in favor of our approach.
In order to deal with the low level aspects of the system we will spend
effort to augment the object oriented systems programming language with features
that support parallelism and distribution.
We have coined the name Active C++ for this effort [Eliëns and Visser, 1992].
Specification
In addition to a systems implementation language, we wish to provide
a high level language that enables to specify the functionality of a system
in a rule-based manner, so that our understanding of the behavior of
a system can rely to a large extent on the logical, declarative semantics
of its specification.
This effort will be based on the distributed logic programming language
DLP, that we have developed previously.
DLP as it is, provides apart from a logic-based formalism (Prolog),
features such as encapsulation and inheritance.
However, we also studied how to augment DLP with reflective
capabilities that allow to specify the dynamic semantics
(with regard to parallelism and distribution)
of the language constructs in a more application oriented way [Eliëns, 1992b].
Applications
To allow an easy transition from a high level (executable) specification
to an efficient implementation in the systems programming language,
both language must be highly integrated.
Program animation and visualization support must exist on both levels.
To realize this goal we will reimplement DLP in Active C++.
Other components of our framework that require an implementation will be realized
in DLP and Active C++.
Since our framework is designed to be open we envision that on top of
DLP we may (easily) implement application oriented languages, object oriented reasoning systems and
specification formalisms for conceptual modeling.
To this end we wish to provide the tools that support the specification
of the syntax and semantics of such language formalisms in a way that fits
within the object based approach as sketched.
Integration
The use of CASE tools in the area of distributed systems is relatively unexplored, and the potential
of (object oriented) CASE tools for heterogeneous distributed hypermedia systems needs to be investigated.
An important problem we have is how to integrate the variety of tools needed
for the actual construction and maintenance of hypermedia applications,
such as debugging and monitoring tools.
Tool integration
To solve the problem of tool integration
we have a trade-off between support in the programming language
enabling to monitor and analyze the behavior of a program
and facilities provided by the tool-environment allowing
the inspection of the dynamic execution of a (distributed) program.
To our mind, the mechanisms that enable the cooperation, that is the synchronization
and communication between tools, must be embedded in the tool-environment.
However, the information required by the tools to perform these monitoring tasks
must be provided by the program(s), either explicitly programmed by the programmer
or compiled into the executable(s) by a smart compiler. See [Reiss, 1990b] and [Stasko, 1990].
An interesting area of research in this respect has evolved around
the meta-programming facilities and reflective capabilities offered
by a number of current object oriented languages. See for example [London and Duisberg, 1985].
Interaction
Not only from the perspective of tool integration is
a formalism which allows to express the interaction of objects
of interest but also (scientifically and practically) as a means to
impose additional structure on a collection of objects,
in addition to the structure imposed by the client-server and inheritance
(or subtyping) relations.
A challenge in this area is to augment the communication mechanisms employed
by a reasoning component to allow for an intelligent interaction
and cooperation of objects.
This research aims at providing a formalism for what is called interaction oriented
programming. See [Helm et al, 1990].
Application framework
To conclude our motivational remarks, our aims are
to develop a framework
(that we have named DejaVu) to assist the development of distributed hypermedia
applications.
Environment
The DejaVu framework advocates
in essence a multi-lingual approach
to the development of complex software systems.
To our mind, no single language
(including Lisp, C/C++, Prolog) is fit
to be used for any application in a natural way.
Rather, for specific domains (such as reasoning,
numerical computation, and so forth)
developers seem to have a strong preference for
a particular language.
Besides, a uni-lingual approach may easily lead
to large monolithic systems.
Our approach, instead, supports the
development of component-based (distributed) systems.
By providing adequate glueing technology
we intent to encourage the reuse of
building-block components.
Consequently,
the framework must support the encapsulation and reuse of
existing software.
Also it must provide the tools for monitoring heterogeneous
distributed systems by means of program animation and visualization.
And, it must support the creation and use of online associative documentation.
The approach supported by the DejaVu framework is motivated
by the desire to provide
a specification formalism as well as
an implementation platform that may be considered
natural for a particular application.
Hence,
we will provide an implementation platform
that supports both a concurrent distributed object oriented
systems implementation language (Active C++) to deal with the
low level aspects and a very high level
(object oriented) distributed logic programming language (DLP)
that enables to model complex systems in a logic based way.
In addition, the environment will provide a collection
of pre-defined objects for the rapid development
of graphical user interfaces.
The implementation platform is primarily meant
to implement basic (reusable) components
that are needed to construct
hypermedia systems.
To enable the actual construction of a hypermedia system,
we will provide a high-level hypermedia command language
that may be used both for the specification
of a hypermedia system and for
adapting an existing system (developed within the framework)
to more specific needs.
Our preference for a hypermedia command language,
in addition to the functionality provided
by the implementation platform,
is motivated by the observation that the actual
development of hypermedia systems is mostly
done by non-programmers.
For that reason also,
we intent to provide an application oriented
language specification formalism that
supports the specification of dedicated
languages for specific application areas
in a convenient way.
Research goals
Having sketched the outline of our project
it is worth reflecting on how such a framework may be realized.
In the next section we will discuss hypermedia research goals
from a more thematic perspective,
here we will restrict ourselves to discussing the pragmatics
underlying our proposal.
A first observation that must be made
is that currently a number of research groups are working
on one or more of the topics mentioned.
Some research groups work on rather specific topics
such as the development of
a programming environment [Reiss, 1990b],
or tools for the construction of graphic user interfaces
[Linton et al, 1989], [Ousterhout, 1991].
Other groups cover a larger parts of the area,
for example [Weinand et al, 1988] aim at providing an environment to some extent
similar to ours. Another example of a wide-spectrum project
is the project referred to in [Nierstrasz et al, 1992].
Our approach differs from the latter in that we wish to
employ tools that are already available as much as
possible.
There seems to be no need to develop new tools
when these are already there, waiting to be used.
In other words, our intention is
to provide the means to integrate existing tools
in our framework and to employ these tools for
its development.
From this perspective the name of our project
reflects our wish to reuse the products
of research already done.
The second observation is that our project
actually consists of a number of more or less well-delineated
subprojects.
These subprojects are well-delineated in the sense
that the research involved may proceed to
a large extent independently of the other subprojects.
The reason to incorporate the various subprojects
in a common framework is that we feel that these
(sub)projects will mutually benefit from the work done
in the other (sub)projects.
That is to say, to our mind, the (sub)projects are more clearly
defined when regarded from the common background set
by the goal of developing a distributed (intelligent)
hypermedia application framework.
A third observation is that, as a matter of fact,
our research proposal is (partly) based
on our previous research.
In particular, where it concerns the development
of a high level (logic-based) prototyping and
modeling environment, we may
lean on our previous efforts in developing
the distributed
logic programming language DLP,
and devote our attention to applying this language
in a hypermedia context.
Concluding, taking these observations into account,
we feel that we have a sufficient basis to endeavor
in the development of a hypermedia framework along the
lines sketched.
Hypermedia research goals
In the last decade we were able to witness a rapid
growth in hypertext and hypermedia research.
This has resulted in a number of systems,
eg. KMS [Akscyn et al, 1988], Intermedia [Meyrowitz, 1986], Notecards [Halasz, 1988].
An overview of these systems and a more general
introduction to hypertext is given in [Conklin, 1987].
See also [Shneiderman and Kearsley, 1989] and [Akscyn, 1990].
The idea of hypertext dates back almost half
a century. See for example [Nyce and Kahn, 1991] for the historic
background.
Reflecting on the development of Notecards,
[Halasz, 1988] lists a number of research issues that
were not adequately addressed by the systems
existing at that moment.
These research issues concerned both the
architecture and design model of hypertext
systems as well as user aspects and authoring issues.
In a follow-up speech [Halasz, 1991], discusses the
dilemma's faced by hypertext/hypermedia development
groups, dilemma's with respect to the functionality embodied
in documents and links,
and dilemma's with respect to the generality
and functionality of retrieval and navigation mechanisms.
Most of the dilemma's sketched may be regarded
from an architectural perspective,
in that they may be translated into a preference
for a particular architectural solution.
In the following section we will examine a number of these
issues.
Link varieties
Basically, hypertext is just a collection of nodes
(documents) and links (expressing relations between documents).
Evidently, for hypermedia, documents may take a number
of forms. Less evident is that links may exist
in a number of ways.
In this section we will more closely
examine the nature of links.
We will discuss the way
links may impose structure on a hyperdocument,
by what means we may represent links,
how to employ knowledge-based processing
to support 'inferential links',
and finally we will discuss the pros and cons
of intrinsic versus extrinsic links.
Referential versus structural links.
Currently, there is a lively debate
in the hypertext community whether to support the means
to deal with structured collections of documents
in addition to the traditional referential links
that represent arbitrary associations
between documents.
To our mind, there are strong arguments in favor
of supporting structural links as a means
of representing the hierarchic structure of a compound
document.
Structural links are essential to produce
a linearized version of a hyperdocument.
Moreover, structural links allow for user defined
semantic checks,
whereas referential links are by nature
arbitrary.
Implicit versus explicit links.
Another question with respect to the architecture
of hypermedia systems is whether links
between documents must be represented explicitly
or implicitly.
Explicit links have the advantage that they are
directly (that is efficiently) available.
However, implicit links that are computed in
a particular information context do have the
advantage of flexibility and are functionally
more powerful.
Structural links are likely to be explicitly
stored in as far as they represent the hierarchic
structure of a hyperdocument.
However, for 'guided tours' or
tutorials based on a user model, which may also
be considered as represented by structural links,
it may be more convenient to employ an implicit representation,
in order to be able to adapt to the users need.
Direct versus inferential links
Our research interest is directed towards
exploring the use of what we like to call
'inferential links',
links that are computed by processing
the knowledge available at the time the
link needs to be established.
In contrast with
other links, including implicit links that
are the result of evaluating a function,
the functionality of inferential links
is characterized declaratively by a number of
knowledge rules.
To our mind a knowledge-based approach
is valid for both structural and referential links.
For example a guided tour may depend on answers
provided by the user.
Similarly, the importance of an annotation
may be decided by simple rules.
Intrinsic versus extrinsic links
A distinction that is somewhat analogous,
yet distinct from the distinction between
implicit and explicit links is that between
intrinsic and extrinsic links.
Intrinsic links are links that are somehow embodied
in the document and hence physically
connected with the actual document.
Extrinsic links, in contrast, may exist
completely independent of the actual document.
As an example of extrinsic links between
two documents, one may think of the relation
between coordinate positions of the bitmaps
representing the documents on a screen.
Another example is a relation between
documents expressed as file positions.
A definite advantage of extrinsic links is the fact that
these links may be stored independently of the actual
documents involved.
However, extrinsic links must be considered dead
links, since they will not reflect any change
in one of the documents, which clearly is
a disadvantage.
The tradeoff between intrinsic and extrinsic links
is a point of future research.
One possible solution here might be to
develop appropriate update protocols.
Document types
Evidently, hypermedia must support multiple
types of documents, such as ordinary text documents
but also sound samples and video images.
Active documents
Hyperdocuments are intrinsically active, since they must support
the dynamic interpretation of their contents as commands.
As an example, an ordinary referential link is an active spot
in a document since it allows the passage to related documents.
Multimedia documents are active in yet another sense.
For example, a document consisting of sound samples
may be considered active since displaying such a document
requires sound generation activity taking place
independently from the other processing involved.
In order for a user to manipulate such documents,
a handle must be available to display a sequence of
sound; and in addition, to integrate a document
of this kind in a hyperdocument, handles must
be provided to store links and annotations
for specific positions in a sequence.
Documents as objects
There is a close analogy of (active)
documents to objects (in the sense of OOP).
Documents, containing data of some sort,
must support methods that enable to view or display the
information contained and methods that allow
to relate parts of that document to other documents
by means of links.
Naturally, such objects must in some way be persistent,
since hyperdocuments (including the links)
must survive multiple sessions.
Multimedia (document) objects
must support autonomous (concurrent) behavior
in order to mediate the synchronization between
user requests and the devices in use.
An additional argument for employing
active objects (active in the sense of Active C++/DLP)
to represent multimedia documents is that active objects
are convenient for simulating the behavior
of active documents in the absence of a working device.
In other words, active objects provide
the flexibility needed to model the behavior of
a multimedia hyperdocument in a more abstract way.
Cf. [Gibbs, 1991].
Semantic constraints
One research issue of particular interest
is how we may model constraints
related to document types in a generic yet
flexible way.
One could think for instance of defining the structure
of a document by means of as SGML-grammar (for ordinary text)
or a HyTime specification (for time-based material).
However, in addition to specifying the syntactic
requirements we also wish to be able to check
for semantic constraints laid down in for instance
rules that specify the dynamic behavior of
a document.
Our intent is to employ the inference
capabilities of DLP for this purpose.
A problem still, however, is how to define
such constraints in a rule-based form.
Hierarchic contexts
Many of the current hypertext/media systems treat an application
as a large unstructured collection of documents connected by arbitrary link,
e.g. NoteCards [Halasz, 1988].
In contrast,
the Intermedia system allows the user to construct so-called
webs that provide a context for connecting documents.
The same document may occur in different webs with different
connections.
In addition to a context mechanism as provided in Intermedia
we like to explore a notion of hierarchic contexts
that automatically provide structural links
and may also be used as a mechanism to inherit shared
information.
Such contexts may be used both as a single (compound)
document as well as a collection of separate documents
that may each be accessed individually.
Hypermedia command languages
Another important research issue, pointed at in [Halasz, 1988],
concerns the means offered to authors of hypertext/hypermedia
systems to develop applications.
Scripting languages provide these means in a flexible way,
and may also be used by end-users to customize an application.
Currently, there are a number of scripting languages,
eg. Toolbook, HyperTalk, that support the development of hypermedia
applications.
In a recent lecture, Alan Kay remarked that there are over 750.000
people using HyperTalk, most of which are non-programmers.
Having established the need for an easy-to-use
hypermedia command language, we must remark that the scripting
languages that exist offer rather limited functionality,
or if they do it is in the form of a rather unstructured collection of
ad hoc solutions without a firm semantical basis.
See for example [Younggren, 1988].
Embeddable command languages
We believe that a hypermedia command language must be usable both in
a shell like fashion, to enable the construction of simple scripts,
and in the context of a compiled program,
to allow the development of more complex, yet efficient, applications.
Research concerning embeddable command languages is reported in
[Ousterhout, 1990] and [Ousterhout, 1991], which describe respectively Tcl,
an embeddable command language interpreter (embeddable in C programs)
and Tk, an X-windows toolkit based on Tcl.
As a first step in developing the environment we envisage,
we have developed the hush class library,
the C++ programmer interface to Tcl/Tk.
Interprocess communication
The approach taken in Tcl allows for an application
to have commands executed by command interpreters of other
applications. To achieve this, Tcl employs the X-windows
application manager to register existing interpreters and
to exchange commands.
Such an approach is of particular importance for hypermedia
applications since it allows to dispense with large monolithic programs
in favor of a number of small (cooperating) processes.
In particular, this allows for incorporating a variety
of software (such as a debugger or network
communication programs) in a seamless way,
that is consistent with the overall look-and-feel of
the application.
Declarative specifications
A hypermedia command language must be both easy to use and functionally powerful.
We wish to provide a language that allows to specify a hypermedia
application in a declarative way (to the extent possible).
We intent to explore the employment of logic-based
languages in this area (and in particular the distributed logic programming language
DLP) since these have a clear and easy to understand semantics
yet great expressive power.
Research in this direction has been reported a.o. in [Anjewierden and Wielemaker, 1989],
which describes an extension of Prolog with object oriented graphics
primitives.
We expect that, in combination with Active C++ and
the hush library, the use of DLP will enable
us to provide high level support for the
development of distributed (intelligent) hypermedia systems.
System implementation issues
With respect to the development of graphical user interfaces,
we have studied a number of toolkits.
[Hansen, 1990], [Linton et al, 1989], [Ousterhout, 1991] and [Young, 1990].
For our purposes we need a toolkit that fits in smoothly with Active C++.
In our group we have developed a pilot hypermedia system
with the InterViews library [Linton et al, 1989].
A drawback of InterViews, however,
it turns out that it is rather complex to use.
Another disadvantage of InterViews is that it
supports only a limited number of the widgets
commonly used in graphical user interfaces.
In contrast, many of such widgets are available
for example in the OSF/Motif widget kit. [Yo
A possible route to incorporate such a widget kit
in C++ is by using the wrapper classes provided
by the WWL library. toolkit
The WWL widget library [Fekete, 1992]
implements an approach that does allow the integration with programs developed
with OSF/Motif and other kits on top of X-windows,
by providing a wrapper mechanism that enables a flexible use
the C-based Athena, OSF/Motif and HP widget kits in a C++ context.
However, the drawback of this approach
is that it provides only a very shallow object interface,
clearly lacking the elegance of the InterViews
library.
A radically different approach to developing
graphical user interfaces is represented
by the Tcl/Tk toolkit.
The Tcl/Tk toolkit offers a large number of widgets
and a very flexible environment for rapidly
developing graphical user interfaces by means of Tcl
scripts.
Moreover, Tcl scripts defining interfaces are
easily coupled to applications developed in
C/C++.
However, we felt that the C programmer interface provided
by Tcl/Tk was not adequate for our approach.
Hence (to have the best of both worlds)
we developed the hush C++ interface to Tcl/Tk
in a style reminiscent of InterViews.
The hush class structure is, however, considerably
less complex than the class structure of InterViews.
Yet, it inherits in a natural way the rich
functionality offered by Tcl/Tk.
Software components
Our project aims at providing a software platform
that supports the development of distributed
hypermedia applications.
In this section we will delineate the software
components that we plan to develop
in the context of our project.
We distinguish between three layers of software.
Our implementation platform Active C++/DLP
must be regarded as the bottom layer.
We consider what we call the linguistic symbiosis between
Active C++ and DLP as crucial to the success of our project.
It is one of the innovative features of our framework,
and together with the second layer, which consists of a
library and toolkit for constructing hypermedia systems,
we consider this the core of our project.
The third layer we envision is of a more general, explorative
nature. It will provide additional hypermedia
development support tools.
Linguistic symbiosis
The object oriented language C++ is a powerful language
for implementing (complex) efficient systems.
It is likely to become an industry standard of the near future.
We have recently developed Active C++, an extension of C++ with active classes
and communication by rendez-vous. See [Eliëns and Visser, 1992].
Active C++ is currently being employed for implementing
the distributed logic programming language DLP.
In order to provide a flexible and powerful software platform
for the construction of distributed hypermedia systems,
we aim at a linguistic symbiosis between Active C++ and DLP.
The notion of a linguistic symbiosis has originally been put
forward in [Ichisugi et al, 1992], and it expresses the wish to mix
computations specified in different formalisms.
More precisely it indicates a means to specify the relation
between a high level language and its underlying implementation
language in a way that allows the programmer to profit
from both worlds in a non ad-hoc manner.
Such an environment enables the programmer to effect a smooth
transition between a prototype in DLP
and an efficient implementation in Active C++,
which in our opinion may significantly reduce the production cost of
complex systems.
Another advantage of this approach is that it supports
the implementation of inferential links in a rather
direct way.
Active C++
Active C++ is a minimal extension of C++ supporting
active objects and communication by rendez-vous.
From the outside, for client code, there is no
distinction between calling a member of an active object or calling a member
of an ordinary object.
Whether an object is active or not is determined
by the definition of its class.
The actual object created is of a subclass
of the class defined for the object, dependent on what type of
process is associated with the object.
In addition to the encapsulation provided by the typechecking mechanism
of C++, Active C++ provides strong dynamic encapsulation by allowing
to determine the order in which method calls are accepted.
This is done by a somewhat Ada-like accept-statement.
Active C++ is implemented as a pre-compiler (which is a preprocessor
to be used before cfront)
that generates the proper derived classes for classes
that define active objects.
Currently, both light and heavy weight processes are supported.
At run-time, calls to active objects are dealt with by message-passing.
We chose this model because it is clean, it is universal (across multiple platforms),
it is easy to establish its correctness and (very important also) it is flexible.
The message-passing model moreover may be optimized
in shared-memory situations.
Other run-time models, although they may sometimes result
in a better performance in specific situations, are considered as semantically unclear,
inflexible, difficult to implement, and difficult to support uniformly on multiple platforms.
Due to the type-information we get from our pre-compiler, we can deal with
a number of issues such as distribution, persistence and type-security
quite easily. Marshalling and unmarshalling can be transparently dealt
with by inserting the appropriate stubs.
Currently, we study how we can best incorporate primitives for the allocation
of processes on a network of processors.
In our approach thus far, we assume that processes running on multiple processor machines
are created from a single root process.
This enables us to deal with arbitrary C++ code, without artificial restrictions
specific to active classes.
DLP
We will employ the distributed logic programming language DLP
that allows to specify an object oriented system in a highly
abstract way. DLP is fully described in [Eliëns, 1992].
The language DLP extends logic programming with features specifically
geared towards the specification of object oriented
systems and thus corrects what has been commonly felt to be one of the major
drawbacks of logic programming:
the lack of support for specifying large systems in a structured way .
See [Eliëns, 1989].
In addition to object oriented features, DLP supports
parallelism, by allowing objects to have activity of their
own.
For many problem areas, concurrency or parallelism is a very natural phenomenon.
Parallism and distribution fit in well with the object oriented paradigm
since the actual (possibly concurrent) behavior or location of an object
may remain hidden for the clients of an object.
An important application of DLP lies in the area of distributed knowledge based systems.
We feel that the object oriented modeling approach may support
a proper distribution of the various reasoning tasks that are involved,
by taking the natural activity of the actors in a domain as
the guideline in developing an intelligent system.
See [Eliëns, 1991] and [Eliëns, 1992c].
Hyper Utility Shell
We distinguish between three subcomponents that together will
comprise our hypermedia toolkit.
First of all, we need a (kind of) hypermedia abstract machine
that allows the storage of documents and links
and that supports elementary storage and retrieval tasks
(and in the future also versioning).
Secondly, we must provide a library of common user interface items
(widgets in X-terminology) to support the (rapid) construction
of hypermedia interfaces.
And lastly, we wish to provide a hypermedia
command language that supports a script-based definition of
links and retrieval and navigation semantics.
The name hush , which stands for
hyper utility shell ,
is used to refer to the class library providing
an interface to Tcl/Tk as well as to the interpreter
for (Tcl-like) hypermedia scripts.
(Actually, it is a variation on wish ,
the original window shell interpreter
that is part of Tcl/Tk.)
Hypermedia Abstract Machine
What we need is a uniform mechanism to store documents,
links and context information in an efficient and reliable manner.
Currently, we are exploring the use of O++,
which provides an object oriented database extension to C++ as part
of the Ode environment. See [Agrawal and Gehani, 1989] and [Agrawal and Gehani, 1990].
Our approach now is to store the raw contents of a document
as an ordinary file.
However, the additional information, such as links to
other documents and the structure of compound documents,
is stored in persistent objects.
In the near future, we intend to support persistent objects in Active C++,
which will give us greater control
over the storage and retrieval policies employed.
Another important feature of a hypermedia abstract machine
is the support it offers for various documents and link types
and the mechanisms it provides for retrieval and navigation.
Cf. [Campbell and Goodman, 1988].
As explained in our discussion of hypermedia research issues,
our framework will include the support for inferential links
that allow retrieval and navigation to be controlled by contextual
knowledge.
However, this states a research issue, rather than a ready solution!
As other interesting issues, we mention version control and support
for group work.
HyperViews
For hypermedia systems, user interface issues are closely connected
with functionality.
Apart from the primitives for define graphical
user interfaces, we also need to provide
the functionality to present the various
document types (including time-based documents)
and links in a user consumable fashion.
In [E. Rijvordt and M. Kalkman, 1992], a pilot implementation of HyperViews is described,
developed as part of a student project.
(The name HyperViews was the idea of the students.
It reflects their intention
to provide for hypermedia what InterViews provides
for the development of graphic user interfaces.)
The HyperViews library currently supports bitmaps and ordinary text
as document types and provides mechanisms to define extrinsic links
between documents of these types.
The HyperViews system is open in that similar support for
other documents may easily be defined.
A limitation of the current approach, however, is that it
offers no real support for hierarchically structured documents
and that it only supports extrinsic links.
Hence, it does not allow the sharing of information
and it is difficult to dynamically update the information of individual
without compromising the consistency of the link structure.
The next version of HyperViews (or a library akin to it)
will be based on the hush library (and Tcl/Tk primitives)
Also, we expect that our approach will be to
a greater extent script-based in order to allow
for the definition of soft (dynamic) links.
Hypermedia Command Language
From the perspective of the average user,
the most important part of our implementation
platform will consist of a shell-like
scripting language (based on Tcl).
Naturally, we need additional functionality to accommodate
the construction of hypermedia systems.
The advantage of using a Tcl-based scripting language
in this respect is that it may be extended
and integrated with existing programs.
We think that this feature is especially important
in the area of hypermedia applications,
since a language or system designer cannot possibly foresee
every need of future users.
Scripts, moreover, have the advantage that they may be
easily transported across a network.
Being human-readable, they moreover provide an
excellent way to communicate complex information.
Application Development Support
Projects such as ours are somehow intrinsically open ended.
Therefore, in addition to the two layers described
previously, we distinguish a third layer comprising
additional application development support.
To realize this layer, our intention is to reuse
other software whenever possible
by employing so-called software wrappers .
The generic phrase software wrappers
describes an approach to reusing traditional (read C-based)
software in an object oriented context (read C++)
by embedding the software in one or more classes.
An example of this approach is the work reported in
[Fekete90],
that we have discussed in section toolkit .
In a similar vein, we have developed a pre-processor
that wraps the output of the scanner
and parser generators lex and yacc in
appropriate classes.
The advantage of using a wrapping technique
is that it allows to hide many of the complex details
of the software involved behind a (rather) clean
interface.
As an aside, wrapper generators as described are
another instance of the glueing technology
around which our framework is built.
In the following we will discuss our plans
to develop an integrated programming environment
and tools for software documentation support.
Also, we will discuss our ideas with respect
to declarative specification formalisms.
Integrated Programming Environment
Developing distributed systems is error-prone.
As an essential part of our software platform we need to have
some basic tools for debugging and monitoring a system developed
in Active C++/DLP.
We intend to model our programming environment after
Field [Reiss, 1990b], which offers a collection of tools
for the static and dynamic analysis of a program.
The Field-environment supports a tool-interaction protocol
that enables tools to cooperate in the task of monitoring
a program.
This protocol allows to monitor the behavior of the distinct components
of an application separately and hence to focus the activity
of debugging on any particular component.
Our implementation platform offers the primitive needed for the implementation
of this protocol.
Currently, we are studying on formalisms that enable to specify
the interaction between tools cooperating in a debugging task in a formal way
in order to specify such protocols in a verifiable manner.
See section studies .
Software Documentation Support
Without wanting to engage in an ideological debate,
we wish to state our belief that a suitable software documentation tool
facilitates the maintenance of software.
See also [Webster, 1988].
It is our intention to document the software developed in our software
in a web-like manner
along the guidelines defended in [Knuth, 1992].
Additionally, for user documentation and reference manuals
we intend to employ the gnu latexinfo system,
that allows to generate both a latex copy and a hypertext-alike online
manual out of a common source.
As one of the possible applications of our environment,
we suggest the development of a fully fledged
hypermedia application based on these tools.
Both the latexinfo and web tools mentioned are instances of
report generators which are found in a number of systems.
We choose for report generator tools,
among other reasons, for the quality of output.
Declarative Specification Formalism
We have already argued the usefulness of a hypermedia command language.
More in general,
applications may profit from a command language
that is extendible with user-defined commands.
Another approach to support user defined command languages
in a C++ context is provided by our wrapping technique,
which allows to embed a scanner and a parser (generated by lex and yacc)
in a class.
Due to the encapsulation provided by C++ an arbitrary number of these
scanners and parsers can be employed
(whereas without wrapping only a single scanner/parser pair is allowed).
This enables the system developer to define an arbitrary number
of application specific languages.
Whether this is the most viable approach depends of
course on the nature of the application at hand.
For some applications visual languages may considered
to be more appropriate. See [Harel, 1988], [Grafton, 1985], [Ichikawa et al, 1990].
Certainly, we need more experience in this area.
Ultimately, we like to provide the means to derive a prototype
system from a declarative specification of an application.
However, specification technology has not matured enough yet
to make this at all possible.
Our approach of supporting an extendible command language
meets our ends to some extent.
In addition, however, we wish to explore how to translate
formal specifications, in Z or a related specification language,
to DLP automatically.
Suggestions in this direction can be found for instance in [Diller, 1990].
An advantage of using DLP to implement such specifications
is its support for distributed processing.
Finding the proper translation mechanisms to represent specifications
in DLP is a difficult but potentially very fruitful research issue.
If successful it would result in a support environment for the development
of applications other than hypermedia systems as well.
Apart from the means for specifying a system we would also like to provide
some support for verification.
Our thoughts in this respect are directed towards
applying a theorem prover such as Otter [Wos et al, 1992], or a special purpose
theorem prover built in DLP, for verifying invariance and
consistency assertions.
Theoretical Studies
Our approach raises a number of interesting theoretical questions
that deserve to be studied independently
from a more theoretical perspective.
The issues that need to be clarified concern the mechanisms needed to allow
applications or components thereof to interact,
the means by which (hierarchically) structured applications
may store and share information, and
the opportunities for automatically generating links
based on information with respect to the documents type (and possibly its contents).
Also, we plan to study the more general software and knowledge engineering
issues involved in developing
complex hypermedia applications.
Inter-application Interaction Mechanisms
Currently, we are studying a number of interaction mechanisms
proposed in the literature, e.g. [Helm et al, 1990].
From a more pragmatic perspective, the tool-cooperation protocol
employed in the Field-environment has served as an example [Reiss, 1990b].
Also, we have been led by the ideas embodied in Tcl/Tk, such as the primitive [Ousterhout, 1990].
Another source of inspiration is
[Dharap and Narayana, 1992], which describes an incremental distributed editing environment.
The interaction protocol employed there
is based on semantic actions, allows a central server to propagate
the changes invoked by multiple independent clients.
For the DejaVu framework
we aim at a formalism
describing the interaction between objects in a general and formal way.
As a starting point we have taken the notion of contracts ,
as proposed in [Helm et al, 1990] and [Meyer, 1988]. Contracts allow to specify the interaction
between components of a system in a declarative way.
The contracts formalism allows, moreover,
for the refinement of contracts analogous to
the inheritance refinement relation offered by object oriented
languages.
Hierarchical Information Systems
The functionality of hypertext systems is usually expressed in a very
informal and operational way.
We wish to develop a mathematically more satisfying semantics.
Such a semantics must deal with the way hierarchically structured information systems
deal with shared information,
how information is accessed and what information may be retrieved
at a certain moment in time.
More in particular, the semantics must be able to give an account
of the way the system processes events, such as the definition of links
and the loss of information.
References to relevant literature in this area are [Garg, 1988] and [Stotts and Furuta, 1988],
and (for a theoretical perspective on inheritance systems) also [Touretzky, 1986].
Document Type Inference
Another interesting theoretical issue is how we may automatically
provide links.
One possible route is to use structural information
to establish containment relations and the existence of forward
and backward directed links.
Another route, however, is to exploit the information
that is implicitly contained in the document type.
An example of this is may be found in the relation that exists
between documents generated in successive phases of a software component.
Obviously, the documents that are produced during analysis
must correspond with documents produced during the design and implementation.
A system may automatically provide the links necessary for navigating between
these documents.
The (software/knowledge) engineering of hypermedia applications
In [Howell, 1992] a number of guidelines for developing
hypermedia applications are presented.
The guidelines proposed are derived from
a classical waterfall conception of the software life-cycle.
Working in a distributed setting,
we think that it is necessary to develop our own set of guidelines. Cf. [Shatz and Wang, 1987].
Our approach lies closer to a prototyping framework
and does not easily fit in a more classical life-cycle model.
Recall that we provide a rather complex
software platform based on a linguistic symbiosis
between a low-level system implementation language (Active C++)
and a high-level logic based language (DLP).
In addition, we provide an extendible
command language.
Together, this offers a very powerful and flexible platform,
but we do not expect that it will be particularly easy to master.
Our framework allows for a gradual refinement of specifications,
but for such an approach to work it is necessary
to provide clear guidelines and examples of 'how to do it'.
For this we must develop an understanding of the
appropriate idioms for developing hypermedia applications.
Equally important is that we gain understanding of how to employ
inferential links in order to provide the developer
of an application with adequate guidelines in this respect also.
Conclusions
We have sketched the framework DejaVu.
We wish to stress that this framework
is meant explicitly as a vehicle for research.
The DejaVu approach is rich in scope, yet we believe
that our attitude is sufficiently pragmatic
for the project to be realized.
Part of the work is intended to be done
in the context of student projects.
Partial results of the DejaVu project may be obtained by ftp
(at ftp.cs.vu.nl:eliens ).
These fragments include DLP and the hush API to Tcl/Tk.
We consider
as our major contribution to hypermedia research
our notion (and implementation) of inferential links .
In addition, we regard our concept of linguistic symbiosis
as being a fruitful and challenging answer to hypermedia system
implementation issues.
Together, they contribute to the realization of
a framework addressing the programmability of hypermedia systems
in a fundamental way.
[]
-
[up]
[up]
introduction
background
hypermedia
components
studies
conclusions
