Chapter 1: Web-Hermes 1.0 Overview
"How much finer things are in composition than alone."
Emerson, Journals, 1833.
1.1 -- Introduction: The computer industry's
rapid evolution soon spawned a plethora of diverse, often incompatible,
hardware and software systems. This presents a major problem for today's
businesses as cooperative efforts commonly requires data sharing. To address
this, many companies developed, and adhere to, common communications protocols,
such as CORBA or ODBC,
for database systems -- They press data applications into a common mold.
While such practice provides easy communications between like systems (mostly
on like platforms), such standards often apply only to those systems similar
and currently in existence (common to many users too) and frequently neglect
large, non-public, legacy systems common in corporate, governmental and
The University of Maryland's Hermes project
addresses these concerns by defining a language and software system which
allows integration of like and non-like data sources through an adaptable
software communications layer -- We modify the software to suit the data
application. This allows easy communication between diverse data applications,
distributed often across networks, and potentially implemented on a variety
of hardware platforms. Simply stated, Hermes readily adapts to legacy
and future software applications.
1.2 -- Hermes (HEterogeneous Reasoning and
MEdiator System) specifics: The Hermes Project defines a unified
theoretical framework and a set of practical software programs that provide
an application-independent platform for scalable software and data integration
across local and wide area networks. The Hermes software consists
of adaptable search engine code and a variety of front-end user interfaces
which mask the underlying complexity and convey an integrated data schema
to the user.
Sparc stations, Macintoshes, PC Laptops,
and even the new Windows CE palm-top devices -- Global Hermes
usage became possible with the Web-Hermes front-end development; Through
dynamic Hermes HTML pages for the world-wide-web, users can access widely
distributed Hermes search engines using common Web browsers available
on many platforms.
Hermes renders a logic-based database system
which provides a simple, but powerful, framework for solving many problems
described by C.J.Date in An Introduction to Database Systems, Volume
I, Addison-Wesley, 1990, page 643.
1.2.1 -- Representational uniformity: It becomes possible to define
a database language in which base data, "deductive axioms", queries, and
integrity constraints are all represented in the same uniform way.
1.2.2 -- Operational uniformity: Proof theory provides a basis for
a unified attack on a variety of apparently distinct problems, including
query optimization (especially semantic optimization), integrity constraint
enforcement, database design (dependency theory), program correctness proofs,
and other problems.
1.2.3 -- Semantic modeling: Proof theory also provides a good basis
on which to define various semantic modeling extensions, such as events,
type hierarchies, and certain types of entity aggregation.
1.3 -- Hermes currently provides many of these capabilities,
and others are being added; It extends the general logic-based approach
in several directions, using concepts that are simple, general, and powerful.
1.3.1 -- Hermes extends its rules with functions that access
external software and data. While a traditional rule-based system is limited
to its own closed world or specialized domain, Hermes adds functions
that open the system to the world and many domains. Commercial software
currently integrated with Hermes includes relational databases (dBase
and Paradox on the Windows platform). Public domain software
includes University Ingres and two U.S. Army route planning packages
on the UNIX systems. Other integrated software has been developed
at the University of Maryland, including flat file relations, spatial databases,
multimedia databases (including image, text and audio databases, plus face
recognition software), and numerical software (linear programming). Hermes
can also access the Internet to retrieve data, images, text and audio from
around the world.
1.3.2 -- Hermes applies metalevel operators to elements
of the logical language to extend the language power. Currently implemented
intelligently cache functions and predicates;
do repeated actions;
save actions for a user to invoke; and
print the set of answers for a query to a file for further processing.
1.3.3 -- Hermes provides client/server capabilities that
allow queries to be distributed across a network, using different types
of software on different machines and operating systems.
1.3.4 -- Hermes mediators contain sets of backward-chaining
rules that can access, combine and mediate diverse software and data. The
same logical language is used for defining rules as for querying mediators.
Hermes rules apply predicates, comparisons, assignments and array,
record and set operators to constants, variables and functions. The predicates
are annotated with numeric truth values that state their relative confidence
or certainty, as in traditional expert systems.
1.3.5 -- Hermes domains allow software and data abstractions
that may be viewed from a logical perspective separate from the underlying
implementation. Such abstractions range from large programs, such as a
relational database management system, to sets of related functions, such
as mathematics functions, tapped from the host operating system.
Each domain contains one or more functions. A domain
function is a high-level function that accesses software and data in a
domain. A domain function is declared with its inputs and output and a
brief English description of its process. At the programming interface
level, a domain function may be implemented with calls to external programs
(such as a relational database management system), C calls to other
modules linked with Hermes (such as a text database), or a block
of C code (such as for mathematical functions). Hermes provides
the flexibility to integrate only the necessary functions from a software
program; new functions can be added any time. The Hermes language
provides a simple and uniform logical framework for solving many problems
and for rapidly developing new applications.
1.3.6 -- The distributed version of Hermes utilizes query
servers and domain function servers to access software and data across
a network. For distributing queries across the Internet, Hermes basically
uses a few network communication functions on top of some of the Hermes
modules. This approach efficiently provides a general-purpose distributed
implementation that is intelligent, flexible and scalable. Domain function
servers provide a simple and general method of distributing queries across
the Internet and other networks. These servers combine some of the Hermes
modules with the domain interfaces for the software that is used on a given
machine. (The application software may in turn access data distributed
on various machines.) The domain function servers provide a general and
uniform means to access software and data on remote machines, and can easily
be configured to provide exactly the necessary domain functions on a given
machine. The TCP/IP stream socket communications between a mediator and
any domain function servers that it accesses are automated by Hermes.
The same domain interface code can be used on a local machine as on a remote
machine -- it is only necessary to use a few predefined functions in the
interface to direct the domain function to a remote machine if necessary.
The character-based communications protocol facilitates portability across
different types of machines and networks. The results of remote domain
functions can be stored on a local machine and reused as appropriate. Hermes
currently runs across the Internet and can easily be scaled up to include
1.4 -- Technical challenges in implementing Hermes
involve integrating software, integrating data, and distributing that software
and data on a network. The problem of building integrated information systems
is divided into two parts -- software integration and data integration.
Software integration requires interfacing Hermes with the necessary
functions provided by existing software. A domain catalog provides the
mediator-level declarations of the domains and their functions. Once the
necessary software functions have been integrated with Hermes, they
can generally be used for a wide variety of applications without further
interface programming. Once a software program has been integrated with
Hermes, any database accessed by that program can be used in a mediator
simply by declaring its location and type structure and by writing the
appropriate rules. For integrating software, a domain function can be implemented
with a fragment of C code (such as for mathematical functions), C calls
to other modules linked with Hermes (such as to search a text database),
or calls to separate programs (such as a relational database management
system). Data integration requires defining the syntax and semantics of
the data returned by the software functions. Data syntax is specified by
data declarations in a mediator. Data declarations in a mediator describe
the location and structure of the databases accessed by that mediator.
Data semantics are specified by rules, which can access data, combine data
and resolve conflicts. The Hermes standard data format for exchanging
information with domains provides a rich set of data structures: single
constants, records, arrays and sets -- in any combination. The Hermes
language provides easy access to the elements of these data structures.
Unstructured or binary data are exchanged through files.
1.4.1 -- Hermes provides a general-purpose logic-based graphical
interface that uses the logical query language directly. Hermes
also provides for application-specific graphical interfaces that can present
the user with menus, lists and so forth. Both types of interface provide
for multimedia answers, in the form of images, text and audio.
General goals of Hermes include:
1.4.2 -- Hermes provides logical foundations, as well as
a search engine and software tools and methodologies, to support these
maximizing the variety of software and data that can be integrated;
maximizing the interoperability between different software and data;
minimizing the time to integrate new software and data; and
minimizing the time to process queries to these integrated sources.
1.4.3 -- Hermes is implemented in C ; Standalone versions
run both on Unix and (experimentally) on Microsoft Windows operating
systems. The distributed version runs on Unix across the Internet,
using TCP/IP stream sockets for the client/server communications.
NOTE: Hermes is under continuing development, and new capabilities
will continue to be added and documented.
1.5 -- Acknowledgments: Web-Hermes 1.0
is, and continues to be, a group effort; From the programmers poking through
peculiar bits and bytes, to the theorists pondering distant goals, many
(too many to cite) imaginative individuals have toiled long, sometimes
difficult, hours to bring Web-Hermes into reality.
Documentation has long been a problem as the Hermes
target never ceases to change; Building on previous efforts, this document
draws structure and basic background information from earlier notes written
by Ross Emery, one of the founding project programmers. New sections include
those (finally) defining procedures for software installation and compilation,
guidance for writing mediators, and instructions for integrating future
1.6 -- Audience: This manual is written for persons:
using mediators, either interactively or from another program
As such, it assumes some basic knowledge of logic
programming and/or C programming, although there are many explanations
and examples. Chapter 3 provides an overview
of the current system architecture and the basic tasks associated with
using the system. It also suggests which subsequent chapters would be helpful
for performing which tasks.
Some familiarity with logic programming is helpful
in understanding Hermes and this guide, but Chapter
4 will provide a detailed explanation of the proof process for a simple
Applications developed using Hermes typically
have their own graphical interfaces which are separate from the Hermes
logical language and easier to use. These interfaces would either be self-explanatory
or have their own documentation.
At the GUI level are easy-to-use application-specific
graphical interfaces, which use menus, lists, fill-in-the-blanks, and so
forth, rather than the Hermes logical language. More exotic multimedia
interfaces are possible. For example, a travel planning application could
let a user specify areas of interest by clicking on a map. The graphical
interfaces for these applications would typically not require any knowledge
of logic and would have their own documentation or be self-explanatory.
1.7 -- Font Conventions: Sample code and examples
appear in figure boxes throughout the document. Actual program text appears
in a Courier (sans-serif) fonts with appropriate comments in Times New
-- Hermes language syntax is defined using BNF (Backus-Naur
Form) notation, plus English description where the left side of a definition
contains the term being defined. The right side contains one or more sub-terms,
which have their own definitions, or text characters typed by the user.