void my_function() {
   char *data = malloc(1024);
   return; // oops! memory leak
}

function my_function() {
   var data = [1, 2, 3, 4, ..., 1024];
   return; // data will be freed later
}

function counter() {
   var n = 0;
   return function() {
      n++;
      return n;
   }
}
 
c = counter();
c(); // returns 1
c(); // returns 2

$("button").click(function(event) {
   // handle the click
}

var handlers = [
   function() { ... },
   function() { ... }
];
 
var thingsToRun = {
   red: function() { ... },
   blue: function() { ... },
   green : function() { ... }
}

function Thing() {
    this.name = "Bob";

    this.foo = [1138, 42, 1701];
}

var thing = new Thing();

1. A reference to a function
2. With the enclosing environment

(function () {
   var name = "Bob, the Closure String";
   $("button").click(function() {
      alert("My closure has a name variable: " + name)
   });
})();

sin(3*pi/2)

function capitalize(list) {
   for (var i=0; i<list.length; i++) {
      list[i] = list[i].toUpperCase();
   }
}

1. No return value
2. Mutates the input list
   

function upper(str) {
   return str.toUpperCase()
}
 
function capitalize(list) {
   return list.map(upper)
}

1. Can be chained with other functions
2. Referentially transparent
3. Easily testable

$.get("http://example.com")
   .then(doSomething)
   .then(doSomethingElse)
   .then(andFinish)

• Performance wins
• Construct infinite data sets

function findNextPrime(previousPrime) {
    // do lots of work
    return nextPrime;
}

function findNextPrime(previousPrime) {
    return function() {
        // do lots of work
        return nextPrime;
    }
}

translated_string = trans("Hello, world!") 

var x = {name: "Bob"};
x.name = "Fred"; // Not allowed!

• More easily testable
• Easier concurrency
• No side effects
• Easier flyweights