---------------------------
ANNOUNCE: CorbaScript 1.3.5
---------------------------

CorbaScript is an interpreted object-oriented scripting language dedicated
to CORBA environments. Scripts (i.e. CorbaScript programs) can invoke any
operation, get and set any attribute of any CORBA object. Moreover, any
OMG IDL interface can be implemented by scripts. CorbaScript provides a
dynamic binding to OMG IDL descriptions: no OMG IDL stub or skeleton need
to be generated. OMG IDL descriptions are extracted from the Interface
Repository and are made directly available to scripts. Invocations of
CORBA objects are achieved by the CORBA DII mechanism. The CORBA DSI is 
used to implement CORBA objects with CorbaScript. Moreover scripts can 
invoke any world-wide CORBA object through IIOP.

CorbaScript fully hides these complex CORBA mechanisms via a simple,
attractive and powerful scripting language. Finally CorbaScript is
the first implementation of the OMG's IDL Script specification
(have a look at http://www.omg.org/technology/documents/formal/corba_script_language_mapping.htm).

-----------------------
Downloading CorbaScript
-----------------------

CorbaScript is an academic project available in full source form, free of 
charge for any use. Try it and give us feedback to improve it.

Go to the http://corbaweb.lifl.fr/CorbaScript/ page
to download the lastest CorbaScript release now!

-----------------
The Hello Example
-----------------

Imagine the following well-known OMG IDL interface:

  interface Hello {
    void hello ();
    void display (in string message);
  };

With CorbaScript, we can interactively invoke a CORBA object that implements
this OMG IDL interface:

  unix_prompt> cssh
  CorbaScript 1.3.5 (Jul 20 2001) for ORBacus 4.0.5 for C++
  Copyright 1996-2001 LIFL, France
  >>> # the `hello' variable refers to a CORBA `Hello' object.
  >>> hello = Hello("IOR:....")
  >>> # the 'hello' operation is invoked on this CORBA object.
  >>> hello.hello()
  >>> # the 'display' operation is invoked on this CORBA object.
  >>> hello.display("Hello World!")

  >>> # we obtain the CORBA Naming Service.
  >>> NS = CORBA.ORB.resolve_initial_references ("NameService")
  >>> # we resolve a name into the CORBA Naming Service.
  >>> object = NS.resolve(CosNaming.Name(CosNaming.NameComponent("anHelloObject","")))
  >>> # we can use an easier syntax because CorbaScript can automatically
  >>> # convert array values into OMG IDL sequences and structures.
  >>> object = NS.resolve ([["anHelloObject",""]])

  >>> # Now we can invoke OMG IDL Hello operations on this object.
  >>> object.display("Hello World!")

Then invoking CORBA objects becomes very simple and user-friendly with CorbaScript.
But, how could we implement the `Hello' interface with CorbaScript?

  unix_prompt> cssh
  CorbaScript 1.3.5 (Jul 20 2001) for ORBacus 4.0.5 for C++
  Copyright 1996-2001 LIFL, France
  >>> # we define a script class.
  >>> class HelloImpl
      {
        # This is the constructor.
        proc __HelloImpl__(self)
        {
        }
        # This is the implementation of the OMG IDL `hello' operation.
        proc hello (self)
        {
          println ("The OMG IDL `hello' operation is invoked.")
        }
         # This is the implementation of the OMG IDL `display' operation.
        proc display (self,message)
        {
          println (message)
        }
      }
  >>> # we create an HelloImpl instance.
  >>> hello = HelloImpl()
  >>> # We can locally invoke this instance.
  >>> hello.hello()
  The OMG IDL `hello' operation is invoked.
  >>> hello.display("Hello World!")
  Hello World!

  >>> # Now we connect it to the CORBA bus and fix what
  >>> # OMG IDL interface this instance implements.
  >>> CORBA.ORB.connect(hello,Hello)
  >>> # we register it into the CORBA Naming Service.
  >>> NS = CORBA.ORB.resolve_initial_references ("NameService")
  >>> NS.bind ([["anHelloObject",""]],hello._this)

  >>> # Now, this instance is an available CORBA object.

What do you think about this small example?
Could you invoke and implement CORBA objects more easily than with CorbaScript?
More complex examples are provided in the CorbaScript distribution like
a CORBA Naming Service shell and a CORBA CosNaming implementation.


--------------------
CorbaScript Features
--------------------

The syntax of this new language looks like the C++ and Java languages but
type checking is done at runtime. It reuses some interesting features of
the Python and SmallTalk languages: everything is an object, source code
is translated into a pseudo code executed by a Virtual Object Oriented
Machine that includes a simple garbage collector.
Current CorbaScript features are:


  ------------------------
  Basic Scripting Features
  ------------------------

  * interpreted language.
  * interactive or batch shell.
  * dynamic type checking at runtime.

  * basic value types: long, double, boolean, char, string, array, dictionnary.
  * variables and scopes.
  * control flow management: if-else, while, do-while, for-in.
  * exception management: throw, try-catch-finally.
  * procedures.
  * modules: reusable scripts.
  * classes: polymorphism, multiple inheritance.

  * simple garbage collecting based on reference counting.

  ------------------------
  CORBA Scripting Features
  ------------------------

  * invocation of any CORBA object through the CORBA DII (the Dynamic
    Invocation Interface) to implement CORBA client programs or tools.

  * support synchrone, oneway and deferred calls.

  * implementation of any CORBA object through the CORBA DSI (the Dynamic
    Skeleton Interface) to implement CORBA server programs.

  * access to any IDL description, calls with any OMG IDL argument types
    like basic types and also complex types (struct,union,array,sequence),
    in, out and inout modes supported. Complex OMG IDL types are managed by
    the CORBA DynAny API.

  * type checking done thanks to the CORBA IFR (the Interface Repository)

  * an IFR cache to improve the performance of type checking.

  * OMG IDL information displaying to, for instance, view functionalities
    provided by an OMG IDL interface.

  ---------------------------
  Advanced Scripting Features
  ---------------------------

  * access to any dynamic C library.

  * access to a Java virtual machine (under work).

  * an extensible runtime: add your own code or new objects in C++.


-------------------------------------
Statement Of Compliance for Year 2000
-------------------------------------

As the C++ code implementing CorbaScript never manipulates times
and dates then CorbaScript is fully Year 2000 compliant. 

But as CorbaScript uses an ORB product which uses an operating system
then CorbaScript will perfectly work after Year 2000 as long as
the used ORB and OS is compliant with the Year 2000 :-)


------------
Getting Help
------------

You should not have any problems compiling the source, but do not 
hesitate to send requests for assistance.
Just send an e-mail to "mailto:goode-support@lifl.fr".
And we will add new needed users features.

There is also a CorbaScript mailing list. To subscribe, just send an
e-mail to "listserv@univ-lille1.fr" with the command:

SUB goode <Your_Real_Name>

in the body of your e-mail message.

To unsubscribe, just send an e-mail to "mailto:listserv@univ-lille1.fr"
with the command:

SIG goode Your_Email_Address

in the body of your e-mail message. You could also go to 
http://wwsympa.univ-lille1.fr/wws/signoff/goode to unsubscribe yourself.


To post a message to the mailing list, send your message as an e-mail
to `goode@univ-lille1.fr'.

This public mailing list is also accessible at:
http://wwsympa.univ-lille1.fr/wws/info/goode

And public list archives are accessible at:
http://wwsympa.univ-lille1.fr/wws/arc/goode

You can find the latest information on CorbaScript on our Web-Site
"http://corbaweb.lifl.fr".

Some scientific information can be found in papers at http://corbaweb.lifl.fr/papers/index.html.

Have fun with CorbaScript. 
