This post was imported from my old blog at http://dylanmccall.blogspot.com/2010/07/harvest-stuff-for-gsoc-week-7.html

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!

One Response

  1. Great work Dylan – this is amazing!