May 02, 2001, 5:14 PM —
We like to do a lot with a little. That's the attraction of scripting: it manages big,
complicated computing systems -- CORBA, for example -- with simple, low-cost means.
We affectionately call CORBA "complicated." This column explains why, and touches on
other news in the scripting world.
CORBA is a specification for distribution of objects; CORBA is an acronym for Common
Object Request Broker Architecture. Some older literature punctuates that "Common Object
Request Broker: Architecture." The Object Management Group is an industry consortium -- with
a long membership list -- whose principal product is the CORBA specification. Version 1.0
appeared in October 1991.
CORBA is most often compared to Microsoft's DCOM protocol, the still rather raw .Net, and
Sun ONE. CORBA incorporates elements from throughout the history of distributed computing,
including lower-level precursors such as network file system (NFS) and remote procedure call
(RPC), vanquished rivals like OpenDoc, and a variety of academic projects in distributed
operating systems.
For the purpose of this column, the main point to take from CORBA's history is that the
protocol is a smashing success. We mean this in a precise sense: CORBA 1.0 was difficult,
expensive, and esoteric. Ten years later, CORBA costs little or nothing (at least in some
varieties), it is widely used, and hobbyists and students expect to use it safely.
Multipage "Hello, World!"
CORBA has been tamed, but it remains a heavyweight. CORBA tutorials need to introduce
several concepts, including object request brokers (ORBs) and the interface definition
language (IDL), before the first exhibition of a usefully distributed "Hello, World!"
That is where scripting languages come in. All the leading open source scripting
languages have serviceable CORBA modules that factor out most or all of the "boilerplate"
necessary to make a CORBA application run. Many production systems are coded partly or
entirely in languages such as Perl, Python, and Tcl.
That is rather remarkable. Although CORBA was designed all along to be language-neutral,
early work was done almost entirely in C/C++ and closely-related "systems languages."
Because of skepticism about whether attempts to script CORBA would ever work, a committee
was formed to demonstrate a scripted binding.
By the time a rather Pythonic CorbaScript was released, though, general-purpose scripting
languages had already begun to establish themselves as fit CORBA tools. CorbaScript is a
nice language; a simple script for invoking a standard "Hello, World!" might look like
this:
NS = CORBA.ORB.resolve_initial_references ("NameService")
object = NS.resolve ([["anHelloObject",""]])
object.display("Hello World!") You don't need CorbaScript for something that easy, though. General-purpose scripting
languages can do the job; their syntaxes are comparably sensible, and their performance and
functionality match up well. CORBA programming has become a bit of a "commodity."
And you're the beneficiary. If you need or want to work with CORBA someday, don't be
afraid of it. You can keep using familiar high-productivity scripting languages, and expect
to get about as much performance (sometimes more!) and functionality as you would with C++
or Java. CORBA is going to be around for quite a while, as DCOM and RMI are gradually
replaced by SOAP and .Net. CORBA is particularly popular in finance and engineering
circles.
Two-tiered programming
The Resources section contains links to specific material that can
get you off to a good start with CORBA. But keep in mind a more general principle, of which
CORBA is just one example: scripting is productive. It makes sense that complicated,
performance-constrained, complexly structured technologies like CORBA, enterprise resource
planning (ERP), graphical user interface toolkits, databases, Web servers, compilers, and
engineering solvers are typically written in C/C++ or Java. To combine the elements of such
libraries, though, in novel user-level applications, is best left to scripting languages.
We'll return to other examples of that principle in coming months. For more on that
programming philosophy, see "Good girls don't" and "Scripting -- the fourth generation" in
