Home from UDS-N

I’m back home from UDS-N in Orlando! It was an intense week; I don’t think an hour went by without something excellent happening. Of course, the most excellent thing for me was that Canonical sponsored me to attend. That was incredibly kind. To everyone who organized UDS, thank you for putting all of this together!
(And the Ubuntu notebooks are really nice, too)

The hotel seemed to be a place of extremes. It was very hot outside, so they turned the convention center into a freezer. That way we had a choice to freeze inside or melt outside. I chose the former, as it was more consistent with home. The beds were regularly MADE (in the most intense fashion I have yet witnessed) so that every night, when one finally succeeded in wedging between the sheets and the mattress, one felt truly accomplished. The hotel was massive but well organised, and the service was excellent. (Including the shuttles). A server remembered that I like tea (with milk in it) with breakfast, which is outstanding given the number of us there.

They even have a parrot!

Mark’s big announcement about Unity Desktop was a catalyst for some really action packed discussions. There is a lot of change going on this cycle, but it feels attainable. I think everyone has done a great job positioning the new goodies in the platform so they can suddenly jump to life in one coordinated, shiny burst of energy next year.I think this year is the “OMG we can make videos!” year for Ubuntu. The first thing that happened in the introduction at 9AM on Monday was an amazing, well produced video about Ubuntu. With colours. And moving things. And sound. And there were no full-screen videos of the desktop where the viewer is expected to care about some tiny movement over a sixteenth of the screen. Oh, and the computer talked to the projector. That was pretty cool to see. More, please!

I went in doubtful about Unity on the desktop. To be honest, I hadn’t explored it much beyond a brief surface scan and a bit of groaning about the less-than-stellar state it shipped in with Maverick with regards to stability. Some sessions — Mark’s impromptu Unity Q&A, Neil’s presentation of the Unity Places API — and the very tangible interest in accessibility quickly changed my tune. Unity’s design is glorious. There is a ton of energy, and I think it’s going to amaze people with 11.04. I learned it is mostly written with Vala, too, which makes me as a potential contributor very happy.

It also helps that the Places API session began with Neil showing off libdee. Though it may have been a bad idea to have that at the start; I was already distracted, excitedly installing the thing and playing with it on my own machine because it is that amazing. It abstracts a bunch of DBus stuff so you can have a number of individual programs that share data between each other, where dee connects those programs for you. So, a bunch of DeePeers share a DeeSharedModel object and new DeePeers can pop in and manipulate that same object at the same time. (Technically, each has its own copy and no one peer is depended on by all the others). Pretty darn cool.
Places is even more amazing. Really. It is going to do great things.

Had a very productive session about Harvest where we talked about the new stuff all hosted at harvest.ubuntu.com, discussing what people need and want for it to serve them well. Being a simpleton, all I want is a new logo, and then I can make the header look pretty ;)
I volunteered to work on RSS feeds, a “link to these results” button and a few odd bug fixes.

I received lots of kind words about my GSoC project over the week. I was frequently surprised to get them and reacted with a terrifying amount of modesty, so if I forgot at the moment I will say it now: thanks for all the kind words. And thank you for letting me mess with Harvest, Daniel H and James W!

Speaking of thanks, somebody very kindly organised for a bunch of people to go to the Disneyworld Epcot park. I went on Wednesday with fearless leader Jussi, Rodrigo, Harald and Rohan and, yes, we met Mickey and Pluto.

This photo is by Jussi. Unfortunately, the group photo with Mickey is probably trapped forever on Disney’s website. We figured out the photopass service exists to make money only when it was too late.

All these Kubuntu people are obviously in the midst of a subversive plot to convert everyone, by the way. At this point I feel a nearly overwhelming urge to use Kubuntu, or at least to make stuff with Qt (and I have been thoroughly trained to always pronounce it “Cute”). The only thing holding me back is its default wallpaper. (Thanks, Rohan). The multiple lightning talks about QML were spectacular, too. It’s a declarative language for creating beautiful user interfaces with Qt. Wondrous animated magic in a few lines of very simple, friendly looking code. (And QtCreator is involved, too. Eeee!)Tragically, I haven’t figured out who organised this and paid for the tickets. So, thank you, mysterious benefactor! It was really nice to do, I wouldn’t have figured it all out normally and I would have regretted if I hadn’t. That really was a wonderful way to spend Wednesday night.

I’d better look productive again. Talked to a lot of people about the installer slideshow in Ubuntu, Kubuntu, etc. I didn’t get everyone, but we’re poised to get out of the way with this cycle and land things at sensible times. I’m hoping to freeze strings before the Documentation String Freeze and leave a lot of room for translations to come in and be tested naturally. If all goes well, nobody will need to think about it from here on out. (Unless you happen to be responsible for one of those slideshows or are interested in contributing to a highly visible part of Ubuntu’s first run experience. In that case, please do think about it and contact me!)

I was at the session about the Free Culture Showcase. Ivanka has a really cool vision for how this should be in the future and I’m looking forward to where it goes. One thing we all agree on is it needs more videos. Videos like the photos; as diverse, fun and attractive as the people who use and make Ubuntu :)

If you're wondering what happened to all the things with lights in them at the closing party…

It was a very exciting, energising week. Thanks, everyone, for a fantastic UDS. The Natty Narwhal is going to be great.

Harvest + GSoC week 12

Well, I managed my last-minute merge request for Summer of Code 2010, and with that done it is time for my last GSoC 2010 blog post!

I am really glad I did this. It’s taught me a lot about myself (having never done a project in this fashion before) and I’m happy with how it turned out. GSoC was a nice change of pace and I hope to keep this up for a while!

(Hamster still says I’m a slacker. I need to convince it otherwise)

So, here are the results of some recent tinkering:

First, of course: new font! It requests the delightful UbuntuBeta font first and borrows some conventions from the Ubuntu Web guidelines.
Daniel added help text to the opportunity list filters. He gave each one a tooltip with a nice explanation.
There’s now a permalink for every source package, a nice Edit button for each opportunity, and some other small visual tweaks. Just little stuff like that.

Previously, every opportunity in Harvest had a text box labelled “Comment” that saved to a single database field. The idea was someone could fill it in with useful information for other Harvest users. It felt sort of like Launchpad’s Whiteboard feature in Blueprints.

I decided that implementation would encourage very complex comments. That’s a problem because Harvest aggregates other stuff. There’s a good chance whatever it links to will have its own comment system. I wanted to differentiate Harvest’s comments so they would never be seen as alternatives to whatever is in a referenced bug tracker. Instead, these should be, from top to bottom, specifically for small pointers.

So, we played with it and I added Notes (which is apparently the least commonly implemented synonym of Comments). Notes are little messages you can add to opportunities. Each note is basically a text field limited to 250 characters. No special formatting and no newlines. When I write one, I think of IRC.

The feature isn’t as quick to find as I’d like (there’s an app bug report for that), but it’ll be good to see how people use Harvest before adding more stuff. There are probably all sorts of cool things that could be done, so I’d love to know in the comments here if you have an idea!

(…And I can’t believe I haven’t done this yet)
Thank you to Daniel for being a great mentor! I can confirm the rumours are true: he is an excellent guy. I’ve really enjoyed working with him.

I didn’t quite get to everything I wanted for GSoC (and I have to admit I got carried away with design trivialities this week), but now we’re just a few small pieces away from a spectacular tool for Ubuntu developers. After a bit of a coding / remembering last year’s math course break, I’ll be back helping with some more of those bits. It’s going to be fun!

Here’s a completely unrelated bit of good news: I learned that UDS-N is now short for UDS-Natty, and I miraculously have no exams anywhere near late October ;)
So, assuming I can find a narwhal and convince it I am indeed smart and fashionable, I’m totally hoping to get there, meet people, learn lots of stuff and wax lyrical about Harvest, slideshows and release notes (as I do). Should be fun!

Harvest + GSoC week 9!

The past week, unfortunately, hasn’t been very productive for me. Still, I have a few things to show!

I did a bunch of cleanup (again) and I toyed with animations for a while. There is now an animation (and a loading indicator) when new results are retrieved for the filters. One philosophy I have found myself following is that this UI that never, ever blocks on a task. So, no matter what is happening, you should always be able to click the same buttons you could before.
(On a related note, I’ve been very excited about Blender lately).

Turns out non-modal design has an interesting impact as far as loading indicators are concerned. I wanted this indicator to be totally unobtrusive, but also obvious. So, as soon as someone starts adjusting filters, they can see that Harvest is waiting, then loading results.

It’s a little bubble that appears from the top of the results and is always visible at the top of the screen as the user scrolls. Conveniently enough, the existing results are all pushed away to make room for it. That was an accident at first, but really it makes the slide in a bit more pronounced and it means it doesn’t overlap anything you may have been looking at. (And even if it does, you can fix that by scrolling up).

Pretty simple :)

I made a quick video to show how this is all working:

The other thing I tried doing was to have the Javascript interface record its state in the location so it can be bookmarked and navigated through in the browser history (with the Back and Forward buttons).

I learned a lot of terrifying things, since I’ve never done that before.

Of course, the first terrifying thing is that you can’t change any part of the URL except the part after #, which never gets sent to the server. Well, you can change the other parts, but when you do it redirects to the given URL. That’s a good thing, but it does make life a little difficult for me :)

So, what we need to do is change location.hash to describe the current state, just like we do with the query strings sent to the server. There also needs to be an event handler watching for that change. With those two bits in place, that event handler is called whenever the user presses the Back button or loads the page from a bookmark, and it can apply the given state.

There are piles of jQuery plugins for this job. Two stood out above the pack: Asual’s impressively professional looking jQuery Address, and Ben Alman’s deliciously silly sounding jQuery BBQ. After some pondering and licking my lips, I went with jQuery BBQ.

BBQ is very clever in its simplicity. It uses the existing jQuery.param stuff to generate a query string the usual way, then it puts that in the hash part of the url instead of the ? part. It adds a “deparam” function to deserialize those query strings, a browser-agnostic hashchange event, a few helper functions, a bunch of documentation, and that’s it.

Unfortunately, even with jQuery BBQ, my work got really loopy here. In short, there are a lot of variables to deal with already and adding more almost exploded my brain.
(That was no doubt strengthened by a brief interlude at the family cottage, where I regressed to glorious redneckism and finally unlearned PHP)

So, unfortunately, I’m going to hold off on that for now. I could have planned the Javascript stuff much better, and getting BBQ working smoothly is likely a rewrite away. It may be a bad idea anyway. If someone shares a link that has #querystring instead of ?querystring, that link won’t work for anyone who has Javascript disabled. Instead, I’ll probably go the Google Maps approach, offering a “Permalink” button but never editing the URL in operation.

Next up: nicely formatted package details, and editing opportunities!

Harvest stuff for GSoC: Week 7!

Time for my bi-weekly Harvest update! Everything this time went into the gsoc-client-stuff branch.

The first thing I learned (well, decided) is that YUI has incredibly dense, loopy and uncool documentation. I guess different people are compatible with different kinds of docs. As I read the YUI stuff I just couldn’t keep it all straight for some reason. Its landing page leads off in many directions: there’s an API reference that was written and designed to put me to sleep, an Examples section that doesn’t bother to link to the API reference (but is more pleasantly written), and a lot of extra listings in between.

All I could think about was how much I preferred JQuery’s docs. So, I dropped YUI for JQuery and nothing has exploded. In fact, it’s all gone wonderfully.

JQuery has a considerably simpler core than YUI, but there is lots of functionality in little self-contained plugins. Some of these are official parts of the project, others are external things linked from the plugin repository. (Granted, lots of redundancy there). It’s a different approach — YUI is richer from the start — but for me, JQuery wins by being so much easier to take in at a glance. That, and its documentation is a lot prettier. Instead of your boring automatically generated list of docstrings attached to function names, they have a beautifully presented web app. There are no frustrating stubs; everything I may think to use is there and explained in detail. And it’s a single destination. One page to learn everything there is to know about each bit of functionality in JQuery, including examples. Pretty cool.
JQuery, I promise I will always love you :)

I also learned about doing object-oriented Javascript. This one surprised me. I have used Javascript for lots of small jobs before, but I have never used it with anything big. I realized Javascript doesn’t have the class keyword I have come to love, but after some learning I am back to thinking it’s a pretty cool scripting language. That is mainly thanks to an excellent blog post by Stoyan Stefanov, all about doing classes in Javascript. Everything is an object, so of course we don’t need a class keyword! (Apparently we’re getting one some time this century, though, if everyone is nice to it).

Making something that feels like a class is a bit of a hack, but it works elegantly in the end. It’s really just a function, and we put other functions and things inside it for methods and properties. I’m doing them like this:function Filter (dom_node) { var filter = this; this.get_value_serialized = function () { return null; }}

To create an instance we use Javascript’s new keyword and write out the function as usual (including its parameters). The this keyword can’t be trusted if we are using callback functions, because each function is given its own version based on what object it is being called with. (If it’s via a reference to a function stored somewhere else, things get messy). On the other hand, anything inside Filter can see that filter variable we created at the top, as well as the dom_node parameter.

Those variables pointing at functions, of course, can be really easily reassigned to point at different functions. Lots of power here. For fancier stuff, including multiple inheritance (yes, it gets crazier), Mike Koss has an excellent article. In my case, I decided not to go into that. (Well, okay, I chickened out then called it a decision). Proper subclasses might make my code look smarter, but in this case that whole chunk barely needs to do anything anyway, so I’m fine how it is.

With that all out of the way, I worked on a really fun list of new stuff!

I have Harvest using XHR in a few different places now. XHR is a wonderful thing that lets us directly request new data for our page and handle it through Javascript. It means, if you want to select a bunch of filters, you can do it without flooding our server with each one.

When a filter’s value is changed, it posts the query parameter that change represents to the global Results object. (Some goodies here: if you change the value of a filter in a positive way, that filter is selected implicitly). Instead of instantly yapping at the server, the Results object stores the parameter it receives in an object (dictionary style) and starts (or restarts) its timer. When the timer finishes, it uses JQuery’s $.get function to request new results for the selected filters, passing the function its dictionary of new parameters. (JQuery magically turns that into a querystring for us, so if something weird happens and everyone decides to use something else, Harvest will still work).

The result surprised me. I’m still not doing much to limit the number of results, but even with a query that returns the most packages possible (around 3700 at once) the whole thing feels a lot quicker than it did. Funny…

The next one is expanding packages. When the user clicks a package, we send another http request asking for that package’s details. We get a snippet of HTML back from the server, throw it in the right element and reveal it with an animation. (Did I mention I love JQuery?).

By the way, I worked on the visual design for packages. Any comments? Thoughts on the arbitrary green highlight?

I don’t trust http requests going on unchecked. So, as is the convention, I added little “loading” indicators (from the very helpful and sickeningly popular ajaxload.info). It was really distracting to have these appear all the time, though, so I played with it and now the indicators will slowly fade in. A loading indicator should only become obvious if there is a long operation going on. If everything is normal and the operation is nearly instant, the indicator stays out of the way.

I went two whole days without an Internet connection this week (oh, the humanity!), so I was thinking about people with similar predicaments. It sucks when an application decides it wants to download something and keeps on trying and trying, oblivious to my repeated attempts to convince it I have no connection. JQuery’s $.get function returns an object to control the http request, so I store that using the $.data method:package_node.data('xhr', xhr);Later, if someone tries to collapse a package that was still loading its details before expanding, we can do something like:package_node.data('xhr').abort();We give $.get a callback function that is run when the request is finished — be it successful, an error from the server, or an abort. So, cleanup (like removing the loading indicator) can all be done there.

The Django debug-toolbar only kicks in when we load a whole new page inheriting from the base template, so I had to try something new to gauge performance. In this case I found a cool bit of middleware at DjangoSnippets.org. It adds a header for every page Django creates, saying how long it took to generate. It isn’t much information, but it helps! What I like here is it doesn’t edit the page at all and it’s a really small bit of code; it is as unobtrusive as possible. The data is always visible with a tool like Firebug or Webkit’s web inspector (or telnet, if you’re crazy). It is super easy to present this with Javascript, too:time_header = xhr.getResponseHeader('X-Django-Request-Time')if (time_header) { $('#requeststats').html('Results generated in '+parseFloat(time_header).toFixed(2) + ' seconds');}

And that is that! There is lots of polish left to do for next week, and a strange headache of a merge conflict to resolve. Assuming bzr doesn’t eat anyone’s work, things are really picking up!

Harvest GSoC project: week 5!

The last two weeks of my Harvest project have gone really well. It isn’t flashy and exciting and earth-shattering (yet), but I’m happy with it.

First of all, my branch now has Packages and Opportunities filters. I implemented a bunch of each, and they are resolved in order. First Harvest runs the package filters, then it filters the opportunities that belong to those packages, then it hides packages that have no visible opportunities after all that filtering.

After a long period of me obsessively poking things, Daniel talked me into making a merge request for my branch (to lp:harvest). He and James W gave it some really thorough code review, which has been a huge help! Now it all feels tidier and a little more justified, so I can use the code I wrote without that constant temptation to rewrite it.

At this point, performance is much improved. Details are only shown for one package at a time, so the incredibly long waits (and self-destructs) have gone away.

In addition, the filter system consistently does 4 SQL queries no matter what is being searched for. Of course, that doesn’t say it’s running as well as it can, but it does mean the system is more orderly. It only hits the database once for each type of data. (One query for package sets, one for opportunity lists, one for relevant source packages, one for relevant opportunities). This puts more thorough optimization within reach.

Rather than trying to optimizing things for eternity, I’m off to something completely different for now: fancy Javascript to load new content in line with the page! The idea is a big query will still have a visible wait (always will!), but a complete page won’t need to be created each time; just the specific results, with a nice spinner while they’re loaded. Less jumping around, quicker and more fun.

For the first step, I have to admit I got a little carried away and started redoing the base template from scratch. (It should save me some time, really. The Javascript will be attached to some kind of DOM tree and I don’t want to fiddle with that twice). Still an early WIP, but I think this looks quite pretty :)

I am starting with a prototype written in straight HTML; no Django template markup yet. It’s helping me straighten my thoughts for how the filters’ render() functions should link together. The interface is taller than I would like, so I will need to do something to collapse the Choice filters when they aren’t being used. Oh, and we don’t seem to have a logo. Still, the gist of it is there.

Next for me is figuring out YUI and making that filter interface on the left interactive. Really exciting! Javascript toolkits are amazingly fun to use.

Speaking of web design, I decided I didn’t like my nearly-stock Blogger template anymore so I spent way too long redesigning it (while cursing Blogger for being an awful platform to make templates with). What do you think?

Filters are addictive! (GSoC 2010 Week 3)

The last two weeks I have spent a bit more time than I expected playing with filters, filters and more filters. The first iteration went in maybe a bit too quickly, so I have done quite a bit of clean-up. Python is being too lenient with me!

I’m finally pulling my head out of the code and looking at this from further back, and from here things are looking pretty cool. There is still a lot of stuff in the implementation that needs fixing, but it is entirely possible to start playing with something else without wasting any effort.

 

Yes, that bar on the left is for controlling the filters! Clicking on a filter toggles it, which is done by loading a new URL with the appropriate parameters appended so Harvest knows what to do. The debug toolbar is reminding us that performance is still pretty ugly, but most of those SQL queries are from the opportunities list below each package. Some time in the next few weeks I will be moving that feature so it only appears on demand.

As for the other filters, those are coming. At this point it should be pretty easy to get a rough implementation of everything that is on the left side in the mockup. They won’t be pretty, but they should work. Just extend one of the Filter base classes, add a custom function for manipulating a queryset, override the render function if desired, and it’s done!

All the HTML stuff for that filters bar had to be implemented in Python, rather than the template. It’s the same kind of design as Django’s own forms module, so I think it is forgiveable…

Speaking of filters, I’ve developed a dangerous obsession with The GIMP’s collection of goodies. Quite proud of this rendering I made for a friend. It’s proof he looks exactly like Tintin!

It was straight-forward to do. I used the toon filter and oil painting filter to add outlines and soften the details. Then I whipped out the trusty liquid rescale to make his face a little taller (which worked beautifully given that the other details were insignificant). Finally I did some extra brush work to mimic Herge’s drawing style, making colours more solid and connecting some lines.

In the end it’s probably too subtle, and it would have been easier (though slightly less exciting) to draw it from scratch. Still, it was an interesting exploration. I look forward to doing this to more peoples’ heads in the future.