% (C) Copyright International Business Machines Corporation 23 January 
% 1990.  All Rights Reserved. 
%  
% See the file USERAGREEMENT distributed with this software for full 
% terms and conditions of use. 
\documentstyle [12pt]{article}

\setlength{\parindent}{0in}    % no indented paragraphs
\setlength{\parskip}{\baselineskip}  % skip a line between paragraphs
\setlength{\topmargin}{0in}      % This sets the space on top of the page to
\setlength{\headheight}{0in}     % an inch
\setlength{\headsep}{0in}        % a little more than an inch

\addtolength{\textheight}{1.0in}  % This has effect of making 1 in margin below
				 % page number at bot of page (otherwise it is
				 % larger margin)
\setlength{\oddsidemargin}{0in}   % This sets the left margin on odd and even pages
\setlength{\evensidemargin}{0in}  % to 1 inch + 0 inches.  (Default is more than 0)

\addtolength{\textwidth}{+1.5in} % This has the effect of making right margin 1
			         % inch (otherwise it is 2.5 inch)
\input isil

\def\And#1{\end{tabular}\\[#1]\begin{tabular}[t]{c}}
\begin{document}
\section*{Hermes Language Availability}

The Hermes language system, developed at the IBM T.J. Watson Research Center,
is now available.  The Hermes distribution
includes source code, does not require a license agreement, and is
free of charge.

Hermes is a very-high-level integrated language and system for implementation
of large systems and distributed applications, as well as for general-purpose
programming.  It is an imperative, strongly typed, process-oriented language.  
Hermes hides distribution and heterogeneity from the
programmer.  The programmer sees a
single abstract machine containing processes that communicate
using calls or sends.  
The compiler, not the programmer, deals with the complexity of
data structure layout, local and remote communication, and interaction with the
operating system.  As a result, Hermes programs are portable and easy to write.
Because the programming paradigm is simple and high level, there are many
opportunities for optimization which are not present in languages which give
the programmer more direct control over the machine.

Some important features of Hermes are:
\begin{itemize}
\item {\bf Process Paradigm:}
The process is the unit of modularity.  Hermes processes are as `lightweight'
as procedures in Algol-like languages, and have the same data hiding properties
as `objects' in object-oriented languages.  A process is an independent active
entity, consisting of private data and a sequential 
program.  Processes interact by issuing
calls on `output ports' (e.g. {\tt call p(a, b)} sends
the callmessage {\tt (a, b)} on the port {\tt p}), and receiving
calls on `input ports'.  
This model yields a simple compositional semantics.  It
is easy to reason about Hermes processes, since a Hermes process behaves the
same `in isolation' as it does when linked up to a large system.
%The Hermes paradigm is similar to the Mach paradigm except
%that distribution is hidden and the primitive operations
%are embedded within a high-level language.

\item {\bf Tables:} There is a single type constructor for homogeneous
data aggregates---a relational table.  Tables are
a consistent abstraction for data which could be
implemented as strings, arrays, linked lists, hash
tables, trees, indexed files, etc.  The programmer can insert and remove
elements from tables, retrieve elements by content, merge two
tables, and copy or extract selected subsets of a table.  By providing tables,
Hermes makes programming simpler and more portable, gives the compiler more
freedom to provide alternative
efficient data representations, and eliminates potentially
dangerous explicit pointer manipulation.

\item {\bf Compile-time checking:} Hermes is
strongly typed.  The use of operations with operands
of the wrong type is detected at compile-time.  Additionally, Hermes introduces a dataflow-based checking called
{\em typestate checking}.  Typestate checking detects such additional errors as
failing to initialize a variable, and using a variant from the wrong case.
Typestate analysis also allows the compiler to insert
automatic finalization code (`typestate coercions'). It is
a goal of Hermes to detect as many errors as possible
before a process begins execution.  A {\tt polymorph} data type is
provided as an escape to defer type and typestate checking until run-time.  

\item {\bf Security:} In many languages, a single erroneous
module can bring down an entire program.  Because a `program' in
a systems language might include multiple users, it
is important to limit the effect of programming errors.  In Hermes, an
erroneous process may generate incorrect output values of the correct type, or
may fail to generate any output values, but it can never cause other
processes to crash
or violate the Hermes semantics.  Hermes enforces security largely at
{\em compile-time}, thanks to typestate checking.  Typestate checking
improves performance as well as reliability, since processes on a single
machine can safely share a single hardware address space, even when these
processes are acting on behalf of different users.

\item {\bf Dynamic Configuration:} Using Hermes,
programmers can create, link, and rebind processes dynamically using language
primitives without the need to make system calls.  Ports are first-class values
in Hermes.  They can be assigned to variables, stored in tables, passed in
messages, etc.  The port type determines the interface only, not the binding to
code.  The effect of replacing one port value with another is to rebind a port
to a `plug-compatible' process which may have completely different code but
which is guaranteed to have the expected interface.  The combination of
dynamics with security is valuable in implementing long-lived systems that evolve
over time.

\item {\bf Capability-Based Access Control:} In Hermes
there are no global names.  A process can only interact with processes for
which it has been given ports.  Since ports are first-class, a programmer can
provide controlled access to resources by writing processes that manage the
resource and giving out ports only to these processes.  This provides the
flexible access control found in capability-based systems.  Using ports as
capabilities is efficient because all the checks which are needed to assure
that capabilities are not forged have been done at compile-time.
\end{itemize}

The Hermes system is written in a combination of C and Hermes, and should port
easily to most 32-bit Unix systems.  It currently runs under 4.3 BSD on the
IBM RT, Sun 3's and 4's running SunOS, and on the IBM RISC
System/6000.  The compiler and run-time environment are
highly modular, table-driven, and extensible.  Existing and de-facto standards
have been used wherever possible.
  
%Among the research topics that Hermes is well suited for
%are:
%\begin{itemize}
%\item {\bf Distributed Applications:}
%The process model and communication primitives in Hermes make it easy
%to write distributed programs without requiring knowledge of the
%underlying machine, operating system, and network-dependent
%communication mechanisms.  Because Hermes integrates the relational
%table data structure within a complete language and supports
%strongly-typed persistent data, it may be an ideal language for
%prototyping distributed data base applications.
%
%%\item {\bf Process Migration and Load Balancing:}
%% The clean separation between
%%%processes and existing facilities to encode arbitrary data structures as byte
%%%streams make migration relatively simple.  With relatively little effort,
%%%Hermes could be enhanced for research in process migration and load balancing.
%%%
%%%\item {\bf Language Design:}  The parser is in Yacc, and the type and typestate rules
%%%are encoded in easily modifiable tables.  New language primitives could be
%%%incorporated into Hermes for experimentation.
%
%\item {\bf Optimization:}
%The compiler produces an `abstract program object' which
%could be used as input to an alternative code generator.  Because of Hermes'
%typestate checking, rules against aliasing, and high-level data types like
%tables, much more compile-time knowledge is available to drive sophisticated
%optimizations.
%
%\item {\bf Environments:}
%Hermes offers several challenges for language-based tools.
%Such tools should be able to deal with high level data structures, program
%transformations, dynamic configuration, and distributed processes.
%\end{itemize}
%
Hermes is based on previous work on the Network Implementation Language (NIL),
which is described in the September 1989 issue of Computing Surveys.

The system is being made available both for those wishing
a simple and secure language for writing distributed programs and for those
interested in using Hermes as a testbed for their own research in programming
languages, distributed systems, optimization techniques, or programming
environments.  Hermes is an experimental language, and will continue
to evolve.  The Hermes group is eager for feedback regarding
implementation bugs and suggestions for enhancement.  Your input
will be valuable in directing future work on Hermes.  However, we
obviously cannot guarantee the same level of service as a commercial product.

The prototype Hermes system includes a compiler and interpretive run-time
system, interface to the Unix stdio library, make tool, shell, disassembler,
Gnu Emacs mode, and, as a demonstration application, a distributed appointment
scheduler.  The documentation includes a tutorial, a reference manual, an
installation guide, and the formal tables which drive the compiler source code.

To request a copy of the Hermes system or manual, or if you wish to be added
to the Hermes mailing list, send mail with your e-mail and postal address to
hermes-request@ibm.com.  We'd appreciate your including in your request
a brief description of your interest in Hermes.

%%We are currently taking requests for copies of the system and documentation.
%%Requests may be sent to dfb@ibm.com.

\vskip 10pt

\leftline{David Bacon, Arthur Goldberg, Andy Lowry, Rob Strom, Dan
Yellin, Shaula Yemini}
\leftline{IBM T.J. Watson Research Center}
\leftline{P.O. Box 704}
\leftline{Yorktown Heights, NY  10598}


{\bf References:}
\begin{itemize}
\item {\it Programming Languages for Distributed Computing Systems}, by Henri E. Bal,
Jennifer G. Steiner, and Andrew S. Tanenbaum, Computing Surveys Vol. 21 No. 3,
September 1989.

\item {\it NIL: An Integrated Language and System for Distributed Programming}, by
Robert E. Strom and Shaula Yemini, Proceedings of the SIGPLAN '83 Symposium on
Programming Issues in Software Systems, June 1983.

\item {\it Typestate: A Programming Language Concept for Enhancing Software
Reliability}, by Robert E. Strom and Shaula Yemini, IEEE Transactions on
Software Engineering, Vol. SE-12, No. 1, January 1986.
\end{itemize}
\end{document}

