Let's Push Things Forward

Folks building and passing tests consistently

2013-02-24T22:44:16Z

In the Folks project, we've managed pretty good buildability as we've been developing the project. So far, that's mostly been through us checking buildability of patches during reviews and fixing any build breaks immediately when we hit them on our own machines. As I said in my FOSDEM talk, I don't think this "spot checking" is sufficient for the kind of reliability GNOME projects really need given our reliance upon jhbuild (which, by its design, does not cope well with unbuildable master branches).

A couple weeks ago, Martin Pitt announced the jhbuild continuous build server he has been working on. It's a great setup and clearly details which modules are failing to build and why. It also keeps useful metrics like "time of last successful build", "time of last failed build", and runs and reports on the results of "make check".

This is a great safety net for GNOME as a whole, since it continuously checks our entire stack in a common environment. Once maintainers get reliably notified about any breaks, I think we'll see broad benefits. When our code reliably builds and passes its unit tests, it's a lot more attractive to outside (and inside!) developers.

With, thankfully little work, Folks is now reliably building and passing its unit tests on this server, and I intend to keep it that way :)

I'd like to thank Martin for setting this all up and him and Jean-Baptiste Lallement for helping debug some LXC-related issues which were causing some of our tests to fail on this server (but not for us maintainers, making it hard for us to help).

In the process of fixing these issues, the build server proved its usefulness for our project already because it caught a build break I didn't hit on my own system (because I had an older version of EDS build). Normally, this could have taken days or longer for me to notice because I tend not to re-build the stack below Folks very often. If I'm working on a large feature, I want to get it all working before I potentially break my build environment with unstable changes in our dependencies. A continuous integration system should also make frequently updating dependencies less of a risk (which is just more good news for everyone).

Decisions

2013-02-05T01:43:08Z

I coincidentally stumbled across this on my flight back from FOSDEM:

The word decision, closely related to incision, derives from the meaning 'a cutting off'. Making effective decisions—and learning effectively—requires massive elimination and the removal of options.
—Tim Ferriss, The 4-Hour Chef

Answering the question: "How do I develop an app for GNOME?"

2013-02-02T13:15:44Z

During the GNOME Developer Experience Hackfest this week, one of the major goals we identified was the need to pick a single language to give a simple answer to "how do I write a GNOME app?".

Right now, if you ask that question, you'll get about 8 different personal-preference answers, which drives people away from our platform. Having to potentially evaluate several different languages and their stacks gives potential developers a lot of unneeded extra work.

There was broad consensus in the hackfest for this goal because it allows us to:

It allows us to focus when we write developer documentation, fixing bugs in the development environment and the development of tools. This reduces our maintanence costs and enables us to be vastly more efficient.

It enables code and knowledge sharing to occur, so that people can easily copy and paste code from existing applications, or find information about common problems and challenges.

It provide a coherent and easy-to-follow path for new developers.

It allows us to include the full GNOME framework within the language itself.

We spent a long time discussing the different options that are available to us, and there were a variety of opinions. However, at the end of the day, we had to recognize that no language is perfect and there will always be disagreement. The important thing was that we had to make a decision.

It's critical that everyone understands this decision as a plan to elevate the language, bindings, tools, and documentation to a level of quality we have not yet achieved. It is not a decision to abandon any other language bindings. We will continue to distribute other bindings and documentation as we do now and compatibility for the other languages will continue to be developed as they are today by the developers involved with those modules.

Our decision is to support JavaScript as the first class language for GNOME application development. This means:

We will continue to write documentation for other languages, but we will also prioritize JavaScript when deciding what to work on.

We will encourage new applications be written in JavaScript.

We will be working to optimize the developer workflow around JavaScript.

C will remain the recommended language for system libraries.

Why JavaScript?

Our language of choice needs to be dynamic and high level.

There is already momentum in the GNOME Project for JavaScript -- it's used in GNOME Shell and GNOME Documents.
There's a lot of work going into the language to make it especially fast, embeddable, and framework-agnostic.

JavaScript is increasingly being seen as a first class desktop programming language -- it us being used in Windows 8, mobile platforms, and for local web applications.

JavaScript is self-contained -- it doesn't come with its own set of core libraries, which makes it more convenient for us when integrating it into the platform.

This is the start of a process and there's obviously a lot of work ahead of us. However, prioritizing a single language will enable us to turn GNOME into a compelling platform for application developers in a much more effective and efficient manner.

Inbox Zero and GTD: a personal success story

2012-08-23T20:38:56Z

After years of attempting to apply the philosophies of Inbox Zero and Getting Things Done (including, appropriately, failing to finish the GTD book twice), my personal and work inboxes are empty and I've never felt so on-top of my tasks. In no particular order, here are some changes I've made that have helped me out:

Forget what you're standing on and focus.

I read The 4-Hour Work Week, which touches on Inbox Zero and adds some interesting productivity-increasing ideas, including giving up on boring articles and the controversial "don't waste time reading news". I haven't stopped reading news, but I feel like I've gotten a little more efficient at it. I mostly ignore mailing lists (except those for my immediate projects). The only reason I'm subscribed to some is so that I can reply to them on the occasion I'm CC'd or someone brings up a specific discussion to me.

Along the line of distractions, I've been training myself to catch them before they happen. Because there's increasing evidence that multi-tasking reduces productivity (and it seems obvious to me anyhow), I push myself to not switch tasks unless I absolutely have to. And I actively ignore anything that I know will needlessly steal my focus. This includes only checking up on IRC periodically (and mostly just to check for messages that have been highlighted for me). If it's urgent, people will send me a direct message (and Gnome Shell will give me a nice notification).

I believe the author of 4HWW intentionally mentions keeping only calendar events, not tasks. I've always liked the idea that you will remember anything important and anything minor will come up again (particularly because I've struggled with far too many tasks in my GTD system). But that seems too extreme/unworkable for me, so the key has just been being much more aggressive in deleting tasks that sit too long (knowing I'll never get to them) and doing periodic sweeps through each list. If you have trouble with that, you might want to create a "some day" list to move neglected tasks to. Then, just make a point to ignore that list. I think I'm nearly ready to delete mine.

Another part of minimizing mental burden has been closing application tabs and windows and conversation notifications as soon as I can. When I finish a task, I close everything related to it (even if I think I'll use some of them later). The stress saved by this reduction in visual noise is much greater than occasionally having to re-open something sooner than expected (which is incredibly rare, as you might imagine).

Your screen should not look like this.

And the latest change I've made, just before reaching inbox zero/GTD zen, has been to batch process my inboxes. I had a terrible habit of glancing at mail, flagging it important and unread, then moving on. It turns out that I subconsciously skip over bold, red lines of text. This was a horrible priority inversion that lead me to sporadically clearing out the simple mail while ignoring the high-priority, difficult tasks.

Now, when I do my few daily mail passes, I do two quick passes (always in oldest to newest order, never skipping any):

Add tasks, file mail
1. parse out new tasks to my GTD system (setting due date and priority appropriately)
2. if it needs a trivial or no response, give it immediately, then file
3. otherwise, move on to the next letter
Give non-trivial responses
1. Read the letter in detail
2. Respond to each point necessary

Now, with an empty inbox, I can get work done by just drilling through items in my work or personal task list in order from highest to lowest priority. It's a lot harder to skip around, ignoring the important tasks, when they're sitting in front of you, in the exact order you've chosen yourself.

I still have things to improve (I really wish I had one place to manage all my tasks, not several), but I finally feel in control of my day-to-day goals!

Conferences and anti-harassment policies

2012-08-15T17:43:08Z

Valerie Aurora posted a very insightful article about harassment at conferences. She focuses largely on "hacker"/security conferences, like DEFCON, but the general principles apply to all conferences. And I've personally seen related bad behavior (though to a much lesser degree) at conferences I've attended (which have all been based around open source software, not "hacking"/security).

The work that Valerie's Ada Initiative is critically important for the technology industries, which still have a lot of work to do on being inclusive (particularly to women).

As some personal anecdotes, most of the best conferences I've attended have had strict anti-harassment policies/codes of conduct (including Linux.conf.au and GUADEC). They help make the conference a more-welcoming place by clarifying unacceptable behavior, which brings in more participants from a wider variety of backgrounds, which makes the conference better for everyone.

Specifically, GUADEC's and Gnome's work to include more women has really started to pay off. The official count this year was that 17% of the attendees were women, and it was obvious. And it was especially for anyone who's been attending since Vilanova in 2006, like me, where I can honestly only remember a few women attendees. The Gnome Outreach Program for Women certainly deserves a fair amount of credit here, as do the Gnome community's clear and consistent enforcement of the Code of Conduct.

Codes of Conduct/anti-harassment policies/many laws should not be necessary. But they clearly are because some people otherwise don't understand or refuse to comply with common decency. These policies really require a fairly minimal amount of effort to create and enforce, open attendance to a much wider and diverse audience, and benefit everyone as a result. Everyone wins!

Folks discussion / hackfest on Tuesday

2011-08-07T16:16:52Z

We're going to have a Folks & Friends hackfest and discussion at the Desktop Summit on Tuesday at 10:00. Meet in front of Kinosaal and we'll re-locate to a room with tables.

Topics include (but are not limited to):

User input. We'd really like to hear what you think about Folks and its Empathy and Gnome integration.

Constructive compliments

A follow-up on progress on the tasks we set at the Social IM/Contacts hackfest in Cambridge

General discussion/questions/requests

Talking about Folks at the Desktop Summit

2011-08-03T02:07:08Z

Saturday at 11:20 in Rm2002, I'll be giving a talk on Folks, covering exciting topics like:

What is Folks?

What isn't Folks?

Folks in Gnome 3.2, MeeGo, and Qt Applications

How Folks can help you be a more-complete person*

A lot has been going on in Folks lately (including the 0.6.0 release, which will be happening shortly), so you really won't want to miss it!

*This may or may not require subterfuge

IM, Contacts, Social hackfest successful

2011-06-20T14:49:14Z

I just got back from the highly-productive and thoroughly-enjoyable IM, Contacts & Social hackfest.

We discussed a number of issues related to chat, video/audio calls, contacts, and social web service integration into Gnome. After each session, we filed all the necessary bugs to make sure we don't lose track of anything. Check out the session pages for notes and links to the related (mostly new) bugs.

It was especially good to have usability people Nick Richards and Allan Day on hand for our user-facing discussions. In general, I'm very happy to see Gnome continuing to move toward an interaction-design-driven development methodology. I'm quite confident that having a strong, consistent design-first, code-second process is the way we can (more than) close the usability gap that all-too-often exists between open source projects and their closed source counterparts.

Gnome 3.2 is going to have fantastic chat and contacts integration with the appearance of Gnome Contacts, Folks getting an EDS backend, Folks/Gnome Shell integration, and a number of other integration points. And it will only get better from there!

I would like to thank my employer, Collabora, for sponsoring the hackfest with a venue and especially the time of so many relevant developers (and to Guillaume for organizing the hackfest). Thanks also to the Gnome Foundation for additional sponsorship and Intel and Red Hat for sending along a few people each. This type of collaboration will help ensure that Gnome (and related platforms) not only keep up with our closed-source friends but begin to surpass them in ways we traditionally haven't (particularly usability).

Updated Folks/QtFolks roadmap

2011-05-04T17:10:41Z

We've focused the plans for Folks for the next few months and beyond in our much-revised Roadmap.

Some highlights:

Finishing the Evolution Data Server backend and making it the default primary backend

Adding search-based contact retrieval

Lazy-loading of attributes (to avoid a performance crunch as we've added a lot of attributes)

The Tracker backend will be the default primary backend for MeeGo until it officially switches to EDS for local contact storage. Around that time, we'll spin it off into its own module to make sure Folks can play well with out-of-tree backends.

New features in Folks 0.4/0.5

2011-04-25T23:01:00Z

A lot has been going on in the world of Folks lately, so it's time for another update. There have been a ton of fixes and clean-ups in the code (including some well-documented API breaks). We're narrowing down on another set of API breaks in our unstable 0.5.x branch before starting the stable 0.6.x branch. Our goal is to have very few (if any) API breaks after that.

Perhaps more importantly, we've added a lot of great features in the last few months. Read on for more (heavily-summarized) details.

I'd like to thank Intel for both sponsoring most of this work and understanding open source development. We were able to work in the open very early on and keeping things upstream was a goal, not a challenge. All the work is LGPL 2 or 2.1 and none of it requires copyright assignment.

New Fields

One big focus in 0.4.0 was adding a number of address-book-type fields, like:

• Role (within an Organization)
• Birthday
• Notes
• Postal address

In all, contacts from Folks support most of the generally-useful fields you'd find in a typical address book.

The remaining features are new as of version 0.5.0.

Primary backend

A design goal of Folks, since the beginning, has been to simplify the way writes happen. There is, at most, one (primary) backend which provides contact linking hints to the aggregator and which stores address-book-like contacts (which are generally fully-writable for all supported fields). This has historically been (hard-coded as) our simple key-file backend but it is now configurable.

Tracker backend

The new Tracker backend acts as an address book and supports both reads and writes. Creating this help fill out our support for local, address-book-like contacts, so that portion of Folks is in decent shape now. It can be set as the primary backend, though the default remains the key-file backend. My colleague, Raúl, did a great job putting this and a sizable set of tests together.

libsocialweb backend

We've also added a backend for libsocialweb which lets us expose contacts from various web services through Folks. This required a little work on libsocialweb itself to add a Contacts interface and implement it for a handful of services (so far, Facebook, Flickr, Twitter, and Last.FM). Alban picked up on Marco's work in this area, added the last three services and implemented the newer Folks interfaces for the libsocialweb backend.

I think this area is especially exciting, since it lets us include contacts' details from a very wide range of services in the future, just by adding more services to libsocialweb.

Potential Matches

A long-requested feature has been the ability to hint matches between various contacts within Folks (since it's tedious to have to manually discover them all yourself). This clears the way for us to make linking nicer in Empathy.

In the future, we'll be looking into making this process even easier.

folks-inspect

Our handy folks-inspect utility has gotten a bit of attention to support the fields added since 0.4.0, making it even more useful for debugging.

QtFolks

I've followed up on Marco's initial QtContacts bindings for Folks (QtFolks) by adding additional fields and supporting contact adds, edits, and removes. The git respository is here and release tarballs here (for now).

I hope we can get our KDE-using friends interested in Folks now that we've got some decent Qt bindings!

Demos

The moment everyone has been waiting for:

(In case your browser can't play WebM: download here; YouTube version here)

The demos in the video are done through the QtFolks demo program because Empathy filters out non-IM contacts (at least as of this writing). But we'll certainly be supporting all Folks contacts in the Gnome 3.2 contacts features.

Folks 0.1.17 includes a migration tool

2010-09-11T00:06:57Z

The latest release of Folks, 0.1.17, includes a new folks-import tool to import meta-contacts data from Pidgin. So if Pidgin knows frank.reynolds@example.com and the_penguin@example.org are the same person, folks-import will catch Empathy up-to-speed.

Now would be a good time to double-check your "Excuses for not switching to Empathy" list.

Thanks to Philip for writing the tool.

We've also got a nearly-working Pidgin backend to let Empathy support this functionality native in its Import wizard, but it was too late in the Gnome 2.32 release cycle to squeeze it in.

And farther into the future, Folks should perform reasonably aggressive auto-linking, which should make even semi-automated linking like this unnecessary.

--

If you've got AIM accounts, you may bump into bgo#629311. See the workaround.

Empathy hacking setup

2010-09-03T18:34:38Z

Edit: Good News, Everyone! Sjoerd pointed out that the D-Bus fiddling in this post is unnecessary (as I'd hoped, but hadn't been able to manage). I mistook bgo#628738 for misconfiguration on my system.

So, this "guide" can be shortened to:

create a new user (empathy-dev)

install jhbuild

jhbuild build empathy

echo "export PATH=/opt/gnome/sbin:/opt/gnome/bin:$PATH" >> /home/empathy-dev/.bashrc

echo "export XDG_DATA_DIRS=/opt/gnome/share:/usr/share:$XDG_DATA_DIRS" >> /home/empathy-dev/.bashrc

slogin -X empathy-dev@localhost

empathy

In order to do development on Empathy, I've created another user on my system (creatively named "empathy-dev") and run my development versions of programs, libraries, and services through this user. This has a couple major benefits:

zero downtime - I frequently restart Empathy during development. Running the default system version of Empathy as my regular user means I can stay online as I develop.
fault isolation - if I horribly break my development environment (eg, the bleeding-edge libraries I depend upon introduce major bugs), it doesn't affect my system stability

It was somewhat non-trivial to create a good setup, so I thought other people might find this handy.

Throughout this short guide, I use references to /opt/gnome, which is the standard jhbuild $PREFIX. So substitute your development $PREFIX as necessary. I make a point to not use the standard Unix development $PREFIX (/usr/local) so that my regular user doesn't run the development programs or libraries (for stability and sanity; see below).

Skip the remaining steps this guide - it's needlessly complicated

First, we need to set up a few bits and pieces so your shell and D-Bus know where to find the development programs and config. I use a fairly standard D-Bus local session config file.

The important (and only non-standard, I think) part is:

/opt/gnome/share/dbus-1/services

This allows the programs installed in our $PREFIX to launch necessary services (eg, Mission Control, the Telepathy Connection Managers) through D-Bus activation.

Download this file, adjust it as necessary, and put it in /home/empathy-dev/.dbus-1

Add this to the end of your development user's .bashrc:
export PATH=/opt/gnome/sbin:/opt/gnome/bin:$PATH # let programs find any new icons, default config files, etc. export XDG_DATA_DIRS=/opt/gnome/share:/usr/share:$XDG_DATA_DIRS # automatically start a D-Bus session bus alias dbus-setup="dbus-launch --config-file=$HOME/.dbus-1/session-local.conf" session_setup=$(dbus-setup) if [ $? -eq 0 ]; then echo "\nSet up D-Bus session for $USER:"; echo $session_setup eval export $session_setup else echo "\nFAILED setting up D-Bus session for $USER"; fi
Once you've got that set up, it's easy to launch the development version of Empathy as a different user:

slogin -X empathy-dev@localhost

Then, just run empathy and marvel at its independence from your main user's instance. However, if you haven't installed a newer version of empathy in $PREFIX/bin, this will just fall back to your system-installed version.

Fix this by setting up jhbuild and running "jhbuild build empathy". Find something to do for about 20 minutes. When you come back, if our dependencies haven't failed to build, you'll be able to run the latest version of Empathy as empathy-dev, without getting in the way of your system user.

Happy hacking!

--
dbus-launch will keep the dbus-daemon (and anything it activates) running by default after your development user logs out. There's a --exit-with-session option, but for some reason, if I use it here, about 30% of my keystrokes at the shell don't arrive. I'm flabbergasted, but it seemed completely tied to this dbus-launch option (I tried several times each way).

Meta-contacts in Empathy (and beyond!)

2010-08-30T17:34:49Z

We've finally closed Gnome Bug #460647 (Empathy: Support metacontacts)!

Let's get right to the pictures:

This is our "Link Contacts" dialog. Selecting a number of contacts on the left side designates which contacts will be included in the Individual (read: meta-contact) at right.

We currently auto-link contacts with the same service ID (foo@example.org) contained in multiple accounts. In the future, we're going to push as much into auto-linking as possible. My goal is that most users would never need to use this dialog. Until then, this dialog is how you designate meta-contacts in Empathy.

If you accidentally link together contacts you didn't mean to, you can simply open the Individual's info dialog and hit Unlink to start over.

One of the first benefits of meta-contacts is pulling together multiple modes of contact for a person into a single place. So if you've got a friend with separate work and personal IM, you can be an upstanding citizen and only send funny cat pictures to their personal IM address. (If they sign on to both at work, at least you tried your best).

We've kept the 1-click Chat/Audio Call/Send File/etc. actions for the (I think, more-common) case that you just want to communicate and you don't care about the specifics. This just uses any valid (ie, online) account for that Individual.

Thanks

This meta-contacts functionality is all possible thanks to the Folks project. It's a collection of libraries (so far, all distributed together) that collect contact information through various backends (Telepathy so far; many more to come) and aggregate Individuals (ie, People). Empathy was our starting point, but we really plan to integrate very well into the Gnome desktop and beyond. Think: typing -Alice- to start a chat with Alice through the Gnome Shell.

I'll discuss Folks in greater detail in future posts.

I'd like to thank my colleagues Philip "code factory" Withnall for helping with Folks development/Empathy integration and Empathy maintainer Guillaume Desmottes for letting us know exactly what we broke in each commit. And, of course, a special thanks to our employer, Collabora, for sponsoring us to work on this full-time.

Try it now!

Since you're no doubt very excited about these new features in Empathy, you can use them Right Now™ in version 2.31.91 (also coming to Debian experimental shortly). Be sure to file any and all bugs you run into, so this will be as solid a stable release as any other!

If software bugs have you leaping onto the nearest elevated furniture, no problem -- Empathy will, of course, by included in Gnome 2.32, coming to a friendly Linux distribution near you!

Empathy accounts work for MeeGo (and free desktops everywhere)

2010-05-28T17:38:18Z

I'd like to congratulate the MeeGo team on shipping MeeGo 1.0 for Netbooks! It's nice to see user-experience-driven design on Linux (where it tends to be conspicuously absent), shipping in a complete product. It really shows, too -- the UI is extremely responsive and it makes the whole experience a joy.

Thanks to Intel hiring Collabora for some MeeGo work, I made a few contributions to the distro some months back. Some were evolution data server code clean-up, adding tests, etc. For the interesting, user-visible changes (that I didn't work on), see Michael Meeks's post about Evolution in MeeGo.

But the more visible contributions were to Empathy's account settings. Originally, Empathy's "first-run" account setup wizard and accounts settings dialog were in the same process as Empathy. This meant you had to launch Empathy before you could edit your accounts, which is a little awkward if you're another application. Telepathy accounts aren't Empathy-specific, so it makes sense that the dialog be independent (though it still lives in the Empathy source tree).

Thomas Wood's unified Control Center work appears MeeGo, and I adapted the Empathy accounts dialog to embed in it. The screenshot is fairly self-explanatory. When you access the accounts from the Control Center, you get a nice, full-screen version of the dialog:

Michael Meeks mentioned how small most netbook screens are. When you also factor in the MeeGo panel at the top of the screen, you can get situations where you need scrolling (but didn't on the full-sized desktop). So we added a scrollable view to the accounts dialog (to fit the full content of the Advanced section for protocols with a bevy of bells and whistles):

Since the actual dialog content is the same whether it's embedded or not, the same functionality works when it's stand-alone as well:

And because the MeeGo team understands open source software, these features were developed out in the open and have been included in the last few releases of Empathy. So if you don't have them already, you will soon!

Google frees VP8, announces WebM (with a little help from Collabora Multimedia)

2010-05-19T18:11:59Z

This morning I was thrilled to hear that Google has opened up their high-performance video codec, VP8 and announced WebM, a container format with VP8 video and Vorbis audio. So now we've got a media format that's high-performance (not Flash), has low-power-requirements (not Flash) and is fully open and freely usable (not Flash, not H.264). The only missing piece is making sure it's widely supported (like Flash and, to a slightly lesser extent, H.264). So if this takes off, we can expect a much better experience for audio, video, animation on the web and on our phones.

There are a number of important players supporting this effort, including Collabora (GStreamer and our projects that use GStreamer, like Telepathy for multimedia calls), Google (YouTube, Android, Chrome, Chrome OS), Mozilla, Opera, Skype, Adobe (through Flash, surprisingly) in terms of software. And practically every major hardware player as well (AMD/ATI, ARM, Broadcom, Freescale, Logitech, nVidia, Qualcomm, TI, and more). This should make the problem of hardware support (which has traditionally been a problem for open media formats) a moot point.

Collabora Multimedia and Entropy Wave have added WebM/VP8 support to GStreamer, so support is already available for the open desktop.

Exciting times!

LCA 2010 - Day 3

2010-02-06T21:15:00Z

Day 1 | Day 2

Andrew Tridgell - FOSS and Patents

This informative talk went into a bit of detail on the current situation with (software) patents and some best practices for open source projects who want to avoid litigation. First, if you do get contacted by a company who claims your project violates one of their patents, contact public defenders, such as the Software Freedom Law Center or Electronic Frontier Foundation. In general, it's useful to know how to read patents, such as reading the abstract (but not stopping there, since they can often be misleading), then skipping ahead to the individual claims (which are the core of the patent), and then referring back to the diagrams, definitions, etc. as necessary.

And important point is that the "prior art" defense that so many people like to cite is actually very hard to win. This requires that the prior art covers every single claim in the patent. Instead, a "non-infringement" defense only requires that your work not (exactly) match every independent claim in the patent. There tend to be far more dependent claims than independent claims, so this defense tends to be easier to win.

An interesting point Andrew brought up was that he doesn't think it's to our advantage to avoid reading patents. His point is that even single damages (in the case that you unknowingly infringe a patent) is enough to end an open source project, so if you are forced to pay triple damages (in case you are aware of the patent), that doesn't change the end result. I unfortunately didn't have time to ask him this: wouldn't it matter to the author themselves whether they have to pay $LARGE_SUM_OF_MONEY or 3*$LARGE_SUM_OF_MONEY out of their own pocket? In either case, it's an ugly situation that you can be punished for being more knowledgeable.

Finally, Andrew suggested this strategy for open source projects to make themselves worse targets for patent suits (which is really all that matters): find and widely publicize work-arounds to patents. Closed-source companies are unlikely to do so, since a work-around could be a business advantage over another competitor who might otherwise be forced to license the patent. That way, we'll appear (and effectively be) a lot more work for patent owners to troll. That way, we can build up a reputation for not being worth the hassle. A great thing to aspire to.

Paul Mackerras -- Perf Events (in the kernel)

A replacement for perf counters, perf events provide kernel probes and simple API to perform fine-grained performance benchmarking on a Linux system. Whenever possible, perf events use hardware to get the most-precise data possible. There's a reasonable software-only fallback based on the high-resolution system clock (which most systems support at this point).

The API is essentially just one system call (which returns a file descriptor) and specific content behavior from that virtual file. Everything else is read(), close(), etc.

Events can be per task, per CPU, and, recently added, per-task-per-CPU. Per-task tracking can be recursive (forked processes get a copy of the parent counter struct and its final values are added to the parent upon exiting or explicitly synchronizing).

Perf events can trace cache (including TLB) activity, page faults, context switches, CPU migrations, and data alignment and instruction emulation traps.

Useful benchmarking always starts with good tools, and it sounds like we're finally getting a great tool with perf events!

Rusty Russell -- FOSS Fun with a Wiimote

Rusty detailed his geeky plans for making sure his daughter grows up to be a geek. These mainly involve writing some software to (ideally) translate her hand movements to actions on their TV. The idea was to help her establish causality at an early age, I think.

Anyway, I can't really do it justice in writing. You'll have to wait until the video is posted to see for yourself.

Carl Worth -- Making the GPU do its job

After giving a brief history of computer graphics an GPU development, Carl explained how hardware graphics support has sort of oscillated between discrete and integrated (into the CPU) hardware. (I wasn't aware that we'd already made the integrated → discrete → integrated cycle once before our current (in some contexts) migration back to integrated graphics).

The main problem with graphics in Linux right now is that we often have bad performance (which also means bad power consumption) and we need two drivers per video card (family, at least) -- one for 2D and one for 3D.

In order to figure out our bottlenecks, Carl created cairo-trace to measure the actual performance. This nifty program records the timing of cairo API calls for any program running under it. These traces can be played back through cairo at any time (at maximum speed), to continually improve performance for real-world uses of Cairo. I'm not sure if it's already in place, but these could easily be added to the (from what I hear, very good) automated cairo test suite, to avoid releasing regressions. If only more open source projects took testing and performance this seriously!

As it turns out, the current performance in most cases was actually better in pure software than in cairo-xlib (the latest stable backend for cairo).

An experimental GPU-accelerated backend (cairo-drm), in which Cairo bypasses X and uses GEM to render directly in the kernel, improves performance dramatically (10x speedup for Firefox). But the caveat is that it requires yet another driver per video card (bringing us to 3 total, for those of you keeping track at home).

Another approach, cairo-gl, which has Cairo bypass X to render to MESA, requires only 2 drivers total and should eventually have performance closer to that of cairo-drm. But for the moment, its performance is much worse than cairo-xlib.

Robert O'Callahan -- Open video on the web

Video on the web right now has two major players: Flash and Silverlight. (Maybe I just took ambiguous notes, but it's obvious that Silverlight is nowhere near Flash in terms of marketshare).

Beyond the obvious problem of software freedom, Flash is notoriously unstable (apparently a huge percentage of crashes of OS X are directly Flash's fault). Mozilla has decided that it's time to do something to push open media formats, to ensure this important (and growing) chunk of the Web retains the openness that has made the rest of it so popular and useful.

Some questions about the open formats:

Should we ignore patents?
This is only feasible while open formats are irrelevant, which isn't a great strategy.
Wait for the patents to expire?
They'll just be replaced with the next closed format.
Just pay the licensing fees?
Using a codec means you need to license it for your market size and per viewing (according to MPEGLA's fee structure), which is impossible for most websites serving content and for Mozilla to pay for distributing Firefox.

Another issue: video is not just about YouTube (passive watching). Flash adds interactivity (related videos, captioning, relevant ads, etc.), so we'll need an open counterpart to this as well.

Mozilla's solution for open video is Ogg Theora, which has had nice advances lately. GStreamer developer David Schleef got decent performance on OMAP3's DSP (in the N900 and other embedded devices) for Theora. The Ogg Index project adds indexing to the Ogg (container format?) to fix stream seeking over the web (which is frequently unusable without an index).

Mozilla has been shipping Theora support in Firefox 3.5+, since it doesn't want to pay, can't pay, and shouldn't pay for licensing codecs. If suddenly software patents were invalid, it'd be fine to just standardize on h.264, but that probably won't happen.

A big part of the chicken-and-egg push for open formats requires working with content providers and distribution networks. So Mozilla has gotten Dailymotion, the Internet Archive, and other websites to support Ogg Vorbis and Theora.

The other half is getting the browser to support the formats. Firefox 3.5+ can handle a Theora <video> tag; Chrome ships Theora (and H.264) support; Opera will ship Theora only. In FireFox 3.6, we'll get fullscreen Theora. Also in the pipeline is GPU-accelerated playback and Mobile/Maemo optimizations.

Partial successes in this push to open video include Vimeo and YouTube planning to support HTML 5's <video> tag on their sites (though they'll only be using the non-free H.264 codec).

So open media formats are slowly advancing on the web. We're basically at the point where most web standards are friendly to free software; if Gecko and (or) WebKit can't implement it, people don't propose it as a standard.

LCA 2010 - Day 2

2010-01-25T07:36:47Z

Day 1

Glyn Moody -- Keynote on OSS-like transparency outside of software

This talk covered a handful of ways in which open source software has inspired collaborative efforts in non-software fields, even reminding science of its origins in "open workbook" experimentation, where all the raw data is provided (as it should be). Jim Kent, a hacker working on his own, just barely beat Craig Venter's company, Celera, to sequence and publicly publish the human genome. Without this effort, Celera may have patented chunks of the genome (which obviously would have been a Bad Thing™). Kent did this thanks to a 100-machine Linux cluster, which was obviously a big win for both open source software and science.

Glyn then went on to point out that one of the biggest problems with the global financial system (and a large part of the crash) was due to its opacity. Even the industry experts don't really know much of the details, because all the data are locked up. Some governments are working to force this data to be more open -- Recovery.gov (in the US) is a good start, and the UK, Australia, and New Zealand are working on similar efforts.

Emmanuele Bassi -- A year of Clutter

Emmanuele delivered a few lightning talks in a row to cover what's gotten Clutter to 1.0, what has happened since its release, the plans for Clutter 1.2 (due in March), and the general plan for Clutter 2.x (begin before Clutter 1.x is end-of-lifed, and add any features that necessarily require API/ABI breaks; any changes that don't require breaks will also find their way into Clutter 1.x).

I'm not terribly familiar with Clutter, but it sounds like they've been making a nice amount of progress (which is especially important if it may become a dependency of GTK 3.x).

Dave Airlies -- Graphics drivers in the kernel; now what?

At the time X was first designed, graphics drivers in the kernel were infeasible, since they'd need to be re-written for all of the (many) different Unix kernels at the time. The environment is very different now, so it's worth the effort. Kernel-mode-setting (KMS) is the solution that Linux has adopted.

Tungsten tried doing something like KMS, but being developed top-and-bottom-inward, it ended up with an ugly API that didn't work very well. Keith Packerd wrote the Graphics Execution Manager (GEM), and KMS ended up being a combination of Tungsten's code with something more like GEM's API.

A couple immediate benefits of this new way of handling graphics is that we can now begin to handle video card power management and use the kernel debugger from within X.

Dave briefly discussed Wayland, the alternate display server. It seems to be desktop-environment-dependent and it isn't very complete (eg, keyboard input doesn't work yet), so it won't be replacing X.org (any time soon, if ever).

The Intel KMS driver is the most complete (except for GMA500), and just needs a little more work. AMD/ATi support is pretty good, though there's a stunning number of different video cards to support. Nouveau (the open nVidia driver) just moved entirely to KMS, and it's making decent progress.

Jan Schmidt -- Toward GStreamer 1.0

Jan gave us an overview of the progress GStreamer has made since its initial version (a lot), the current state (pretty good), and the future. There have been discussions of finally promoting the version number to 1.0; some of the downsides include a risk of development lull (as happened between 0.8 and 0.10) and the benefits include the ability to cut deprecated code and make it more clear to new developers that it's safe to use.

We also got a handful of nice demos (fully-functional DVD support, including menus and special "asides" subtitle support). But the crowd favorite seemed to be a demo app that tied playback rate to his laptop's orientation (from -$fast to +$fast). As Jan put it, "that's what accelerometers are for."

Adam Jackson -- The Rebirth of Xinerama

In a follow-up to his talk at last year's LCA about Shatter (an effort to better support aribtrary multi-screen setups), this talk updated us on the state of Xinerama to support similar configurations. Shatter eventually proved unworkable, but there has been some headway in other areas. At this point, X and the graphics drivers can support reasonably large-sum-dimensions displays, but the multiplexing of work across multiple GPUs needs to play catch-up (since more systems are starting to have multi-GPU configurations). The performance is linear with the number of GPUs -- unfortunately, it's 1/n, not n.

Adam discussed a number of potential solutions, as well as other issues which may be looming over the horizon (which is worthwhile, since most users weren't too concerned about supporting multiple GPUs in a single machine even recently).

LCA 2010 - Day 1

2010-01-21T21:10:39Z

This week, I'm in beautiful Wellington, New Zealand for LCA 2010. It's very well-organized conference (as always), and the weather has been even better than predicted!

Benjamin Mako-Hill -- Keynote on anti-features

Mako described his concept of anti-features (product features which intentionally reduce its functionality) and provided a number of amusing examples. I remember coming up with essentially the same idea several years ago (shortly before I switched full-time to Linux, coincidentally enough). It somewhat boggles the mind that there are so many engineers spending their time crippling their own work.

As Mako pointed out, most cell phones are surprisingly restrictive, but most of us just accept it. I gleefully raised my hand when he asked how many people had root access on their phone. Score another point for the N900 (which even avoids the G1 developer version's "freedom tax")!

Jonathan Corbet -- Kernel Report

Jonathan explained in great, yet digestible, detail what's happened in the Linux kernel in the last year. This shouldn't be too shocking to anyone who's familiar with his great reporting on Linux Weekly News. I'm fairly bad at keeping up with kernel news, so this was a great summary.

Chris Double -- Implementing HTML 5 Video in Firefox

A great update on the history and latest-and-greatest in video support in Firefox. They first built their own solution on some of the higher-level Xiph Ogg Vorbis and Theora libraries, but ran into a number of performance problems; then tried per-platform native implementations (including GStreamer on Linux), but the major platforms have no default codecs in common; next the tower caught on fire and then fell into the swamp; and most recently they've switched to an internal implementation that uses only the lowest-level Xiph libraries.

It was interesting to hear about some of the implementation limits. Apparently sound on Linux is still hard.

Chris's demos were fantastic - playback was very smooth, even when doing impressive green-screen, object insertion, and other fancy transformations. I can't wait to see websites take advantage of the video tag. Anything that minimizes our reliance upon Flash is exciting to me!

Denis Kenzior -- oFono: Open Source Telephony

oFono is a framework for handling mobline phone call/text/etc. features. It works on the idea of generalized modems for the various radio types (which, based on its goal of exposing only the interesting details to applications, I assume are hidden from the API) and has a daemon to do the work of sending and receiving audio calls and SMSes. The framework is meant to only support mobile phone functionality and intentionally ignores voice-over-IP (which Telepathy handles very well on the desktop and embedded systems by way of its telepathy-sofiasip connection manager).

There's an in-progress Telepathy connection manager which wraps oFono named yafono, written by my Collaboran colleague Andres Salomon.

Denis states that the current functionality is enough such that you could implement a 2G iPhone's cell stack with it.

Matthew Garrett -- Social Success for (and in) the Linux Community

Matthew discussed some of the social shortcomings of the Linux Community, who we consider members (mostly just developers, unfortunately). We were also graced with a number of relevant quotes and a touching story of his own transformation from occasional mailing list flame-thrower to sympathetic human being.

Early Christmas!

2009-12-18T20:50:06Z

My employer, Collabora was very generous and bought N900s for the entire company!

Mine just arrived:

I was lucky enough to pick one up at the Maemo Summit in October as well. However, those have to be sent back to Nokia in a few months, so now I won't have to dread the deadline :)

In related news, I'm (slowly) working on a handy Maemo 5 app of my own. More details as soon as it's usable (and uploaded to Maemo Extras [Devel]).

Talking about the new Address Book at the Maemo Summit

2009-10-03T00:08:39Z

Next week(end), I'll be co-presenting the Maemo 5 Address Book with Mathias Hasselmann

The entire Address Book team has put a lot of effort into this new release, and it really shows. It's very feature-ful, fast, and well integrated into the rest of the system. I think we're all proud of how it's turned out.

No shiny screenshots or screencasts here -- you'll have to come to the talk! :)

It'll be on Saturday, Oct. 10th at 18:00 in the "N900" room. Our talk will be followed up by drinks in the same room, so why not grab a seat early? ;)

N900 and Maemo 5 goodness

2009-08-27T14:24:26Z

To everyone I said "sorry, I can't tell you" in the last year or so, please believe that it was really hard!

...because this is what I had to not talk about:

And it's got a big list of nice features:

Packed with Open Source Software (including Telepathy, GStreamer, and GTK+)
Unlocked by default!
Very nice 800x480, 3.5" screen
Flash 9.4 support
32 GB of storage
5 MP camera with dual flash
Fast (A)GPS
Multiple, customizable desktops
Mozilla-based browser
Very slick UI with plenty of bling to go around
Does both charging and data transfer over a standard micro-USB cable
Oh, and it makes phone calls and SMSes :)
Lots more!

I just can't wait until it's released :)

Fix for Intel video cards on Ubuntu Jaunty Jackalope

2009-07-19T00:35:53Z

My last run on the dependency upgrade treadmill ended with me dist-upgrading from Ubuntu 8.10 to 9.04. I'd been avoiding the upgrade because I'd read that the performance of Intel video cards (which I have) was terrible and there didn't seem to be a fix in place yet.

Sadly, there isn't a fix in place, and as far as I can tell, there won't be for the lifetime of 9.04. With the number of Linux users with Intel video cards, I can't believe this wasn't a release-blocking bug.

Anyway, there does seem to be a manual work-around. I followed steps A-C, and performance is back to good. Eg, I can again watch 720p flash full-screen (1920x1600 on my i965).

Back in 8.10, performance would usually gets a *little* sluggish with my usual assortment of programs running (probably something like 40 windows from 20 programs spread over 9 desktops). Given that it's an integrated card (displaying on a large external monitor), I was impressed that it could handle this load. I haven't been in this new package setup long enough to know for sure, but I'm holding out hope that it may be even faster than before (which is supposedly why pieces of X were rearchitected, causing this snafu in the first place).

RMS's GCDS talk - or - You're Not Helping

2009-07-09T13:30:39Z

I got to the Gran Canaria Desktop Summit Saturday night, so I didn't see Richard Stallman's talk. From what I heard, the Free Software portion was fairly good, but I heard several people recall his Saint Ignucius segment about how some women in the audience were "EMACS virgins" and should be introduced to it, etc. Lefty described it well in his own post, so I won't go into that detail.

Of course, Stallman's satire immediately reminded me of the FLOSSPOLS reports, which reference an earlier study showing that women were only 1.8% of participants in open source in 2005. I think things have improved slightly since then, but not nearly as much as I would have hoped.

While what he said didn't seem to be overtly sexist, it certainly creates a more hostile and uninviting environment for women in our projects. As the FLOSSPOLS reports suggest, it's important that we (Gnome, KDE, Free Software in general) make a point to emphasize that we do not support hostility against our community members. This is the reason why, for instance, Gnome and Debian have adopted Codes of Conduct.

Richard is of course welcome to think and say whatever he wants, but if he's going to claim some position of leadership, I don't want him lumping together unrelated and offensive material with his advocacy of Free Software. If he insists to continue, I'd like him to openly acknowledge that he doesn't represent many or most of us in the Free Software community that he claims to.

Fútbol!

2009-07-01T20:04:51Z

One of the highlights for me each ~~GUADEC~~ Gran Canaria Desktop Summit is FreeFA - the casual soccer tournament for geeks!

As of now, our roster looks a little short. If you're interested, log in, then register by adding yourself to the wiki page!

I'll see you on the field!

PS: we could probably use a couple volunteer photographers. I could only find about 10 photos on Flickr for 3 years of tournaments!

Paranoia / It will destroy ya!

2009-06-27T19:50:52Z

When it comes to security, I consider myself a moderate. On the modern scale from "I'll never regret posting these drunken photos of myself on Facebook, right?" to "I forge my own steel helmets because the government WANTS you to think tin foil is enough", I'm somewhere in the middle. I don't have a real problem with putting some personal information "in the cloud", since I trust the service providers to only display my phone number and mailing address to my friends (as I've requested). But I use different passwords everywhere and quickly replaced all my private SSH keys when I lost a USB drive that contained them.

(Though, admittedly, I'm fortunate in that nothing I'm interested in is illegal nor terribly controversial. So there isn't much beyond passwords, private keys, and private communications that I'd care about being out in the open.)

The other day, in an effort to reduce some clutter on my desk, I got some new, USB-powered hard disks for my personal back-ups to replace the big, loud, failing disks I currently use. So, knowing it's a privacy risk to dispose of hard disks without properly erasing them, I started some research into secure-deletion software. (Again, I'm not paranoid enough to incinerate the disks with thermite.)

The man page for wipe(1) brought up this little gem:

Be aware that harddisks are quite intelligent beasts those [sic] days.
...

I hereby speculate that harddisks can use the spare remapping area to secretly make copies of your data. Rising totalitarianism makes this almost a certitude. It is quite straightforward to implement some simple filtering schemes that would copy potentially interesting data. Better, a harddisk can probably detect that a given file is being wiped, and silently make a copy of it, while wiping the original as instructed.

(Emphasis mine)

Well, I hereby speculate that the author of that section has a very warped sense of other peoples' interest in their personal data. Unless you're a celebrity or involved in some very shady dealings (or your government is in terrible shape), I don't think anyone cares much about what's on your hard drive. And somehow I doubt any of those apply to the original author.

I really wonder what it is about the software field that makes some people go off the deep end with respect to privacy and security. Maybe the fact that we typically have a greater degree of control within our own domain than those in other fields? Or understanding that, after the locks are opened, it's possible to have your privacy invaded very rapidly nowadays (regardless of how likely it is, especially with the right locks and all but the worst locking practices)?

At any rate, your security is only compromised when someone cares more about copying your data than you care to secure it. A tiny bit of security goes a long way to locking out attackers. And beyond that point, you have to accept that you can't prevent this scenario:

CC-BY-NC 2.5, XKCD

Update: just to clarify, I don't think most people actually do live up to what I consider adequate/moderate security practices. Eg, I'll bet most used hard drives (inside a computer or otherwise) sold on eBay aren't even reformatted, much less properly erased.