Nerdworks Blogorama - Nerdspeak

IE9 web cast / Chennai Web Camps / OSI Days 2011

2011-11-24T04:09:03Z

It has been a somewhat hectic two weeks shuttling between Chennai and Bangalore for a bunch of stuff. As usual, I’ve been happily handing out promises about posting resources for my talks on my blog. Like candy. Turns out you’ve got to come good on them eventually. So here goes:

IE9 Web Cast on ECMAScript 5

Get the deck (there isn’t much in the deck but there it is for what its worth).
Get the JavaScript eval console I was showing off in the session.

Chennai Web Camps

All the resources for the web camps sessions are available here.

OSI Days 2011

Session on WebMatrix: Building a complete website within an hour
- Get the deck
- Get WebMatrix
Session on building cross browser HTML5 web apps
- Get the deck
- Get the demos

That’s all folks. Hope the sessions were useful. If you’ve got feedback on any of these, please feel free to leave a comment. If you want to be nasty and use dirty words, please email them to me.

Partial function application in JavaScript

2011-11-07T09:32:22Z

Partial function application is a functional programming technique that allows you to transform functions that take N parameters into functions that take a subset of N parameters. For example, say you have this fairly useless function:

function add(a, b) {
    return a + b;
}

Let’s say that for some reason we need a version of "add" that will always have the value 5 for the parameter "a". One way we might do it is like so:

function add5(b) {
    return add(5, b);
}

No black magic there. I was wondering if there might be some way that we can automate the process of generating functions with part of their arguments pre-bound. Here’s what I came up with:

function partialBind(f, context) {
    // arguments length MUST be greater than 2
    if(arguments.length <= 2) {
        // coz. what're you "partial binding" otherwise?!
        return null;
    }

    // convert args to array excluding param "f" and "context"
    var arrayProto = Array.prototype;
    var params = arrayProto.slice.call(arguments, 2, arguments.length);
    return function () {
        // append params passed to this function to "params"
        var args = params.slice(0, params.length);
        if (arguments.length > 0) {
            arrayProto.forEach.call(arguments, function (p) {
                args.push(p);
            });
        }

        // call the original function
        return f.apply(context, args);
    }
}

This function allows me to transform pretty much any function that takes at least 1 argument into a new function that takes a subset of the arguments. Transforming our "add" function into a single parameter version with "a" bound to 5 for instance, would now look like this:

var add5 = partialBind(add, null, 5);
var val = add5(10);
assert(val === 15);

Interestingly, "partialBind" allows us to compose argument binding to multiple levels. If we wanted to take our "add5" function and create another version that binds the second parameter to, say 20, then we can do this:

var add5_20 = partialBind(add5, null, 20);
var val = add5_20();
assert(val === 25);

Note that we are doing a partial bind of a function that is already a partial bind of another function. Turns out we can take this to as many levels as we want. The example given above is of course somewhat concocted because we could have achieved the same result with a single partial bind instead of doing it in two levels:

var add5_20 = partialBind(add, null, 5, 20);
var val = add5_20();
assert(val === 25);

All of this works because JavaScript supports closures. Pretty nifty don’t you think?

Web Camps, Virtual Tech Days and jsFoo

2011-10-17T05:28:01Z

So I’ve had a busy few weeks recently doing a bunch of sessions at Web Camps (in Delhi and Hyderabad), Virtual Tech Days and jsFoo. At each of those events I promised attendees that I’d put up the demos and the decks on my blog “soon”. Well, truth be told I’ve not been exactly conscientious about doing this quickly and I apologize for that. At any rate here’s the material for folks who came by for these sessions:

Web Camps

Bold and Beautiful with CSS3 – deck / demo
Spice it up - Advanced HTML5 – deck / demo

Folks who attended the Hyderabad event might remember that I used a HTML5/CSS3 version of the decks during the session. If you’d like a copy of that code then hang tight because I hope to put up a post here on how I built it and intend to share the source with that post.

Virtual Tech Days

Socket programming on the web – deck / demo
Threading and async programming on the web – deck / demo
Baking some HTML5 goodness into your ASP.NET apps – deck / demo

jsFoo

A primer on ECMAScript 5 – deck
Advanced JavaScript Techniques – deck
Best practices for building async apps with JavaScript – deck / demo

A number of jsFoo attendees requested that I share the “eval” console that I used to geek out on many of the advanced JS and ES5 samples during the session. I already have a post on that here:

http://bit.ly/js-eval

You should be able to download a copy for your own use from that post or use the online version if you prefer that.