Category Archives: August 2009

Behind the Scenes with Lucas Rocha

Paul Cutler interviews Lucas Rocha on his history in participating in GNOME as a developer and board director, love of music, and motivation for hacking. Lucas is one busy guy!

Short Intro


How did you first become involved with GNOME?

I became involved with GNOME towards the end of 2004 or the beginning of 2005. It was with a small dialog tool, called Zenity, for the command line. At the time Glyn Foster was the maintainer, and I emailed him, not knowing about Bugzilla, and mailed him a patch to implement “Save Mode” on the file selection. And he liked the patch! I didn’t think I’d be good enough, and he accepted the patch with minor comments and that motivated me to do more work.

I spent some time sending small patches to Zenity. When Glyn took a larger role at Sun, he asked me to maintain Zenity. That was another step towards motivation. I never imagined myself working with international software communities.

I would hang out on IRC and try to figure out who else was there and what they do. It’s something I’ve always done since the beginning and I liked to know what everyone was working on, even today.

What other GNOME teams have you or do you work with?

Since I started in 2005, I’ve been contributing in several random ways. I’ve been module maintainer of Eye of GNOME, Zenity, gnome-session (even though I’ve been a lousy maintainer lately…), GNOME Journal release organizer (role now taken by the interviewer), GNOME GSoC admin (nowadays Sandy, Daniel, and Adam), GNOME Foundation board member (since 2007), Release Team member (since 2008), Roadmap Gang coordinator (since 2007), Membership Committee member (between 2006 and 2007), Planet GNOME editor, Drooling Macaque band organizer (that’s a very important one!), GNOME Brazil coordinator (now coordinated by Jonh Wendell and others), GNOME Annual Report editor (since 2007), and some other random stuff. I try to keep a balance between community management type of activities and hacking, as both types of contributions excite me. Recently, I’ve been focusing mostly on the GNOME Foundation Board, Release Team and the coordination of the development of the new GNOME website. Most of my hacking energy is concentrated in my job at Litl (working for a startup can be quite demanding…)

What do you work on today with GNOME?

Much less than I want due to my current job at Litl. When I was at Nokia, I had more time and motivation to work on GNOME. I’ve always been a GNOME volunteer. I am also a member of the release team and the Foundation Board. I’ve been doing some minor coding every 2 months on gnome-session. Well, maybe once a year…. I just don’t have the energy or time for the coding side.

I am currently working at a startup called Litl working on secret stuff that everyone makes jokes about, like Vincent. We’re in startup mode which is a bit of a drain on my time for doing GNOME work.

What motivates/keeps you motivated to work on GNOME?

It’s a combination of having fun, love of hacking and learning, social activism, meeting new smart and generous people, making friends, visiting nice places, and more! Not necessarily in this order 🙂 Working in such a large project and community like GNOME opened a wide range of personal and professional opportunities for me. And I’m very grateful for that. I have some great friends inside the community and I strongly believe in the fundamental goals of GNOME as a project: a free, open, accessible, easy to use set of technologies that help people to achieve their personal and professional everyday activities.

You were just elected to a second term on the GNOME Foundation Board of Directors. How did you become to be on the board?

I became a board member to replace Dave Neary in 2007 during GUADEC in Birmingham. The board chose me to replace him when he stepped down. I was elected in 2008 and re-elected in the last election.

What do you like about being on the board (Vincent giggles in the background)?

It has a lot to like, as I was saying earlier, where you can support the community in different ways. You learn a lot of what is going on in the community by paying attention to how they are asking for help.

It’s a good position to support the community in a more concrete way, and help make things happen.


Favorite food?

Biased answer, as I haven’t eaten this in a long time. Acaraje’, abara’, and moqueca.

Favorite vacation?

Brazil – It’s weird to say that as a Brazilian! Salvador.

What are you passionate about?

I have basically two passions in life: hacking and music. I started loving music way before hacking. This is mostly because I grew up seeing my Dad playing acoustic guitar with his BPM (Brazilian Popular Music) band at home, parties, bars, etc. So, since I was 12 years old, I’ve been playing (drums/percussion) in different bands of different genres: samba, bossa nova, heavy metal, grunge, hard rock, funk, forró, etc. It’s been some time since I played anything (except at the jam sessions at GUADEC). I really miss it… On the hacking side, I think I started very late from an “average geek” perspective. If I remember correctly, I started doing web development (mostly PHP) a year before I got into university back in 1998. I dived deep into hacking at university where I started to use and develop free software for real thanks to all the smart people I met there.

Who are your favorite GNOME hackers? Why?

Hmm, this list is a bit long… I have several favorite GNOME hackers for a different reason for each: andreasn, vuntz, hp, owen, alexl, ross, federico, mclasen, behdad, walters, desrt, shaunm, and many more.

You originally created the Behind The Scenes interviews for GNOME Journal. What was your inspiration?

It’s not a new idea really. KDE had People Behind KDE and Ubuntu had a similar thing. I thought we needed something similar in GNOME. The cool thing about the Behind the Scenes interviews is that you get to know a contributor from a more personal perspective. It’s something to/from the community. I think the ludic side of working on a free software community must not be forgotten: it’s a fundamental aspect of our daily activities that keeps us all together, working on the same stuff.

Discuss this story with other readers on the GNOME forums.

Writing Open Source Conference

Paul Cutler, a member of the GNOME Documentation Team, recaps the Writing Open Source conference held earlier this summer in Owen Sound, Ontario, Canada.

The Writing Open Source Conference (aka Woscon) took place in June, 2009 in Owen Sound, Ontario. The conference was conceived and hosted by Emma Jane Hogbin, a documentation contributor to a number of open source projects, including the Linux Documentation Project, Drupal and Ubuntu.

The GNOME Foundation, through a donation funded by Intel, sent four GNOME documentation team members to the conference: Shaun McCance, Phil Bull, Milo Casagrande, and Paul Cutler. There were a total of sixteen attendees, with representation from such projects as GNOME, BSD, XFCE, Ubuntu, Drupal and more.

The conference ran over three days, and each day had a different focus. The first day included keynotes from five speakers:

  • Fame, Fortune and Technical Writing by Dru Lavigne, Author
  • Information Architecture: panning for gold by Lynda Chiotti, Information Architect
  • Learning styles and documentation to match by Belinda Lopez, Instructional Designer
  • Cat Herding 101: Community management in Open Source by Addison Berry, Documentation Lead, Drupal
  • Licensing and Authoring by Megan Langley Grainger

Each talk offered key takeaways and learnings for the GNOME Documentation team. From Information Architecture, we learned the importance in planning your writing and understanding the message you want to deliver in creating documentation. This talk has influenced the way that we are planning GNOME 3.0 documentation through planning sessions in IRC and email.

The first keynote of the day, Licensing and Authoring, was informative on the benefits of using various licenses for writing documentation, such as the GNU Free Documentation License (GFDL) and various Creative Commons licenses. The timing of this talk was perfect, as the Documentation team was thinking of switching from the GFDL to a Creative Commons 3.0 Share-Alike license. This talk helped us understand the challenges in switching licenses, as well as the benefits of using the CC-SA 3.0 license. Since Woscon, the decision was made to use a CC-SA 3.0 license for all new documentation in GNOME going forward.

The Information Architecture and Learning Styles talks both discussed knowing your audience and creating personas for them. When writing documentation, it’s important to keep your audience in mind, and write documentation that speaks directly to them in language they understand.

Addison Berry’s talk on community management has influenced the GNOME Documentation team, and with Woscon over, we’ve put these practices into motion. To create a more welcoming community, the GNOME Documentation team has re-organized their wiki pages to make it easier to find information, get involved, and update the pages in a timely manner. We’ve also started scheduling formal monthly meetings to discuss the team’s priorities, and bi-weekly community meetings, which are open question-and-answer sessions where members of the Documentation team are scheduled to be in IRC. Lastly, we’ve created a GNOME Documentation Team blog to update the community on what we’re working on.

The second day was in the form of an “unconference”, similar to a Barcamp. There were a number of roundtable talks and presentations, including:

  • Introduction to Project Mallard and Pulse
  • Making documentation easier for translators
  • FLOSS Manuals project (
  • Creating certification programs for free software projects
  • Community management

Throughout all of these talks and presentations, it was helpful to learn that all of our open source projects share the same challenges, from community involvement to translation challenges.

The third day of Woscon was a hackfest. The GNOME documentation team put this time to good use. We created a roadmap for the GNOME 2.28 and GNOME 2.30 / 3.0 releases; had a tutorial form Shaun on Mallard, the new XML schema for GNOME documentation; planned the topics to be included in the new user guide for GNOME 3.0; and planned and wrote documentation for Empathy, written in Mallard, to be included in GNOME 2.28. We also used this time to triage half of the open bugs in the GNOME User Guide, and closed over a third of all open bugs. Lastly, we revamped the team’s wiki pages, organizing the Documentation team into three subteams (Writing, Translating and Community) and adding tasks and updating our roadmap.

One of the biggest benefits coming out of Woscon was the various open source documentation projects coming together to create a new community. While the GNOME team worked on the tasks above during the hackfest, other conference attendees were transforming the conference registration site into a full blown community site so all of us would be able to continue to communicate and share best practices among projects. Another group started work on a brand new open source style guide that documentation projects across free software could utilize. All of these tools will be able to be leveraged over time, and it was exciting for us within the GNOME community to be able to be present at this first conference. As with any hackfest, the energy and enthusiasm that occurs when working in person was in full effect, and we are grateful for the opportunity to attend the first Writing Open Source conference.

Discuss this story with other readers on the GNOME forums.

Putting the Network back into G(N)OME – An Interview with John Palmieri

Paul Cutler interviews John Palmieri to discuss network applications and innovation in GNOME, based on John’s recent talk at GUADEC 2009.

You recently gave a talk at GUADEC entitled: “Thinking Outside the Box: Bringing the Network Back into G(N)OME”. What was your inspiration for giving that talk?

Back when the Linux desktop’s biggest claim was that one could make it look like a Mac OS, Windows, Solaris (CDE/OpenLook) or even NextStep desktop, two contenders arose to lead the charge towards developing an actually viable Linux desktop operating system. Of course I am talking about KDE and GNOME, both of which I compiled and used since they initially showed up on the scene. I like to joke that I stuck with GNOME because one day KDE wouldn’t compile for me. Yhe truth, however, is that the GNOME Panel was probably my biggest source of frustration with it crashing all of the time.

The real reason I stuck with GNOME was that it had a vision or at least was very good at making me feel like it had a vision. In those days, G.N.O.M.E. stood for the GNU Network Object Model Environment, which conveyed a meaningful purpose of developing a system of small components that linked together to form larger programs. This was very much in line with the Unix principal of writing a program to do one thing well and pipe them together to solve complex problems.

Over time we realized that for a desktop environment, this vision was a bit too technical and G.N.O.M.E. became to be known as GNOME and our vision shifted to becoming a desktop that your grandmother could use. After working on D-Bus and OLPC and witnessing the work at Red Hat on Yarr!, Mugshot and Online desktop, I sort of realized that we don’t just want to be the desktop your grandmother could use – we need to be the desktop your grandmother, mother, sister, brother, niece, nephew and best friend, to name a few, WANT to use. People use computers for communications and community these days and the only way to achieve that is through the smart use of the network.

I have to admit I thought it was a pretty cheeky title. Since the N in GNOME used to stand for network and we had already done such a great job of networking inside the box with D-Bus, I thought, why not ask people to think outside their own boundaries by thinking about how we could harness applications running outside of the desktop to make the desktop a more compelling experience.

GNOME has had a number of technologies over the years such as CORBA and Bonobo (which was itself similar to Microsoft OLE) that have tried to focus on networked computers working together. What did these kind of technologies do well, and what opportunities did they have for improvement?

So, Microsoft OLE was one of the many inspirations that geniuses like Miguel De Icaza and Nat Friedman had in mind when starting GNOME. People knock Miguel because he went on to create Mono, a clone of another Microsoft technology, but the truth is his vision and ability to form large communities to execute that vision is something to praise. Without him there would be no GNOME.

Sometimes our vision was good but needed some tweaking. This was the case with CORBA and Bonobo. Instead of taking our vision and figuring out what we really needed, we got caught up in the hype that was CORBA. CORBA is a networked object model that allows you to write an object in any language and have applications piece these objects together to form a larger application. In this larger application, the pieces can run either in-process or out-of-process. The truth is, CORBA is highly tied to C/C++ and pretty overly complicated. We never even looked at the networking part where you could run objects across a network via CORBA.

Bonobo was an attempt to put a layer in between CORBA and the programmer but in the end, most of what we wanted to do was much simpler to do with GModules and GObjects directly. For any out of process interactions D-Bus’s communication bus model along with a pseudo object mapping layer was much easier to wrap ones head around than a full blown object model.

The idea of simplifying development by making applications concentrate on what they were good at was a great idea, but in practice, CORBA turned out to add more complexity than it was worth. In a world where you had most, if not all of the source code, it was much easier to achieve the same goals using pluggable libraries like gstreamer, in process widgets and an inter-process communications bus for the times neighboring processes needed to communicate.

You were a long time contributor to D-Bus, which eventually replaced Bonobo. D-Bus enables communication between desktop applications. In your opinion, what has led to the success and wide spread adoption of D-bus?

Well, many technologies replaced Bonobo, D-Bus just replaced the inter-process communication bits. We still don’t have a full blown object model but that is because we don’t need one. I attribute D-Bus’s success to a couple of factors. First is its simplicity. By adding routing, auto-discovery and native marshaling of data types to Unix domain sockets, and integrating the dispatching into both the glib and Qt main loops, we gave the developer all the power they needed without having to dive into the details of systems network programming. Furthermore, the native bindings and relative simplicity of recreating the D-Bus spec from scratch led to implementations that matched the work flow of each environment. Where CORBA meant adapting your programming experience to match the CORBA model, D-Bus language bindings meant developers got a much more familiar experience. You still need to know a few D-Bus’isms to produce effective D-Bus code, but the barrier to entry isn’t quite as high.

Yet another reason for the success of D-Bus was that unlike CORBA, which was re-purposed for the desktop, D-Bus was designed with the desktop in mind from day one. And then there is the community of applications that sprung up around D-Bus. Before HAL hit the scene, we were interacting with system services through setuid hacks and haphazard event systems which sometimes worked if the moons were aligned and your hardware configuration was correct. D-Bus gave us the ability to centralize event policy in a few compartmentalized applications which sped up the solving of issues such as desktop hot-plug and device configuration. Because we were able to see such large gains so quickly with D-Bus, more and more people turned to D-Bus as a new way to solve whatever programming issues they were working on. It open the floodgates of ideas on what is possible when communication becomes a central theme of application design.

What are some of your favorite applications that take advantage of D-bus and why?

It is hard to say, I love them all, even the ones which use D-Bus in a crackful way. That being said I like apps that get out my way and just do the job they are meant for. NetworkManager kicks butt. Chris Blizzard of Mozilla has to work with Mac and Windows. He also boots into Fedora to keep up with the progress the Linux desktop is making. Whenever I see him he extols the virtues of NetworkManager and how they are light years ahead of anything in Windows or even MacOS. Wireless just works, VPN just works. I also like the libraries like Mojito and Telepathy which use D-Bus to provide a standard API for anyone who wishes to use it. One of the most unique applications I have heard of was a guy on the mailing list who said he uses D-Bus with TCP/IP sockets to control those card reading systems some cities have installed in their subways. He didn’t say which city but it is kind of cool that people have found it useful for applications I would have never even imagined.

You made the arguement at GUADEC that GNOME desktop developers should also be web service developers. What are some of the opportunties in the GNOME desktop and web services GNOME developers could play a role in?

To tell you the truth I don’t even know of all of the initiatives out there. I came to GUADEC with my talk not to just say we should be doing this but to also say people are doing it and they need to be more public about what they are doing. Here are the key areas I think we need to expand on though:

  • Data sharing – one place we can really give proprietary software a run for its money is to have our content creation tools make it easy to share data and to collaborate on creating content.
  • Metadata – people forget that code is content too and we have a lot of metadata on that code that would make it easier and less error prone to develop GNOME. Metadata such as release history should be queryable and should hook up to some sort of notification system.
  • Existing service connections – people put their lives in blogs and on facebook, etc. We need to provide easy access to those services. We also need to make it easy to move from say twitter to the more open

My favorite quote from your presentation focused on what adding network technologies to GNOME applications means for GNOME’s end users: “Because meaningful connections turn consumers into producers!”

People who produce are the backbone of our community and most of us started as users. It is because of good experiences, these meaningful connections I speak of, that we decided to do more and produce content. If we can get more people producing content our numbers and influence grow. By adding networking, or in more social speak, communications to our applications, we increase the potential for meaningful connection to happen. The more people feel they are not stuck on an island by themselves but are instead part of a larger community, the more incentive they will have to start contributing content of their own in order to make the experience with that community richer. Just look at Twitter. Why do people take time to pull out their phone to write a short blurb about what they are doing or feeling? It is because they know they are potentially networking with millions of people who may end up learning a bit about the poster. The poster has now become a producer, not because they felt they should produce something but because the meaningful connections proved to be a powerful incentive.

You highlighted a number of GNOME applications that you believe are taking advantage of the network today. In your own words, can you describe what excites you about the following applications:


Most of us blog. Right now I’m writing you answers to your interview questions but it is all very deliberate. Tomboy is sort of quick, at this moment, stream of consonance writing medium. Soon we will be able to easily publish and sync those notes with snowy the web app component to Tomboy (or GNote if someone writes the functionality into it). Going further than that, what if the same publishing concept was extended to contextual situations such as reading documentation in DevHelp and then being able to upload notes on say a code snippet so others reading the same document can also read your notes.

Abicollab / OLPC:

Collaborative editing is just a great idea on many levels. Imagine a teacher tutoring a child without having to look over their shoulder or even having to be in the same room. Or, how about teams needing to put together a single report together. By making it real time collaborative instead of splitting up each section, the text will most likely flow better and mistakes can be caught and corrected in real time.

Rhythmbox and Banshee:

In the world of media players content is key. If I can’t get my hands on content they are useless to me. Being able to buy songs or listen to internet radio out of the box, without having to configure things makes these apps useful the first time I launch them.

One Laptop Per Child and Sugar:

I worked on these projects so I am a bit biased, but from the beginning the concept of the mesh network revolutionized how we thought of connectivity. It meant that every activity had to in some way give the ability for the user to produce something to share over the mesh. It could be simply bookmarks in the browse activity or pictures in the capture activity.


Going through the logs of a past conversation. Cost – a couple of minutes. Feeling “connected” to your friends – priceless

Seriously though, Empathy not only gives you chat functionality, it has widgets ripe for embedding in other apps.

What brainstorming ideas have you had for new features or new applications that can leverage the network and collaboration?

Right now I am working on developer tools in the guise of the Fedora Community portal. What I would love to see is real time communications between upstream and the distros where we get instant notice of releases and patches to the people who care. If we can make development more open and streamlined instead of behind walled gardens we can spend more time innovating instead of chasing bugs.

Discuss this story with other readers on the GNOME forums.

Glade 3 sees the light of day

The GUI designer tool that has been building your GTK+ applications for years is back with a completely new generation of homegrown free software. Supporting all the widgets in the GTK+ 2.8 family, gnomeui widgets, the gnome canvas widget, and a whole new feature set, this new tool is sure to raise a few eyebrows.

Glade 3 has been a lingering myth for several years now. Originally thought up and designed by Chema Celorio, Damon Chaplin (author of the original Glade tool) and others who were around back in 2001 before GTK+ 2.0 was ever released; Glade was worked on vigorously by Chema, Carlos Perello Marin and others. Chema was an outstanding contributor to GNOME in many ways and was unfortunately taken from us in a skydiving accident in november 2003, this one goes out to you Chema!

Joaquin Cuenca Abela, who was working on edalg, picked up work on the Glade rewrite later in 2002 and hacked hard, along side Paolo Borelli and many others for a good few years. In the mean time when GTK+ 2.0 had finally hit the streets and it was apparent that the rewrite was going to be a little bit late; Glade was ported to the new GTK+ without a redesign: “after all” says Paolo “it was supposed to be a stop gap solution for a few months” – Damon has since then been bearing with us and keeping the port up to date with the new GTK+ widgets that we all need.

When I stumbled upon Glade 3 (for some work related reason); Joaquin was nowhere to be found and the mailing lists had been down for a few months, so I sent mail to lists, kicked and screamed and then in september 2004 we got the project back on its feet again.

David Hoover took maintainership duties and put gtk-doc headers on all the functions everywhere, we all thought it was a little much; but now we have great documentation so thanks David! I’d have to say we had our own rocky start since we all agreed that Glade should be using libglade as the parser module of Glade proper, this was an expensive change in design to finally ditch (it all turned out to be to complex and had namespace issues to boot).

Since then Glade has been simmering and refining itself under my watch, it’s been lonely at times but I’ve usually had the company of at least one other solid contributor; Juan Pablo Ugarte and Ivan Wong to name a couple.

Thanks to all the great people that brought Glade to be over the long years, patch writers, translators, maintainers, those people on IRC that said stuff like: “why does Glade crash when I add a text entry?”, and bug reporters alike; we’ve been able to realize this great project that has been for so long, only a hope and a dream.

So what’s so good about the new Glade tool?

Glade will not do your dishes or walk your dog, but here are a few of the things that it does do now:

  • As a base standard, you are now allowed to undo and redo all of your actions that effect your project widgets with a history list of the entire session, so no more fear about making crazy mistakes; deleted widgets come back to life.
  • You can now manage multiple projects at once and move widgets back and forth freely, sporting a recent project list for your added convenience.
  • No pain switching tools: this new Glade tool supports all 2.8 widgets and is fully compatible with the libglade format and reads Glade files generated by Glade 2 like a champ.
  • You can now integrate your own widget catalog into the Glade tool as well as libglade. With the available documentation ; adding a widget to your custom widget catalog should normally be a matter of a few lines of XML.
  • Next on the menu, for your added user wowing blingness, we’ve got your new palette that resizes impressively:

  • Drag and resize support now available in GtkFixedGtkLayoutGtkTable and GtkBox classes.

  • Contextual help using the Devhelp documentation browser.

  • As usual, Glade also builds wherever GTK+ builds.

Under the hood

For the curious, heres a little look at what makes it tick. The new Glade tool takes maximum advantage of introspection mechanisms in the GObject framework in order to minimize the work load of widget integration and allow for a more generic way of supporting widgets, properties and signals in general.

This Glade was also designed to be a simplified component, now there is no code generation and it can be embedded into an IDE:

An IDE would also be the right place to install code generation plugins if that were really desired.

Glade is now also sporting a dynamic widget catalog, which gives you fine-grained control on how your new widget can be handled by the Glade tool, basically; Glade will lookup the type, initialize the object class and introspect all the signals and properties. After that, the internal representation of widget classes are updated from the catalog. Support routines can be loaded from the plugin backend and properties’ defaults can be overridden, properties can also be added to widget classes. Glade will load these catalogs at startup in order of their dependencies so that each catalog that is loaded inherits the functionality of its parent, for example – a custom derived GtkBox will come with fully functional drag support for its children. We’ve implemented the libgnomeui and gnome-canvas widgets as separate catalogs and they will be distributed separately.

A container abstraction layer is present in Glade 3 that allows you to treat certain hierarchic relationships specially; in this way, any object can parent any other object, furthermore, many container relationships can be defined for a single object class; each performing container tasks (add/remove/child properties) via separate code paths. Because of this abstraction, a treeview like object could also be a normal container and allow for widgets to be added in the normal way, but also support the addition of child treeview columns and those treeview columns’ child renderers, etc. We hope to be able to address all the possible object hierarchies that can exist using this technique. This type of functionality actually already works (TouchTunes has been using Glade 3 with GObject delegates for about a year) if you apply the gobject support patch to libglade. Currently using non-standard hierarchic relationships in libglade require you to write custom code to build and add the children to their parents; hopefully with the GTK+ builder we’ll be able to address that problem in the widget code itself.

The Future

For those who didn’t know, GTK+ will be supporting Glade files natively as a part of the 2.12 release cycle (or a very similar format). The GTK+ builder will support building gobjects and also allow for tricky hierarchic relationships in an encapsulated fashion. It’s a big priority for Glade to support the new format as it will unlock a lot of doors to new features. What this spells is that users will finally have access to treeview columns, treemodels, sizegroups, adjustments, actions, pixbufs and all gobjects. We plan to maintain compatability with both Glade formats and allow for smooth conversions between the two formats.

We also have a new contributor worth mentioning, Jeff Westerinen, a developer from PalmSource Tools Development says:

PalmSource has always provided our licensees and developers with the tools it takes to create great applications, so when we decided to transition our platform from a proprietary offering to one based on open source components, we were faced with the task of searching for tools in the open source community that would suit the needs of our developers. One of those tools was a UI editor. Having made the decision to adopt GTK+ as our UI platform, we went in search of a GTK+ UI design tool.

After some research and mailing list interactions, Jeff stumbled upon the new Glade:

In short order, I’d downloaded the module, read the documentation, and, with great help from Tristan, Juan, and others, our widget designer and I were able to add our own widgets within about a week.

Recently, Jeff has been given the “go-ahead to begin to contribute to the Glade 3 project” and goes on to say:

I can honestly say that, from the start, this has been a very positive experience for me, and I’m looking forward to being a part of the Glade 3 team.

Welcome Jeff, together let’s make GTK+ look awesome on the handheld!

Vincent Geddes (author of that sexy palette) is also working on the most exciting and visual new Glade features (as usual). The first revisions of the single window version of the Glade UI that embeds the project widgets will be available in CVS HEAD shortly.

And of course there are many features on the wishlist! I’m still wondering who will be the lucky contendor to implement the “style” tab in the property editor… (hint)

About the author

Tristan Van Berkom lives in Montreal (Canada) and is currently working for TouchTunes Digital Jukebox, a basement and coffee brewed, self-taught hacker who discovered the computer back in 1999. His passion and life discipline is b-boying (breakdance) and his hobbies include writing jukeboxes, writing Glade and enjoying the view at the swimming pool. Luckily the jukebox gigg has been paying the bills for quite some years.

Discuss this story with other readers on the GNOME forums.