Use ILU? (Was: Re: Information integration at client or server?)

Bill Janssen (janssen@parc.xerox.com)
Thu, 21 Jul 1994 20:17:49 PDT


(I'm posting this at the urging of Larry Masinter, who thought it might
be interesting.)

I haven't been following the discussion about "binary HTTP" very
closely, but a possibly useful tool is PARC's ILU system, a freely
available object interface system which includes flexible object RPC
code. I know that many of you are familiar with it. Using ILU would
involve describing an interface in `ISL', ILU's Interface Specification
Language. This interface is programming-language and network-protocol
independent. ILU tools then compile this ISL to specific programming
languages and network protocols and transports. ILU hides all the
connection management and transport layers from the application
programmer, allowing them to be modified and experimented with at will,
so that different protocols can be used with transports of different
characteristics, without the application program having to know about
it. TCP or UDP could be used transparently. This would prevent WWW
from falling into the trap of having to define a bit format on the wire,
or overly specific connection protocols.

More information on ILU, and the 1.6.4 distribution, can be found at
ftp://parcftp.parc.xerox.com/pub/ilu/ilu.html.

Just to give you the flavor, an *extremely* simple ISL description for a
WWW server might be (I haven't tried to ``compile'' this :-):

(* ======= interface for simple WWW service *)
(* == Bill Janssen <janssen@parc.xerox.com> 20.7.94 *)
INTERFACE WWW-Simple;

TYPE URL = ilu.CString;
TYPE Document = ilu.CString;

(* define a format name for format negotiation *)

TYPE FormatName = ilu.CString;
TYPE Formats = SEQUENCE OF FormatName;

(* only one exception, a "bad URL" with a value of URL *)

EXCEPTION BadURL : URL;

(* and one object type, the server *)

TYPE Server = OBJECT
METHODS
Get (id : URL, acceptableFormats : Formats) : Document
RAISES BadURL END
END;
(* ======= end of WWW-Simple == *)

A more interesting interface might be

(* ======= slightly more capable WWW interface *)
(* == Bill Janssen <janssen@parc.xerox.com> 20.7.94 *)
Interface WWW-Still-Simple IMPORTS WWW-Simple END;

(* use URL type from WWW-Simple *)
TYPE URL = WWW-Simple.URL;
TYPE Bytes = SEQUENCE OF BYTE;
TYPE MailAddress = ilu.CString;

(* HTTP headers *)
TYPE Header = RECORD name : ilu.CString, value : ilu.CString END;
TYPE Headers = SEQUENCE OF Header;

EXCEPTION AlreadyCheckedOut : MailAddress;
EXCEPTION Unauthorized;

(* Introduce a document object which has methods *)
TYPE Document = OBJECT
METHODS
GetURL () : URL,
Get (f : FormatName) : Bytes,
Headers (f : FormatName) : Headers,
Checkout (who : MailAddress) : OptionalCapability
RAISES AlreadyCheckedOut END,
Checkin (authority : OptionalCapability)
RAISES Unauthorized END,
Post (headers : Headers, newdata : Bytes) : Document,
TextSearch (query : ilu.CString) : BOOLEAN,
Formats () : WWW-Simple.Formats,
Render (format : WWW-Simple.FormatName) : ilu.CString
END;

(* introduce a subtype of WWW-Simple.Server which returns
document objects *)
TYPE Server = OBJECT SUPERCLASS WWW-Simple.Server
METHODS
GetDocument (id : URL) : Document RAISES WWW-Simple.BadURL END
END;
(* ======= end of WWW-Still-Simple == *)

It might also be fun to mix the ``Document'' class into the ``Server''
class, so that servers are themselves documents (much like Gopher
folders). A lot of variations on these themes can be played...

Bill