Distributed objects (and CORBA) for Guile

[Bill Janssen <janssen@parc.xerox.com>]

This is to announce the availability of an alpha release of ILU 2.0,
ILU 2.0alpha11.  See ftp://ftp.parc.xerox.com/pub/ilu/ilu.html to
download the sources for UNIX or Windows.

The Inter-Language Unification system (ILU) is a multi-language object
interface system.  The object interfaces provided by ILU hide
implementation distinctions between different languages, between
different address spaces, and between operating system types.  ILU can
be used to build multi-lingual object-oriented libraries ("class
libraries") with well-specified language-independent interfaces.  It
can also be used to implement distributed systems.  It can also be
used to define and document interfaces between the modules of
non-distributed programs.  ILU interfaces can be specified in either
the OMG's IDL language, or in ILU's Interface Specification Language,
which allows extensions to the CORBA spec.  Programming languages
supported in 2.0alpha11 are ANSI C, Common Lisp, Java, and Python;
rough C++ support is also present.  Operating systems supported in
2.0alpha11 are all Windows platforms with Win32 and WinSock, and all
UNIX platforms with BSD sockets and minimal POSIX compliance.
2.0alpha11 supports interoperability with ONC RPC services, OMG CORBA
services, World Wide Web HTTP services, and XNS Courier services.
``Plug-in'' extensibility is provided for RPC message formats, message
transport schemes, URL schemes, accounting and authorization identity
types, threading and event loop processing, and various other things.
ILU is provided free for unrestricted use.

Known bugs are listed in the README file.  Despite being an alpha
release, 2.0alpha11 is very stable along a number of dimensions.
Principal areas still under development, and hence unstable, are: the
specific APIs for security, the C++ mapping, the Java mapping, the
mapping of ILU object references to various RPC protocols, the
specific algorithm for automatic generation of type UID fingerprints,
and the specific contents of the ILU profile in the OMG CORBA IOR.

Patches will be appearing in the file
ftp://ftp.parc.xerox.com/pub/ilu/2.0a11/patches.html.


Changes from 2.0alpha10 to 2.0alpha11
-------------------------------------

   * *Documentation re-done.*  The documentation for the various
     language runtimes has been re-done to a standard template.

   * *New OMG IDL parser.*  A very nice parser for OMG IDL has been
     contributed by Martin von Loewis, and has been incorporated.  It
     consists of two C files which are integrated into the parser
     library, instead of the huge and buggy C++ idl2isl program
     previously supplied (and no longer part of the distribution).
     Many thanks, Martin!

   * *New ISL to IDL program.* The file `stubbers/pprint/isl2idl'
     converts isl2idl when possible.

   * *Guile Scheme support.* Bill Nell at Siemens Corporate Research,
     Inc, has contributed the beginnings of support for Guile Scheme,
     including a Scheme stubber, a working ILU LSR for Guile, and
     working versions of the `examples/test1/' example client and
     server programs.

   * *Multiple ports on server.*  It is now possible to add multiple
     ports to an ILU server, so that the same set of objects can be
     exported via multiple protocols.  All languges provide hooks to
     add multiple ports to a server.

   * *Serialization and pipelining on non-concurrent protocols.* The
     ability to have calls delivered to the callee in serial order over
     a single connection has been added for non-concurrent protocols
     with an abstraction called serialization.  In addition, the
     ability to have multiple outstanding calls on connection that uses
     a non-concurrent protocol has been added via an abstraction called
     pipelining.  Access to this kernel functionality is currently only
     provided via the C LSR.

   * *Custom surrogate support added for all languages.*  The ability to
     specify a user-implemented class for surrogate instances has been
     added to all languages.  This allows implementation of custom
     caching strategies and similar techniques.

   * *Custom record support added for all languages.*  The ability to
     override record type marshalling in languages where the type
     system allows it has been added.  This capability is useful for
     support of objects-by-value.  Not yet available in Common Lisp or
     Guile.

   * *HTTP support improved.* The ILU `HTTP' support will now properly
     redirect for responses.  It also responds to non-1.0 versions of
     the `HTTP' protocol more kindly, and has the beginnings of support
     for `HTTP 1.1'.

   * *IIOP improved.*  The IIOP support will now respond appropriately
     to relocation replies, common with other ORBs, though not used in
     ILU.  It now supports CORBA 2.1 character set negotiation.  A
     non-concurrent version of `IIOP' is available as `"siiop"'; note
     that since the OMG spec clearly identifies `IIOP' as concurrent
     (in the ILU sense), `"siiop"' should only be used between ILU
     clients and servers.

   * *World Wide Web MUX transport included.* This release includes an
     implementation of the MUX transport described in
     `http://www.w3.org/Protocols/MUX/WD-mux-961023.html',but with the
     modifications suggested in
     `http://lists.w3.org/Archives/Member/w3c-mux/msg00039.html'.This
     transport, called `"w3mux"', allows for multiple simultaneous
     sessions or connections over a single TCP/IP connection.  It
     supports message fragmentation and interleaving of streams.  It
     supports bi-directional connections over the TCP/IP connection,
     thereby supporting callbacks through firewalls.

   * *Java improvements.*  Java support for Win32 platforms (using
     Javasoft JDK 1.1.x and Microsoft Java SDK 2.0 beta 2) is now
     included.  The ILU support no longer works with JDK 1.0, but now
     supports JDK 1.1.x.  Lots of minor improvements have been made.
     The generated stubs are now by default (mostly) compatible with
     the original Java mapping document
     (`ftp://ftp.omg.org/pub/docs/orbos/97-03-01.pdf').  The
     originalILU mapping is available as a stubber option.

   * *CORBA 2.0 C++ support - limited*  CORBA 2.0 C++ is currently
     working for Visual C++ (sans nested modules and pickles/anys
     support).  [This is very new software - it has received very
     limited testing.]

   * *CosNaming service included.* The distribution now includes an
     implementation of the CORBA name service, under
     `ILUSRC/etc/CosNaming/'.  It is automatically built and installed
     if OMG IDL and IIOP support are configured in.

   * *Sun RPC portmapper support included.* A C library for use with
     the Sun RPC `portmapper' is now included, in
     `ILUSRC/etc/portmapper/'.  Included is an ILU ISL description of
     the `portmapper' interface, which can be used directly with other
     languages.

   * *Auto-stubbing of modules supported for Python.*  The `import'
     mechanism in Python can now be augmented by calling the function
     ``ilu.AutoImport()''; this modifies `import' so that, when
     attempting to import a module called `foo', if it fails to find
     `foo.py' and `foo.pyc' on the `PYTHONPATH' environment variable,
     it will then walk down the directories listed in the `ILUPATH'
     environment variable, looking for either `foo.isl', or, if OMG IDL
     support is enabled, `foo.idl'.  If either of these are found, it
     will run the Python stubber on the file, putting the results in a
     temporary directory, and then load the resulting surrogate-side
     `foo.py' file.

   * *FUNCTIONAL caching is now supported for Python and Lisp.*


Dan Larner, larner@parc.xerox.com
Xerox PARC, 3333 Coyote Hill Rd., Palo Alto, CA, USA 94304