GNOME, Its State and Future
Gill (GNOME Illustrations) and Eye of GNOME (image viewer and organizer) are the most recent additions to the suite of productivity applications for GNOME.
Gill is particularly interesting, since its native file format is the Web Consortium's Scalable Vector Graphics (SVG). Internally, the application has been organized around a Document Object Model (also a W3C standard). Gill is still in its infancy, but given that it is based on a strong foundation, it is already a fairly powerful display.
Eye of GNOME is also in its infancy, but has served as a test bed for various new GNOME technologies: our new imaging system, various new GNOME Canvas improvements and the new model-view-controller-based widgets. It is our image viewer of choice right now and amazingly fast, too.
The lack of a standard, freely available system for component programming is a problem present in the UNIX world today. One of the issues being addressed by the GNOME project is providing such a framework. The GNOME framework is based on the CORBA object model. During the design of the GNOME component interfaces, we tried to address a range of needs:
Automation: allow applications to be remotely controlled. People should be able to launch and control GNOME applications remotely. This is achieved by the GNOME Object Activation Directory (GOAD), the supporting libraries (the GNORBA libraries) and making use of the CORBA facilities for binding CORBA to scripting languages.
Compound document creation: it is important to design and implement the GNOME applications in such a way that they will let the user create compound documents (those with contents that may have been produced by different tools).
In-place document editing: the next step in compound document creation is providing ways to edit embedded documents inside a container application. This means it should be possible to make changes to an embedded spreadsheet document inside a word-processing document in a seamless fashion: it is important to make this integration simple and easy to use.
Component reuse: filters and pipes proved to be important building blocks in UNIX, but they are very limited: the flow of control usually goes in a single direction, and the protocol used to exchange information is too simple to meet today's needs.
Desktop integration: the GNOME desktop deals with CORBA interfaces to services. As far as an application is concerned, only the published interface a program provides is used.
In GNOME, interfaces for specific tasks play an important role. It is up to the user to choose which implementation of those interfaces he uses. For example, the Mailer interface is implemented by the GNOME Balsa mail reader, but it can also be implemented by Emacs RMAIL, Emacs GNUS or the Mozilla mail reader. If any of those provide the CORBA Mailer interface, they will work properly with the GNOME desktop.
All these needs can be met by the use of CORBA, an OMG standard (http://www.omg.org/). We are using ORBit as our CORBA implementation, with very good results. ORBit was designed to be small, fast, robust, reliable and efficient. Many times people hear the word CORBA, and they immediately think “bloat”. This is not the case with ORBit. ORBit is thin: for most applications, the working set of ORBit's ORB is around 30K, which makes it suitable for embedding in almost every application. This is exciting, because applications such as Gnumeric and a few others export their internals to the desktop as highly specialized reusable components (think “UNIX filters on steroids”).
CORBA has proved to be very useful, as we can use it to run regression tests on our applications from a Perl script using Owen Taylor's wonderful CORBA-Perl (people.redhat.com/otaylor/corba/orbit.html). This just happens to be one of our favorite CORBA bindings for a scripting language, but you can get CORBA bindings for almost every language.
By using CORBA as our foundation, we ensure interoperability with existing systems, and anyone who supports CORBA can talk to our applications. CORBA in GNOME plays the same role COM plays in the world of Microsoft Windows.
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 conjunction with other components. In the Bonobo universe, CORBA is used as the communication layer that binds components together. More about component programming can be found in the Bonobo documentation.
In short, Bonobo provides the following features to an application developer:
An infrastructure for creating reusable components as full-blown processes, shared libraries or remote processes.
An infrastructure for reusing existing components. For example, you can use Gnumeric to provide data-entry facilities in your own application or as a computation engine.
An infrastructure for creating persistent controls.
An infrastructure for creating compound documents. This means not only reusing existing applications in a vertical application, but creating single documents composed of various parts: spreadsheets, equations, graphics and so on.
- diff -u: What's New in Kernel Development
- Divx# Watch The Other Woman Full HD Online Streaming Viooz
- Numerical Python
- Use Linux as a SAN Provider
- Great Scott! It's Version 13!
- NSA: Linux Journal is an "extremist forum" and its readers get flagged for extra surveillance
- RSS Feeds
- Tech Tip: Really Simple HTTP Server with Python
- Adminer—Better Than Awesome!
- Linux Systems Administrator