Bonobo is the GNOME architecture for creating reusable software components and compound documents.
Bonobo was designed and implemented to address the needs and problems of the free software community for developing large-scale applications.
Modern applications are increasingly functional and more powerful. As these applications grow in terms of functionality and features, the internal complexity of these applications increases as well.
As applications become larger, the task of maintaining the code becomes harder: re-targeting the internals of applications takes more programmer time, changing the code becomes more difficult and doing a re-design on the applications while being compatible takes a large amount of time from the core developers to push an application into a new direction.
Adding complexity to a software project is extremely simple, and once the projects goes down that road, the barrier for free software programmers to contribute to a given project is increased. Once the complexity barrier has been raised, the time a developer needs to get acquainted with the code and feel comfortable with the over-all architecture to start contributing is raised forever.
Given the nature of the GNOME project, of being a system that is pretty large and consists of multiple applications, it is very important for us to keep the code as simple as possible. Choosing simple, clean and correct design takes precedence over other constraints whenever possible.
Software created by the free software community has been historically done by hobbyists on their spare time working on the things they are interested in. Unlike other software projects, the contributions of individuals to a project can disappear and stop contributing at any point, without further notice.
The Bonobo component system has been designed to solve these problems and the problems derived from the facts outlined above.
Component software helps reducing the complexity of applications by reducing the amount of information a programmer needs to know about the system. This is achieved by making each software component implement a very well-defined interface (note: these interfaces are CORBA interfaces specified in the CORBA Interface Definition Language).
Component software also enabled programmers to build larger, more complex applications by glueing different components together into bigger applications. For example, you can use a Gnumeric spreadsheet component for entering tabular data in your application. You can use an HTML display component to embed HTML text into a region in your application; You can embed a plotting component to add graphic capabilities to your application; You can use an scalable vector graphics (SVG) component to display, edit and manipulate SVG files in your application.
Bonobo is the GNOME foundation for writing and implementing reusable software Components. Components are pieces of software that provide a well-defined interface and are designed to be used in cooperation with other components. In the Bonobo universe, CORBA is used as the communication layer that binds components together.
The magic behind component programming is in the "interfaces" that component export to the world. Each one of these interfaces is a "socket" into which other components and applications can plug into. These interfaces are defined in terms of CORBA interfaces.
One added benefit of basing the component system on top of CORBA, is that programs written in any language can use components written in any other language. The only requirement is that the components agree on the CORBA interfaces used. In the case of the Bonobo architecture, we have provided a number of interfaces that define the interactions required for this to work. By having components implement the Bonobo interfaces, they will work along any other Bonobo-based components.