Letter From the Editor: GNOME 3.0

Join Jim Hodapp as he apologizes for the absence of GNOME Journal, describes his thoughts on the future of GNOME, and asks you, the readers, to start dreaming big for GNOME 3.0.

Let me be the first to say to you, the readers, it’s been a long time since the GNOME Journal has published any new issue and to let me formally apologize … sorry! With that out of the way, let me also welcome any active readers back to the brand new and highly reinvigorated GNOME Journal! As you all know, just like GNOME itself, GNOME Journal is entirely written by volunteers. Nobody gets paid a dime to work on it and so when the number of motivated writers approaches zero, GNOME Journal is very difficult to publish. If you like to write and would like to write a regular column about GNOME, its community, a certain GNOME application, etc., please don’t hesitate to volunteer. If you’d like to write an article once, we’ll gladly accept that as well.

Now on to the real topic for my article, the topic that has been a hot topic among the community blogs lately: GNOME 3.0. Just when you thought GNOME was doomed to forever increasing its 2.x release number, ad infinitum, a real glimmer of dreaming, design and actual working code has surfaced under the label of GNOME 3.0. In my opinion, I don’t care what it’s called, GNOME 2.30.0 or GNOME 3.0.0, it’s time to bring some excitement and re-energize the user base of GNOME with a fresh desktop experience in a sleek and modern looking way. This is not just about a new theme however. There are a lot of new technologies out there that need to be better integrated into an API that will encourage application writers to use. To accomplish this, GNOME needs an API that accomplishes a similar feat to what Cocoa does for Mac OS X programming. I believe that the GNOME project is in a unique position in the open source desktop space to bring the same experience as Cocoa, but in a completely open, and thus more effective manner than Cocoa could ever accomplish. Let me give some specifics examples as to what I am referring to.

Consistency is a large goal of the core GNOME API. This means that the general API needs to feel the same no matter if one is trying to install their application to automatically startup when a user’s session starts, or if one is trying to add a file dialogue to prompt a user to select a file to open. It doesn’t matter what one is doing, it needs to be named similarly, it needs to try and hide as much detail about how the desired functionality needs to work, and it should do this in a very modular way. The fact that the core of GNOME, gtk+ and obviously glib are written primarily in straight C can sometimes hinder this. It is amazing what can be done in an pseudo object-oriented fashion in C and the developers have done an excellent job in this, but I believe that libraries that most application writers for GNOME will use to write their applications need to be written in an object oriented programming language. My personal favorite is C++ since you get the powerful nature of true object oriented programming while still getting much faster speed when compared to a language that requires a underlying virtual machine like Java or C#. But this is a side issue; the language here doesn’t matter as much though as the underlying concept: modular, object oriented design is very important in graphical interface design. Object oriented programming lends itself very well to more naturally describing the data structures, hierarchical structure of a GUI, and reusable, modular nature of GUIs. Functional programming with advanced description capabilities of data types using structs in C only go so far. At some point, the C language reaches its limitations and the cost to benefit ratio swings largely in favor of a slightly higher level language. It might be time to consider writing some of the core GNOME APIs in a real object oriented language.

Apple was able to accomplish this through the use of Objective-C for the Cocoa API. Objective C is an advanced, object oriented programming language that accomplishes the two main things that I mentioned previously. First, it’s a fast system level language that doesn’t add too much overhead to the API calls. It still accomplishes what should be a core goal of any good core API design – speed and efficiency. Second, it gives the modern, rich descriptive nature that only a true object oriented language can give. I don’t believe that GNOME needs to necessarily use Objective-C for the core APIs (though it’d be a large improvement over using straight C), the point is it’s time to move on from C.

Another way that GNOME 3.0 should change is to completely rewrite what it means to be a desktop environment. Maybe the entire desktop need not be a desktop metaphor at all. The community has a lot of bright and creative people. I believe its time for the open source desktop community to bring the best minds together to create something completely new. The general interaction of using a mouse, keyboard, and in some circumstances, using ones hand through a touch screen, hasn’t changed in decades. Sure, some fancy 3D effects and such have been added, but the underlying metaphor has not changed. Maybe this isn’t possible in one large change. Maybe iterative design is the way to go. I hope I’m proven wrong.

Now that I’ve added a few of my opinions on some core things that I think need to shape GNOME 3.0, let me encourage you, the readers, to start dreaming. Like I mentioned in the previous paragraph, I believe now is a unique time in the history of GNOME to take it to the cutting edge of interface design. We need to take into consideration what the interface of a computer means today. Computers are used everywhere, from the average desktop machine used to do word processing, web surfing and email, to the more simple, but advanced interface of a touch screen mobile phone. GNOME is more than just a desktop, it is the interface from the human user to many pieces of cutting edge electronic technology. Let’s take GNOME beyond the simple desktop metaphor that the computer industry has been stuck in since the 1980s. I encourage all of the GNOME Journal readers who are interested to blog about their ideas for GNOME 3.0. After posting a blog entry, go ahead and post an email to the GNOME Journal mailing list with a link to the entry. Let’s get a large discussion going that dreams up what GNOME 3.0 can and should look like.

After posting to the mailing list, if you’re a programmer or you’ve been looking for an excuse to get into programming, I recommend this as the time to put your code where your mouth is. Experiment, starting with simple concepts of what you’d like to see for GNOME 3.0, moving to more complex implementations in an iterative way.

Dreaming and then shaping GNOME 3.0 by contributing ideas and code will not only improve the general GNOME desktop, but it also has the possibility to change the entire computing experience. I believe that if we can succeed in turning GNOME into something new and innovative, it will start to be used more and more by people who find it useful and exciting. As a final thought and as an example of this point, consider what happened to Firefox. It came out of the ashes of Netscape Navigator into something new, lightweight, innovative and useful. It now commands considerable world wide adoption and adoration. The same can happen to GNOME if we, as the core community behind GNOME, come together to design something amazing.

Discuss this story with other readers on the GNOME forums.

Advertisements

Posted on April 21, 2009, in April 2009. Bookmark the permalink. Leave a comment.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: