Inter-Language Unification

# ILU

    >From janssen@PARC.Xerox.Com Fri Sep 10 20:32:05 1993
    Newsgroups: comp.client-server, comp.object, comp.lang.lisp, comp.lang.modula3
    From: janssen@PARC.Xerox.Com (Bill Janssen)
    Subject: Alpha testers wanted for ILU, a multi-lingual interface system
    Organization: Xerox Palo Alto Research Center
    Distribution: comp
    Date: 10 Sep 93 16:36:32

We are getting ready to release our ILU system, and this message is to solicit alpha testers for our first outside-of-PARC release.

## What's ILU?

    It stands for Inter-Language Unification, and it is an attempt at
    providing interface technology for application programs in a language
    neutral fashion.  It does this by requiring interfaces to be written
    in a neutral language, called ISL, for Interface Specification
    Language, and, for each supported programming language, includes tools
    for generating language-specific versions of the specified interface,
    and libraries for supporting these language-specific interfaces.

    Those familiar with the canonical approach to supporting RPC on UNIX
    platforms will recognize this approach as being quite similar to that
    used by various RPC toolkits.  Exactly so, and ILU will indeed serve
    to combine program fragments either in a single address space, or, via
    RPC, over multiple address spaces.  However, it does not dictate the
    use of any specific RPC protocol for these distributed applications,
    but is engineered to work with various RPC protocols.  (We currently
    have mappings to Sun RPC and Xerox Courier.)  Similarly, it does not
    dictate any specific underlying transport such as TCP/IP, but can work
    with various reliable byte-stream transport mechanisms.  (We currently
    have mappings to TCP/IP and the XNS Sequenced Packet Protocol.)  The
    mappings to standard RPC protocols are such that some subset of
    existing services can be used directly from ILU without modification
    -- those for which an ISL interface description can be written.

    The concepts supported in the ISL interface specification language
    include

      - namespaces (non-nested)
      - 16, 32, and 64 bit integers, signed and unsigned (and bytes)
      - 32, 64, and 128 bit floating point numbers
      - ASCII and Unicode characters (and strings)
      - boolean and pointer values
      - structs (records), tagged unions, multi-dimensional arrays
      - sequences (lists)
      - object types (multiple-inheritance)
      - object methods (synch/asynch) (result caching/non-caching)
      - exceptions
      - garbage collection

    We currently have (working) mappings of these concepts to 5 languages:
    Modula-3 (DEC SRC), Common Lisp (Franz Allegro 4.1), C++ (several
    compilers, thought to be generic), FORTRAN (Sun f77), and ANSI C
    (again thought to be generic).  Mappings use an object-oriented
    approach throughout; we add a simple object system to C and FORTRAN,
    and extend the object system in Modula-3 to support multiple
    inheritance.  The C mapping conforms as much as possible to the C
    mapping specified by the Object Management Group's Common Object
    Request Broker Architecture, for their IDL.  Our ISL parser will also
    parse a subset of OMG IDL (disallowing any IDL "#include"s which
    cannot be turned into ISL "IMPORT" statements; disallowing the more
    baroque IDL union specifications; disallowing any IDL statements
    outside the scope of a "module" statement; disallowing any definition
    of anything but member functions or attributes inside an IDL
    "interface" statement; disallowing the IDL "object" type; disallowing
    the IDL "typecode" type).

    The system is written in ANSI C on Sun SunOS 4.1.3 workstations.  We
    believe that it will port fairly easily to other operating systems,
    and to other versions of UNIX.  We have ported our kernel library and
    our C++ support to the Macintosh, as a test.  The system will be
    released publicly later this year, under a copyright which should
    freely allow use in almost any situation.

## So what's an Alpha Tester?

    We'd like to find *a small number* of alpha testers interested in 1)
    porting the Lisp support to Lucid CL, CMU CL, and Mac CL; 2)
    exercising the support for the various languages, and submitting bug
    reports; 3) porting the kernel and tools to MS-Windows; 4) porting the
    kernel and tools and support for various languages to different UNIX
    platforms; 5) providing RPC support for OSF DCE.  We intend to gather
    together these various pieces of work and re-release this with our
    beta test version.  If you'd like to participate, please send me a
    message with some description of why you in particular would be
    wonderfully qualified to test/port this.

    --
     Bill Janssen      janssen@parc.xerox.com      (415) 812-4763
     Xerox Palo Alto Research Center      FAX: (415) 812-4777
     3333 Coyote Hill Road, Palo Alto, California   94304