When you load the app it shows you a list of the available opportunities you can achieve:

(obviously a bunch of these are dummy ones).

You can use the combo boxes at the top to choose which types of opportunities (e.g. Ubuntu Community, Ubuntu UK LoCo Team) you want to view, as well as their category (e.g. Ubuntu Community could have categories such as QA, Development, Advocacy).

Some of the opportunities have padlocks on them. This means that you need to complete another opportunity before that one is unlocked. This helps provide more of a logical journey of things that you can do.

Part of the goal of the accomplishments project is to provide better, more contextual information for how to get started doing something. As an example, if you are curious about the Filed First Bug opportunity, you can double-click it to read information about how to complete it and where to find help:

Obviously this information can be improved (and particularly the links, they are just dummy links). We would also want to add nice things like clicking on an IRC channel and it loading in an IRC client.

The Filed First Bug is a real working accomplishment. When you run the scriptrunner (part of the prototype, but not tied into the GUI yet) it will run the accomplishment’s script and check Launchpad to see if you have filed a bug. If you have, a small notify-osd bubble appears and you can see your trophy in the My Trophies view:

In the real implementation the scriptrunner would run as a service without you having to run the app to start it.

I am pleased with the progress I am making. Next I want to get some more example accomplishments tied in and then I am going to start looking at building the verification service. Should be fun!

Fortunately (or unfortunately, depending on your view), I have had Python and GTK to serve my needs here. Python, with it’s awesome batteries-included range of facilities and GTK as a simple yet flexible toolkit has allowed me to create implementations of the ideas that I have dreamed of. I started using these tools many years ago, and they have always provided a simple and effective toolset for me.

My preferred toolset of choice. One day…

Having not written any code for a while, I got the itch this weekend to start writing the trophy helper app that I wrote about as part of the accomplishments system spec that I created with Stuart Langridge and Daniel Holbach. I thought this would be a good opportunity to brush up on my skills, given that PyGTK is dead and the new world is instead the GIR approach to GTK. In a nutshell, this is where the language bindings basically match the C API for GTK thus reducing the need for people to maintain different language bindings.

Of course, this is a good thing: less work for volunteers in maintaining multiple-language support for GTK and a consistent API is good. Unfortunately, I found getting started with this new world a little more complex than I imagined.

From reading the documentation it suggested that all I needed to do was to import Gtk from gi.repository and instead of creating widgets with gtk.<foo> that they would be Gtk.<foo>. The docs suggested a few other lexical adjustments, but not much more than that. There is even a pygi-convert.sh script that can convert older PyGTK code over to the new PyGI way. Unfortunately the script didn’t work for me, so I instead used it as a cheat-sheet for things that needed changing. Sadly, it seemed like some things were not covered in the script.

An example of this included when I was creating a ListStore. In PyGTK code I could add a gtk.gdk.Pixbuf to the ListStore for an icon, but I had a difficult time trying to figure out the new way to describe this. I tried Gtk.gdk.Pixbuf and Gtk.Gdk.Pixbuf but had no luck. Fortunately the awesome Ryan Lortie informed me that it needed to be GdkPixbuf.Pixbuf. Another example of this was gtk.SORT_ASCENDING in my original code and the new Gtk.SortType.ASCENDING in the new code. It seems like various functionality in GTK has been moved around and re-factored.

Unfortunately I could not find any documentation to help me with this. Sure, the C docs are available online, but I am not a C programmer; I am (in the most generous and understanding way) a Python programmer and where I previously had a pretty decent tutorial and reference guide to PyGTK, as a desktop app developer I no longer have these resources to help me. Even though I am not a fantastic programmer, I have written enough Python and GTK code to fumble my way through writing various apps, and if it stumped me as a relatively old hand, I wonder how a brand new developer would get on.

Pictured: old hand.

Now, this may sound a little critical, but it is not mean’t to be. I have tremendous respect for the GTK team, and I am hugely thankful to them for all their hard work. I am also thankful for the team that has worked on the GIR support so that multiple language support can be more efficiently provided. Thanks to all you folks for providing great tools that let a programming numpty such as myself be able to write Free Software.

I just wanted to share this because I feel like these tools are missing the final component: if we had a good solid set of reference documentation generated for each language (naturally, Python is the language I mainly care about), this would help novice and established developers use GTK more effectively. From my personal experience, my patience started wearing pretty thin when I felt like I didn’t have anywhere to find help as I navigated C documentation to try and figure out how the API fitted into my Python application. A good solid Python reference manual would have resolved this issue, and from what I understand, this could potentially be generated from the GIR files. Unfortunately, I don’t think I have the skills to help solve this problem, so I figured the best I could do was to share my story and see if anyone would be interested in helping to solve this problem.

If so, thanks in advance, and thanks again to the GTK team for all your hard work!

Update

I found this excellent documentation after publishing this entry. This provides exactly the kind of documentation I was looking for. Thanks to anyone who helped contribute to this!

The nice thing about the system we designed is that it is de-centralized, it uses Ubuntu One as a transport mechanism (which means we don’t have to build our own transport system and your trophies are visible across all your Ubuntu machines), and the system has a verification process to ensure that people can’t fake their community accomplishments.

I wrote this all up into a spec which you can find here.

We had an interesting session about this topic at UDS and Stuart put together a draft implementation which is at lp:~sil/+junk/libaccom-draft/. The implementation defines a set of sample accomplishments and provides a daemon that runs to maintain state on which accomplishments have been achieved and which are still yet to be completed. The system is neatly integrated into Ubuntu and accomplishments are displayed in a notify-osd bubble:

Stuart also wrote a small API (libaccomplishment) that client apps can use to query the system and present trophies achieved or those yet to be achieved. You can read more about this draft implementation here.

In the original spec there are two clients that would be in the system. A lens:

…and a helper app that is loaded when you click on a trophy in the lens which can provide more information about an accomplishment as well as showing the list of achieved accomplishments and those yet to achieve:

This weekend I decided to start writing this helper app (Michael Hall has expressed an interest in writing the lens). To get things rolling I wanted to display the list of trophies that have been accomplished. It looks like this so far:

This app is using the libaccomplishment API that Stuart provided in his draft implementation and this code could obviously used to develop the lens. There is obviously still lots to build into the app, but it provides a useful proof-of-concept for how it could work. This is a Quickly project and you can grab the code from lp:~jonobacon/junk/trophyinfo.

If you want to play with this, grab Stuart’s draft implementation (lp:~sil/+junk/libaccom-draft/) and run examples/demo.sh – this will start the daemon. You can then grab my branch (lp:~jonobacon/junk/trophyinfo) and run quickly run and see the trophies in the view.

Everything so far has been something of a proof of concept, but I wanted to see if anyone else was interested in participating. There are a number of things that we need to do:

• Stuart’s draft implementation needs extending, and he would like to find a new owner for it. Currently the API is simple but might need fleshing out further.
• The helper app here that I created a first cut of needs expanding and functionality added. We need to provide different ways of filtering the trophies, providing information about a specific trophy and how to achieve it, and the other features outlined in the spec.
• Each accomplishment has a script that is run to see if you achieved something (e.g. if you filed a bug in Launchpad). In the spec, when one of these scripts returns that you accomplished the task, it creates a trophy, and syncs it via Ubuntu One to a validation server which runs the same script to verify you really did achieve the accomplishment. This then signs the trophy which then syncs back to your machine. We need someone to build this verification service.
• We need to evaluate and extend the .accomplishment format to include documentation for how to achieve a trophy. I know Jim Campbell expressed an interest in working on this and I would love to encourage others to participate too.
• We need to create a library of Ubuntu Community accomplishments. Stuart’s draft implementation includes an example script for filing a bug. See the list of ideas that Daniel has been working on.

Anyone interested in taking part?

UPDATE

Since I posted this I have made a bunch of improvements to the helper app. This includes:

• The app now displays trophies achieved on the My Trophies page and those not yet achieved on the Opportunities page.
• Locked trophies (i.e. those that need another trophy to be accomplished before it can be) now use a different icon (we will need new icons for all of these, so I am using stock icons right now).
• Trophy/opportunities status is now updated with each page load which means that trophies are updated more dynamically.
• Double-clicking an opportunities will take you to the WebKit page to display info about it. I just need to update the .accomplishment scheme to provide more useful info.

I pushed all these updated to lp:~jonobacon/junk/trophyinfo if you want to play with it.

• Using the GMail web interface – I back-end all my mail in GMail and traditionally use IMAP to access it via the default email client in Ubuntu (e.g. Thunderbird). While I love Thunderbird and Evolution, unfortunately GMail IMAP access is a touch slower than I would like (I have talked to Chris Coulson about this issue in Thunderbird who has looked into it) and the small delay in loading messages makes the email experience feel a little less sleek. Using GMail directly removes this slight lag, and it has made the email experience feel more satisfying (obviously for those of you who don’t have this lag, such as POP users, should be fine). Importantly, if you use GMail too, check out the GMail labs split pane view which makes GMail act like a traditional email client; I find that it makes GMail useful for me as opposed to the traditional view.
• Top posting – I realized recently how anal I am about laying out my messages and replies. I hit reply, say hi to the person, respond inline, make sure there is space between my response and the quoted text, add my name etc. For most 1-on-1 conversations this level of layout is not really needed (although on mailing lists I still bottom post), and just hitting reply and typing without all this laying out makes email feel so much more efficient.
• Don’t star mails to reply to – my traditional email workflow is that I wake up in the morning, grab my tablet, and while I wake up I read my email and star all the mails I need to respond to. I then grab breakfast, do all my calls, and then get to the starred emails to respond to. Instead of starring I experimented by marking emails unread that I need to reply to. For some reason this makes the urgency of replying more amplified in my head. I think that I just don’t like seeing unread emails, and it flips a psychological bit that makes me want to reply to them quicker as opposed to starring and my email just being another list of things to tend to. I know sounds a little strange, but this small change also affects how I handle my email.

Of course, while these things work for me, many of these won’t be of interest or work for you folks, but some may, and I just wanted to share them. I am sure there are lots of little tweaks to your own email workflow that you have found useful, and I would love to hear them in the comments. Happy emailing!

This cycle has been very much focused on integrating GNOME3 into Ubuntu and focusing on fit and finish both at a software and design level on Unity and it’s components. The goal with Ubuntu 11.10 is to build on the accomplishments in Ubuntu 11.04 and to continue refining the experience.

Before, I start, remember, there are a few caveats here:

• Ubuntu 11.10 is not finished. There are still plenty of bugs, quirks and other oddities that need fixing.
• What you see here may well change.
• I have smudged out some personal bits, but it should be pretty clear which bits are smudged out.

Oh, and click on the images below to see them full-size.

So let’s get started with what the typical desktop looks like right now in 11.10:

Here you can see a few changes:

• The Ubuntu button is now on the launcher (user testing told us most people look there to launch applications).
• There has been some small changes to the indicators in the top right part of the screen.
• Here you can see I have a number of apps open, and see the concertina effect on the Launcher.
• Note how there are no longer Apps / Files places on the Launcher.

So, if you click that Ubuntu button on the Launcher you see the new Dash:

Here the dash opens up in this really nice translucent way, and the launcher and panel look nice and translucent too. The translucency is actually tweaked based upon your wallpaper, so it shades it smartly.

You can see at the bottom of the dash are a series of little icons. This is now where you find your different lenses (Apps, Files, a new Music one, Gwibber etc) and this makes it much nicer to see the different types of lens, instead of having to find them on the launcher.

Let’s take a look at the Apps lens:

(I know some icons are missing in this screenshot, that is a bug)

Here you can see the lens works in a similar way as the apps lens in 11.04, but we have this new Filter Results feature (which is open in this screenshot). Here you can select different categories and those categories will only be shown in the icon view on the left. You can also search by rating which is useful for apps that are shown available to download.

Different lenses have different types of filters. As an example, here is the Gwibber lens:

As you can see this provides different methods of displaying different types of content.

One other cool element of the dash is that it uses an active blur. This means it really blurs what is behind it, so for example, it will blur a video as it plays behind it in the movie player:

Let’s now look at loading apps. Here is GEdit in it’s maximized state:

As you can see, Unity provides a lot of workable space and the shell just wraps around the app in the most minimal way possible to give you as much space as possible for the app. You can also see that when maximized the window buttons and menus are not shown; they only appear if you hover the window title with the mouse. This actually makes the desktop feel much nicer and less cluttered.

Here you can also see that the toolbar buttons have been styled with the dark theme to carry this theme throughout the desktop. This is a subtle but really nice change. As an example, here is Thunderbird with the same style applied:

In the GEdit example the icons are not monochrome but the Thunderbird ones are. We are not expecting an icon refresh in Ubuntu 11.10, but I suspect in the future we will see more icons tuned for the darker toolbars. Here is the compose window:

An app that has had quite a refresh has been Gwibber:

Gwibber is now much faster, much sleeker to use, and just a far more pleasant social networking experience. It also looks wonderfully consistent with the dark theme.

Another app that has been re-jigged is the Ubuntu Software Center:

The new Ubuntu Software Center feels faster, is more interesting to look at and explore, and feels far more integrated into the system.

I am also delighted to see the wonderful work that has gone into the GNOME Control Center in GNOME3 also brings the same consistent look, feel, and ease of use:

The whole configuration experience feels slicker and easier, and here is one of the panels:

Let’s now talk indicators:

Lots of great work and stability improvements has been performed here such as adding settings links that are relevant to each indicator, improved power and me indicators and other improvements.

Finally, a wonderful new feature added is the refreshed Alt-Tab switcher:

I absolutely love how this works, and I love how it shares the look and feel of the wider desktop. Here you can hit Alt-Tab and then use the arrow keys to move around to select the app you want to see. If there are more apps open than space in the switcher, they concertina just like in the launcher — it looks really cool.

If you have multiple windows open for an app (e.g. Firefox), you can find the icon and press the down arrow to show the multiple windows:

…and that pretty much wraps up the screenshot tour. I hope you enjoyed having a leaf through some of the features you can expect to see in Ubuntu 11.10.

I am really excited for the release, and I particularly enjoy how integrated, unified, consistent and slick the entire system feels. I also love the fact that the design, colouring, and structure is noticeably Ubuntu. So, all in all, I am really looking forward to Ubuntu 11.10 and the opportunity it has to put Free Software in the hands of more and more people. Thanks to everyone in the community who has contributed to it so far!

Beta 1 will be here on the 1st September, so get ready to test it my friends!

Unity in this release was very much a first cut. I am hugely proud of the accomplishments of the Desktop Experience Team, Design Team, and Ubuntu Platform Team in delivering Unity in 11.04, but we all acknowledge that there is lots to be done. Quality has to come first and foremost in the Ubuntu experience, and Mark Shuttleworth affirmed that fit and finish is going to be a key goal for Ubuntu 11.10, the Oneiric Ocelot.

In Search Of Quality

As part of this focus on quality, the Canonical Design and Desktop Experience teams are committing their time to fixing some of the design and software bugs that have been reported since the Natty release. As is usual with software teams, bugs have been identified and assigned to respective developers and these bugs will be merged into future Unity releases.

In addition to this, serious bugfixes (such as crashers) are being released as Stable Release Updates for Natty. Currently the first Unity stable release update release is currently in the proposed archive and should be released to 11.04 users over the next few weeks. The team are also focusing on a second SRU update that will resolve further issues. Of course, these bug fixes will also make it into Ubuntu 11.10 too. These stable release updates will ensure that current and future Ubuntu 11.04 users will get an even more stable experience and the Ubuntu 11.10 release will set off on the right foot when it comes to stability.

Of course, there are many software bugs open for Unity (software defects, problems, and oddities), but there are also design bugs open too. Unity was not just a first cut of a software release, but also a first cut of a design delivered in a desktop edition of Ubuntu. As such, since 11.04 there have been lots of design problems and bugs reported too. We are really keen to ensure these issues are also resolved as the Unity design continues to mature and evolve.

John Lea, fearless designer on the Design Team, has worked with the team to process these design bug reports, work with the team on proposed solutions, and get these solutions signed-off. As such, we now have this list of design bugs that are focal points for being resolved in 11.10. Some of these bugs are assigned to Canonical developers, but not all are.

To help with this work, Jason Smith from the Desktop Experience team has been going into these design bugs and providing instructions on what needs to be done to fix them. This is hugely helpful for community volunteers to fix these bugs and help improve Unity.

How You Can Help

So let’s get to the heart of the matter.

This really has nothing to do with this post, but…well, I just love ducks, and they are clearly the badasses of the waterfowl world.

Quality is something we can all improve. Whether you are interested in writing documentation, programming, testing, translating…there is a way in which you can help improve the quality of Unity in 11.10. Canonical is certainly investing in this, but we are an Open Source community and such the wider community we can all help.

If you are a developer and know some C++, you can make Ubuntu better for millions of people. A few hours of your time working on some of these bugs could bring great quality of experience to Unity and Ubuntu and help us to take Free Software to even more users as a stable, secure, feature-packed, and well-designed platform.

To get started, take a look at Jorge’s first post about Unity contributor plans in 11.10 – this post explains where to find the bugs, how to get started, where to find help and more. Jorge will be posting every week with new opportunities and bugs to work on and showcasing the great work of our community.

With the Desktop Experience team working on some bugs and also new features, and the community working to help bring an even higher-grade of quality and fix more bugs, together we can deliver a rocking 11.10 release!

I will be talking more in later posts about other ways of helping, such as documentation, translations and testing. I look forward to see the Unity contributor family growing, and don’t forget to come and join us in #ayatana on freenode.

Today things are really quite different. I was thinking about this sheer change in desktop quality, and felt an incredible urge to share the reasons why I love my desktop and love the integration. All of this is based on a default Ubuntu 10.04 Maverick Meerkat installation with Unity enabled as the desktop. You can switch on Unity with:

sudo apt-get update
sudo apt-get install unity

…and then at the login screen select Ubuntu Netbook from the list of available sessions. Rock and roll!

Unity

I am really digging Unity. While still quite new and still maturing, I find it’s current form really sleek and easy to use. I like the design and the structure of how I get at my apps, my data, and control what is going on on my desktop:

One element of Unity that I really enjoy is the theme and the new Ubuntu font. It really gives the desktop a subtle sheen, and the dark theme makes it look slick and sexy.

One key feature of Unity that is going to become an increasingly big deal is the Places API:

Unity provides a consistent user interface for displaying different types of content (such as files and applications), but this extendable. Neil Patel who is one of the lead Unity hackers has already created an example of this work which plugs YouTube in, and it is great to see this kind of content embedded into the experience. I can’t wait to see how application authors will use this technology to provide better access to content, all using this consistent user interface.

As many of you know, Unity will be switched on by default in Ubuntu 11.04, and the performance and accessibility issues are currently being tended to. For more details see this blog post.

Microblogging

Microblogging has become all the craze over the last few years, and Twitter, Facebook, identi.ca, and others have all made the micro-blogging experience simple and useful. I love the micro-blogging support built right into my desktop, firstly with Gwibber:

Gwibber is an awesome micro-blogging tool. It provides simple and quick access to see all of my accounts together, helps me see a standard set of searches that I care about, and lets me tweet once and have the message go to all of my accounts.

In addition to this I love how I can tweet right from my desktop with the Me Menu:

This is how it should be: when the thought or inspiration takes me, I always have a quick interface for tweeting, irrespective of what I am doing, because it is built into the shell of the desktop. Rock and roll!

Indicators

Speaking of indicators, I use the indicators all the time. In particular, I find the Messaging Menu really useful:

It is incredibly handy having all the things that need my attention to appear in the same place, all neatly packed into that menu, and when it lights up I know I need to check it.

In addition to this, the recent addition of the Sound Menu enhancements are awesome:

Like many, I put music on during the day when I work, and typically the only things I need to with it are use the transport controls (e.g. to fast forward, replay, or pause a song), or more often than not, see which artist/album is currently playing if I have it on shuffle. No longer do I need to keep showing the Rhythmbox window to do this; it is right there in my sound menu. Really handy.

Rhythmbox

Speaking of Rhythmbox, I love it to bits:

Rhythmbox lets me manage my music collection easily, and has lots of nice features to really enjoy the music I listen to.

Sure, we are moving to Banshee in 11.04, but I love that too – I think we have such great choice in the media player world. One thing I really love about Rhythmbox is that I can enable the DAAP plugin and I can control and listen to my songs via my Playstation 3 and hear my tunes on our home theater system. Much better than laptop speakers, and a doddle to do this.

Evolution

Like many of you, email is at the center of my life, and I find Evolution serves me really well:

A lot of people talk a lot of smack about Evolution, but I think the Evo team have done a great job. I get a lot of mail, and Evolution helps me set up filters to prioritize how I see, respond to, and manage my mail. What’s more, it integrates nicely into my desktop, and integrates perfectly in the Messaging Menu.

Empathy

Instant messaging is a common thing I use my desktop for, and again this is all perfectly handled with Empathy:

I love how Empathy brings all my messaging accounts together and provides the same interface for interacting with my friends. It looks beautiful, works smoothly, and is a pleasurable experience.

Getting More Software

I have also been delighted to see how the experience of getting more software has been refined with the Ubuntu Software Center:

We have always had this incredible catalog of software available for Ubuntu, but now it is finally becoming more accessible for new users. This will also becomes infinitely more useful when ratings and reviews land in the Ubuntu 10.10 release – this will help all the really great software bubble to the surface!

In Conclusion

In addition to my Ubuntu machines, I have a Windows 7 machine that powers my home studio. When I compare and contrast my Ubuntu installation with Windows 7, it feels like Ubuntu is much better attuned to what most users want – awesome web browsing, email, communications, media playback and production, and a consistent, attractive experience.

I think we should all be hugely proud of how far we have come with the Linux desktop, and I am intensely proud of how slick and integrated Ubuntu is, and the impact the design team has had on the experience. I would love to hear why others love their desktops too, do share!

I think this is a fantastic opportunity for Free Software, and this is going to be a busy cycle. We have a lot of work to do, and we know that quality is a firm focus for this release, and we have identified a solid set of issues we need to focus on and resolve, but I know the final product will be something that we will all be proud of. Another key focus is performance; we have already started porting Unity from mutter to Compiz and the initial work is much faster, most notably on hardware that has traditionally had the most trouble from bug reports. Quality meets design meets performance. Together as a community we can make this rock.

There is going to be some questions about this decision in relation to GNOME. I want to make something crystal clear: Ubuntu is a GNOME distribution, we ship the GNOME stack, we will continue to ship GNOME apps, and we optimize Ubuntu for GNOME. The only difference is that Unity is a different shell for GNOME, but we continue to support the latest GNOME Shell development work in the Ubuntu archives.

If anyone has any questions, I will be running around the Ubuntu Developer Summit like a headless chicken, so feel free to grab me here if you have any questions, and I will get online to respond to queries when I get time away from sessions.

Thanks, folks.

Some time back the Ayatana project introduced the Application Indicator Framework, based upon technology created by the KDE project. We have been shipping this technology in Ubuntu for a few releases now and it makes the top-right part of the desktop a smooth, efficient, and pleasant experience, getting over the inconsistent and limiting notification area we had before.

To help build integration in the GNOME panel for this indicator work we had Ted Gould, Cody Somerville, and Jason Smith produce an implementation complete with C, Python and C# bindings, had Aurélien Gâteau continue to perform his excellent work with KDE, and Jorge Castro to help spread awareness of this work. In addition to this we contracted some developers to port apps with notification indicators that we ship in Ubuntu to the new framework, and this included apps such as Brasero, GNOME Bluetooth, GNOME Power Manager, Gnome Settings Daemon, XChat-GNOME, iBus, Nautilus, Policykit GNOME, Empathy, Gwibber and more. All of these patches are publicly available if other distros would like to use them.

The community has really got involved with the technology too, with community patches for Lernid, Banshee, LottaNZB, and DejaDup, and System Monitor, Weather, Screenshotting, Workspaces, Device Mounting indicators, support for the indicator framework built into AWN and Lubuntu, and more. I am absolutely delighted to see so much interest from application developers in the technology.

One of the reactions from the survey was that Red Hat are responsible for 16% of the contributions to GNOME whereas Canonical are responsible for a measly 1%.

Of course, this has generated some flame, such as a particularly angry post from Greg DeKoenigsberg and the rather pithy response from Jeffrey Stedfast. Greg is clearly pissed, and Jeffrey is clearly pissed at Greg being pissed, and I suspect Greg is going to get even more pissed at Jeffrey being pissed. The worse thing is that they are both going to be pissed at me for this blog post.

First I want to put these figures in perspective and then I want to talk about how we read the figures we do have.

I think the GNOME Census report is excellent, and it provides some excellent visibility into contributions in GNOME, but it only takes into account upstream contributions to GNOME itself. What the report doesn’t take into account are upstream contributions that are built on the GNOME platform but (a) not part of official GNOME modules, and (b) hosted and developed elsewhere, such as Launchpad. As such, while the report is accurate for showing code and contributions accepted into GNOME, there are also many projects built on GNOME technology that are not taken into account due to non-inclusion in GNOME modules or being developed outside of GNOME infrastructure.

As a general rule, Canonical staff develop inside Launchpad. The reason is simple; Launchpad and Bazaar provide a powerful development environment that was also built by Canonical and we therefore have lots of internal skills and best practice based on these tools. Launchpad is also a fundamental component in Ubuntu development and all the software we develop ultimately ships in Ubuntu, so using the same development forge makes sense. Finally, the site is a Free Software and Open Source project, so there really no philosophical reason to move, testified by the 18,000+ Free Software projects happily using Launchpad already.

Canonical is actively developing upstream desktop software, but doing it in Launchpad. Some examples include:

• notify-osd
• Messaging Menu
• Application Indicators
• Indicator Applet
• Indicator Date Time Applet
• Sound Indicator
• Me Menu
• Indicator Global Menu
• Unity

This is by no means the full list, and is other work such as Simple Scan, the Hardware Drivers tool, Computer Janitor, and more. Many of these contributions (such as Application Indicators and Simple Scan) could bring real value to GNOME, but they have not been accepted. I know that the Canonical engineers who work on them would be delighted if they were included in GNOME.

The above list also doesn’t include significant upstream investment in other areas such as Upstart, Bazaar, Launchpad, and a full team building Ubuntu. I don’t want to turn this into a “who contributed more” competition, but I think for some to suggest Canonical is a bad citizen who is not contributing upstream code is unreasonable. To suggest that Canonical has limited code inside approved GNOME modules is fair.

So that was the first thing I wanted to clarify; Canonical does invest heavily in upstream work, but GNOME is not the only home for upstream contributions.

If there is one thing that the GNOME Census has really outlined is that we should all be proud of Red Hat and their contributions to GNOME. You only have to take a look at all the red items on this image to get a feeling for the wonderful work that Red Hat is doing inside GNOME. Novell too. Look the green items in there; Novell has done a wonderful job maintaining many modules inside GNOME. In fact, there are many companies investing inside GNOME modules and inside GNOME infrastructure. I don’t believe it would be fair to undermine these contributions in any way; they are testament to the ethos of those companies and their commitment to GNOME. All of the people working at those companies are doing good work within the spirit of Free Software.

Likewise, I don’t think it is fair to undermine Canonical’s contributions just because many of them exist outside of GNOME. Our engineers are also doing good work within the spirit of Free Software. I have never claimed for a second that Canonical are equal to Red Hat and Novell in terms of our accepted contributions in GNOME; it is clear that there are far few contributions from Canonical staff inside accepted GNOME modules, but this does not for a second mean that Canonical is not (a) producing upstream contributions and (b) heavily invested in the GNOME platform. Ubuntu, our primary product is a GNOME desktop, and the vast majority of our engineers are GNOME users and developers and they work every day on a GNOME based product.

So in a nutshell, this is my take: both Red Hat and Canonical invest heavily in Open Source development, but they do it in different ways and different places. The GNOME Census clearly outlines that within GNOME modules, Red Hat are doing far more, but that doesn’t mean that Canonical are sitting on their thumbs and doing nothing, far from it.