For example, consider a function add that takes 3 integers, and returns their sum. Using partial application, you can do this:

intermediate = add(1,2)
 
# .. do some other calculations ..
 
result = intermediate(3)  # 6

So, currying simply allows you to apply the arguments to a function in multiple steps. Some languages support curried functions out-of-the-box (like OCaml), while in other languages like JavaScript, you need to use a helper function to achieve this (side note: Functional.js and Underscore are both terrific libraries that offer various functional extensions to JavaScript, including currying).

ECMAScript 5 introduced bind() which brings (among other things) native currying to JavaScript. Once again, let’s take the add function.

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

This is how you curry it using bind().

var intermediate = add.bind(undefined, 1, 2);
var result = intermediate(3);   // 6

The first argument to bind() actually sets the infamous this context of the function. We can leave it undefined here, since it has no effect.

So, why curry? Currying is both elegant and useful when you want to cache re-usable computations. I am going to steal this converter example, which I have refactored to use bind().

function converter(toUnit, factor, offset, input) {
    offset = offset || 0;
    return [((offset+input)*factor).toFixed(2), toUnit].join(" ");
}
 
var milesToKm = converter.bind(undefined, 'km', 1.60936, 0);
var poundsToKg = converter.bind(undefined, 'kg', 0.45460, 0);
var farenheitToCelsius = converter.bind(undefined, 'degrees C',0.5556, -32);
 
milesToKm(10);            // returns "16.09 km"
poundsToKg(2.5);          // returns "1.14 kg"
farenheitToCelsius(98);   // returns "36.67 degrees C"

You can follow me on Twitter right here.

Let’s assume that the latest git commit id on your master branch is abcd. Let’s say that you do know that this bug did not exist in the previous release, whose last git commit id is wxyz. To identify the git commit which introduced this bug, and which lies between wxyz and abcd, do this:

$ git bisect start
$ git bisect good wxyz
$ git bisect bad abcd

You are essentially telling Git to bisect the commits between wxyz and abcd. Git will temporarily move you to a new branch called bisect and will now point to a commit that’s in the middle of both commits.

Bisecting: 34 revisions left to test after this
[25d71758dd0e131e9409f3896416eabc81d69ec8] Search field fixes

Verify whether the bug exists at this state. If it still does, type:

$ git bisect bad

Once again, Git will halve the number of commits needed to test by pointing you to a commit that’s right in the middle, between the previous bad commit and the good commit. Continue this process, telling git at each stage, whether a commit is “good” or “bad”, and git will eventually identify the first bad commit.

5bc592ab9065b12bf1bc516ab9e0fe461699971b is the first bad commit

Once you are done figuring out what changes caused the bug, you can return back to your original working state by:

$ git bisect reset

What I have been doing lately is using admin interfaces as a ground for testing and learning about these new features. So long you get your clients to use the latest build of Firefox or Chrome, you are good to go. With Chrome, that’s pretty easy with the automatic rolling updates, and Firefox will soon be doing the same. Of course, this is not going to happen with every client, but it’s not that hard to make them use a better browser by just telling them how it can save them development cost. And, that’s true.

The other day, I had to get color alternating rows of a table – grey, white, grey, white, and so on. With an older browser, you have to resort to first modifying your code to give alternate rows class="odd" and then specifying a different color for this class in the CSS file. With CSS3, you can just do:

tr:nth-child(odd) { 
    background-color:#eee; 
}

Want to highlight only the first child of a parent?

#parent-id:nth-child(1) {
    background: #eee;
}

Quick form validation on an internal admin tool? HTML5 form validators FTW.

<input type="text" pattern="[-0-9]+" required />

Those are admittedly trivial examples, but the fact is knowing these little shortcuts quickly add up and help you get stuff done faster. As an added bonus, you also keep your presentation and code separated. The next time you look at a CSS3 or HTML5 feature and think that you can only use them in 2015, think again!

Now, you have access to proxies, weak maps, maps, and sets!

Proxies

I am very excited about the Proxy API – it will allow you to create objects whose properties can be computed at run-time dynamically, and for hooking into other objects for auditing and logging purposes. A simple example:

var proxyObj = Proxy.create({
  get: function(obj, propertyName) {
    return 'Hello, '+ propertyName;
  }
});
 
console.log(proxyObj.John); // "Hello, John"

You can do all kinds of meta programming stuff using Proxies (that’s probably another blog post).

Maps and Weak Maps

The use of Maps and WeakMaps allows you to create dicts where the keys are objects.

var m = new Map();
var obj = {foo: "bar"};
m.set(obj, "baz");
m.get(obj);   // "baz"

The difference between a WeakMap and Map is that the WeakMap is not enumerable. Although the Map is enumerable, it relies on the iterator proposal, which is yet to be implemented in V8. So for all practical purposes, the Map and WeakMap are essentially the same for now.

Set

Again, you can add, delete and check for existence of a value in a Set, but cannot yet iterate through it.

var s = new Set();
s.add(2);
s.has(2); // true
s.had(10); // false

Finally, there was is a small but significant change in the way typeof operates on null. In ES3:

typeof null === 'object';  // true

But in ES5:

typeof null === 'null';  // true

This page from ECMAScript Harmony Wiki talks more about this semantic change, and how to support both ES5 and ES3 when writing code.

The immediate value of any of these features to browser-side JavaScript development is probably none, but nevertheless I’m excited to see the roll out of ES5 and ES6 features into V8, so we can start using them soon on atleast node.js.

You can follow me on Twitter right here.

val numbers = List(1,2,3,4)
numbers.map(2 * _)  // List(2, 4, 6, 8)

You can go a step further.

val numbers = List(1,2,3,4)
numbers.map(2*)

You can completely omit the _ as well, because * is actually a method on 2. Scala is smart enough to understand that it requires one parameter, and automatically passes it each element of the list.

In my last post on Scala, I mentioned how Scala’s power can be easily abused. This is one instance where it’s easy to end up abusing the convenience offered by the language. Let’s look at another code snippet:

// constant defined somewhere
val photoPath = "photos/"
 
// in another file
val memberIds = List("abc","def","ghi","jkl")
val photoUrls = memberIds.map("http://example.com/member/"+photoPath+)

See that innocuous looking + operator at the end of the last line? It’s very easy for someone who is tired at the end of a long day to just delete that, thinking that it’s a stray operator left behind by some lazy developer. Ouch.

Having said that, the use of anonymous arguments is elegant in some cases. Consider this:

def complicatedLogic(x:Int) = {
  // do something complicated
  x*2
}
val input = List(1,2,3,4)
val output = input.map(x => complicatedLogic(x))

We can rewrite that last line this way:

val output = input.map(complicatedLogic)

P.S: I have taken the liberty to use the term “anonymous argument” here to refer to this handy trick – but I will update the post if someone can tell me what this behavior is referred actually as.

You can follow me on Twitter right here.

print "\033[0;32mGREEN TEXT\033[0m"

Although that looks gibberish, the format can be broken down like this:

START_SEQx;y;zmDISPLAY_TEXTEND_SEQ

Starting sequence: \033[
x;y;z: ANSI color codes
Display text: Text you want to display
Ending sequence: \033[0m

You can mix and match x;y;z combinations to get a variety of effects! For example, this will print a blinking green text on red background:

print "\033[5;41;32mGREEN TEXT\033[0m"  # oh the horror!

ANSI color codes for your pleasure: