IBM developerWorks: Introduction to Bonobo: Bonobo & ORBit

“Large-scale software is hard to write in a monolithic
fashion. Inevitably, designs are broken into subparts and layers to
make the software more manageable and tractable to parallel-team
development and debugging. Also inevitably, however, there are
problems at the interfaces: Often the interfaces are not well
specified, and often they are subject to change. Another problem is
that large applications tend to be split into modules that require
hard build-time linkage together, whether as separate source
modules or as libraries. Furthermore, large pieces of software have
often evolved into huge unwieldy beasts that become impossible to
maintain or extend.

Component software is one solution to this traditional problem.
Component software is not monolithic in the least; on the contrary,
it is minimalist. In Bonobo we use the OMG’s IDL (Interface
Definition Language) to codify the contract between components,
providing an easy-to-understand overview of a component’s external
obligations. Bonobo also allows out-of-process components. This
means that a huge piece of software can be pulled in as a component
or automated without any nightmarish symbol mismatches. At the same
time, it allows many bugs in a complex multi-component system to be
easily isolated to a certain component. Similarly, this
out-of-processes operation makes the stability of a multi-component
system a constant: that of the container, rather than scaling
linearly with the number of components (assuming that the container
can sensibly handle subcomponent failure).

Using Bonobo also solves one of the tricky problems in Free
Software that is also one of its strengths: diversity. Often in the
Free world (and in the non-Free world as well, for that matter),
people cease maintaining projects due to time pressure, and
replacements are rewritten from scratch. Or again, competing
projects, such as CD player applications, arise. Allowing these
applications to share the same Bonobo interfaces makes it easy to
provide functional replacements, and tracing the entry points
allows you to better understand an old application.”

Complete Story