March 15, 2010

March record scores!

It’s the 14th already, and I actually blew through my record budget within the first week. I would have made this post earlier but

  1. I was a little embarrassed I blew through my record budget within the first week
  2. I was waiting for a record to come in from the Czech Republic

So here they are, in all of their beautiful waxy glory.

  1. Eternal – Lucifer’s Children: Electric Wizard side project band!! X/500!
  2. Anima Morte/Hooden Menace split picture disc! X/500
  3. Leather – Ancorite. I don’t know how many of these there are, but I got a test press!
  4. Killing Joke s/t
  5. Sisters of Mercy – Floodland
  6. Bauhaus – Press Eject and Give Me the Tape

Not bad for $50 right? The Eternal record is killer, I saw the artwork in the record store and it struck me as Electric Wizard like, so I picked it up, brought it home, and found out a) it’s rare b) it’s pre-electric wizard c) IT’S HEAVY

So.. you want to try out the Alpha version of Fedora on a usb stick?

Sometimes I like taking the latest releases of Fedora Linux for a spin. There aren't any guides for quickly getting Fedora's usb creator working on Ubuntu.  So I decided to change that.

Download Fedora Alpha here (I strongly suggest using the torrent so it's verified automatically)
*Note* you could also choose to get a stable version of Fedora, as Alpha can mean the usual, aka data loss, losing access to your Ubuntu drive if you install it, or the network card on your computer becoming permanently made useless, etc.

Get the file: liveusb-creator-3.9.tar.bz2 (140K) (under Source)
https://fedorahosted.org/liveusb-creator/

Install the following dependencies - which I believe would all be installed by:
apt:python-qt4-dbus,python-parted

Extract the liveusb-creator-**** file.  Run with following command:
gksudo "./liveusb-creator --noverify"

Then follow the on-screen instruction. Enjoy testing!

Couple of testing points:
  • On initial bootup, just press enter when you see "boot:"
  • Just wait when you get to the login screen, it will eventually log you in.  Don't try clicking on anything, it doesn't seem to like it.

2 year cadence for major releases: some progress

Even though the idea of formal alignment between the freezes of Debian and Ubuntu didn’t hold, there has been some good practical collaboration between the maintainers of key subsystems. There are real benefits to this, because maintainers have a much more fruitful basis for sharing patches when they are looking at the same underlying version.

Harmonization for Ubuntu 10.04 LTS and Debian Squeeze

I think this is where we stand now:

Ubuntu Debian RHEL SLES
Kernel 2.6.32 + drm-33 2.6.32 + drm-33 2.6.32 2.6.32
GCC 4.4 4.4
Python 2.6 2.6
OpenOffice.org 3.2 3.2
Perl 5.10.1 5.10.1
Boost 1.40 1.40

I’m sure there are inaccuracies, please help me keep this up to date, sabdfl on freenode is the best way to reach me. The RHEL and SLES numbers are third-hand, so up-to-date information would be appreciated.

The actual release dates of Ubuntu LTS and Debian will vary of course, because of different priorities. And there’s no requirement that the same base version be used for every major component – there may well be differences allowing for different approaches. But where we do have it, we’ll be able to collaborate much more effectively on bug fixes for key upstream pieces. If a lot of distributions pick the same base upstream version, it greatly increases the value of extended shared maintenance and point releases of that upstream.

Why every two years?

Two years is a compromise between those who want 1 year releases for better support of cutting-edge hardware and those who want 7 year releases so their software stack doesn’t change before their job description does ;-) .

A whole-year multiple has several advantages. It means we can schedule the processes that are needed for collaboration at the same time of year whenever we need them – unlike 1.5 or 2.5 year cycles. Three years was felt to be too long for hardware support. Two years is perceived to be the Goldilocks Cadence – just right.

What are the criteria for choosing a common base version?

In both the Ubuntu and Debian cases, we’ll be making a release that we support for many years. So be looked for versions of key upstreams that will pass the test of time. Sometimes, that means they can’t be too old, because they’ll be completely obsolete or unmaintainable in the life of the release. And sometimes that means they can’t be too young. In general, it would be better to be reviewing code that is already out there. But there are also lots of upstreams that do a credible job of release management, so we could commit to shipping a version that is not yet released, based on the reputation of the community it’s coming from.

What if there’s no agreement on a particular kernel, or X or component-foo?

We will almost certainly diverge on some components, and that’s quite OK. This is about finding opportunities to do a better job for upstreams and for users, not about forcing any distro to make a particular choice. If anyone feels its more important to them to use a particular version than another, they’ll do that.

Open invitations

It’s really helpful to have upstreams and other distributions participate in this process.

If you’re an upstream, kick off a thread in your mailing list or forums about this. Upstreams don’t need to do anything different if they don’t want to, we’ll still just make the best choices we can. But embracing a two year cadence is the best way you have to be sure which versions of your software are going to be in millions of hands in the future – it’s a great opportunity to influence how your users will experience your work.

Of course, we’d also like to have more distributions at the table. There’s no binding commitment needed – collaboration is opportunistic. But without participating in the conversation one can’t spot those opportunities! If you represent a distribution and are interested, then please feel free to contact me, or Matt Zimmerman, or anyone on the Debian release management team about it.

I think this is a big win for the free software community. Many upstreams have said “we’d really like to help deliver a great stable release, but which distro should we arrange that around?” Upstreams should not have to play favourites with distributions, and it should be no more work to support 10 distributions as to support one. If we can grow the number of distributions that embrace this cadence, the question becomes moot – upstreams can plan around that cycle knowing that many distributions will deliver their work straight to users.

Downloading Large Files Async With GIO

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. :-)

gudev-sharp is born!

In some of my spare time I’m working on modernizing Banshee’s hardware support (all the while lamenting the death of HAL). With HAL we had a nice (although monolithic) toolkit-agnostic hardware layer that was used through dbus. HAL was deprecated in favor of using udev, which is the the Kernel’s hardware event system. I’m sure udev is much nicer from an engineering point of view, but it’s certainly not as nice for application developers as a big old dbus-interface where any information about hardware could be retrieved was. Regardless of how I feel about HAL, HAL is still gone, so Banshee still needs updated to udev. Since udev is so new, no one had made C# bindings for libgudev yet, so I decided to take a stab at using GAPI to generate C# bindings. After hours of talking to myself in irc, trying to trick RAOF into doing my work for me, gudev-sharp is born! It just successfully ran the (incredibly simple) test code I wrote just to make sure it wouldn’t segfault. If you’re interested in modern hardware support via C#, help write unit tests!

I know some people are going to say “bzr? launchpad? And you want this adopted?”. It can move whenever it needs to, LP and bzr are my tools of choice, but if upstream Mono wants to move this into svn, I’d be happy to see it go.

New Ubuntu Brand … New Business Card

With the recent announcement of the new “light” look for Ubuntu, I thought that it would be really cool to have some business cards for Ubuntu Members that went along with the new style. I talked to Martin Owens, and he was able to throw together a new design for a business card based on the new boot splash screen.
I am not an artist (and I don’t know how to use programs like Inkscape) so Martin was even nice enough to teach me how to edit the file so I don’t print a business card with his name on it. You can download the source file by visiting Martin’s website.

Also, you will need to install ‘texlive’ package to get the correct fonts.

March 14, 2010

Aubergine

Thanks to Peter Stevens for pointing this video out to me. I’d not seen it before, and it raised a smile. Those of an impatient disposition might want to skip to 2 minutes in to the video. It’s only 4 minutes long in total and is worth watching in full. Although you might find yourself unable to shake the tune and words as I am.

Note: If you’re viewing this in an RSS reader you might not see the above flash video. Click through to the post. Also viewable in html5.

http://en.wikipedia.org/wiki/Eaton’s#Bankruptcy has a little history.

Digg This  Reddit This  Stumble Now!  Buzz This  Vote on DZone  Share on Facebook  Bookmark this on Delicious  Kick It on DotNetKicks.com  Shout it  Share on LinkedIn  Bookmark this on Technorati  Post on Twitter  Google Buzz (aka. Google Reader)  

Mxit Isn’t Android Friendly

Today I tried out the official Android Mxit client. I was very very disappointed. The inability to press the "back" button upsets me. This button is always referred to as back back and never exit. It is part of the Android spec.

The reasoning is simple they don't want you to background the app?: Pressing the back button asks the user "Logout from MXit" with the options "no" and "logout" neither were what I wanted to do.

Fear not Android users there is a work around. Pressing the home button will background the activity and return you to your home screen.

Mxit please fix your back button. Thanks

Ubuntu Weekly Newsletter #184

newspaper-icon3

The Ubuntu Weekly Newsletter, Issue #184 for the week of March 7th – March 13th, 2010 is now available here.

In this Issue:

* Lucid Kernel now Frozen
* Ubuntu 10.04 beta 1 freeze now in effect
* Intel, Eucalyptus and Canonical join forces to help user build cloud infrastructures confidently
* Call for Testing: Cluster Stack – Load Balancing
* Google Summer of Code 2010: Ubuntu application
* New Ubuntu Members: Asia Oceanic Board & Americas Board
* Request for input for Lucid Beta 1 technical overview
* International Womens Day “How I Discovered Ubuntu” Winners
* Ubuntu Stats
* Ubuntu Global Jam(LoCo Style)
* Getting started with launchpadlib: Launchpad’s Python library
* Ubuntu Global Jam – what’s it all about?
* New stuff for the Ubiquity slideshow(Proposed)
* Alan Pope: Why (I think) Ubuntu is Better Than Windows
* In the Press & Blogosphere
* Ubuntu hits HTC’s Touch Pro2, is any Windows Mobile handset safe?
* Upcoming Meetings & Events
* Updates & Security

And much. much more!

This issue of the Ubuntu Weekly Newsletter is brought to you by:

* John Crawford
* Craig A. Eddy
* Dave Bush
* Amber Graner
* J Scott Gwin
* Liraz Siri
* And many others

If you have a story idea for the Weekly News, join the Ubuntu News Team mailing list and submit it. Ideas can also be added to the wiki!

Except where otherwise noted, content on this site is licensed under a Creative Commons Attribution 3.0 License BY SA Creative Commons License.


Ubuntu Manual Icons

Getting Started with Ubuntu 10.04 needs icons to mark Warning and Advanced notes in the document.

First row Warning, based on the icon in the Humanity set, rest Advanced. dangerous bend approach inspired by Knuth (thanks Kevin Godby).


Filed under: Icons, Planet Ubuntu, Ubuntu, Ubuntu Manual Project

The Bazaar Package Importer

The Bazaar package importer is a service that we run to allow people to use Bazaar for Ubuntu development by importing any source package uploads in to bzr. It's not something that most Ubuntu developers will interact with directly, but is of increasing importance.

I've spent a lot of time working in the background on this project, and while the details have never been secret, and in fact the code has been available for a while, I'm sure most people don't know what goes on. I wanted to rectify that, and so started with some wiki documentation on the internals. This post is more abstract, talking about the archtecture.

While it has a common pattern of requirements, and so those familiar with the architecture of job systems will recognise the solution, the devil is in the details. I therefore present this as a case-study of one such system that can be used to constrast other similar sytstems as an aid to learning how differing requirements affect the finished product.

The Problem

For the Ubuntu Distributed Development initative we have a need for a process that imports packages in to bzr on an ongoing basis as they are uploaded to Ubuntu. This is so that we can have a smooth transition rather than a flag day where everyone switches. For those that are familiar with them think Launchpad's code imports but with Debian/Ubuntu packages as the source, rather than a foreign VCS.

This process is required to watch for uploads to Debian and Ubuntu and trigger a run to import that upload to the bzr branches, pushing the result to LP. It should be fast, though we currently have a publication delay in Ubuntu that means we are used to latencies of an hour, so it doesn't have to be greased lightning to get acceptance. It is more important to be reliable, so that the bzr branches can be assumed to be up to date, that is crucial for acceptance.

It should also keep an audit trail of what it thinks is in the branches. As we open up write access to the resulting branches to Ubuntu developers we can not rely on the content of the branches not being tampered with. I don't expect this will ever be a problem, but I wanted to ensure that we could at least detect tampering, even if we couldn't know exactly what had happened by keeping private copies of everything.

The Building Blocks

The first building block of the solution is the import script for a single package. You can run this at any time and it will figure out what is unimported, and do the import of the rest, so you can trigger it as many times as you like without worrying that it will cause problems. Therefore the requirement is only to trigger it at least once when there has been an upload since the last time it was run, which is a nicer requirement than "exactly once per upload" or similar.

However, as it may import to a number of branches (both lucid and karmic-security in the case of a security upload, say), and these must be consistent on Launchpad, only one instance can run at once. There is no way to do atomic operations on sets of branches on Launchpad, therefore we use locks to ensure that only one process is running per-package at any one time. I would like to explore ways to remove this requirement, such as avoiding race conditions by operating on the Launchpad branches in a consistent manner, as this would give more freedom to scale out.

The other part of the system is a driver process. We use separate processes so that any faults in the import script can be caught in the supervisor process, with the errors being logged. The driver process picks a package to import and triggers a run of the script for it. It uses something like the following to do that:

write_failure(package, "died")
try:
    import(package)
except:
    write_failure(packge, stderr)
finally:
    remove_failure(package)

write_failure creates a record that the package failed to import with a reason. This provides a list of problems to work through, and also means that we can avoid trying to import a package if we know it has failed. This ensures that previous failures are dealt with properly without giving them a chance to corrupt things later.

Queuing

I said that the driver picks a package and imports it. To do this it simply queries the database for the highest priority job waiting, dispatching the result, or sleeping if there are no waiting jobs. It can actually dispatch multiple jobs in parallel as it uses processes to do the work.

The queue is filled by a couple of other processes triggered by cron. This is useful as it means that further threads are not required, and there is less code running in the monitor process, and so less chance that bugs will bring it down.

The first process is one that checks for new uploads since the last check and adds a job for them, see below for the details. The second is one that looks at the current list of failures and retries some of them automatically, if the failure looks like it was likely to be transient, such as a timeout error trying to reach Launchpad. It only retries after a timeout of a couple of hours has elapsed, and also if that package hasn't failed in that same way several times in a row (to protect against e.g. the data that job is sending to LP causing it to crash and so give timeout errors.)

It may be better to use an AMQP broker or a job server such as Gearman for this task, rather that just using the database. However, we don't really need any of the more advanced features that these provide, and already have some degree of loose-coupling, so using fewer moving parts seems sensible.

Reacting to new uploads

I find this to be a rather neat solution, thanks to the Launchpad team. We use the API for this, notably a method on IArchive called getPublishedSources(). They key here is the parameter "created_since_date". We keep track of this and pass it to the API calls to get the uploads since the last time we ran, and then act on those. Once we processed them all then we update the stored date and go around again.

This has some nice properties, it is a poll interface, but has some things in common with an event-based one. Key in my eyes is that we don't have to have perfect uptime in order to ensure we never miss events.

However, I am not convinced that we will never get a publication that appears later than one that we have dealt with, but that reports an earlier time. If this happens we would never see it. The times we use always come from LP, so don't require synchronised clocks between the machine where this runs and the LP machines, but it could still happen inside LP. To avoid this I subtract a delta when I send the request, so assuming the skew would not be greater than that delta we won't get hit. This does mean that you repeatedly try and import the same things, but that is just a mild inefficiency.

Synchronisation

There is a synchronisation point when we push to Launchpad. Before and after this critical period we can blow away what we are doing with no issues. During it though we will have an inconsistent state of the world if we did that. Therefore I used a protocol to ensure that we guard this section.

As we know locking ensures that only one process runs at a time, meaning that the only way to race is with "yourself." All the code is written to assume that things can go down at any time as I said, the supervisor catches this and marks the failures, and even guards against itself dying. Therefore when it picks back up and restarts the jobs that it was processing before dying it needs to ensure that it wasn't in the critical section.

To do this we use a three-phase commit on the audit data to accomany the push. When we are doing the import we track the additions to the audit data separately from the committed data. Then if we die before we reach the critical section we can just drop it again, returning to the inital state.

The next phase marks in the database that the critical section has begun. We then start the push back. If we die here we know we were in the critical section and can restart the push. Only once the push has fully completed do we move the new audit data in to place.

The next step cleans up the local branches, dying here means we can just carry on with the cleanup. Finally the mark that we are in the critical section is removed, and we are back to the start state, indicating that the last run was clean, and any subsequent run can proceed.

All of this means that if the processes go down for any reason, they will clean up or continue as they restart as normal.

Dealing with Launchpad API issues

The biggest area of operational headaches I have tends to come from using the Launchpad API. Overall the API is great to have, and generally a pleasure to use, but I find that it isn't as robust as I would like. I have spent quite some time trying to deal with that, and I would like to share some tips from my experience. I'm also keen to help diagnose the issues further if any Launchpad developers would like so that it can be more robust off the bat.

The first tip is: partition the data. Large datasets combined with fluctuating load may mean that you suddenly hit a timeout error. Some calls allow you to partition the data that you request. For instance, getPublishedSources that I spoke about above allows you to specify a distro_series parameter. Doing

distro.main_archive.getPublishedSources()

is far far more likely to timeout than

for s in distro.series:
    distro.main_archive.getPublishedSources(distro_series=s)

in fact, for Ubuntu, the former is guaranteed to timeout, it is a lot of data.

This is more coding, and not the natural way to do it, therefore it would be great if launchpadlib automatically partioned and recombined the data.

The second tip is: expect failure. This one should be obvious, but the API doesn't make it clear, unlike something like python-couchdb. It is a webservice, so you will sometimes get HTTP exceptions, such as when LP goes offline for a rollout. I've implemented randomized exponential backoff to help with this, as I tend to get frequent errors that don't apparently correspond to service issues. I very frequently see 502 return codes, on both edge and production, which I believe means that apache can't reach the appservers in time.

Summary

Overall, I think this architecture is good, given the synchronisation requirements we have for pushing to LP, without those it could be more loosely coupled.

The amount of day-to-day hand-holding required has reduced as I have learnt about the types of issues that are encountered and changed the code to recognise and act on them.

Dry Rub Barbeque Trout

Made this up after buying a nice piece of locally caught freshwater trout. I think that it would be even better if you were to hot-smoke it. Apply the rub between two and twelve hours before cooking.

Mix up the following then rub on to the flesh of the fish (enough for four servings):

  • 1 tbsp sea/rock salt.
  • 1 tbsp black peppercorns crushed.
  • 1 tbsp ground cumin.
  • 1 tbsp ground coriander.
  • 2 tsp caraway seed.
  • 2 tsp dried tarragon.
  • 2 tsp dried thyme.
  • 2 tsp chilli powder.
  • Zest of one lemon.

To drizzle on top when cooked melt some butter in a pan, add the juice of the lemon you used above, a pinch of salt, one crushed clove of garlic, and a handful of chopped coriander. Simmer for a couple of minutes.

Enjoy!

Ink Scape + PyGame = Fun

Dropped in some new image files while working on the PyGame template tutorial

Titlebar button position

I hate them on the left. I really do. Fortunately, when you hang out on IRC, sometimes little gems of information come by :)

<IdleOne> to change the buttons layout from left side of the window to  the rightside , hit the  alt-F2 keys then type gconf-editor, then apps > metacity  > general > button layout > menu:minimize,maximize,close

Happy π day :)

My Lucid Quickly Task List

I'm seeing if I can just recycle this post instead of create a whole new one ...
Here's a screen shot of a game that I made by modifying the Quickly PyGame template I am working on. I found a few bugs with the template while creating it, and fixed those. Now I will get started on the tutorial I think. I think I can make a nice video demo as well.
__________

We have entered the Lucid end-game. Which is great. Sadly, there were a whole mess of things for Quickly that I wanted to get done this cycle. I know I won't get to everything, but I can still do a lot. I decided to set out a list of goals, and to work on the list each night, hopefully picking one item off per evening.

I always consider work on Quickly to be related to, but not actually part of, my day job. Thus I enjoy working on it in my free time, but don't typically commit to accomplishing anything specific, because it is my free time, after all. However, let's see how this works.

Here is my tentative list (completed ones are crossed out):
  1. Finish fixing pygame template indentation and comments.
  2. Refactor pygame template to put screen size in the configuration file.
  3. Create my own sample sounds for pygtame template.
  4. Make pygtame template actually a template (add the string replacement functions and derive from ubuntu-application commands).
  5. Remove CameraButton from quickly-widgets.
  6. Finish quickly-widgets documentation.
  7. Make quickly-widgets tests work (test apps currently work, but some of the tests fail erroneusly).
  8. Fix the ubuntu-application template tutorial to use quicky.widgets.couch_grid instead of desktopouch.couch_grid.
  9. Add PPA section to ubuntu-application tutorial.
  10. Write PyGame template tutorial
  11. Make new videos for ubuntu-application.
  12. Make videos for PyGame.
Those 10+ things seem like good goals to start. If I missed something, etc... please provide a comment.

New Business Card

I got a request from ubuntu member Chris Johnston about a new look business card using the new style/branding and to give you all an example of what what would look like I give you this quickly put together design (it’s not that good I admit):

You can download the source svg from deviantArt and don’t forget to install the LMMathSymbols10 font in the texlive package for the name text.

Update: Chris and Ben have both done modified versions of the design which you might be interested in looking at.

March 13, 2010

Ubuntu Manual Title Page

I worked with the Ubuntu Manual Team to refine the mission statement, define the audience, tone/message, to have a solid, documented and shared base for the design of not only the title page.

Much of that has its roots in a single IRC meeting. It’s documented in the wiki (link to the latest revision at the time of writing).

Summary:

The mission is to create and deploy a document that is suitable as first point of reference regarding the use of Ubuntu by beginner-level users.

The main target audience are pragmatic novice computer users. They want to get things done, they don’t see using the computer as an end in itself. We expect a peak of potential users in the range between 30 and 60 years of age.

The tone should be friendly, respectful and serious. From everyday people for everyday people. There should be an aura of competence and being goal driven. The message regarding Ubuntu shall be that it is solid, secure, trustworthy, capable, easy to use, empowering, about community (altruistic and pragmatic aspects), about FLOSS and not a clone of another system.

This all started before the announcement of the new Ubuntu identity design. The old logo-type encouraged me to me go for a slight handmade/organic touch. The community side of the new identity seems less suitable to hit the desired tone than the commercial side in my eyes, but we should not signify involvement of Canonical where this is very much a community project (see Mark Shuttleworth’s post about this dualism). So there’s one variation using lots of Aubergine, but it’s use would be problematic.

The following thumbnails link to PDFs, so you can judge the variations in their full scalable glory:

SVG source

In any case, some last tweaks will be required, including adjusting the margins based on the internal layout and using the right orange, once there’s an official and final definition.

Many thanks to David Nel for his idea to use icons and a mouse pointer and to Vish for helping with the icons.


Filed under: Icons, Planet Ubuntu, Ubuntu, Ubuntu Manual Project

‫New theme and RTL languages‬

Hey all,

Recently Ubuntu got a new theme, which (IMHO) looks awesome. Some people complain about the close button change, some doesn't like the theme at all, but I want to show a completely different problem in the theme.

Few days ago a good friend, IsraeliHawk, complained about the way the new theme looks in RTL languages.

In the new theme the title is in the left side of the window, which might look great in LTR mode, but in RTL it's seem to look a little buggy.

For that reason Uri opened a bug report, which explains quite good what is the problem.

So if you're an RTL user, or even just some who care, please have a look and see what you can do ;)

Thanks,
Dor.

Edit: Thanks for Haggai Eran who commented another RTL bug with the new theme.

RC bugs of the week

I just couldn’t resist… I joined the game, but did it the other way around.

I could only file 51 new FTBFS (Fail To Build From Source) bugs this time. Looks like Squeeze is getting closer!

I’ve also been doing rebuilds of Ubuntu lucid. There are currently 561 packages that fail to build from source in lucid/amd64, versus 430 in sid/amd64 (I will start rebuilding squeeze instead of sid after the freeze). Surprisingly, only 131 packages fail in both. I would have expected that number to be much higher.

The 51 new FTBFS bugs:
#573648: gnome-chemistry-utils: FTBFS: Nonexistent build-dependency: libgoffice-0-8-dev
#573649: …/api/package-list is no longer compressed
#573650: …/api/package-list is no longer compressed
#573651: virt-top: FTBFS: configure: error: Cannot find required OCaml package ‘extlib’
#573652: heartbeat: FTBFS: Nonexistent build-dependency: libcluster-glue-dev
#573653: abiword: FTBFS: Nonexistent build-dependency: libgoffice-0-8-dev
#573654: helium: FTBFS: Makefile: hGetLine: invalid argument (Invalid or incomplete multibyte or wide character)
#573655: mlton-cross: FTBFS: /bin/sh: wget: not found
#573656: pytest-xdist: FTBFS: ImportError: No module named setuptools
#573657: libfile-fu-perl: FTBFS: tests failed
#573658: libphysfs: FTBFS: docs/man/man3/PHYSFS_addToSearchPath.3: No such file or directory at /usr/bin/dh_installman line 127.
#573659: ecl: FTBFS: rm: cannot remove `/build/user-ecl_10.2.1-1-amd64-S2bazb/ecl-10.2.1/debian/ecl/usr/share/info/dir’: No such file or directory
#573660: …/api/package-list is no longer compressed
#573661: libdbix-class-schema-loader-perl: FTBFS: tests failed
#573662: …/api/package-list is no longer compressed
#573663: libthai: FTBFS: /usr/bin/install: cannot stat `./../doc/man/man3/th_render_text_tis.3′: No such file or directory
#573664: …/api/package-list is no longer compressed
#573665: hunspell-dict-ko: FTBFS: build hangs
#573666: plexus-active-collections: FTBFS: missing junit:junit:jar:debian
#573667: nuapplet: FTBFS: Can’t find gnutls library developpement files!
#573668: binutils-z80: FTBFS: /bin/sh: cannot open /build/user-binutils-z80_2.20-3-amd64-MwJBIl/binutils-z80-2.20/binutils-2.20.tar.bz2: No such file
#573669: keynav: FTBFS: keynav.c:799: error: too few arguments to function ‘xdo_mousemove’
#573670: moblin-panel-applications: FTBFS: moblin-netbook-launcher.c:1640: undefined reference to `mx_scroll_view_get_vscroll_bar’
#573671: tetradraw: FTBFS: /bin/bash: line 1: automake-1.7: command not found
#573672: beid: FTBFS: rm: cannot remove `_src/eidmw/bin/eidmw_*.qm’: No such file or directory
#573673: swfdec-gnome: FTBFS: Nonexistent build-dependency: libswfdec-0.8-dev
#573674: swfdec-mozilla: FTBFS: Nonexistent build-dependency: libswfdec-0.8-dev
#573675: jasmin-sable: FTBFS: Error: JAVA_HOME is not defined correctly.
#573676: corosync: FTBFS: `Depends’ field, reference to `libcorosync4′: error in version: version string is empty
#573677: banshee-extension-mirage: FTBFS: ./PlaylistGeneratorSource.cs(469,39): error CS0539: `Banshee.PlaybackController.IBasicPlaybackController.Next’ in explicit interface declaration is not a member of interface
#573678: gnucash: FTBFS: Nonexistent build-dependency: libgoffice-0-8-dev
#573679: libwx-perl: FTBFS: xvfb-run: error: Xvfb failed to start
#573680: …/api/package-list is no longer compressed
#573681: fso-usaged: FTBFS: fsobasics-2.0.vapi:110.2-110.84: error: `FsoFramework’ already contains a definition for `AsyncWorkerQueue’
#573682: libiscwt-java: FTBFS: Nonexistent build-dependency: libswt-gtk-3.4-java
#573683: nordugrid-arc-nox: FTBFS: ld: cannot find -larccrypto
#573684: cssc: FTBFS: rm: cannot remove `/build/user-cssc_1.2.0-1-amd64-XCK7aQ/cssc-1.2.0/debian/cssc/usr/share/info/dir*’: No such file or directory
#573685: django-threaded-multihost: FTBFS: distutils.errors.DistutilsError: Could not find suitable distribution for Requirement.parse(’setuptools-hg’)
#573686: …/api/package-list is no longer compressed
#573687: davical: FTBFS: /bin/sh: phpdoc: not found
#573688: gauche-gtk: FTBFS: gauche-gtk.c:450: error: too few arguments to function ‘Scm_Apply’
#573689: quilt: FTBFS: tests failed
#573690: pyabiword: FTBFS: Nonexistent build-dependency: libgoffice-0-8-dev
#573691: flumotion: FTBFS: configure: error: You need at least version 2.0.1 of Twisted
#573692: libnet-dns-zone-parser-perl: FTBFS: tests failed
#573693: nip2: FTBFS: Nonexistent build-dependency: libgoffice-0-8-dev
#573694: hedgewars: FTBFS: Error: Illegal parameter: -Nu
#573695: epsilon: FTBFS: FAILED (skips=5, expectedFailures=1, errors=7, successes=229)
#573696: python-glpk: FTBFS: Unsatisfiable build-dependency: libglpk-dev(inst 4.43-1 ! = wanted 4.38.999)
#573697: libnanoxml2-java: FTBFS: cp: cannot stat `/usr/share/doc/default-jdk-doc/api/package-list.gz’: No such file or directory
#573698: doxia-maven-plugin: FTBFS: Reason: Cannot find parent: org.apache.maven.doxia:doxia

Fun with Gwibber themes

In order to be fully buzzword compliant, all conference type gatherings in this web 2.0 social media age now have a compulsory twitter tag and live twitter projected display. Oggcamp (which, I would just like to mention, The Open Learning Centre is sponsoring) is no exception to this rule, but being all about Free culture needs to incorporate identi.ca (or status.net) dents alongside the tweets. The best way to do this is to leverage (I have a buzzword for every situation) the existing technology and make Gwibber fit for the purpose of projecting a continuous stream following a hash tag at a conference. The first thing it needs is a full screen mode. I have hacked one in, but it needs a bit of improvement, some more bits really need to be hidden when in presentation mode. The next thing I wanted to do was give each of the various hashtag pipelines (or “hash pipes” as I like to call them) it’s own theme. This bit was tricky as the search query isn’t currently available to the theme engine. I asked the upstream developers for a bit of guidance at this point and within 15 minutes of me explaining what I wanted to do I was given a new patch by segphault that exposes the search query to the theme.

So now I have a nearly finished Oggcamp theme which adapts when it sees you searching for #oggcamp, #ubuntu, #lo, #shotofjaq or #uupc. If I missed out any interesting hashtags then do let me know. Screenshot below is it running fullscreen on my 2048×1152 monitor. In reality it would be tracking two of them on a 1024×768 projector, but this shows all the hash pipe themes together, click to go large.

I will be pushing up a bzr branch of all this so you can play with it in the comfort of your own home or your own conference. If you have further suggestions, or want to help tweak it a bit more, then give me a shout in the comments.

APTonCD and Themes.

After a long time without being able to add any new functionality or improve something already done, decided to resolve an issue that bothered  a lot users, the visual behavior to using different themes.

To illustrate the problem, a brief introduction: APTonCD uses a color scheme to highlight the status of packages on it’s list.

They are:

  • Installed with newer version;
  • Not installed but with newer versions;
  • Installed but using an old version;
  • Not Installed but using an old version;
  • “CUSTOM” packages, using the  ‘add’  button or by draging’n droping from nautilus;
  • BAD Packages, packages that was not correct loaded by APTonCD;

The most common problem was to show packages with older versions using a color that aware the user for an old package, the development team chose the insensiteve color used by themes in the background color of a Label to show an item that does not respond to events mouse or keyboard. The result can be seen in the figure below:

Notice how difficult is to see informations  of  adduser (3.110ubuntu7) and adobe-flashplugin (10.0.42.34-2karnic1) packages.

After change it, the theme color used is the STATE_ INSENSITIVE for text and not backgrounds. The result is much better.

Now it’s using the new Python-apt API.

There’s much more coming, fasten your sit belts!!!

Ubuntu Manual Project Logo

Logo/header variations for the Ubuntu Manual Project.

This work is primarily meant to be inward facing, not necessarily for the audience of the manual. I decided to focus on the project being a collaborative (several sources) process to build a document.

The font is Biolinum, to be used for titles in the manual, in combination with Libertine for body text.

The CoF in an orange circle looked too aggressive in this context.


Filed under: Logos, Planet Ubuntu, Ubuntu, Ubuntu Manual Project

Call for input on Lucid Lynx Beta 1 - Technical Overview

Over on the Ubuntu Marketing Mailing list earlier today, Steve Langasek issued a call for input, below is what he had to say:


The first beta of Lucid Lynx is coming up next week, on March 18.  It would be good to have a refresh of https://wiki.ubuntu.com/LucidLynx/TechnicalOverview leading up to this with more input from people who can say what's great about Lucid instead of just people like me who spend our time enumerating all the things that are wrong with it. :-)  What's great about the Ubuntu 10.04 beta that you want our users to know?

Take a look at the wiki and see if you can help answer slangasek's question -"What's great about the Ubuntu 10.04 beta that you want our users to know?"

Irssi Handling JOINS/PARTS/QUITS

Irssi, as blogged extensively throughout this site, is one solid client. The flexibility never ceases to amaze me, and tonight was one of those times.

Hanging out in the amount of channels I do, I see a lot of activity in my statusbar for all of my joined channels. This can be overwhelming for some, but I don’t mind it. What I do mind, however, is when I check in on a specific channel, and see pages and pages of scrollback that is nothing more than people joining and leaving the channel. I’ve tried blatantly ignoring JOINS, PARTS and QUITS, as they’re called, but I always disable it, because I usually want to be kept abreast of when someone leaves a channel that I’m having a conversation with. I don’t want to look silly continuing to chat to someone, long after they’ve left. So, I need a way to keep on top of when people are joining and leaving the channel, but not have that information in the channel itself. Thankfully, Irssi meets this need.

The concept is simple. A JOIN, PART or QUIT is what is referred to as a “level”. There are a number of different levels that Irssi supports, all of which can be found with “/help levels” in Irssi. With Irssi, it is possible to ignore, or even redirect, levels. In my case, I want to redirect these three levels to another window, if possible. So, digging through the settings in Irssi, I found “window_check_level_first”. By default, this setting is “OFF”, which means that Irssi has a global setting for levels, and how they’re handled. Enabling this setting, means to follow the levels that have been assigned to their respective channels. However, if you turn this on first, without doing some initial setup before hand, you’ll notice everything going to your status window by default, including chat. This isn’t what we want, so let’s get setup.

The first thing we need to do is set our levels for all of our currently open windows, as well as any future windows that we open. We can accomplish this with two commands in Irssi:

/foreach window /window level ALL -JOINS -PARTS -QUITS
/set window_default ALL -JOINS -PARTS -QUITS

Now, the next thing to do is to create a new hidden window that will be the new home for all your JOINS, PARTS and QUITS. So, from Irssi:

/window new HIDDEN

Navigate to that window, wherever it is placed, and give it a name. For me, I called it “junk”. Of course, this isn’t necessary, just optional, but I prefer that each of my windows have a name:

/window name junk

It will have picked up the -JOINS -PARTS -QUITS from our default setting we just applied, so we’ll need to reverse that. Easiest way is to just apply the converse of what you did earlier:

/window level -ALL JOINS PARTS QUITS

Sweet. Our window is finished. Now, we can turn on the setting that will tell Irssi to look for each individual window level setting:

/set window_check_level_first ON

Wait a bit, and you should see all the JOINS, PARTS and QUITS going to your new hidden window, rather than each respective channel. You’ll also notice that it doesn’t print the channel where these are originating. I don’t know of an easy way to set that without a script, so if you know of such a script that exists, or want to write one yourself, sharing that would be appreciated. In the meantime, this is better than nothing.

Don’t forget to save:

/save

Also, you may not want to make your “junk” window hidden, but rather make it sticky, and split Irssi, putting the junk window on the top. I’ve done this with my highlight window, so it would make sense here. In that case, just:

/window stick on
/window show (number|name)

You can then size the window as needed if you decide you split your Irssi.

And, there you have it. Now, when people are joining and quitting, rather than filling your scrollback where precious chat exists, it’s all being forwarded to a window of your choice. If eventually, you like this setup, and you find that you’re not checking your junk window for joins and quits, then you may be able to get away with just ignoring JOINS, PARTS and QUITS altogether Irssi-wide. Which means, if for any reason you want to reverse this setup, it’s rather trivial:

/set window_check_level_first OFF
/foreach window /window level ALL
/set window_default ALL
/window close
/save

And that would back you out of this configuration, and get you back to default.

I should mention that I’ve heard that WeeChat has a feature that only people you’ve recently chatted with will show when they quit, or there is a setting for setting this. I personally think WeeChat is a solid client. However, in this case, I don’t want to see any quits, even with those I’m chatting with, in that buffer. However, I would like to see it in another buffer, and Irssi makes this painless. So, while I’m sure WeeChat can also meet similar needs, Irssi meets my needs best.

As with my other Irssi tutorials, I hope this one was helpful. I find that I personally benefit from my own writing, and that’s the major reason why I blog. I have searched for doing solving problems in the past, only to stumble upon my own blog post, outlining the very issue I’m faced with again. So, if it won’t benefit you, at least it will benefit myself.

Ubuntu Art: March

One of my many jobs in the community is to bring you lovely Ubuntu planet readers some of the wonderful art works that are created using Ubuntu and the FOSS tools we have in the repositories, all these works come from the Ubuntu deviantArt group. These are my picks for the month of march:

If you or someone you know is a good artist and would like to show off their work in our featured gallery. Do join up at our deviantArt group’s front page and start submitting work to the favourites and the galleries.

March 12, 2010

Call for Testing: Cluster Stack – Load Balancing

Continuing with the Ubuntu Cluster Stack testing, it is the time now for Load Balancing. During las UDS, we discussed that we should based the Load Balancing as part of the Ubuntu Cluster Stack using Keepalived due to its speed. However, since the main Cluster Stack is based in Pacemaker, we decided to do Load Balancing with Pacemaker/ldirectord too.

The wikipage showing the procedure is THIS ONE. If you find any bugs in the documentation, please let us know by leaving your comments at the END of the wikipage in preparation for the Documentation that might be included in the Ubuntu Server Guide.

All the packages are now in the archives. So please test the configurations and if you find any bugs, please report them in LP :) .

Fitts’ Law Misunderstood

Fitts’ Law is being thrown around quite often. Some people seem to think that it is all about how the edges of the screen and especially the corners are easy/fast to hit with the pointer. We have to thank Tog for that ;) This is at least not entirely wrong, but I also saw claims it would have to do with targets becoming harder to hit if you place other targets in close proximity.

It really only covers: The time to acquire a target is a function of the distance to and size of the target. It has to be noted that this does only refer to linear movement, so the size of the target has to be measured along the axis of movement.

Here’s a nice article with pictures (and the actual formula).


Filed under: Planet Ubuntu, Thoughts

Some Thoughts on the Mobile Device Interface

Smartphones: Yesterday's News


As some of you know, I started 2010 by working in a new position at Canonical: Ubuntu Project Manager. I've been having an absolute blast; working my butt off has never been more fun, challenging, or interesting. I'm finding that nearly every side-interest I've had in the past several years is coming to the forefront in my project management work.


There were all sorts of adjustments I needed to make before PM'ing again, and one of those was catching up on communication technology. I now live by email, calendars, IRC, Skype, and phone conversations. Gone are the days of going heads-down into some code for a week or two. I need to stay connected, 100% of the time. I needed to get a smartphone.


What I really wanted was a Nokia N900. Sadly, T-Mobile's not offering one, so I got an Android phone with a physical keyboard instead: a new G1. Yeah, out of date, but considering that I was still using a Razr, the G1 is cutting-edge ;-)


I gotta tell you, this little phone has changed my life. The craziest thing is not the apps, the Market, the features, etc.; it's the touchscreen that has made me a believer.


You Can Touch This


I can't believe how radically the touchscreen phone has changed my computing habits and preferences. When I sit down at my laptop or desktop to do something quickly, I don't want use the keyboard or mouse. I want to point, swipe, and tweak with my fingers. When I'm on the phone, my brain has my speaking and text-processing faculties tied up. To easily multitask while talking, I need to be able to use a different part of my brain: that part involved in motor control.


I like using the touchscreen so much that I will often use my G1 for tasks that are better suited for my laptop, merely because of the joy I get from using the interface.


Touch, tap, drag, push, swipe. I love it. Can't get enough of it.


The best thing of all? This is really silly: I love the virtual desktops and being able to navigate between them with a swipe. Whose idea was this? That designer or engineer needs to be promoted! I have never experienced a more intuitive way of switching virtual desktops. I didn't even know how much this was important to me until I used the G1. I want this for my laptop!


Having such a positive bias towards tactile technology, you can imagine my joy when I saw this Ubuntu blueprint. And then when I was asked to work with Bryce and Andy on the PM portion of multi-touch support, I was quite delighted. This will give application developers and device engineers what they need in order to start creating new exciting stuff for the Ubuntu world. You will be able to have an iPad-like experience on your Linux devices (that have the proper hardware).


The thing is, as much fun as tactile interfaces are, I want way more now. I've been given a taste... now I want the banquet.


An Interface for the Future


So the iPad has been getting lots of press. It's bigger than a phone, I like that: I could replace my pen-and-paper medium-sized Moleskine with one. The thing I like the best though? Yeah, you guessed it: the interface. Curling pages and apps that have been re-worked specifically for the new format/size. I love it when a device lets me use it in a way that is natural and intuitive, and provides visual (or other sensory) feedback on my use.


Apple has made, in my opinion, a good and interesting product. But certainly not a revolutionary one. It's a natural progression from what folks are already doing with smartphones and netbooks.


So let's talk about revolutionary :-)


Imagine you've got a crazy new shirt, one whose fibers convert your movements to electrical current and can power your devices. Perhaps it comes with a "battery net" for literally flexible power storage. Now imagine that some clever sod has equipped your shirt with sockets for micro-SD cards (or something similar). If you've read my "After the Cloud" posts, then you probably know where I'm going with this :-)


Now add some embedded micro-controllers, and bluetooth, a smart phone with cloud-controller software, and you've got a personal S3 with potentially terabytes of light-weight, wearable storage. And your phone controls the nodes, redundancy, failover, etc. Maybe your phone runs Ubuntu and you're pushing backups of your personal cloud onto your U1 account.


But how do we interface with all this great storage? Here comes the banquet I mentioned :-)


I want to be able to reach "into" my phone, grab an icon (application, file, contact, whatever) and put it where I want. But I mean really put it: I can pick up some data off my desktop, and throw it over my shoulder or at my feet. With appropriate sensing equipemnt on the power shirt's sleeves, my arms and hands are now the perfect "mice."


In fact, there's no more virtual desktop (that's old skool). One of the new primary functions of your mobile device is to peer "into" the halo of data that surrounds you now. You can either spin your virtual storage space around you like an inverted, 3D lazy susan, our you can physically move your phone around, like a diving mask peering into the water.


Closing Thoughts


The more data I have, the more I feel that I live in it. The problem is that our current tech forces us into tiny sardine cans and we have to consume our data with the equivalent of a single chop-stick. If I'm going to live in my data, I want to have the best possible experience of immersion that I can. I want an interface that can handle my future.


I could go on and on... I love this sort of thing. The important thing to know now is that the community is working on the building blocks for our technological future. The first steps are being made in open source software that will allow us to take giant, insanely cool steps in the not-to-distant future.




QCon London 2010: Day 3

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.


2 reasons not to use when claiming Lucid changes are bad

This blog is in response to http://humphreybc.wordpress.com/2010/03/11/its-the-little-things-that-count/

1: Ubuntu users aren't used to the change
I'm getting pretty sick and tired of the Ubuntu users out there that revert to saying that all changes that canonical has made to Ubuntu for 10.04 are bad "because Ubuntu users aren't used to them".  I don't really see how you can consider anything change unless something has ... well ... changed.  Yes, these same people that are making those claims are the same people that are out there complaining about there being no changes.

What's wrong with there being change for the sake of change?  I learned Ubuntu not by someone telling where every little button is, but by playing around with the UI and seeing where everything is for myself.  Even the typical egghead when it comes to computers knows that there will be a close/maximimize/minimize button somewhere in the top of a window.  Just because it's magically been moved to the other side doesn't mean Ubuntu's gone to the crapper.

2: Windows users will get confused if they want to switch
I'm kind of expanding on my last statement here, but it's not exactly rocket science here trying to find out where things are on the Desktop GUI.  I would imagine that most people that want to make the switch to Ubuntu aren't going to go crazy and get depressed because things "aren't where they should be".

I don't see the macintosh users out there going "hmm, I'm not sure if the windows users who switch over to macintosh are going to like that the title bar menu options are now right next to the window title" or "oh gosh, windows users are going to spontaneously combust when they see the close/maximize/minimize buttons on the left hand side".

The ability for the new Ubuntu user to use their common sense is something that too many people are ignorant of.  There is no reason that a single change made so far by the team at Canonical should be seen as something any new Ubuntu user can't get a grasp of with the use of a little common sense.

I for one am happy that Canonical has finally decided to make some decent UI changes to Ubuntu, because thats something that I get to look forward to on a constant basis as I test of the newest versions of Ubuntu.  There are too many lazy users out there that just aren't willing to accept the changes because IMO they have gotten into such a routine with their daily computer lifestyles that any and all changes are the straw that broke the camels back.

You-in-Ubuntu: When will Ubuntu 10.10 get a name?

You-in-Ubuntu: Checking out the history of the "Funky Fairy" naming system!





As the Ubuntu Community is gearing up for the release of Ubuntu 10.04, Lucid Lynx, there are those, myself included, who are anxiously awaiting the announcement of the code name of Ubuntu 10.10?
I went looking around the wiki's to see what I could find out about how each release gets it's name. I found a greatDevelopment Code Names wiki. Here's what I found out.

To read the full article please visit: You-In-Ubuntu.
image is by Olivia Galbraith and is available for download @https://wiki.ubuntu.com/Artwork/Incoming/Karmic/Backgrounds/Extra_Abstract

Ubuntu as project in Google Summer of Code 2010

I’m very excited to announce that Ubuntu has applied as participating organisation in the Google Summer of Code 2010!

We submitted an organisational application, along with suggested ideas for potential projects for students. We also encourage students to come up with their own ideas.

If you’re a student interested in Open Source (or if you know students who are), now is the time to act to get involved in Google’s wonderful Summer of Code program.

Also, if you are thinking about becoming a student’s mentor please visit:

https://wiki.ubuntu.com/GoogleSoC2010

Make sure you read all the necessary information carefully and join the IRC channel and mailing list for more discussion.

The timeline is as follows:

  • The list of accepted Mentoring Organisations will be announced on March 18, 2010 at 12 noon PDT / 19:00 UTC and will be posted on the Google Summer of Code 2010 site.
  • The student application period begins March 29, 2010 at 12 noon PDT / 19:00 UTC and ends April 9, 2010 at 12:00 at 12 noon PDT / 19:00 UTC. Please see the Google Summer of Code 2010 timeline and FAQs for further information.

[Discuss Ubuntu and the Google Summer of Code 2010 on the Forum]

Originally sent to the ubuntu-devel-announce mailing list by Daniel Holbach on Fri Mar 12 09:59:16 GMT 2010

Purple vs Orange


Scottie posted an entry earlier about the new Ubuntu branding. I’ve been meaning to make a very similar post, but I’ve had lots more important things to do the last two weeks.

For those who have missed it, Canonical announced the new branding and artwork on the day of the User Interface Freeze for the Lucid development cycle. The decisions around the new branding have been met with some controversy, and as Scottie pointed out, some awkwardness around it. I’ll try to sum up my views about it in this post.

Purple / Aubergine

One of the major changes in the artwork is a change from the yellowy-brown colours to purple and orange. Most of the highlights are in purple, so is the terminal background. The aubergine (purple) is supposed to signify the corporate and the commercial aspects of Ubuntu, while the orange represents community.

I love the way the background is slightly transparent by default. The compositing capabilities in Ubuntu is powerful and should be showed off. The amount of transparency is also just subtle enough that it shouldn’t bother people who usually prefer a solid background. I think the colour is horrible though. I’d go as far as to say it’s offensive, I can write that off to personal taste though. The really bad thing about it is that it changes your default profile to the so-called “Ambiance” theme automatically without any warning. At least it was easy to delete and my older, much more aesthetically pleasing terminal was restored.

Button Positions

The button positions have been a bit more controversial than the actual colours. Personally, I didn’t like it at first but it only took a few hours to get used to it. It was the same when I used OSX for the first time, the positions feel weird at first but they grow on you fast. I don’t think the button positions will be a problem for users who use Ubuntu pretty much exclusively. Not all my machines are on Lucid yet, so it’s been a pain to move between machines that have the controls on the left and that have them on the right. I can imagine that having the controls on the left may be a major annoyance for someone who uses the one system at home and another at work.

Besides that, many applications are set up to have the close button at the top right, and it’s usually not configurable. Scott mentioned something similar with regards to tabs, here’s an example in an OpenOffice document:

Font / Logo

Besides the announcement on the day of UI Freeze, the new Ubuntu font is still not complete either. This means that some derivatives (Edubuntu, for one), doesn’t have a new logo yet since the “e” and “d” letters haven’t been finalized yet. We’re also waiting for a new logo from Canonical, it’s a bit painful that this couldn’t have been better communicated or planned in advance.

Scott wonders why few other people have talked about this, but it’s not the first time Canonical has made big changes on or just before a freeze. It’s probably not the last either. I don’t think people are comfortable providing feedback, especially at the risk of being labeled as a bad apple that just wants to complain about stuff and especially if it won’t change anything.

Changes

Having said what I have so far, I’m all in favour of making big, bold changes. If Canonical puts this much effort into the design of every release, and if they can find a way to involve the community as well (turn their cold purple hearts a bit more orangy), then I think Ubuntu will make major strides in usability and design that ultimately, everyone else would want to copy.

Archive frozen in preparation for Ubuntu 10.04 Beta 1

One week away from the first Ubuntu 10.04 Beta release, the archive is now in hard freeze for preparation of that Beta.

During the freeze, all uploads to main must be approved by a member of the
release team, so if you have fixes which are important to get in, please get in touch as soon as possible (and preferably, get your packages uploaded in parallel!). Uploads to universe require a manual push through the queue, but are not subject to release management approval.

Full details can be found in the mailing list archive.

Why menu bars are evil, take 54304

Seif Lotfy posted excitedly about Ian Cylkowski's in-depth Nautilus redesign mockup.

I found it very nice and refreshing, too. However, I noticed one strange thing: the menu bar just up and vanished. Ian`s incentive intrigued me:
Hidden Menubar: I’m not going to take sides here on whether we should still be having a menubar in applications or not; it’s another minefield of opinions and flaming. I’m personally fine with a menubar inside the application, but I also happily use applications that tuck away the menubar under a single icon (think Google Chrome). But I do think that we should have the option here. In my mockup, all the menubar settings can be brought up with the settings icon (first icon after the pathbar). But if you would like to see the menubar permanently then this, too, should be an option.

Being one of those people who considers the slightest growth of an options dialog a crushing defeat, I just have to debate that. Hopefully this won't cause the flame-war Ian predicts. That would be a bad start for my first aggregated blog post. (Hi, Planet Ubuntu!)

What I would like to do is go over why Chromium's menus are great, and why they absolutely are not just “tucked away under a single icon” but intentionally designed that way and inseparable from that particular approach. It's about simplifying the menu so it relates to the two distinct subjects the user interacts with: the application and the current page.

There are millions of things I dislike about menu bars, but that would take all year to discuss. (And I have different things to fix). I'll just vent about two problems which relate closely to each other:
  • They traditionally consume 100% width. A small menu bar looks wimpy. Half of that menu bar will inevitably be wasted space no matter how hard the developers try to cram stuff into there.
  • There is a strange urge to duplicate everyone else's menus for consistency and have as many of these as possible. For some reason the uniqueness of an application is expected to vanish at the menu bar, which becomes an abstract world with words like “File” referring to web pages, photos, applications and video clips alike. Menu bars are popular things for accessibility, so I wonder if this abstraction helps in that regard or hinders.


Having said that, GNOME applications deserve some credit for usually replacing the title of the File menu with Music or Photos. Yet, the generic top-left-most menu is still there in spirit.

As we can see from the gnome-terminal screenshot, though, the File menu's spirit is weak. Challenge of the day: name one file related thing there, then explain why adding and editing profiles should be in different places.

So, Chromium is interesting because it is one of few applications to finally take a bold step against the '90s fashion in menu bars. First of all, the distinct lack of a menu bar clears up the interface considerably. There are still menus, however, because menus are important to categorize functionality in a pleasant fashion. Then they accept that, to an end user, the browser is not interacting with “files” but with web pages. So, the File menu becomes a Page menu. Completely. They also throw away all the baggage that the File menu used to have.
...and that is where the magic happens. Now the menu has a far more powerful, meaningful context. Actual useful functions can be put there that are of importance to people and relevant to what they are doing. Things like zooming, printing, copying and pasting inside pages.

The remaining stuff happens in the context of the Application menu (the wrench). Quitting, opening windows, changing preferences, dealing with bookmarks; anything that is related to the application as a whole, not the current page. Since Chromium was designed with a logical scope, that is everything else it does (except what extensions add).

I think we can do a lot better than the traditional menu bar. Just yanking it out, though, won't do us much good.

It’s time to fix the window controls

This is awkward.  We need to talk.

March 3rd was a strange day. It was one day before User Interface freeze for the upcoming Ubuntu Lucid long term support release.  By the end of the day we were supposed to have the entire look and feel of the desktop settled on so people could start writing documentation and books.

This was the same day that Canonical finally released the new theme that had been under secretive development.  It was bold, daring, light-inspired, and perhaps most popularly, not brown.  Jono Bacon, Canonical’s community manager, broke the news.  Mark Shuttleworth followed up on his own blog, thanking three members of the design team for leading the effort.

The most important change, however, wasn’t actually talked about.  The designers don’t blog themselves, and Mark and Jono didn’t mention it directly.  It had to be found in the screenshots, or experienced firsthand by alpha testers.

This is not ok

Soon, the community learned the change was intentional: a bug about the misplaced window controls was quickly marked invalid,  and when the controls briefly reappeared on the right again the change was reverted.  What’s disturbing is that Planet Ubuntu has been rather silent on the topic.  No one’s posted a real defense of this change yet, or for that matter even claimed responsibility. It’s like there’s this collective unease about criticizing something that feels like it came directly from on high.  So, instead, people are just silent.  I’d certainly be if I worked for Canonical.  Perhaps I should be, as I still hope to work for them.

If you read between the lines, you can tell that people aren’t too happy about it.  The most flattering thing a developer’s said about the left-sided Window controls is that they “got used to them after a few days”.  We’re quick to praise the theme (it’s gorgeous), but talking about this major sudden change to the window controls feels like taboo.  That’s incredibly unhealthy for a community project.  It’s like there’s this collective unease and everyone’s worrying if we’re about to release something embarrassing.

This experiment was a failure and we need to realize it

The alpha releases are great places for usability experiments.  Sometimes, they don’t work out.  Put a new user on today’s Ubuntu Lucid and they’ll think it’s fantastic, sleek, and absolutely gorgeous right up to the point where they have to close a window.  That’s where our first impression becomes something awful.

Note: The new card backs pictured above are my doing and are now default (Mads Rosendahl drew them).

A brief summary of the complaints about the left side window controls

Some of these I noticed myself, a few are gathered from various comment threads on forums and blogs over the past week.

• Because the window title isn’t centered, the window controls being placed directly in front of it put it in a weird indented position
• The “slightly off left” location is inconsistent with Nautilus, Firefox, Thunderbird, Pidgin, Empathy, and every other tabbed program we have, which have close buttons for their tabs on the right.
• The left position is inconsistent with Windows, previous versions of Ubuntu, and even OSX – users have to relearn decades of muscle memory.
• Users who interact with both Windows and Ubuntu machines (or migrate from Windows) will have a much harder time than they did before.
• The buttons are too close to the file and edit menus, making catastrophic misclicks much more likely.  Closing something on accident should be as rare as possible.
• Even without misclicking, a user will have to take more time to use the window control and avoid a misclick.  This is an example of Fitt’s Law.
• The close position is also inconsistent with the power button in upper right.  Currently, “close it down” is something you can always do from the upper right anywhere in the system: within a tab, within a window, and even for the whole computer.  The new window controls break that entirely.
• The new position leaves a lot of empty, wasted space in the upper right of most windows.  While strictly speaking the amount of unused space is the same, it looks much worse when it’s all clustered together.  When the controls are on the right, the extra space can function as a buffer for the potentially destructive window controls.
• Similarly, the upper left of most windows now becomes much more crowded, creating a rather unpleasing contrast to the relatively empty upper right.
• In previous Ubuntus you could close windows on the left if you really wanted, by expanding the small circle menu that’s now gone entirely.  File->Quit is also an option, which is now very close to the close box.
• Gnome upstream has them on the right, causing consistency and developmental problems when we deviate.  This is particularly jarring with the adoption of future projects like Gnome shell and Gnome 3, which will change again how we interact with window controls.
• The current implementation breaks themes not designed for the new button order (which is currently every theme we ship, so even changing the theme back doesn’t help)
• A day before User Interface freeze of a long term support release is the worst possible time to suddenly spring this on everyone without explanation.
• It is very difficult to change them back as we don’t have any UI tool for doing this (the current method is manually editing gconf keys)
• The new position doesn’t actually do anything beneficial.

That last point is the most important.  Other than “looking different” the change doesn’t do anything helpful.  It’s a huge usability loss for an awful lot of people.  Some people get used to it quickly.  Others don’t, and like me end up getting physically angry when trying to use their computer.  I can’t remember ever having my computer make me feel this way for a long time, and I’ve been running Ubuntu alphas for five years now.

Let’s admit we have a problem

Ivanka deserves credit for being the first member of the design team to at least talk about the controls:

Are we smoking crack to think that the learning curve or getting used to a new position is ever going to be worth any real or perceived benefit of new positions?

I’ll leave that question to the reader.

New Homepage Design

I've decided my old homepage was bad enough to revisit now that I've got a bit more content hosted deep within it. I replaced my crappy hand written HTML with tools written this decade, and threw in some amateur visual design.

The software

Firstly, in order to keep the webpage fresh with little effort, I've chosen RSS aggregation as the method of content generation. Since I know Ubuntu and Debian both use Planet, that's where I first looked. But it seems Planet 2.0 is aging, and the fork Planet Venus brings some neat new options. It expands the selection of templates, adds a configurable RSS filter step, and makes the normalization step configurable.

It's also packaged in Ubuntu as planet-venus, making it fairly simple to set up. Deployment was a little tricky, as the package leaves most of the site configuration to the admin. You'll need a config.ini (I used /etc/planet/planet.ini), a template dir (/usr/local/share/planet-venus/theme), a cache dir (/var/cache/planet) and an output dir (somewhere in /var/www typically). Finally, you'll need to set up a cron job to run the static output generation script regularly. The script reads all the feeds and parameters in config.ini, caches the results to save bandwidth on subsequent runs, passes them to the template engine, and places the final product in the output dir.

When building a lifestream style site, you have to be picky about the kinds of feeds you put in or it gets Facebook / Twitter style spammy. This is where the RSS filter step can help; Planet Venus comes with a few filters like 'notweets', and a few stripAds filters to cleanse ads before republishing. It's the same design pattern I talked about before here with Liferea. In the future I could write one to add in comment feeds and then filter out everything that fails to meet some strong quality criteria.

Output templates

Planet Venus's real selling point to me is using Django templates. I've been meaning to learn Django for a while now, and this is a pretty good way to work with the templates portion of Django. And again, the filter pattern pops up. Here, filters take python variables as input; in Planet Venus's setup you have access to feed and item variables, as well as planetwide settings. One example filter might be to simply pluralize a word based on a variable (yes, you can even handle 'y' pluralization). Another example is the urlize filter that adds HTML anchor tags to likely URLs (not so great when you already have anchor tags in the filter's input).

I also use templates to generate an RSS feed. Nothing difficult about it, since the input to templates is basically an RSS feed to begin with. To reduce the probability of bugs, I translated a provided example htmptmpl RSS template into Django, and it's much smaller and clearer to me. Unfortunately, there's a bug in Planet Venus that prevents the use of multiple Django templates. I've reported it upstream, and I'm sure I can fix it or work around it.

Web Design

I also decided to take a look at CSS layout frameworks, to get up to speed on the subject quickly. 960.gs is popular, but it's 960 pixel width assumption works poorly with quirky resolutions found on massive monitors and smartphones. Luckily, I found found fluid960, which is very similar, but implements fluid layouts. It retains the CSS class names of 960.gs, so tutorials and documentation on one translate fairly well to the other. Which is good, because fluid960 pretty much relies on you already knowing regular 960 (I didn't). This presentation gives a good summary of things you might want a CSS framework for, and this 960 tutorial covers what I needed to know.

Color scheming is probably the hardest part for me. It's simple to pick a color pallate that goes together, but there is a higher level opportunity to communicate something through visual design. I could choose a purple scheme to reflect my collegiate experience, or an Ubuntu pallete, but it seems inappropriate for a personal site. I've got a bit of low level coding experience, so I could go with a green on black terminal theme, but it's been done to death ever since the Matrix, and it's basically impossible to beat jwz's version.

Since I'm not really looking to break into web design, I went with a relatively muted color scheme that organizes the content without distracting from it. Truthfully it doesn't matter all that much, as experience shows the majority of hits will come via RSS.

Well, that's basically all there is to my automated homepage system. On to more important things, like setting up a calDAV server or a feed processing tool.

Collatz, Haskell and Lua

Sandro Tosi writes in his blog about the Collatz Conjecture, and gives a nice Python script to compute what is the longest collatz sequence in the [1,1e6] range (Project Euler problem 14).
Intrigued by it, I decided to give it a try myself. My first code was in C, just to give me something to base any future trade-off on.
The code is as follows:

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char **argv) {
  long unsigned int n, m, i, max_i=1;
  int len, max_len=0;
 
  if (argc!=2) {
    printf("Needs a numeric argument\n");
    return 1;
  }
 
  n = atol(argv[1]);
 
  for (i=2; i<=n; i++) {
    m = i;
    len = 0;
    while (m > 1) {
      if (m % 2 == 0)
	m = m / 2;
      else 
	m = 3 * m + 1;
      len++;
    }
    if (len>max_len) {
      max_len=len;
      max_i=i;
    }
  }
 
  printf("Max sequenze is %d long for %ld\n", max_len, max_i);
 
  return 0;
}

Nothing fancy here, some brute force and the result is 524 for 837799 (as expected). The time it takes my computer to find the solution is below 1 sec (about 0.7sec).

Second try is in Haskell. A recursive solution is obviously as simple as:

collatz :: Int -> Int
collatz n
  | n == 1 = 0
  | even n = 1+collatz(div n 2)
  | otherwise = 1+collatz(3*n+1)

Even though this doesn’t suffer from stack limitations as its Python sibling, I preferred to use a more straight-forward iterative solution:

collatz :: Int -> Int
collatz n
  | n == 1 = 0
  | even n = div n 2
  | otherwise = 3*n+1

So now one can use the following to compute a sequence, giving a starting integer:

collatz_list :: Int -> [Int]
collatz_list = takeWhile (>0) . iterate collatz

And to find the solution the following code:

collatz_scan :: Int -> Int -> Int
collatz_scan a b =
  foldr1 max $ map (length . collatz_list) [a..b]

Note that I use foldr1 explicitly, and not simply maximum. This is because maximum is implemented with foldl which, as you may know, suffer indeed from stack limitations.
The code is simple and does the job, however it is tremendously slow.
I don’t know exactly what is the culprit here, but I think it is related to lazy evaluation.

This won’t do, I need something to test (and possibly beat) the Python version. I only know two scripting languages well enough, and these are Lua and Perl.
I quite like Lua, it is simple yet powerful, and it is a joy to program with it.

I went on with three versions; the first was again a simple recursive one:

function collatz(n)
   if (n==1) then return 0 end
   count = count+1
   if ((n % 2)==0) then return collatz(n/2) end
   return collatz(3*n+1)
end
 
function collatz_scan(min,max)
   max_count = 0
   max_n = 0
   for n=min,max do
      count = 0
      collatz(n)
      if (count > max_count) then
	 max_count = count
	 max_n = n
      end
   end
   print(max_count,max_n)
end

Nice (at least Lua implements proper tail recursion), but not so fast. The iterative version was better:

function collatz(n)
local count = 0 
   while n > 1 do
      count = count + 1
      if (n % 2) == 0 then
	 n = n/2
      else
	 n = 3*n+1
      end
   end
   return count
end
 
function collatz_scan(min,max)
   max_count = 0
   max_n = 0
   for n=min,max do
      count = collatz(n)
      if (count > max_count) then
	 max_count = count
	 max_n = n
      end
   end
   print(max_count,max_n)
end

And obviously the memoized version:

cache = {}
 
function collatz(n)
   if (cache[n]==nil) then
      if (n==1) then return 0 end
      if ((n % 2)==0) then
         cache[n] = 1+collatz(n/2)
      else
         cache[n] = 1+collatz(3*n+1)
      end
   end
   return cache[n]
end
 
function collatz_scan(min,max)
   max_count = 0
   max_n = 0
   for n=min,max do
      count = collatz(n)
      if (count > max_count) then
	 max_count = count
	 max_n = n
      end
   end
   print(max_count,max_n)
end

This is pretty fast indeed, about 2.4 sec (which includes launching the “interpreter” and bytecompiling the script). Considering that the Python one needs 5 sec. Lua wins hands down here.

Network Effects

Just an interesting image.

Unwrapping The Community Manager at OSBC in San Francisco

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!

Planet Ubuntu

Planet Ubuntu is a window into the world, work and lives of Ubuntu developers and contributors.

If you are an Ubuntu Member, and would like your blog aggregated here, please see the PlanetUbuntu wiki page.

Updated on March 15, 2010 04:21 PM UTC. Entries are normalised to UTC time.

Ubuntu World Wide

Subscribe

Feeds