Posts tagged "programming" - nolan caudill's internet house

Twitter to Flickr, and Back Again

Sun, 30 Sep 2012 07:00:00 +0000

I just got back from a week in Hawaii and only took my film camera. I shot 5 or 6 rolls of film and I look forward to getting them up on Flickr but there are many steps between those 35mm canisters still sitting in the bag I need to unpack and someone being able to click a link to look at them. (Unless everyone wants to come over to my house, which is also fine with me.) I think this is worth the wait but it does remove a bit of the instantaneousness that services like Flickr and Twitter offer. It’s fun sitting on a palm-covered beach or enjoying a tropical drink on a warm patio with a slow-moving fan, taking a picture, and send a modern-day, wish-you-were-here postcard to a few friends. Today, the snapshot app of choice among my friends appears to be Instagram. This is perfectly fine and I use it a bit, but I’m a Flickr man and I’d rather use that, especially since the rest of my Hawaii photos will go there. It’s nice to make a big set of all of the vacation photos, and be able to email the link off to Mom and Pop, and even nicer to be able to see them again together in 1 year, 5 years, 25 years time. As far as Flickr goes, I feel pretty good about their thoughts about longevity. The postcard delivery system, to extend (and strain) the metaphor, is Twitter. Twitter is probably the best spot to put things where people will see them sooner than later. Instagram comes equipped with its own social network but Twitter is the common stomping ground of me and my friends and acquaintances. Bert and Chris built a thing for Recollect mapping your Twitter social clusters. Also, Meghan told me to put more pictures in my blog posts. The crux of the problem was how to get my photos directly to Twitter and Flickr without building a Rube Goldberg device, because things with fewer moving parts break less and are easier for me to understand. Going through a multi-step process, especially when I’m on the go (it’s mobile!) and when I’m trying to enjoy my surroundings (it’s social!), sounds horrible. I want one app and to be able to hit one button. Flickr does have a mobile app, which is serviceable, but I usually already have Twitter up and most Twitter clients have this nice ability to take pictures within the app. With my phone, I’m usually sending a tweet with a photo attached, and not a Flickr photo that I also want to share on Twitter. Twitter to me is the Instant, which is usually what I want when on the go. Twitter is, in its fundamental glory, a magic word distribution system (via Kellan, via Aaron). Most Twitter clients allow you do media-webby things like upload a video or a picture to a service of your choosing, get a link back in return, and then helpfully include that link for you in the tweet. This outsourced-upload thing uses what is formally called OAuth Echo. This is described here and seems to have originally been thought of by Raffi Krikorian of Twitter. Flickr is not one of the upload options, but things like cloudapp, droplr, pikchur, twitgoo are (at least in Tweetbot). I’ll take most of the blame for Flickr not being included as it was something that I was working on in my side time towards the end of my tenure, but didn’t finish before I left. One service does handle this handshake of Twitter-to-Flickr, gdzl.la, but it returns the link back as a gdzl.la link, effectively introducing one more URL forwarder into the world (which is a shitty thing to do if you can help it). Twitter for iPhone used to support different image backends but probably took it out shortly after they built their own image upload thing. So there’s that. So, after a week of wanting to take pictures with my phone and send them along to Twitter, and having to choose between Instagram (look at all those filters!) and Twitter’s Official Image Backend™ (store up to 3200 pictures!), I decided to build my own Twitter-to-Flickr uploader atop Aaron’s parallel-flickr of which I also run an instance of for myself. In theory, this OAuth Echo upload stuff could live by itself (see gdzl.la) and there’s no reason that I couldn’t return my parallel-flickr’s instance URL but there’s something nice about saying “here’s my Flickr kit”, playing along with the aforementioned idea of fewer moving parts as well as knowing all the archival bits-and-pieces going on. Using flamework and the pieces of p-flickr that were already there, a few cups of coffee and a chunk of quiet time, I was able to bolt it on. One important thing that made this possible is that these 3rd party clients, knowing that they are building things that the official client won’t or can’t build WANT you to build more things to fill the gaps. Tweetbot, at the end of the list of the dozen or so included image backends, has a field marked “Custom…” which takes a field to put in an URL endpoint that knows the steps to the OAuth Echo dance. This kind of allowance and permission is refreshing as things become increasingly less so. No, YOU drive. It looks like Aaron merged this change and the upload branch (which made my part really easy) this morning so if you’re running parallel-flickr, feel free to kick the tires on it, and if not, look at the code and see how easy it is do.

A natural progression...

Mon, 05 Mar 2012 08:00:00 +0000

Yep, the import is slow. I know and I haven’t done much optimizing in the code. The Route I’m going is

No Tool

A Tool

A fast Tool

And I’m currently working on 2.

– From https://github.com/MaZderMind/osm-history-renderer#readme

A spin on the “Make it work. Make it right. Make it fast” adage but I enjoyed seeing it in the wild. I feel like I’m almost always working on step 2.

The Code Behind the Yearbook

Mon, 23 Jan 2012 08:00:00 +0000

This is lifted from the README to the github repository. I decided to take all the blog posts, Twitter messages, and Flickr images I made this year, combine them, typeset them, and then get it printed in a hard-bound book. I wrote a bit about the reasoning here. There was a lot of poking and pawing at the scripts I used to create the final product so I thought I’d share them in case someone else could get some use out of them. Big warning: these are mostly worthless until you change them to fit your project. While all the code here works, and it ended up giving me a decent-looking book, you’ll need to modify it, which is mostly the point. This is your retrospective and thus shouldn’t be a cookie-cutter running of the code I wrote (if that would even work). I’ll now explain a bit about the pieces:

The Blog Posts

All my blog posts are just flat HTML (via jekyll) so getting my blog onto my PC was already done. You’ll probably need to run some magic incantation of wget or curl to get yours if they’re hosted somewhere else. TeX, specifically pdflatex, was the workhorse on typesetting it so I needed to get these HTML files into tex format. I ran a find . -name "*html" | xargs -I{} python texify.py {} in my jekyll’s site directory which then ran each of the files through pandoc. Pandoc is a super magic text transformation library that will slurp in most text format and then spit out a transformed version. In this case, I was reading HTML and spitting out .tex files. You can see the command in texify.py. After I had all these converted tex files, I actually loaded all my files up in vim, made a macro that cleaned out things like header and footer, and then just ran the macro across all the open files. I forgot this magic spell almost as soon as I did it, but bufdo sounds familiar. I’d google something like “vim macro across all open buffers” or something. Now that I have a directory full of tex files, one file per blog post, you need a master tex file that actually describes the full document, as well as the pointers to all the various tex files to include. This is the book.tex file in this repository. This is mine lifted as-is, so this is what the finished result looks like and should give you a good idea of how to put yours together. TeX is a frustratingly arcane markup language, but it is extremely powerful and can create beautiful documents. It’s worth it, trust me. I’ve also included a sample blog post tex file. This post includes a couple of images by includegraphics to give you a heads start on that.

Twitter

To format your Twitter posts, you first need the actual Twitter messages. This is actually hard, if not impossible, if you’re especially prolific. Twitter famously only allows you to fetch your last 3200 messages. This limit is enforced but on the official website and by the API. I’ve been running tweetnest on my server for a year or so, mainly because I think it’s pretty, but it turned out to do a whizbang job of archiving as well. Surprise, surprise: this was the source of Twitter messages for my book. I just dumped the table to a text file (via mysqldump) and used that as my source file. Inside of twitter/tweet_transform.php, you’ll see the reading of this file and then spitting out the tex file, separating the messages by month and then by the day. There are some positively Nolan-specific things in here. All the dates in Tweetnest (and probably Twitter’s API) return a timestamp for each Tweet using seconds since the epoch. If I only tweeted from San Francisco in all of 2011, getting nice dates would have been easy: just set the timezone at the top of the script and then call it a day. But as it turned out, I climbed on and off airplanes at various locations and at different times. You’ll see a block of code that dynamically sets the timezone according to when I was boarding and de-boarding airplanes. Another sort of fuzzy, human thing I added to this that you may want to be aware of is that I fudged the edges of what constituted a “day”. Instead of a day being midnight to midnight, I grouped tweets on a 4am boundary. Best I could tell, I never tweeted before 4am after waking up, and never tweeted past 4am by staying up from the night before. This way a day is defined as waking up to going asleep (or passing out, some nights). This script also runs follows some common URL shorteners so you won’t see any bit.ly or goo.gl links in your permanent archive. The hard part of getting the Twitter section together is actually getting the tweets together, but once you do that, it’s a breeze.

Flickr

I uploaded about 600 pictures to Flickr this year. I really wanted to display every single picture for the sake of completeness but figuring out a way to that visually was difficult. I ended up going something like Google’s image search. Stephen Woods was also a major source of inspiration for the layout. This layout lets you plop a lot of images on a page and letting them use their natural dimensions to shoulder out more space as needed. Instead of forcing tex to layout individual images, or individual rows, I figured it would be easier to create an image that represented the full page and then put that on the page, not unlike the old days of people adding <area> tags to full-page images in the early days of the web. The flickr/justified.php file is what creates these image files and then the flickr.tex file that includes them all. I used Aaron Cope’s parallel-flickr as the source of the images. This project conveniently creates an easy-to-query database so I could do something like “give me all the images from Jan 1, 2011, to Dec 31, 2011 ordered by date_taken ascending”. I used the output of this query to select the appropriate images in the correct order and rsynced them to my book’s Flickr directory. There are a few fuzzy parameters that lets you set things like a maximum row height, and how wide your rows are. Feel free to twiddle these knobs as you see fit.

Conclusion

Nothing about this is drop-in-and-run but there are a lot of gotchas that I came across that might help someone else if they ever decide to tackle a project like this.

The Code

Feel free to browse the code at my github repository.

How to Build a Quine

Sat, 01 Jan 2011 08:00:00 +0000

A quine is simply a program that prints itself. This is my explanation of how they are built.

Writing a quine seems like a chicken-and-egg problem but if you really enforce the physical separation between data and code–that is defining the string to print and the code that prints it out–it’s a straight-forward programming exercise.

I divided the quine program into three parts: the data, the code that prints the first part of the program and the data, and the code that uses the data to print the entirety of the code (this section and the former). The data that I mentioned is a just a representation of the code part of the program. After breaking the program into these three parts, it becomes clear that the two code parts (the print-it-out part and the turn-it-into-code part) are two simple loops that can live completely independent of the data. The key to the trick is to write the code that uses the data and then turn that code into data after the fact, thus giving the program knowledge of how to print itself.

Here’s the full paste of the quine which should make it easier to follow along:

https://gist.github.com/749531.js

I found it easier to store the code inside the data part of the program as the decimal values of the code’s ASCII values. This representation avoided unfun issues such as getting the quoting and escaping right. So I wrote the whole program and left the data variable blank since this would be built from the code that yet to be written!

The first part of the code focused on printing the PHP boilerplate, the newlines down to the first variable, and the variable declaration itself. I then looped through the data array of integers and printed them. I then printed out the closing characters of the variable declaration.

The second part of the code turned the data array of ASCII values into their associated characters and printed them. Once again, this was just a simple loop that went through each ASCII value, converted it to its character representation, and then printed out the character. To me, this is the interesting part as the code is actually printing out itself.

To actually build the data array, I wrote a second program that took a block of text and printed out a comma-delimited string of the ASCII values. I copied and pasted the code portion of my quine, which was everything below the data array, and ran it through this second program, taking its output and placing it into the quine program as the data variable.

Now I had the full quine done. I had the data array, which represented the actual code of the quine: one code part that printed out the PHP boilerplate and the actual data array and another code part that looped through the data array and printed its ASCII representation which turns out to be the remaining code.

Running the program and then diffing the output with the original program resulted in nothing. Identical programs, success.

After I finished this, I wanted to do the trick where you have the first program print a second program in another language that prints out a program in a third language and so on that finally prints out the original program. After writing the first quine and seeing how it worked, this turned out to be a simple exercise in quoting and escaping among the various programming languages.

The key to the polyglot quine is that only the very last program (i.e., the one that prints out the original program) is the one that does any real work. All of the other ones are programs that just say “print this string” where the string is the next program. I modified my PHP quine, translating the code portions into JavaScript, and having the PHP program simply print the JavaScript. This gave me a PHP program that print out a JavaScript program that would then print out the original PHP program.

To add more languages, I would take the existing print statement, wrap the string in the next language’s print function, recalculate my data array and then move to the next language. After doing it once, I realized that there wasn’t anything technically difficult to the polyglot quines and felt somewhat embarrassed as passing it off as something impressive. I imagine it’s a lot like a magician’s act: there’s a lot of fireworks and pretty ladies and the tiger is wearing a top hat but the trick is that there is a mirror brought in at the end that makes the actual “magic” happen and the rest is just for show. I added a few common languages, figured that was enough garnish, and stopped at a PHP->C->Python->JS->PHP program.

https://gist.github.com/749686.js

Reading how a quine is built is one thing but actually working through the problem and seeing that code and data which we usually keep separate can be melded into the same thing is really a revelatory experience. It may be a bit like a learning how a magic trick is done but the deeper, Lisp-like knowledge that you get from actually seeing that “code is data and data is code” is well worth it.

Further reading: http://www.madore.org/~david/computers/quine.html

How many fume cupboards are needed?

Mon, 08 Jun 2009 07:00:00 +0000

I’ve recently been brushing up on my statistics by reading Principles of Statistics by M.G. Bulmer. I came across a problem and since I wrote some code to check my answer, I figured I’d post it with a short discussion about the answer.

First, the question:

In a certain survey of the work of chemical research workers, it was found, on the basis of extensive data, that on average each man required no fume cupboard for 60 per cent of his time, one cupboard for 30 per cent and two cupboards for 10 per cent; three or more were never required. If a group of four chemists worked independently of one another, how many fume cupboards should be availabe in order to provode adequate facilities for at least 95 per cent of the time?

My line of thinking to solve this was to find every combination of the 4 chemists needing 0, 1, or 2 cupboards, the probability of each of those combinations happening, and finally summing up the probability of all the hoods needed.

For example, out of the 81 different possible combinations of cupboards required (3 * 3 * 3* 3, with the 3 coming from 0, 1, or 2 hoods needed), there is only one way where 0 hoods are needed in total and this is where all 4 chemists need no cupboards. Following this, there are 4 ways to have 1 hood total be required, with each of the chemists exclusively requiring a cupboard and the other three needing none (1, 0, 0, 0 & 0, 1, 0, 0 & 0, 0, 1, 0 & 0, 0, 0, 1).

So having one cupboard covers the probability of needing no cupbards amongst the 4 PLUS the probability of needing 1 cupboard amongst the 4.

I first did this problem long-handed, figuring out the probability of 0, 1, 2, and so on cupboards until I got to a sum that had a probability > 0.95. I was making a simple arithmetic error (as usual) and my answer was not matching up with what was in the back of the book, so I thought I would write a simple program to calculate the answer since I was confident in what I was trying to do, but was just having trouble multiplying and adding.

Here’s the Python script I wrote (note: you need Python >= 2.6 as I use itertools.product to recreate all the combinations of cupboards needed).

The output is the summing of each of the probability of needing 0 cupboards + 1 cupboard + 2 cupboards and so on. The line with the probablity greater than 0.95 is the answer. In this the case, the answer was 4, which would cover the chemists’ needs 95.85 percent of the time.

from collections import defaultdict
import itertools

probs = {
    '0': 0.6,
    '1': 0.3,
    '2': 0.1
}

trials = itertools.product('012', repeat=4)

totals = defaultdict(float)

for trial in trials:
    #how many hoods needed in this trial
    trial_sum = sum(map(lambda x: int(x), trial))

    #figure probability of exact trial occurring
    total_prob = 1.0
    for item in trial:
        total_prob *= probs[item]

    #add probability of trial to total prob for this number of hoods needed
    totals[trial_sum] += total_prob

#print out all probabilities
keys = totals.keys()
keys.sort()

running_prob = 0.0

for i in keys:
    running_prob += totals[i]
    print i, running_prob * 100

SICP and Lulu.com

Fri, 13 Mar 2009 07:00:00 +0000

I’ve been wanting to read SICP for awhile, but with lots of other books on my to-read list, as well as the $50 dollar price tag for a used copy, I’ve put it on hold. The price, while relatively steep, usually doesn’t stop me from picking up a highly-desired book, but I held off mainly as the book is freely available on their website, under the Creative Commons Attribution-Noncommercial license and this seems like a lot to pay for a free-as-in-beer book.

Since SICP runs close to 600 printed pages and approximately 40 HTML files , I’d rather not read it in my browser and printing it on the home printer is not really an option. I decided that using Lulu might be a workable solution.

Lulu takes PDFs so step one was to convert the SICP website to one big PDF.

First, I used wget to mirror the site. Now that I had all the files, I wanted to clean them up a little. Every single page had the previous and next links at the bottom and this was obviously not needed when the pages are in physical form. I ran the following sed command to remove these lines:

sed -i "/[Go to/d" *html

The next step was to convert the HTML to PDF. I used htmldoc for this particular task. First, I put all the names of the HTML files in one text file, on one line, and in the correct order. I called this file “all_files.txt”. The htmldoc command I used to convert to PDF is the following:

htmldoc -f sicp.pdf --webpage --left .75in --right .75in cat all_files.txt

I then uploaded this file up to Lulu and designed my (very) simple cover. I made it clear on the back cover text that I was printing this book under the rights granted by the aforementioned license and would receive no profit from this book with a link back to the original source. I’m not a lawyer so I hope that covers all bases.

Lulu has a convenient feature that will let you do a private printing. I could probably make this book public, setting my profit to zero, and even though that would be covered under the license, it still feels strange to do.

I am very curious how this book will turn out. The Lulu process was actually fun and if this turns out well, I could see myself using the service again. Once I get the book, I’ll post my reviews of the service and possibly some pictures of the final product. Nonetheless, I’m excited to get a print version of this book for a much-reduced price.

**Edited to add:**Here’s the download for the PDF: sicp.pdf

Keeping the music going

Sun, 22 Feb 2009 08:00:00 +0000

I love listening to last.fm’s similar artist radio stations. I constantly forget that the music I am listening to is coming from one of my Firefox tabs, and will accidentally close it from time to time, stopping whatever music is playing.

I decided to fix this for myself using a ridiculously short Greasemonkey script, using the window object’s “onbeforeunload” function to make sure I actually meant to close the tab/window.

Here it is for consumption. This is obviously not a work of genius or of any considerable effort, just a fix for my own absentmindedness.

**Updated:**I added a little more functionality to the script. There is now a button that will show up in the top right corner that will let you turn off and on the close prompt so that you can browse the last.fm without getting the ‘Are you sure?’ prompt on every page load.

Something new, Something Clojure

Tue, 30 Dec 2008 08:00:00 +0000

I’ve been shopping for a new programming language to learn the past few months and I’ve decided to jump on the functional wagon and expand my mind a little.

For my day job, I’m a PHP and Javascript developer, enjoying the latter more the former, and for personal scripts and side projects, I’ve been a Python guy for years.

I wanted something that was a departure from these more imperative languages which obviously lends itself to the functional languages. At the same time, I wanted something that wasn’t purely academic, but I could build real-world software with it that other people could easily use.

I’ve been fascinated with Lisp and its S-expressions and the idea of code being data and vice versa. At the same time the speedy, static-typed languages like OCaml and Haskell were very intriguing.

After playing with OCaml for a week or two and also working through the first few chapters of Real World Haskell and watching the entertaining Simon Peyton-Jones, I enjoyed them, but I wasn’t infatuated with them. No magic spark, I guess you could say. I think it comes down to me being more inclined to the dynamically-typed languages which seems to cut down one more barrier between me and the implementation of my code.

So ruling out the OCaml and Haskell brand of typed, functional languages, I found myself working my way back to Lisp. Surveying the Lisp scene, I found myself confronted with quite a few choices of Lisp implementations. I decided to go with Clojure, as from my readings, it seems to be a nice Lisp, even coming from the older Lisp guys and you get the almost endless number of libraries of Java, as well as the speedy JVM that runs on all the major platforms. I’m sold.

I’ve played with SBCL going through bits and pieces of Practical Common Lisp and I really enjoy the expressiveness and the speed of going from the idea of what you want to do to actually seeing it run. Stuart Holloway (of nearby Chapel Hill) has written a series of blog posts porting pieces of the PCL code to Clojure which should serve as a nice introductions as well as the screencasts.

I’ll post updates on new discoveries I make, and any software I decide to work on.

Setting up lighttpd/Apache for Django on Slicehost

Sun, 10 Feb 2008 08:00:00 +0000

I finally made the jump and moved the websites I was hosting on my home PC and moved them out to slicehost. Signing up for my slice could not have been easier and so far it has been a flawless experience. The PickledOnion articles were nice to double-check myself to make sure I didn’t miss anything.

I opted for the Ubuntu 7.10 256 MB slice since that was what the sites were priorly hosted on. I decided that I wanted to do things by the book so I set up a lighttpd server that served my media straight up and funneled all Django requests through Apache/mod_python. I couldn’t find an exact way to this previously published so I thought I would add a few code snippets to help others looking to do the same.

First off, I got the Apache/mod_python setup working. This was pretty much a cut and paste from the deployment docs found in the Django book. Nothing tricky there. By default, Apache runs on port 80, but that will be changed later on.

The next step was to get lighttpd working properly. The relevant snippet is below:


$HTTP["host"] =~ "^(www.)?example.com" {
    $HTTP["url"] !~ "^/(public|media)/" {
        proxy.server = ( "" =>
            ( (
                "host" => "127.0.0.1",
                "port" => 81
            ) )
        )
    }
}

Broken down, this says if we get a request for example.com and the URL does not contain one of our media directories (read: a Django request), proxy it to port 81. This way lighttpd will serve up all the static files and then redirect the Django stuff to our Apache instance that will be listening on port 81.

After that, change the ports.conf file for your Apache instance to listen on port 81, and the “server.port” variable in your lighttpd.conf to listen on port 80, and then restart both servers. If everything went correctly, you should now have a 2 servers doing what they do best and have a happy machine to boot.

I did add a couple of lines to my Apache conf to get better performance.

First off, I turned off KeepAlive as suggested by Jacob Kaplan-Moss. KeepAlive is useful if you are using Apache to serve up several files over one TCP connection, like multiple images on a page load. Since on every page load we are making just one request to Apache (for the HTML itself) and lighttpd is handling all of the static serving (which it is very good at it), KeepAlive helps us none and actually hurts us as Apache will quickly become RAM hungry holding on to your full Django code when there is no need for it.

Second tuning measure was to bump MaxRequestsPerChild up. I set mine at 500 and saw a big RAM usage drop. This way since these are fairly RAM-heavy Apache processes, they’ll get cleaned up once they reach a certain number.

Overall, I have been very pleased with slicehost and the Django book was very helpful in getting everything up and running.

jQuery: a new joy

Wed, 07 Nov 2007 08:00:00 +0000

At work, I have been working on somewhat complex site with a lot of Javascript going on in the form of some ajax calls and Google Maps. We noticed that the site had an almost painful load time, approximately 8 seconds for a fresh pull of the home page. This was too much.

The first thing I did was profile it using Firebug’s Net tab. Of all the tools in my web developer’s tool chest, Firebug is far-and-away my favorite, my oft-used, and my most recommended app. Not only does it give you a super nice DOM browser and a great Javascript debugger, but it also has a nice download profiler under its Net tab. It gives you every single element that the browser requests for your page with its HTTP headers and, even more importantly, the time to complete each transaction.

The profiling introduced a few things instantly. First, there were a lot of images and some were rather hefty. Since I was building the site from somebody else’s design files, and that is definitely not my domain, there was not much I could do about that.

The second thing was the Google Maps calls. I put the Google request calls at the end so the rest of the page could load before them. Doing just this took about a second and a half off a fresh homepage load. It was a marked improvement, but still nothing spectacular.

The final thing brings me to the topic of this post. Our standard JS library at work is Dojo. Dojo is great when you are trying to create a RIA interface with all the bells and whistles, such as tabs, number spinners, rich text editors, grids, and trees. Its widget library, dijit, is quite impressive. An early complaint of dojo was that it was a big download. If I remember correctly it was something like 100kb. The Dojo team fixed this 0.9 with a more modular dependency download structure. Say you needed to only use widget A. You’d make the Dojo call in your page for the widget and Dojo would then only download the bits of JS it needed to get that widget on the page. The problem with this is that if you are only using a small subset of the library, you had an exorbitant overhead, not in download weight, but in HTTP requests.

For example, I was only using Dojo to do some absolute positioning stuff for some help tip bubbles and a few simple Ajax calls. This was like going squirrel hunting with a Scud missile. Even with just using core Dojo (no widgets), I made about a dozen HTTP requests just to get the pieces of JS I needed. In total, it took a little over 2 seconds just to load the JS library, even though it only equated to about 60Kb of total file size.

These small tasks almost bordered on something that I could do myself, but since I can be a lazy programmer, I figured a small lightweight JS library that people much smarter than myself have written and tested would be the ticket. I noticed that jQuery was being mentioned more and more in a good way around the web, so I figured this would be the perfect trial to test it out. I can definitely say ‘mission accomplished’ with jQuery.

I used the non-gzipped packed version which had a weight of 47Kb. This took around 50ms to download and even better it all came in one HTTP request, with no just-in-time loading. The Ajax API between Dojo and jQuery was similar enough that it took very little modification to port it over and I even minimized some of my Javascript to use the awesome syntax of jQuery. By simply switching to jQuery, I shaved a little over 2 seconds from the page load time with no loss of functionality. Nice.

After all the profiling and modifying, I managed to cut the page load from a little over 8 seconds to a little over 4 seconds.

As a side benefit, it was actually fun to write Javascript. With jQuery’s well-document API and function list (something that Dojo definitely lacks last checking), I spent more time Getting Things Done than tinkering and experimenting. I was actually trying to do things to improve the visual effects of the site because jQuery made it simple to do so. It was almost completely painless.

This is not a slam on Dojo at all, because if you need some advanced UI features, I’d definitely go down the path towards Dojo. This was simply using the best tool for the job.

I am now looking for more excuses to use the tiny, tidy little jQuery library in other spots. jQuery brought joy to Javascript development, something I wouldn’t really have thought possible.