From: www.itworld.com

Regular Expressions: Manage CORBA with scripting

by Cameron Laird

May 2, 2001 —

 

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

Resources.

One final note: you'll sometimes see references to IDLscript. IDLscript is the OMG

standard that CorbaScript implements. In principle, IDLscript could have multiple

implementations, but so far, it has only one.

ActiveState leads in scripting technology

We've mentioned ActiveState Corp. of Vancouver, British Columbia, in several previous

columns. We now salute the company for living up to its rather populist slogans, which

include "Power to the People." ActiveState is attempting to apply its profit-making formula

not just to Perl, where it started, but to a range of technologies based on open source,

including PHP, Python, Tcl, and XSLT. The latest step is the creation of an ActiveState

Programmer Network (ASPN) modeled on the Microsoft Developer Network (MSDN). This is an

intriguing move, because ActiveState's portfolio of languages is united more by intellectual

character than marketing convenience. Customers almost always pay for expertise in one

language at a time; they're indifferent to deeper abstractions. It'll be interesting to see

how successfully the company presents "scripting" as the common base underneath all its

operations and offerings.

Resources


Unix Insider