Is CORBA legacy?

There are still situations where CORBA could be a good answer:

• when you are building a distributed system involving multiple programming languages and multiple platforms,
• when your system entails sending complex data structures ... and SOAP doesn't cut it,
• when you have high rates of messaging ... and HTTP doesn't cut it, or
• when you have to interact with existing CORBA clients and/or services.

But having said that, there are alternatives that do what CORBA does, only better ... or so they claim. For example ZeroC's ICE

EDIT @fnieto chimes in to say (or imply) that ICE is not free, but TAO is.

This is inaccurate and misleading.

1. ICE is GPL'ed software, and is available for free download. You only needed to pay for ICE if you / your company are not prepared to live with the terms of the GPL. (Or if you need support.)
2. I used ICE as an example of an alternative to CORBA. TAO is CORBA. The ICE authors make a credible case as to why they can get better performance by not being CORBA compliant.
3. TAO is by no means the only free / open-source CORBA implementation. I can think of 3 others, off the top of my head.

The down-side of ICE is lack of interoperability with CORBA middleware stacks, but in my experience interoperability of different CORBA implementations could also be problematic. (Things may have improved in that area ... but I haven't done any CORBA work since ~2002, so I'm a bit out of touch.)

From the existing answers, this gets into almost a religious topic. One can look at CORBA the same way as the half-empty/half-full glass: on one hand, CORBA is dated legacy cruft, and on the other hand it's relatively stable with several implementations available and the "devil you know".

In my line of work, I see CORBA deployed in embedded systems, real-time systems (CORBA has RT extensions), and the like. There aren't many alternatives AFAIK.

Another "advantage" of CORBA is the availability of several high-quality open source implementations, e.g., TAO, MICO, JacORB, etc., with differing licensing and support models. There are also still commercial editions available.

With regard to "most" CORBA apps being implemented in Java--that's not the case in my experience. While the language mapping for CORBA to Java is one of the nicest there is (which may not be saying much), Java already has a very nice distributed computing model that offers richness beyond CORBA, and all-Java apps use that more than CORBA. The vast majority of CORBA development I've seen is in C++ (which is also the worst language mapping).

Finally, CORBA offers standardized asynchronous client-side invocations in the form of AMI, but never offered asynchronous handling on the server side. TAO offers a non-standard server-side implementation called AMH.

I believe that Corba was sort of revived by original EJB spec, as EJB's can be easily turned into CORBA beans by a bit of configuration. I suspect that most Corba deployments were actually implemented in Java.

As to the popularity, I think that there might be some high end deployments remaining for a number of decades but for the majority of people Corba is dead.

There are a whole lot of very sexy ways to do the same stuff (excepting the high end mentioned above).

• Cloud computing (web services, scalable computing, loose coupling, queueing).
• REST services (web-services lite).
• SOAP services (web-services heavy).
• Grid / Cluster computing (queueing, map-reduce and similar)

But of course your Milage May Vary.

Obviously it depends on the type of server and interprocess communication you are considering. And I think Stephen C and Chris Cleeland cover the Corba's positives very well.

Our application has used CORBA (Orbix) for over 10 years so is legacy now. And for how it is written CORBA is a good technology. However if I was starting over I would probably not use CORBA:

• It is complicated and only a small number of people in my organisation know it very well as a result all hard problems fall on them to solve.
• Recruiting staff can be a problem. CORBA just isn't cool any more and isn't getting cooler Although in Ireland C++ developers are a little thin on the ground too.
• Most Consulting firms want to use web services for integration work, so if you want 3rd parties to do the integration you will probably require a web services api anyway.

Now depending on the type of communication I wanted I would probably consider:

• protocol buffers for lots of small messages (I know that I would have to provide the transport)
• web services for fewer large messages

This is based more on finding staff and expertise, 3rd party support and leveraging open source libraries then the technical quality of CORBA, which I use everyday and is strong if a little cumbersome.