Something [I have](https://archivedblog.jonobacon.com/2009/10/19/ubuntu-and-the-opportunistic-programmer/) [talked about](https://archivedblog.jonobacon.com/2009/12/19/unchaining-the-opportunistic-programmer/) [extensively](https://shotofjaq.org/2009/12/quickly-unchaining-the-itch-scratcher/) recently has been my passion to see *opportunistic developers* served well on the Linux desktop. These kinds of programmers are people who want to write small, focused, fun little applications that scratch an itch, even if that itch is to have fun. These kinds of developers are having a whale of a time filling the iPhone App Store with scratch-your-itch type of applications, and I am really keen to see more of these kinds of applications on the Linux desktop, and making Ubuntu the perfect platform to develop them on.

We have been seeing a growing movement inside the Ubuntu community in helping to make Ubuntu a rocking platform for opportunistic developers. While all the components are Open Source and can be shipped on any distribution, I am really keen for Ubuntu to really optimize and integrate around the needs of opportunistic programmers and I just wanted to highlight some of the work that has happened here.

In much the same way that Linux/Apache/MySQL/PHP (LAMP) became a popular arrangement of tools for web development, we have been seeing a similar scenario in Ubuntu too, in which a set of tools work well together and are often preferred by developers. These are:

* **Python** – a simple, easy to learn, flexible and efficient high-level language.
* **GTK** – a simple, comprehensive and powerful graphical toolkit for creating applications.
* **GNOME** – the desktop environment that ships with Ubuntu, offering many integration facilities.
* **GStreamer** – a powerful but deliciously simple framework for playing back and creating audio, video and other multimedia content.
* **Glade** – an application for creating user interfaces quickly and easily, which can then be loaded right into your Python programs.
* **DesktopCouch** – a framework for saving content in a database that is fast and efficient, hooks neatly into Ubuntu One and is awesome for replication.

In Ubuntu land we love this framwork. Many of our applications are written using them and this helped make it simple for others to get involved and contribute patches and bug fixes. It has been interesting seeing many folks settle on the same set of tools.

There are of course may other tools and facilities that can augment this list, but this is a common foundation in many applications. Fortunately, all of these ship with an Ubuntu system except Glade, but you can install Glade 3 by using *Applications->Ubuntu Software Center*.

Many of you will have heard of [Quickly](https://wiki.ubuntu.com/Quickly) which provides a devilishly simple way of generating a new application, hacking on the code, changing the GUI and saving it to bazaar. Quickly also provides some awesome features for uploading the code to [Launchpad](https://edge.launchpad.net/+tour/index) and releasing your program to others in a [Personal Package Archive](https://edge.launchpad.net/+tour/ppa).

What I like about Quickly is that it automates much of repetition surrounding software development and it ultimately allows you to deploy software to a PPA which people can then download and use. Now, PPAs are a little more complicated to install right now: you need to know what a PPA is, know where to find it, and click a few things or enter some commands to switch it on. Fortunately, the rather awesome Ubuntu Software Center which everyone’s favourite Vogt…Michael Vogt…is developing, is going to be extended with functionality to better support PPAs. This, combined with the ratings and review features coming to the Ubuntu Software Center is pretty rocking. I am not sure of the specifics of how PPAs will be supported, but I believe they will first begin on visibility and then follow up with integration features later. If you want to get started with quickly [take a look at this entry](https://archivedblog.jonobacon.com/2009/10/19/ubuntu-and-the-opportunistic-programmer/).

With Quickly able to get folks up and running with development, I wanted to make it easier for opportunistic developers to get their hands on code snippets and examples to learn from. As such, I created the *Acire* and *Python Snippets* projects. These projects provide a simple means in which you get access to a freely available regularly updated library of examples, across a range of different areas. With Acire you will always have a growing knowledge base of real code that you can read, run and share, and the community works together to regularly add to and support that knowledge base. The response so far has been great and you can read more about this in [my previous blog post](https://archivedblog.jonobacon.com/2010/01/12/acire-0-2-released/).

So, at this point we have all the tools needed to build applications, learn from code examples, and publish packages that ultimately will be visible in the Ubuntu Software Center. The one area that neither Quickly nor Acire has particularly served well is improving on how we collaborate together on software. Few Open Source projects have one sole developer, so we really want developers work well together, in conjunction with translators, documentation writers, bug triagers and more.

To do this we have the rather awesome [Launchpad](https://edge.launchpad.net/+tour/index) and [Bazaar](https://bazaar.canonical.com/en/) which are a doddle to use. Launchpad provides everything you need to work together on a software project and I have become a bit of a Launchpad fan as I have got used to using it. In my earlier days I tried Sourceforge, Trac and other systems, but Launchpad is rocking it for me.

While I love Launchpad and Bazaar, their integration in Ubuntu could have been better. As an example, to get code in and out of Launchpad so you can contribute to a project, you use the `bzr` command and the process typically works like this:

* You download some code from the Launchpad project with `bzr`.
* You branch the code: this effectively means making a duplicate directory of the code.
* In that duplicate directory you add a feature, fix a bug or make some other kind of improvement.
* You then commit your changes to your local branch: this effectively tells Bazaar of the changes you have made.
* You then upload your branch to Launchpad (this is called *pushing a branch*).
* The final step is to *propose a merge*. This is when you offer your branch and it’s changes to the project maintainer to merge into the main codebase. Launchpad ties together nicely with `bzr` to handle this process and has a web front end for doing code review.

Now, understanding how all this works and doing it a few times takes a little getting used to, and much of it is learning how to use the different `bzr` commands and how they hook in with Launchpad. Well, very recently my friend and yours Martin ‘doctormo’ Owens has released his [Ground Control](https://doctormo.wordpress.com/2010/01/27/ground-control-demonstration/) project which provides a graphical interface to the whole process by building it into the file manager in Ubuntu. I cannot tell you how bloody cool this is. It works a little like this:

* You create a `Projects` directory in your home directory.
* Click *Places->Home Folder* and go to the new `Projects` folder.
* In there you can see a button to login to Launchpad. Click the button, enter your username and password. Job done.
* You now see a a button where you can select a project to work on. Click on it, enter a project name, select it and it creates a new folder.
* Now go into the folder and there is a button to download the code. Click it, select a branch and the code is downloaded.
* You can now hack on your feature and a button will appear to commit your changes.
* Finally, you will then see a button to propose a merge. You enter some text to describe your change, and it is uploaded.

No commands. None. What I love about Ground Control is that it is highly contextual: it is built into the file manager and it only ever shows you a button for what you can do at that time. It is simple, quick and Martin has done a wonderful job with it. Go and see a video demo of Martin showing Ground Control [here](https://doctormo.wordpress.com/2010/01/27/ground-control-demonstration/).

Ground Control is still very very new so expect bugs, but do give it a go, report bugs, and importantly, he is looking for help to make sure it has full translations support. If you have done this before, drop him a line. The Ground Control Launchpad project is [here](https://edge.launchpad.net/groundcontrol).

With each of these components we are seeing more and more gaps in the integration and ease of the development process getting filled. I am hugely excited about this and I am excited about it bringing more and more people to Ubuntu as a development platform and it ultimately generating more and more Free Software for us all to use. We still have a long road ahead though and plenty of good work yet to do. If you think there is a gap *you* can fill, come and help us rock it. 🙂

Recently I have been talking about how stoked I am that we are [solving the problems](https://gould.cx/ted/blog/Having_a_tidy_systray) in the notification area with [Application Indicators](https://wiki.ubuntu.com/DesktopExperienceTeam/ApplicationIndicators) based on [this spec from the KDE team](https://www.notmart.org/misc/statusnotifieritem/index.html). We are now shipping this functionality in Lucid with Rhythmbox, Nautilus, Empathy, XChat-GNOME, Lernid and other applications using it.

Application developers are pretty excited about the technology, and as such we have scheduled a tutorial session about how to make use of the application indicator framework as part of the awesome [Ubuntu Developer Week](https://wiki.ubuntu.com/UbuntuDeveloperWeek). The session is *today*, the 26th Jan at 7pm UTC / 11am PST / 2pm EST lead by the always awesome Ted Gould. More info on joining the session is [here](https://wiki.ubuntu.com/UbuntuDeveloperWeek) or you can use [Lernid to join really easily](https://archivedblog.jonobacon.com/2010/01/25/ubuntu-developer-week-begins-and-new-lernid-release-to-enjoy-it-with/).

Something we have been spending some time working on in this cycle has been fixing the mess that is the system tray. This is based upon an [awesome specification submitted to Freedesktop by KDE](https://www.notmart.org/misc/statusnotifieritem/index.html). The spec has been implemented by KDE, we have written an implementation for the GNOME panel and it will ship in Ubuntu 10.04 Lucid Lynx Alpha 2. We have also started adding application indicator support to many of the applications we ship in Ubuntu, and of course these patches are going upstream as they are written. I would to encourage GNOMErs to join the discussion on the XDG list regarding the spec.

I think the Application Indicator framework rocks. It solves a problem that has niggled me for years: with it system tray applets now have a consistent UI in terms of spacing, a unified left click to access the menu (no more confusing different left/right menus in different apps), you can scrub between icons, KDE applications render their application indicator menus in GNOME as GTK menus and vice versa and the whole shebang is a lot more accessible.

The Application Indicator team have produced C, Mono and Python bindings and documented it all on [this wiki page](https://wiki.ubuntu.com/DesktopExperienceTeam/ApplicationIndicators). I wanted to have a play with it with Python so I knocked together a simple little script that demos how it works:

#!/usr/bin/env python
#
# [SNIPPET_NAME: Create an Application Indicator]
# [SNIPPET_CATEGORIES: Application Indicator]
# [SNIPPET_DESCRIPTION: How to create an application indicator and add items to it]
# [SNIPPET_AUTHOR: Jono Bacon ]
# [SNIPPET_LICENSE: GPL]

import pygtk
pygtk.require(‘2.0’)
import gtk
import appindicator

class AppIndicatorExample:
def __init__(self):
self.ind = appindicator.Indicator (“example-simple-client”, “indicator-messages”, appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status (appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon (“indicator-messages-new”)
self.ind.set_icon(“distributor-logo”)

# create a menu
self.menu = gtk.Menu()

# create items for the menu – labels, checkboxes, radio buttons and images are supported:

item = gtk.MenuItem(“Regular Menu Item”)
self.menu.append(item)

check = gtk.CheckMenuItem(“Check Menu Item”)
self.menu.append(check)

radio = gtk.RadioMenuItem(None, “Radio Menu Item”)
self.menu.append(radio)

image = gtk.ImageMenuItem(gtk.STOCK_QUIT)
image.connect(“activate”, self.quit)
self.menu.append(image)

self.menu.show()

self.ind.set_menu(self.menu)

def quit(self, widget, data=None):
gtk.main_quit()

def main():
gtk.main()
return 0

if __name__ == “__main__”:
indicator = AppIndicatorExample()
main()

To make this as helpful as possible for people I have added it to [python-snippets](https://code.launchpad.net/python-snippets) which you can of course enjoy using my little [Acire](https://archivedblog.jonobacon.com/2010/01/12/acire-0-2-released/) tool that I blogged about recently. If you want to give it a go, I recommend you use it with another app that uses Application Indicators, and then you can play with scrubbing between icons and using the arrows on your keyboard to move around. It is pretty awesome.

To continue playing with it I thought I would have a go at writing an application indicator plugin for the always awesome [Getting Things GNOME](https://gtg.fritalk.com/). I only had time spend an hour or so on it last night, but my work in progress is available in [this branch](https://code.launchpad.net/~jonobacon/gtg/application-indicator-plugin). Most of it is complete, but what I am missing from the framework is a signal when a user clicks on the indicator icon: I need this to re-generate the dynamic list of tasks in that menu. I spoke to Ted Gould about it and he said this is likely to be added in the future. When it is ready I will propose it to upstream GTG for inclusion. 🙂

We are currently looking for two paid home-based contractor positions in Europe or the USA to come and work at Canonical to write some upstream code to help GNOME applications fit into the full Ubuntu desktop experience. This is an awesome opportunity for talented GNOME developers and a a great way to dip your feet into the Ubuntu development team. The roles involve these elements:

**Responsibilities**

* Create patches for GNOME Desktop applications to provide complete integration with the Ubuntu desktop experience
* Work with upstreams on planning and creating packages
* Work with upstreams to get patches integrated upstream
* Fix integration related bugs and other bugs

**Skills**

* Ability to hack in C and Python
* Experience with bzr, git, and other concurrent versioning systems
* Experience with launchpad and bugzilla bug tracking
* Social skills needed to interact with upstreams and Ubuntu teams
* Ability to set work schedule and systematically report on status

If you are interested, we are looking to fill these roles ASAP, so email me at `jono AT ubuntu DOT com` ASAP and I will forward you on to the right people.