Understanding the structure of underscore.js code

It's probably to do with the noConflict feature if you happen to have multiple versions of underscore running at the same time.

this (window) is passed in so it can detect existing versions of _. Using this notation you avoid a hard reference to window, which is nice. There are also some minor performance benefits: variables in local scope resolve faster.

Alternatives could be:

(function () {
    // library
}(window)); // hard reference to window (not so nice)

(function () {
    // library
}({})); // this will break `noConflict` detection

This is to wrap you whole code in an anonymous function. This way variable declared inside the function will remain private, so other scripts won't be able to access your code.

And .call is a function method. That will invoke the anonymouse function with passed argument as a value of this.

In this case whatever is the value of this is by default it's window object, will be available inside the anonymouse function to. Here is an example of it.

(function(a, b, c ){ // and other arguments
    // Here `this` will refer to document object.

    // And the variables declared here are compltly private

    // If you want any variable to make global use window object

    var someStuff = 'scret'; // Private

    function Lib(){
        return someStuff.length;
    }

    window.Lib = Lib; // This will be available to other scripts

}).call(document, a, b, c);

This kind of wrapper is generally generated by preprocessor languages like CoffeeScript

First part:

var x = 1; // `x` is in the global scope

(function() {
 var y = x; // `y` is in the current function's scope
}());

x = y; // Here `x` becomes `undefined` because `y` is not declared in this "outer" scope

As to the "why" - it's a simple technique to keep out of trouble (no "memory leaks" [all internally declared vars are void when function ends], no declaration collision etc').

Second part: As for the call (there's also apply which is similar) version, it's simply a matter of context.
The author wants that the context of the anonymous function (that function above) will have its this point to the same this of the outer scope.

Hope it's clear :)