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.
Fast/Flexible Linux OS Recovery
On Demand Now
In this live one-hour webinar, learn how to enhance your existing backup strategies for complete disaster recovery preparedness using Storix System Backup Administrator (SBAdmin), a highly flexible full-system recovery solution for UNIX and Linux systems.
Join Linux Journal's Shawn Powers and David Huffman, President/CEO, Storix, Inc.
Free to Linux Journal readers.Register Now!
- Download "Linux Management with Red Hat Satellite: Measuring Business Impact and ROI"
- Client-Side Performance
- Tibbo Technology's Tibbo Project System
- Sony Settles in Linux Battle
- July 2016 Issue of Linux Journal
- Peppermint 7 Released
- Libarchive Security Flaw Discovered
- The Giant Zero, Part 0.x
- Profiles and RC Files
- Git 2.9 Released
With all the industry talk about the benefits of Linux on Power and all the performance advantages offered by its open architecture, you may be considering a move in that direction. If you are thinking about analytics, big data and cloud computing, you would be right to evaluate Power. The idea of using commodity x86 hardware and replacing it every three years is an outdated cost model. It doesn’t consider the total cost of ownership, and it doesn’t consider the advantage of real processing power, high-availability and multithreading like a demon.
This ebook takes a look at some of the practical applications of the Linux on Power platform and ways you might bring all the performance power of this open architecture to bear for your organization. There are no smoke and mirrors here—just hard, cold, empirical evidence provided by independent sources. I also consider some innovative ways Linux on Power will be used in the future.Get the Guide