Canonical Voices

As many of you wonderful people of the Internet should be intimately aware of, the Ubuntu Global Jam takes place from the 26th – 28th March 2010. That is only a few weeks away, and while we have some great events already set up, we need more!

I just wanted to highlight how simple it is to put together an event. I explained much of this in my recent live videocast today:

Can’t see it? Watch it here!

I was keen to summarize much of the key points here though so this post can be linked to so we can spread some best practice around how easy it is to put together an event.

Ubuntu Global Jam events are simple events designed to get Ubuntu users and contributors in the same room to work together and contribute to Ubuntu. This can happen through any means: testing, documentation writing, working on a LoCo team, development or whatever else. The key focus here is on getting people together and having fun with Ubuntu.

Let’s look at how to put together an event.

Step 1: Pick a date

The Ubuntu Global Jam takes place on three days:

• Fri 26th March 2010
• Sat 27th March 2010
• Sun 28th March 2010

The first step is to pick a date for the event to happen. There is no fixed time of how long a jam should be it: it could be a few hours or a few days: it does not need to take place on all days. Just pick the times that work well for you.

Step 2: Pick a venue

The next step is to pick a place to hold your event. One of the misconceptions about global jam events is that they need to be big, professional, full-on events. Not at all! Many are simple, low-key events that are pretty much like most LUG meetings: a group of Open Source fans getting together to have fun and work on Ubuntu together.

When choosing a place I recommend you ensure the following are available as a bare minimum:

• Enough seating for ten or so people.
• An freely available Internet connection.
• Optional but preferable is access to refreshments (e.g. in a coffee shop).

A few great options for venues are:

• Coffee shops
• Bars
• University/school buildings
• Restaurants
• Homes
• If it is a nice day, what about a picnic at a park?

Importantly, you often don’t need to inform the venue that you are going. Just choose a venue (e.g. a coffee shop) and just show up like any other day.

Step 3: Add your event

The next step is to add your event to the list of events that are going as part of the Ubuntu Global Jam.

We are in the process of moving over to our dedicated LoCo teams LoCo directory but as we are in a transitional period, we are also asking LoCo teams to list their events on the old wiki page too. As such, to add your events just follow these instructions:

The LoCo Directory

To add an event to the LoCo directory you will need to be a member of your LoCo team in Launchpad.

1. Go to http://loco.ubuntu.com and in the top right on the page, log in.
2. Click the Venues link.
3. Check to see if the venue you are holding your event at is in the list. If not, click the Add new venue link and add the venue to the system.
4. Click here to straight to the page to add a new event. On that page, click on the team that the event will be happening as part of and then fill in the form. Be sure to select Global Jam in the Related Global Event drop-down box.

The Wiki Page

Simply go to this page and add your event to it.

Step 4: Build some buzz!

Now is the time to spread the word about your event and encourage people to come along! Here are some ideas:

• Be sure to tweet/dent, and post on Facebook about the event. When you add the event to the LoCo directory you will have a link to point people at (e.g. my event’s link is this) – send multiple messages to remind people of the event and keep it upfront in their minds.
• Blog it – particularly if your blog appears on one of the planets.
• Post to your LoCo’s mailing list – let them know about the event, when it is and where it is.
• Post to local LUG mailing lists – let your local LUGs know: many people may want to come along and join the event!
• Put up fliers – fliers in libraries, computer shops, universities and at the venue itself are great ways to get people to join you.
• Website buttons – why not create some website buttons so attendees can put them on their website and link to your event page in the LoCo directory.

And that’s it! If you have any questions, here are a few useful resources:

• Mailing List – this is where the LoCo community discuss general LoCo related topics. In most cases cases teams have mailing lists too.
• #ubuntu-locoteams on Freenode – this is an online discussion channel where you can ask questions and socialize with other LoCo community members.

I look forward to seeing you good folks organizing your events and having a great time!

One of the most wonderful sub-communities in the Ubuntu world are our LoCo Teams; the global span of Ubuntu advocacy groups that are out there every day helping to spread the word about Ubuntu. These wonderful people are on the front-lines helping people to get started with Ubuntu and providing a fantastic place to meet, greet and have fun with other Ubuntu users and contributors.

In terms of resources for this community, we have the following key components:

• Wiki Pages – these wiki pages include best practise and details about how to join the community.
• Teams List – this is the big list of teams, complete with contact details and online resources.
• Mailing List – this is where the LoCo community discuss general LoCo related topics. In most cases cases teams have mailing lists too.
• #ubuntu-locoteams on Freenode – this is an online discussion channel where you can ask questions and socialize with other LoCo community members.

One component we have been keen to fix is the listing of LoCo teams and associated resources and events. We have discussed this over a few UDSs and I am pleased to show off some work that has been going into making our LoCo portal really effective. Thanks to the wonderful LoCo Directory hackers who have been feverishly working away on this project. You can go and play with it at http://loco.ubuntu.com.

The LoCo directory looks like this:

Right now it has the following key features:

• Teams – a list of all the LoCo teams in the community.
• Venues – a list of venues used by LoCo teams (useful so you don’t need to repeatedly enter new venue information each time you organize and event and also good for sharing good venues with other LoCo team members).
• Events – events can be saved to the system and associated with LoCo teams as well as global events such as the Ubuntu Global Jam.

If you click on the Teams link you can see the list of LoCo teams:

This is the full list of teams. Teams that have a humanity colored Ubuntu circle of friends next to them are Approved teams, otherwise it is colored gray and indicates the team is not yet approved. Already this makes finding teams much nicer for new Ubuntu members: just point them at http://loco.ubuntu.com/teams/

When you click on a team you see more information about the team and their resources/events. As an example, here is my local team Ubuntu California:

The team information page shows some key details such as the owner, admins, when the team is next up for re-approval and also links to a series of resources such as websites, IRC channels, forums etc. The page also rather nicely shows their logo.

Not only this, but the page also shows a list of events that have been organized by the team. In the screenshot above there are two events (they are a little squashed, that is a bug). Clicking on an event shows the details for that specific event. As an example, here are the details for the Ubuntu Global Jam event that I have organized in a few weeks time:

When you view an event you can see when it is, what it happens, the location, a map reference and a description. There is also an area where you can RSVP for an event to confirm your attendance or non-attendance: this is a great way of determining how many people are likely to show up to your event.

The way the LoCo directory works is to suck as much information out of Launchpad where possible about teams and then it builds in some of the other features (such as events) into the LoCo directory. This avoids duplication of data and uses Launchpad for key features such as access control and owner/admin information.

Great work, LoCo directory hackers!

Meeting Minutes

IRC Log of the meeting.

Agenda

2010-09-03 Meeting Agenda

Outstanding actions from last meeting

1. None

Lucid Release Status: Bugs

Blueprints: kernel-lucid-bug-handling

Almost done with the analysis of the X debugging pages. JFo will update the team on the current state of the Kernel Team pages and an initial draft of recommended changes to the structure and layout via the e-mail list. Will have the arsenal scripts running (not in dry run mode) by the end of this week.

• I’m almost ready to present my findings on the X wiki debug pages and how I’d like to restructure the Kernel Team pages. I hope to send something on this to the list this week

• I am reworking the way the arsenal scripts gather and process bugs so that I can extend the ‘reach’ of the script deeper into the backlog. I’ll probably do a rather intense round of bug processing during the lull after release freeze.

• I sent out an e-mail to the c-k-t list (meant to send to the k-t list) regarding a wiki page describing the rationale for automated bug processing. Please provide some feedback. I’d like to get this URL integrated into the arsenal scripts soon.

Blueprints: kerne-lucid-kernel-config-review

Discussion thread started on the remaining sub-systems and PATA/SATA driver status. Should have patches for immediatly after Beta-1.

Blueprints: kernel-lucid-kms

We are seeing a lot of issues with i945 and older graphics cards, which includes all the atom netbooks. This is looking to be new occurance of the i915.powersave problems, we will disable powersaving for these ‘older’ cards by default.

Blueprints: kernel-lucid-suspend-resume

Looks like we are getting some useful information as a result of the patch to measure suspend resume times. I am currently looking at the suspend/resume bugs filed recently and trying to get a sense of any common elements we can find.

Blueprints: kernel-lucid-apparmor-development

The latest upstream push is ready go out.

Blueprints: kernel-lucid-boot-performance

The ureadahead patches are with Foundations for testing. Again we should have results in time for the first upload after Beta-1.

Other Release Tasks: Lucid Audio Support

Nothing significantly new this week.

I’m several days into my als-driver bug survey and have looked at almost 200 bugs. I’m basicly going through them one by one and adding tags onto them. If they have not had any action for more than a couple months I’m requesting a test of a dev image and the mainline kernel. I’m pretty amazed at the number of bugs that have not seen any attention since their initial submission.

The biggest buckets are “no sound at all” and “internal mic not working”. There are a few that look like upgrade isses, people running out and buying the latest HW expecting it to “just work”, etc.

I also see that there are a bunch of bugs that are “past expiration”. I asked around about this and was told that the bot that ran around marking these “invalid” had to be turned off because it wasn’t smart enought and was invalidating bugs it shouldn’t. I was told that a new status is being created “Expired” specifically for these bugs and that the bot would be smartened up. This work is supposed to happen this month.

Other Release Tasks: Lucid Better Power Mgt

The release team has pretty much veto’d putting the pmutils functionality in as it didn’t hit b-1. The rest has been postponed due to workload.

Other Release Tasks: EC2 Lucid Kernel Status

Working on Launchpad bug 527208 in linux-ec2 “ec2 instance fails boot, no console output on c1.xlarge” [High,Confirmed] https://launchpad.net/bugs/527208

Have confirmed that it isn’t exhibiting under similar circumstances in rackspace cloud. I haven’t made anymore progress on testing pv-ops.

Status: Lucid

Lucid remains at stable v2.6.32.9, though v2.6.32.10 is now available and will be applied once Beta-1 is over. We have commited patches to expose the DRM backports version such that when v2.6.33.1 DRM patches we can tell that that has occured in bug reports. We have also changed the default settings for the CDROM trays to allow direct removal of disks, userspace will handle this shortly.

All of the main kernels (linux, linux-fsl-imx51, linux-mvl-dove, linux-qcm-msm, and linux-ec2) remain unchanged from last week. linux-ti-omap was just accepted into the archive. Anything which requires a kernel change will have to wait until after beta-1 and will have to pass the abbreviated SRU process (2 acks required).

Security & Bugfix Kernels

Security update is expected somewhen today (after some final tests)

Incoming Bugs: Regressions

Current regression stats (broken down by release):

regression-potential (up 30)

• 88 lucid bugs

regression-update (no change)

• 11 karmic bugs
• 5 jaunty bugs
• 2 intrepid bugs
• 1 hardy bug

regression-release (no change)

• 54 karmic bugs
• 22 jaunty bugs
• 11 intrepid bugs
• 4 hardy bugs

regression-proposed (no change)

• 1 karmic bug

Incoming Bugs: Bug day report

Today is another Kernel Team ‘regression-’ bug day. Thanks for working on these last week. I’ll be looking at the schedule for the rest of this release and proposing more bug days to work out regressions to Pete for inclusion in the schedule. I anticipate that, as we move closer to the release freeze, we will probably do more than one bug day a week, but I want to see what the timeframe looks like before I propose that.

I didn’t get to schedule a community bug day today as I had planned. I will get things ready to hold another bug day against bugs with patches attached for next week.

Open Discussion or Questions

1. Nothing new this week.

I’m very happy the Berlin team is going to participate in Lucid’s Ubuntu Global Jam.

We’ll meet on Saturday 27th March at 12:00 in Berlin’s c-base and have a great time working on all the things that make Ubuntu great, so if you like to hang out, test Ubuntu, ugprade Ubuntu, translate Ubuntu, document Ubuntu, hack on Ubuntu, triage Ubuntu bugs or do anything else, we definitely want you there. Also if you are working on Debian, join us so we can learn to cooperate better and learn from each other.

This is all about having a good time, so head to the LoCo Directory entry, login and tell us that you’re coming.

Do you always enable Byobu to auto-launch when you login to your Ubuntu servers?

If so, we have a neat new feature for you... Lucid's Byobu has a debconf question that will allow you to globally enable Byobu's auto-launch for all interactive accounts on the system. It's currently disabled by default. To toggle the value, just use:

sudo dpkg-reconfigure byobu

d-i pkgsel/include string byobu
byobu byobu/launch-by-default boolean true

/etc/profile.d/Z98-byobu.sh -> /usr/bin/byobu-launch*

Chuck Short (one of the unsung heroes of the Ubuntu Server) has been working hard to get daily builds from upstream source repositories into Ubuntu PPAs in Launchpad.

He recently added qemu-kvm to the list of daily built upstream projects. You can see Chuck's announcement here.

Thanks, Chuck!

:-Dustin

As many of you will know, I manage the Ubuntu Community team at Canonical where Daniel Holbach, Jorge Castro and David Planella work. Together we strive to make the Ubuntu community a fun, productive and engaging environment. This work involves a tremendous range of diverse disciplines and projects.

One thing that we have been really keen to facilitate in Ubuntu is an ethos of just do it. I really believe our community should feel engaged to be creative in their ideas and be able to get out there and do it, with plenty of support resources so others can help them achieve their goals. I am keen that we don’t have a bottleneck where creativity is limited. Of course, this happens from time to time, but we are always keen to resolve it where possible.

While Ubuntu has a great many projects going on at any one time, some of these projects I explicitly put on my radar so I can help contribute to make them successful, and some of these are projects that I have been happy for me and my team to commit their time to. Each of these projects is scoped for a six month cycle, and when we get a little closer to the 10.10 cycle we will start thinking of where we will focus our time in that cycle too.

In the Lucid cycle I was keen to track work on this set of projects in a more effective way. To do this the process worked a little like this:

1. We first had a series of discussions at both UDS and online in which we discuss each project, what is involved and what targets and goals are in scope for the Lucid cycle. Targets beyond the Lucid cycle were explicitly deferred until the 10.10 cycle.
2. The conclusions generated from these discussions were first documented as a Roadmap on the Ubuntu wiki. This provides a high-level set of goals that the project is striving for.
3. We then produced a Blueprint for each project and a set of actions that are assigned to people. The blueprint is what we use to track progress on the project. The actions are stored in the whiteboard on the blueprint (which anyone can edit) and anyone can subscribe to the blueprint, which makes it great for keeping on track projects even if you are not involved in them.

The actions in the blueprint are stored in a set format, like this:

[jonobacon] An example action: TODO

In the above example, it clearly states who the action is assigned to (jonobacon on Launchpad), what it is (an example action) and it’s status (TODO). When an action is completed it is set to DONE and if we decide we want to bump it to next cycle, it is marked as POSTPONED.

This process in itself offers some key benefits:

• Commitments to a given project are clearly scoped to a cycle.
• Work is assigned to people: this is a great way of getting things done. Project Management theory has long taught that publicly assigning work to people improves it’s chances of getting done.
• Transparent: anyone can subscribe to a blueprint. As an example, even though I am not managing the Desktop Experience team or contributing to their projects, I am interested in their work, so I subscribe to a number of their blueprints. Each time the state of an action changes, I then get an automated email with the update. This is great for keeping up to date with their work.

With a bunch of blueprints that follow this format, I then approve a number of them as projects that my team will help have oversight on and help them to succeed. Some of these projects are driven by my team and I, but many of them are entirely community driven projects that I assign my team to have oversight over.

The legendary Martin Pitt then wrote a script to take this range of blueprints and actions and generate a burndown chart. Here is my team’s as of today:

It works like this: the Y axis is the number of actions in the blueprints I have approved for my team, and the X axis is the time until the end of the cycle (it is a little shorter as the graph was regenerated). The thick line through the middle of the chart is the trend line. My responsibility as a manager is to help keep the number of completed actions (shown as green) under the trend line: this ensures that we are on track for completing the committed actions throughout the cycle.

This was a pretty new concept for our community and of course the community is not expected to follow this way of working, but I have been stunned at how everyone has worked hard to stick to the actions they committed to and see the work through. As such this has felt like a really great cycle with some stunning work going on. Thanks everyone for your contributions!

Recently I asked for some help on how to download a file without blocking the GUI. Thanks to everyone who contributed their expertise in the post comments: I now have my program working great.

I wanted to now share my conclusions so that others can benefit from them too. To do this I am going to first explain how this works, and secondly I have created a Python Snippet and added it to the Python Snippets library so there is a great working example you folks can play with. You can use Acire to load the snippet and play with it. This is the first gio snippet, and I hope there will be many more.

The goal I set out with was to download a file without freezing the GUI. This was somewhat inspired from a recent Shot Of Jaq shot that we did on async programming, and I used this app as a good example to play with. Typically I had downloaded files the manual way and this had blocked my GUI hard, but I was aware that this is exactly what gio, part of the GNOME platform is here to solve.

The way async basically works is that you kick off an operation and then you wait for confirmation of the result before you proceed. It is the opposite of procedural programming: you don’t kick off an operation and in the next line process it. When you do things the async way, you start an operation and then tell it what callback should be called when it is complete. It feels very event-driven: kind of how you connect a handler to a signal in a widget so that when that signal is generated, the handler is called.

When I started playing with this the docs insinuated that read_async() and read_finish() were what I needed to use. I started off with code that looked a little like this:

def download_latest_shot(self):
    audiourl = "http://....the url to the Ogg file...."

    self.shot_stream = gio.File(audiourl)
    self.shot_stream.read_async(self.download_latest_shot_complete)

It then calls this callback:

def download_latest_shot_complete(self, gdaemonfile, result):
    f = self.shot_stream.read_finish(result).read()

    outputfile = open("/home/jono/Desktop/shot.ogg","w")
    outputfile.writelines(f)

After some helpful notes from the GNOME community, it turned out that what I really needed to use was load_contents_async() to download the full content of the file (read_async() merely kicks off a read operation) and load_contents_finish() as the callback that is called when it is complete. This worked great for me.

As such, here is the snippet which I have added to the Python Snippets library which downloads the Ubuntu HTML index page, shows it in a GUI without blocking it and writes it to the disk:

#!/usr/bin/env python
#
# [SNIPPET_NAME: Download a file asynchronously]
# [SNIPPET_CATEGORIES: GIO]
# [SNIPPET_DESCRIPTION: Download a file async (useful for not blocking the GUI)]
# [SNIPPET_AUTHOR: Jono Bacon <jono@ubuntu.com>]
# [SNIPPET_LICENSE: GPL]

import gio, gtk, os

# Downloading a file in an async way is a great way of not blocking a GUI. This snippet will show a simple GUI and
# download the main HTML file from ubuntu.com without blocking the GUI. You will see the dialog appear with no content
# and when the content has downloaded, the GUI will be refreshed. This snippet also writes the content to the home
# directory as pythonsnippetexample-ubuntuwebsite.html.

# To download in an async way you kick off the download and when it is complete, another callback is called to process
# it (namely, display it in the window and write it to the disk). This separation means you can download large files and
# not block the GUI if needed. 

class Example(object):
    def download_file(self, data, url):
        """Download the file using gio"""

        # create a gio stream and download the URL passed to the method
        self.stream = gio.File(url)

        # there are two methods of downloading content: load_contents_async and read_async. Here we use load_contents_async as it
        # downloads the full contents of the file, which is what we want. We pass it a method to be called when the download has
        # complete: in this case, self.download_file_complete
        self.stream.load_contents_async(self.download_file_complete)

    def download_file_complete(self, gdaemonfile, result):
        """Method called after the file has downloaded"""

        # the result from the download is actually a tuple with three elements. The first element is the actual content
        # so let's grab that
        content = self.stream.load_contents_finish(result)[0]

        # update the label with the content
        label.set_text(content)

        # let's now save the content to the user's home directory
        outputfile = open(os.path.expanduser('~') + "/pythonsnippetexample-ubuntuwebsite.html","w")
        outputfile.write(content)

ex = Example()

dial = gtk.Dialog()
label = gtk.Label()
dial.action_area.pack_start(label)
label.show_all()
label.connect('realize', ex.download_file, "http://www.ubuntu.com")
dial.run()

I am still pretty new to this, and I am sure there is plenty that can be improved in the snippet, so feel free submit a merge request if you would like to improve it. Hope this helps!

Ladies and Gentlemen of the Internet, on Tues 16th March at 11am PST / 2pm EST / 6pm GMT I will be doing a live At Home With Jono Bacon videocast dedicated to the Ubuntu Global Jam; the fantastic global event taking place from 26th – 28th March 2010 in which Ubuntu contributors get together in the same location to have fun and work on Ubuntu.

In the videocast I will talk about:

• What is the Ubuntu Global Jam?
• What are events like?
• How do you organize an event?
• Q + A

This is a great opportunity to get the low-down on the Ubuntu Global Jam and how to get involved. Be there!

Watch the videocast live here!

Over the weekend I read Cary Millsap's excellent paper Thinking Clearly About Performance. In it, he hijacks the UML Sequence Diagram format by drawing the vertical axis to scale. The bigger the gap between lines, the more time was taken performing that interaction. Suddenly, the sequence diagram can give you a clear picture of where time is being spent.

Slightly technical question for my friends on Planet GNOME. I have been hunting around for some help online with no luck, so I figured I would post here and hopefully this blog entry can be a solution for those who have similar questions.

I am in the process of porting App Of Jaq to to async. To do this I am using gio and have the code that downloads XML feeds up and running pretty well, and the app feels much more responsive. Now I need to have the application download an Ogg asynchronously without freezing the GUI.

My code currently looks like this:

def download_latest_shot(self):
    audiourl = "http://....the url to the Ogg file...."

    self.shot_stream = gio.File(audiourl)
    self.shot_stream.read_async(self.download_latest_shot_complete)

It then calls this callback:

def download_latest_shot_complete(self, gdaemonfile, result):
    f = self.shot_stream.read_finish(result).read()

    outputfile = open("/home/jono/Desktop/shot.ogg","w")
    outputfile.writelines(f)

Now, I am still pretty new to this, and while this code does work, it freezes the GUI pretty hard. Can anyone recommend some next steps for how I can download the file without it freezing? Some example code would be great.

Thanks in advance for anyone who can help.

Inspired by this brilliant picture and wee post over at the Panic Inc. blog I’ve not been able to shake the idea of making a similar status view for us to use when designing Ubuntu and related products. We’re always looking to enhance our processes and what I really like the idea of is creating a board that allows us to show the business not only what we’re working on but also keeps people working on different projects within the team to see what’s happening. This process is all a bit Apple at Xerox PARC. Panic don’t say exactly what their board is showing so I am taking what I think they’ve done there and think relates and am making up the rest. There’s every chance that their bored is very simple. I’ll post up more as I work on my project which I’m currently referring to as Bored on the grounds that I hope it will help keep people focussed in those moments when they stop and look up – or might be a bit bored, and because I’m working on it in my downtime.

I will also be open sourcing my terrible terrible code and designs such as they will be. Here’s some tantilising drawings I’ve done so far.

So where am I now? Well I stayed up late drawing those AMAZING pictures and have come up with the following next steps:

1. Draw up these mock ups and potential flow and interactions in a tidier way.
2. User test with some friends at work and in other places. Am I providing information that they would find useful?
3. Update in line with those findings.
4. Become an opportunistic developer.
5. Show to wowed colleagues and get some help making it work nicely and easier to update.

I’ll also keep an eye on this project on Git as they seem to be creating at least a front end. I don’t think I’ll want to use their code but I might borrow their structure as that’s the bit I know least about I’ll also keep an eye on Panic as they clearly have had a massive response and more talented hands than mine are probably already hammering away at something.

More as we have it!

First of all, as of last night, I am now officially an Ubuntu Member. Go me! Thanks very much to the member board who deal with all of us petitioners. Your work is appreciated.

Now, onto the topic that seems to be the most important thing in the world right now: window button placement.

Seriously.

The way people are reacting, you’d think that Ubuntu pretended to be their friend, helped them move, hung out with them on weekends, and generally palled around for a few years before unexpectedly dropping by in the middle of the day and poisoning their dog.

I’ll go on record right now and say that I like the buttons on the left.

(Did he really say that?  What is he, some kind of misanthrope?  Lock up your children!  Hide your valuables!)

Does it really make that much difference to you whether the buttons on a window are on the left or right?  Despite what people are trying to claim, there’s no logical reason for either.  It’s all personal preference.  You’re used to the buttons being on the right, so having them anywhere else feels unnatural.  Actually, that part is fair — it is unnatural.  But that’s because window controls, windows, even the mouse pointer itself are unnatural!  Having watched my grandmother spend literally 15 minutes and use both hands to try to close a window — with the controls on the right, mind you — I can tell you that there’s nothing intuitive at all about these controls.

I like the fact that the controls are different.  I like that you can immediately tell this is an Ubuntu system rather than a Windows or Mac system.  To be honest, if I had my druthers the controls would be even more different, as having the button that means “make this window go away temporarily until I’m ready to use it again” 8 pixels away from the button that means “make this window go away forever and destroy any unsaved work I have” seems like a Bad Idea.  So stick that in Fitts’ pipe and smoke it.

If it bothers you that much, you can change it.  Just like you can change the default wallpaper, the default theme, the default sounds, the default applications, even the default desktop environment.  The Canonical Police Force isn’t going to come break down your door and force you to conform.  (We’ll leave that sort of thing to the other guys.)

I really can’t tell you how exciting a place to be Canonical towers is right now! Yes, it’s hard work keeping up with all the feedback from the community, we’re terrifyingly close to a release and have to deliver final and updated assets until the cows come home and YES it’s UDS in 8 weeks – eek! We have much to do but this late on a Friday night I want to stop for a moment and just sigh because whatever the boards and the millions of fans and armchair experts are saying we’ve produced a release that is running beautifully and stably on my lovely new laptop and I am having a great user experience every day using open source software!

Beta will be out next week and you know what? Try it! Stick Ubuntu on a netbook or boot it from a CD or try it on a mate’s computer. I don’t care where! Just have a go! You could work and live in an environment like the one below!

Ambiance - our dark theme

Radiance - our light theme

The tracks which interested me today were “How do you test that?”, which dealt with scenarios where testing (especially automation) is particularly challenging, and “Browser as a Platform”, which is self-explanatory.

Joe Walker: Introduction to Bespin, Mozilla’s Web Based Code Editor

I didn’t make it to this talk, but Bespin looks very interesting. It’s “a Mozilla Labs Experiment to build a code editor in a web browser that Open Web and Open Source developers could love”.

I experimented briefly with the Mozilla hosted instance of Bespin. It seems mostly oriented for web application development, and still isn’t nearly as nice as desktop editors. However, I think something like this, combined with Bazaar and Launchpad, could make small code changes in Ubuntu very fast and easy to do, like editing a wiki.

Doron Reuveni: The Mobile Testing Challenge

Why Mobile Apps Need Real-World Testing Coverage and How Crowdsourcing Can Help

Doron explained how the unique testing requirements of mobile handset application are well suited to a crowdsourcing approach. As the founder of uTest, he explained their approach to connecting their customers (application vendors) with a global community of testers with a variety of mobile devices. Customers evaluate the quality of the testers’ work, and this data is used to grade them and select testers for future testing efforts in a similar domain. The testers earn money for their efforts, based on test case coverage (starting at about $20 each), bug reports (starting at about $5 each), and so on. Their highest performers earn thousands per month.

uTest also has a system, uTest Remote Access, which allows developers to “borrow” access to testers’ devices temporarily, for the purpose of reproducing bugs and verifying fixes. Doron gave us a live demo of the system, which (after verifying a code out of band through Skype) displayed a mockup of a BlackBerry device with the appropriate hardware buttons and a screenshot of what was displayed on the user’s screen. The updates were not quite real-time, but were sufficient for basic operation. He demonstrated taking a picture with the phone’s camera and seeing the photo within a few seconds.

Dylan Schiemann: Now What?

Dylan did a great job of extrapolating a future for web development based on the trend of the past 15 years. He began with a review of the origin of web technologies, which were focused on presentation and layout concerns, then on to JavaScript, CSS and DHTML. At this point, there was clear potential for rich applications, though there were many roadblocks: browser implementations were slow, buggy or nonexistent, security models were weak or missing, and rich web applications were generally difficult to engineer.

Things got better as more browsers came on the scene, with better implementations of CSS, DOM, XML, DHTML and so on. However, we’re still supporting an ancient implementation in IE. This is a recurring refrain among web developers, for whom IE seems to be the bane of their work. Dylan added something I hadn’t heard before, though, which was that Microsoft states that anti-trust restrictions were a major factor which prevented this problem from being fixed.

Next, there was an explosion of innovation around Ajax and related toolkits, faster javascript implementations, infrastructure as a service, and rich web applications like GMail, Google Maps, Facebook, etc.

Dylan believes that web applications are what users and developers really want, and that desktop and mobile applications will fall by the wayside. App stores, he says, are a short term anomaly to avoid the complexities of paying many different parties for software and services. I’m not sure I agree on this point, but there are massive advantages to the web as an application platform for both parties. Web applications are:

• fast, easy and cheap to deploy to many users
• relatively affordable to build
• relatively easy to link together in useful ways
• increasingly remix-able via APIs and code reuse

There are tradeoffs, though. I have an article brewing on this topic which I hope to write up sometime in the next few weeks.

Dylan pointed out that different layers of the stack exhibit different rates of change: browsers are slowest, then plugins (such as Flex and SilverLight), then toolkits like Dojo, and finally applications which can update very quickly. Automatically updating browsers are accelerating this, and Chrome in particular values frequent updates. This is good news for web developers, as this seems to be one of the key constraints for rolling out new web technologies today.

Dylan feels that technological monocultures are unhealthy, and prefers to see a set of competing implementations converging on standards. He acknowledged that this is less true where the monoculture is based on free software, though this can still inhibit innovation somewhat if it leads to everyone working from the same point of view (by virtue of sharing a code base and design). He mentioned that de facto standardization can move fairly quickly; if 2-3 browsers implement something, it can start to be adopted by application developers.

Comparing the different economics associated with browsers, he pointed out that Mozilla is dominated by search through the chrome (with less incentive to improve the rendering engine), Apple is driven by hardware sales, and Google by advertising delivered through the browser. It’s a bit of a mystery why Microsoft continues to develop Internet Explorer.

Dylan summarized the key platform considerations for developers:

• choice and control
• taste (e.g. language preferences, what makes them most productive)
• performance and scalability
• security

and surmised that the best way to deliver these is through open web technologies, such as HTML 5, which now offers rich media functionality including audio, video, vector graphics and animations. He closed with a few flashy demos of HTML 5 applications showing what could be done.

I've shown you how to get started with launchpadlib and have shown a slightly more complex launchpadlib script.

Before I cry The power is yours! and return to my home within the earth, I'm going to warn you about the things that can trip you up when using launchpadlib.

Bugs

  for thing in bunch_of_things:
    thing.do_something_on_launchpad()

I just wanted to let you good people of the Internet know that I will be delivering a brand new talk entitled Unwrapping The Community Manager at OSBC in San Francisco at 11.40am on Thu 18th March 2010.

In the presentation I will be deconstructing the role of community manager and discussing:

• who needs a community manager?
• what does the role involve?
• where should he/she report?
• what are requirements for improving the opportunity for success?
• what are the risks?

I will also be sharing my experiences working with Ubuntu and other organizations. I hope to see some of you there!

I was talk-hopping today, so none of these are complete summaries, just enough to capture my impressions from the time I was there. I may go back and watch the video for the ones which turned out to be most interesting.

Yesterday, I noted a couple of practices employed by the QCon organizers which I wanted to note, to consider trying them out with Canonical and Ubuntu events:

• As participants leave each talk, they pass a basket with a red, a yellow and a green square attached to it. Next to the wastebasket are three small stacks of colored paper, also red, yellow and green. There are no instructions, indeed no words at all, but the intent seemed clear enough: drop a card in the basket to give feedback.
• The talks were spread across multiple floors in the conference center, which I find is usually awkward. They mitigated this somewhat by posting a directory of the rooms inside each lift.

Chris Read: The Cloud Silver Bullet

Which calibre is right for me?

Chris offered some familiar warnings about cloud technologies: that they won’t solve all problems, that effort must be invested to reap the benefits, and that no one tool or provider will meet all needs. He then classified various tools and services according to their suitability for long or short processing cycles, and high or low “data sensitivity”.

Simon Wardley: Situation Normal, Everything Must Change

I actually missed Simon’s talk this time, but I’ve seen him speak before and talk with him every week about cloud topics as a colleague at Canonical. I highly recommend his talks to anyone trying to make sense of cloud technology and decide how to respond to it.

In some of the talks yesterday, there was a murmur of anti-cloud sentiment, with speakers asserting it was not meaningful, or they didn’t know what it was, or that it was nothing new. Simon’s material is the perfect antidote to this attitude, as he makes it very clear that there is a genuinely important and disruptive trend in progress, and explains what it is.

Jesper Boeg: Kanban

Crossing the line, pushing the limit or rediscovering the agile vision?

Jesper shared experiences and lessons learned with Kanban, and some of the problems it addresses which are present in other methodologies. His material was well balanced and insightful, and I’d like to go back and watch the full video when it becomes available.

Here again was a clear and pragmatic focus on matching tools and processes to the specific needs of the team, business and situation.

Ümit Yalcinalp: Development Model for the Cloud

Paradigm Shift or the Same Old Same Old?

Ümit focused on the PaaS (platform as a service) layer, and the experience offered to developers who build applications for these platforms. An evangelist from Salesforce.com, she framed the discussion as a comparison between force.com, Google App Engine and Microsoft Azure.

Eric Evans: Folding Design into an Agile Process

Eric tackled the question of how to approach the problem of design within the agile framework. As an outspoken advocate of domain-driven design, he presented his view in terms of this school and its terminology.

He emphasized the importance of modeling “when the critical complexity of the project is in understanding and communicating about the domain”. The “expected” approach to modeling is to incorporate an up-front analysis phase, but Eric argues that this is misguided. Because “models are distilled knowledge”, and teams are relatively ignorant at the start of a project, modeling in this way captures that ignorance and makes it persist.

Instead, he says, we should employ to a “pull” approach (in the Lean sense), and decide to work on modeling when:

• communications with stakeholders deteriorates
• when solutions are more complex than the problems
• when velocity slows (because completed work becomes a burden)

Eric illustrated his points in part by showing video clips of engineers and business people engaged in dialog (here again, the focus on people rather than tools and process). He used this material as the basis for showing how models underlie these interactions, but are usually implicit. These dialogs were full of hints that the people involved were working from different models, and the software model needed to be revised. An explicit model can be a very powerful communication tool on software projects.

He outlined the process he uses for modeling, which was highly iterative and involves identifying business scenarios, using them to develop and evaluate abstract models, and testing those models by experimenting with code (“code probes”). Along the way, he emphasized the importance of making mistakes, not only as a learning tool but as a way to encourage creative thinking, which is essential to modeling work. In order to encourage the team to “think outside the box” and improve their conceptual model, he goes as far as to require that several “bad ideas” are proposed along the way, as a precondition for completing the process.

Eric is working on a white paper describing this process. A first draft is available on his website, and he is looking for feedback on it.

Modeling work, he suggested, can be incorporated into:

• a stand up meeting
• a spike
• an iteration zero
• release planning

He pointed out that not all parts of a system are created equal, and some of them should be prioritized for modeling work:

• areas of the system which seem to require frequent change across projects/features/etc.
• strategically important development efforts
• user experiences which are losing coherence

This was a very compelling talk, whose concepts were clearly applicable beyond the specific problem domain of agile development.

Have you tried lptools?

It's not at all officially associated with the Launchpad project, of course, but it's got a few nice things that you might want to look at, including: