[]
DejaVU Online
-- Project DejaVu (1992)
[]
-
[up]
[up]
introduction
background
hypermedia
components
studies
conclusions
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.
[]
-
[up]
[up]
introduction
background
hypermedia
components
studies
conclusions
