diff --git a/README.md b/README.md
index d5525cb9f1..9871693f94 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,13 @@
-# Airbnb JavaScript Style Guide() {
+# JavaScript Style Guide() {
 
 *A mostly reasonable approach to JavaScript*
 
 
 ## <a name='TOC'>Table of Contents</a>
-
+  1. [General Coding Principles](#general-coding-principles)
   1. [Types](#types)
   1. [Objects](#objects)
+  1. [OOP](#oop)
   1. [Arrays](#arrays)
   1. [Strings](#strings)
   1. [Functions](#functions)
@@ -29,28 +30,52 @@
   1. [Testing](#testing)
   1. [Performance](#performance)
   1. [Resources](#resources)
-  1. [In the Wild](#in-the-wild)
-  1. [Translation](#translation)
-  1. [The JavaScript Style Guide Guide](#guide-guide)
-  1. [Contributors](#contributors)
   1. [License](#license)
 
+
+
+
+## <a name='general-coding-principles'>General Coding Principles</a>
+
+  - 99% of code should be housed in external javascript files. They should be included at the END of the BODY tag for maximum page performance.
+
+  - Don't rely on the user-agent string. Do proper feature detection. (More at [Dive Into HTML5: Detection](http://diveintohtml5.info/detect.html) & [jQuery.support docs](http://api.jquery.com/jQuery.support/))
+  
+  - Don't use `document.write()`.
+
+  - Strive to create functions which can be generalized, take parameters, and return values. This allows for substantial code reuse and, when combined with includes or external scripts, can reduce the overhead when scripts need to change. For example, instead of hard coding a pop-window with window size, options, and url, consider creating a function which takes size, url, and options as variables.
+
+  - Comment your code! It helps reduce time spent troubleshooting JavaScript functions.
+
+  - Organize your code as an [Object Literal/Singleton](http://kaijaeger.com/articles/the-singleton-design-pattern-in-javascript.html), in the [Module Pattern](http://www.yuiblog.com/blog/2007/06/12/module-pattern/), or as an [Object with constructors](http://mckoss.com/jscript/object.htm).
+
+  - Minimize global variables - the less globals you create, the better. Generally one, for your application namespace, is a good number:
+
+    ```javascript
+    window.globalVar = { ... }
+    ```
+
+  - For maximum portability and compatibility, always prefer standards features over non-standards features (e.g., `string.charAt(3)` over `string[3] ` and element access with DOM functions instead of using an application-specific shorthand).
+
+  - Always use explicit scope - doing so increases portability and clarity. For example, don't rely on `window` being in the scope chain. You might want to use your function in another application for which `window` is not the content window.
+
+    **[[⬆]](#TOC)**
+
+
 ## <a name='types'>Types</a>
 
   - **Primitives**: When you access a primitive type you work directly on its value
 
-    + `string`
-    + `number`
-    + `boolean`
-    + `null`
-    + `undefined`
+    * `string`
+    * `number`
+    * `boolean`
+    * `null`
+    * `undefined`
 
     ```javascript
     var foo = 1,
         bar = foo;
-
     bar = 9;
-
     console.log(foo, bar); // => 1, 9
     ```
   - **Complex**: When you access a complex type you work on a reference to its value
@@ -68,7 +93,24 @@
     console.log(foo[0], bar[0]); // => 9, 9
     ```
 
-    **[[⬆]](#TOC)**
+  - Type Checks
+
+    + **String:** `typeof object === "string"`
+    + **Number:** `typeof object === "number"`
+    + **Boolean:** `typeof object === "boolean"`
+    + **Object:** `typeof object === "object"`
+    + **Plain Object:** `jQuery.isPlainObject(object)`
+    + **Function:** `jQuery.isFunction(object)`
+    + **Array:** `jQuery.isArray(object)`
+    + **Element:** `object.nodeType`
+    + **null:** `object === null`
+    + **null or undefined:** `object == null`
+    + **undefined:**
+       + **Global Variables:** `typeof variable === "undefined"`
+       + **Local Variables:** `variable === undefined`
+       + **Properties:** `object.prop === undefined`
+
+  **[[⬆]](#TOC)**
 
 ## <a name='objects'>Objects</a>
 
@@ -101,6 +143,55 @@
     ```
     **[[⬆]](#TOC)**
 
+## <a name='oop'>OOP</a>
+
+  - Definition order
+
+    ```javascript
+    var object = function () {
+      //private variables
+      //public variables
+      //private functions
+      //public functions
+    }
+    ```
+  - Method and property definitions:
+
+    ```javascript
+    /** @constructor */
+    function SomeConstructor() {
+        this.someProperty = 1;
+    }
+    Foo.prototype.someMethod = function() { ... };
+    ```
+
+    While there are several ways to attach methods and properties to an object created via `new`, the preferred style for methods is:
+
+    ```javascript
+    Foo.prototype.bar = function() {
+      /* ... */
+    };
+    ```
+
+    The preferred style for other properties is to initialize the field in the constructor:
+
+    ```javascript
+    /** @constructor */
+    function Foo() {
+      this.bar = value;
+    }
+    ```
+
+  - Modifying prototypes of builtin objects:
+    Modifying builtins like `Object.prototype` and `Array.prototype` are strictly forbidden. Modifying other builtins like `Function.prototype` is less dangerous but still leads to hard to debug issues in production and should be avoided.
+
+  - Custom toString() methods
+    Must always succeed without side effects.
+
+    You can control how your objects string-ify themselves by defining a custom `toString()` method. This is fine, but you need to ensure that your method (1) always succeeds and (2) does not have side-effects. If your method doesn't meet these criteria, it's very easy to run into serious problems. For example, if `toString()` calls a method that does an assert, assert might try to output the name of the object in which it failed, which of course requires calling `toString()`.
+
+    **[[⬆]](#TOC)**
+
 ## <a name='arrays'>Arrays</a>
 
   - Use the literal syntax for array creation
@@ -113,7 +204,7 @@
     var items = [];
     ```
 
-  - If you don't know array length use Array#push.
+  - If you don't know array length use `Array#push`.
 
     ```javascript
     var someStack = [];
@@ -126,7 +217,7 @@
     someStack.push('abracadabra');
     ```
 
-  - When you need to copy an array use Array#slice. [jsPerf](http://jsperf.com/converting-arguments-to-an-array/7)
+  - When you need to copy an array use `Array#slice`. [jsPerf](http://jsperf.com/converting-arguments-to-an-array/7)
 
     ```javascript
     var len = items.length,
@@ -163,8 +254,7 @@
     var fullName = 'Bob ' + this.lastName;
     ```
 
-  - Strings longer than 80 characters should be written across multiple lines using string concatenation.
-  - Note: If overused, long strings with concatenation could impact performance. [jsPerf](http://jsperf.com/ya-string-concat) & [Discussion](https://github.com/airbnb/javascript/issues/40)
+  - Strings longer than 80 characters should be written across multiple lines using string concatenation. **Note**: If overused, long strings with concatenation could impact performance. [jsPerf](http://jsperf.com/ya-string-concat) & [Discussion](https://github.com/airbnb/javascript/issues/40)
 
     ```javascript
     // bad
@@ -188,7 +278,7 @@
       'fast.';
     ```
 
-  - When programatically building up a string, use Array#join instead of string concatenation. Mostly for IE: [jsPerf](http://jsperf.com/string-vs-array-concat/2).
+  - When programatically building up a string, use `Array#join` instead of string concatenation. Mostly for IE: [jsPerf](http://jsperf.com/string-vs-array-concat/2).
 
     ```javascript
     var items,
@@ -209,7 +299,7 @@
     length = messages.length;
 
     // bad
-    function inbox(messages) {
+    function inbox (messages) {
       items = '<ul>';
 
       for (i = 0; i < length; i++) {
@@ -220,7 +310,7 @@
     }
 
     // good
-    function inbox(messages) {
+    function inbox (messages) {
       items = [];
 
       for (i = 0; i < length; i++) {
@@ -240,35 +330,34 @@
 
     ```javascript
     // anonymous function expression
-    var anonymous = function() {
+    var anonymous = function () {
       return true;
     };
 
     // named function expression
-    var named = function named() {
+    var named = function named () {
       return true;
     };
 
     // immediately-invoked function expression (IIFE)
-    (function() {
+    (function () {
       console.log('Welcome to the Internet. Please follow me.');
     })();
     ```
 
-  - Never declare a function in a non-function block (if, while, etc). Assign the function to a variable instead. Browsers will allow you to do it, but they all interpret it differently, which is bad news bears.
-  - **Note:** ECMA-262 defines a `block` as a list of statements. A function declaration is not a statement. [Read ECMA-262's note on this issue](http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf#page=97).
+  - Never declare a function in a non-function block (`if`, `while`, `etc`). Assign the function to a variable instead. Browsers will allow you to do it, but they all interpret it differently, which is bad news bears. **Note:** ECMA-262 defines a `block` as a list of statements. A function declaration is not a statement. [Read ECMA-262's note on this issue](http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf#page=97).
 
     ```javascript
     // bad
     if (currentUser) {
-      function test() {
+      function test () {
         console.log('Nope.');
       }
     }
 
     // good
     if (currentUser) {
-      var test = function test() {
+      var test = function test () {
         console.log('Yup.');
       };
     }
@@ -278,12 +367,12 @@
 
     ```javascript
     // bad
-    function nope(name, options, arguments) {
+    function nope (name, options, arguments) {
       // ...stuff...
     }
 
     // good
-    function yup(name, options, args) {
+    function yup (name, options, args) {
       // ...stuff...
     }
     ```
@@ -317,7 +406,7 @@
       age: 28
     };
 
-    function getProp(prop) {
+    function getProp (prop) {
       return luke[prop];
     }
 
@@ -379,7 +468,7 @@
 
     ```javascript
     // bad
-    function() {
+    function () {
       test();
       console.log('doing stuff..');
 
@@ -395,7 +484,7 @@
     }
 
     // good
-    function() {
+    function () {
       var name = getName();
 
       test();
@@ -411,7 +500,7 @@
     }
 
     // bad
-    function() {
+    function () {
       var name = getName();
 
       if (!arguments.length) {
@@ -422,7 +511,7 @@
     }
 
     // good
-    function() {
+    function () {
       if (!arguments.length) {
         return false;
       }
@@ -443,7 +532,7 @@
     ```javascript
     // we know this wouldn't work (assuming there
     // is no notDefined global variable)
-    function example() {
+    function example () {
       console.log(notDefined); // => throws a ReferenceError
     }
 
@@ -451,7 +540,7 @@
     // reference the variable will work due to
     // variable hoisting. Note: the assignment
     // value of `true` is not hoisted.
-    function example() {
+    function example () {
       console.log(declaredButNotAssigned); // => undefined
       var declaredButNotAssigned = true;
     }
@@ -459,7 +548,7 @@
     // The interpreter is hoisting the variable
     // declaration to the top of the scope.
     // Which means our example could be rewritten as:
-    function example() {
+    function example () {
       var declaredButNotAssigned;
       console.log(declaredButNotAssigned); // => undefined
       declaredButNotAssigned = true;
@@ -469,12 +558,12 @@
   - Anonymous function expressions hoist their variable name, but not the function assignment.
 
     ```javascript
-    function example() {
+    function example () {
       console.log(anonymous); // => undefined
 
       anonymous(); // => TypeError anonymous is not a function
 
-      var anonymous = function() {
+      var anonymous = function () {
         console.log('anonymous function expression');
       };
     }
@@ -483,26 +572,26 @@
   - Named function expressions hoist the variable name, not the function name or the function body.
 
     ```javascript
-    function example() {
+    function example () {
       console.log(named); // => undefined
 
       named(); // => TypeError named is not a function
 
       superPower(); // => ReferenceError superPower is not defined
 
-      var named = function superPower() {
+      var named = function superPower () {
         console.log('Flying');
       };
 
 
       // the same is true when the function name
       // is the same as the variable name.
-      function example() {
+      function example () {
         console.log(named); // => undefined
 
         named(); // => TypeError named is not a function
 
-        var named = function named() {
+        var named = function named () {
           console.log('named');
         };
       }
@@ -512,10 +601,10 @@
   - Function declarations hoist their name and the function body.
 
     ```javascript
-    function example() {
+    function example () {
       superPower(); // => Flying
 
-      function superPower() {
+      function superPower () {
         console.log('Flying');
       }
     }
@@ -577,28 +666,80 @@
 
 ## <a name='blocks'>Blocks</a>
 
-  - Use braces with all multi-line blocks.
+  - if/else/for/while/try/function always have braces, one space around parentheses and always go on multiple lines.
 
     ```javascript
-    // bad
-    if (test)
-      return false;
+    // Bad
+    if(condition) doSomething();
 
-    // good
-    if (test) return false;
+    // Bad
+    while(condition) iterating++;
 
-    // good
-    if (test) {
-      return false;
+    // Bad
+    for(var i=0;i<100;i++) someIterativeFn();
+
+    // Bad
+    object[array[0]];
+
+
+    // Good
+    if (condition) {
+        // expressions
     }
 
-    // bad
-    function() { return false; }
+    // Good
+    while (condition) {
+        // expressions
+    }
 
-    // good
-    function() {
-      return false;
+    // Good
+    var i = 0;
+
+    for (; i < 100; i++) {
+        // expressions
+    }
+
+    // Good
+    var prop;
+
+    for (prop in object) {
+        // expressions
     }
+
+    // Good
+    if (condition) {
+        // expressions
+    } else {
+        // expressions
+    }
+
+    // Good
+    if (condition) {
+        // expressions
+    } else if (condition) {
+        // expressions
+    } else {
+        // expressions
+    }
+
+    // Good
+    try {
+        // expressions
+    } catch (e) {
+        // expressions
+    }
+
+    // Good
+    try {
+        // expressions
+    } catch (e) {
+        // expressions
+    } finally {
+        // expressions
+    }
+
+    // Good
+    object[array[ 0 ]];
     ```
 
     **[[⬆]](#TOC)**
@@ -615,7 +756,7 @@
     //
     // @param <String> tag
     // @return <Element> element
-    function make(tag) {
+    function make (tag) {
 
       // ...stuff...
 
@@ -630,7 +771,7 @@
      * @param <String> tag
      * @return <Element> element
      */
-    function make(tag) {
+    function make (tag) {
 
       // ...stuff...
 
@@ -649,7 +790,7 @@
     var active = true;
 
     // bad
-    function getType() {
+    function getType () {
       console.log('fetching type...');
       // set the default type to 'no type'
       var type = this._type || 'no type';
@@ -658,7 +799,7 @@
     }
 
     // good
-    function getType() {
+    function getType () {
       console.log('fetching type...');
 
       // set the default type to 'no type'
@@ -673,7 +814,7 @@
   - Use `// FIXME:` to annotate problems
 
     ```javascript
-    function Calculator() {
+    function Calculator () {
 
       // FIXME: shouldn't use a global here
       total = 0;
@@ -685,7 +826,7 @@
   - Use `// TODO:` to annotate solutions to problems
 
     ```javascript
-    function Calculator() {
+    function Calculator () {
 
       // TODO: total should be configurable by an options param
       this.total = 0;
@@ -703,7 +844,7 @@
 
     ```javascript
     // bad
-    function() {
+    function∙() {
     ∙∙∙∙var name;
     }
 
@@ -713,10 +854,23 @@
     }
 
     // good
-    function() {
+    function∙() {
     ∙∙var name;
     }
     ```
+
+  - No end of line whitespace.
+
+  - No blank line whitespace.
+
+  - Place one space before and after binary and ternary operators.
+
+    ```javascript
+    var a∙=∙1∙+∙2,
+      b∙=∙a++,
+      c∙=∙a∙>∙0∙?∙'yes'∙:∙'no';
+    ```
+
   - Place 1 space before the leading brace.
 
     ```javascript
@@ -726,7 +880,7 @@
     }
 
     // good
-    function test() {
+    function test ()∙{
       console.log('test');
     }
 
@@ -737,7 +891,7 @@
     });
 
     // good
-    dog.set('attr', {
+    dog.set('attr',∙{
       age: '1 year',
       breed: 'Bernese Mountain Dog'
     });
@@ -746,14 +900,14 @@
 
     ```javascript
     // bad
-    (function(global) {
+    (function (global) {
       // ...stuff...
     })(this);
     ```
 
     ```javascript
     // good
-    (function(global) {
+    (function (global) {
       // ...stuff...
     })(this);
 
@@ -833,19 +987,19 @@
 
     ```javascript
     // bad
-    (function() {
+    (function () {
       var name = 'Skywalker'
       return name
     })()
 
     // good
-    (function() {
+    (function () {
       var name = 'Skywalker';
       return name;
     })();
 
     // good
-    ;(function() {
+    ;(function () {
       var name = 'Skywalker';
       return name;
     })();
@@ -855,7 +1009,6 @@
 
 
 ## <a name='type-coercion'>Type Casting & Coercion</a>
-
   - Perform type coercion at the beginning of the statement.
   - Strings:
 
@@ -927,17 +1080,23 @@
 
 
 ## <a name='naming-conventions'>Naming Conventions</a>
+  - Name variables and functions logically: For example: `popUpWindowForAd` rather than `myWindow`.
+
+  - All Boolean variables should start with "is".
+    ```javascript
+    isValid = (test.value >= 4 && test.success);
+    ```
 
   - Avoid single letter names. Be descriptive with your naming.
 
     ```javascript
     // bad
-    function q() {
+    function q () {
       // ...stuff...
     }
 
     // good
-    function query() {
+    function query () {
       // ..stuff..
     }
     ```
@@ -999,7 +1158,7 @@
 
     ```javascript
     // bad
-    function() {
+    function () {
       var self = this;
       return function() {
         console.log(self);
@@ -1007,7 +1166,7 @@
     }
 
     // bad
-    function() {
+    function () {
       var that = this;
       return function() {
         console.log(that);
@@ -1015,7 +1174,7 @@
     }
 
     // good
-    function() {
+    function () {
       var _this = this;
       return function() {
         console.log(_this);
@@ -1027,23 +1186,64 @@
 
     ```javascript
     // bad
-    var log = function(msg) {
+    var log = function (msg) {
       console.log(msg);
     };
 
     // good
-    var log = function log(msg) {
+    var log = function log (msg) {
       console.log(msg);
     };
     ```
 
+  - Constant values
+
+    If a value is intended to be constant and immutable, it should be given a name in `CONSTANT_VALUE_CASE`. `ALL_CAPS` additionally implies `@const` (that the value is not overwritable).
+
+    Primitive types (number, string, boolean) are constant values.
+
+    Objects' immutabilty is more subjective — objects should be considered immutable only if they do not demonstrate obeserverable state change. This is not enforced by the compiler.
+
+  - Constant pointers (variables and properties)
+
+    The `@const` annotation on a variable or property implies that it is not overwritable. This is enforced by the compiler at build time. This behavior is consistent with the const keyword (which we do not use due to the lack of support in Internet Explorer).
+
+    A `@const` annotation on a method additionally implies that the method should not be overriden in subclasses.
+
+    **Examples**
+
+    Note that `@const` does not necessarily imply `CONSTANT_VALUES_CASE`. However, `CONSTANT_VALUES_CASE` does imply `@const`.
+
+    ```javascript
+    /**
+     * Request timeout in milliseconds.
+     * @type {number}
+     */
+    goog.example.TIMEOUT_IN_MILLISECONDS = 60;
+    ```
+
+    The number of seconds in a minute never changes. It is a constant value. `ALL_CAPS` also implies `@const`, so the constant cannot be overwritten.
+
+    The open source compiler will allow the symbol it to be overwritten because the constant is not marked as `@const`.
+
+    ```javascript
+    /**
+     * Map of URL to response string.
+     * @const
+     */
+    MyClass._fetchedUrlCache = new goog.structs.Map();
+    ```
+
+    In this case, the pointer can never be overwritten, but value is highly mutable and not constant (and thus in `camelCase`, not `ALL_CAPS`).
+
+
     **[[⬆]](#TOC)**
 
 
 ## <a name='accessors'>Accessors</a>
 
   - Accessor functions for properties are not required
-  - If you do make accessor functions use getVal() and setVal('hello')
+  - If you do make accessor functions use `getVal()` and `setVal('hello')`
 
     ```javascript
     // bad
@@ -1059,7 +1259,7 @@
     dragon.setAge(25);
     ```
 
-  - If the property is a boolean, use isVal() or hasVal()
+  - If the property is a boolean, use `isVal()` or `hasVal()`
 
     ```javascript
     // bad
@@ -1073,20 +1273,20 @@
     }
     ```
 
-  - It's okay to create get() and set() functions, but be consistent.
+  - It's okay to create `get()` and `set()` functions, but be consistent.
 
     ```javascript
-    function Jedi(options) {
+    function Jedi (options) {
       options || (options = {});
       var lightsaber = options.lightsaber || 'blue';
       this.set('lightsaber', lightsaber);
     }
 
-    Jedi.prototype.set = function(key, val) {
+    Jedi.prototype.set = function (key, val) {
       this[key] = val;
     };
 
-    Jedi.prototype.get = function(key) {
+    Jedi.prototype.get = function (key) {
       return this[key];
     };
     ```
@@ -1099,27 +1299,27 @@
   - Assign methods to the prototype object, instead of overwriting the prototype with a new object. Overwriting the prototype makes inheritance impossible: by resetting the prototype you'll overwrite the base!
 
     ```javascript
-    function Jedi() {
+    function Jedi () {
       console.log('new jedi');
     }
 
     // bad
     Jedi.prototype = {
-      fight: function fight() {
+      fight: function fight () {
         console.log('fighting');
       },
 
-      block: function block() {
+      block: function block () {
         console.log('blocking');
       }
     };
 
     // good
-    Jedi.prototype.fight = function fight() {
+    Jedi.prototype.fight = function fight () {
       console.log('fighting');
     };
 
-    Jedi.prototype.block = function block() {
+    Jedi.prototype.block = function block () {
       console.log('blocking');
     };
     ```
@@ -1128,12 +1328,12 @@
 
     ```javascript
     // bad
-    Jedi.prototype.jump = function() {
+    Jedi.prototype.jump = function () {
       this.jumping = true;
       return true;
     };
 
-    Jedi.prototype.setHeight = function(height) {
+    Jedi.prototype.setHeight = function (height) {
       this.height = height;
     };
 
@@ -1142,12 +1342,12 @@
     luke.setHeight(20) // => undefined
 
     // good
-    Jedi.prototype.jump = function() {
+    Jedi.prototype.jump = function () {
       this.jumping = true;
       return this;
     };
 
-    Jedi.prototype.setHeight = function(height) {
+    Jedi.prototype.setHeight = function (height) {
       this.height = height;
       return this;
     };
@@ -1159,19 +1359,19 @@
     ```
 
 
-  - It's okay to write a custom toString() method, just make sure it works successfully and causes no side effects.
+  - It's okay to write a custom `toString()` method, just make sure it works successfully and causes no side effects.
 
     ```javascript
-    function Jedi(options) {
+    function Jedi (options) {
       options || (options = {});
       this.name = options.name || 'no name';
     }
 
-    Jedi.prototype.getName = function getName() {
+    Jedi.prototype.getName = function getName () {
       return this.name;
     };
 
-    Jedi.prototype.toString = function toString() {
+    Jedi.prototype.toString = function toString () {
       return 'Jedi - ' + this.getName();
     };
     ```
@@ -1183,7 +1383,7 @@
 
   - The module should start with a `!`. This ensures that if a malformed module forgets to include a final semicolon there aren't errors in production when the scripts get concatenated.
   - The file should be named with camelCase, live in a folder with the same name, and match the name of the single export.
-  - Add a method called noConflict() that sets the exported module to the previous version and returns this one.
+  - Add a method called `noConflict()` that sets the exported module to the previous version and returns this one.
   - Always declare `'use strict';` at the top of the module.
 
     ```javascript
@@ -1194,11 +1394,11 @@
 
       var previousFancyInput = global.FancyInput;
 
-      function FancyInput(options) {
+      function FancyInput (options) {
         this.options = options || {};
       }
 
-      FancyInput.noConflict = function noConflict() {
+      FancyInput.noConflict = function noConflict () {
         global.FancyInput = previousFancyInput;
         return FancyInput;
       };
@@ -1226,7 +1426,7 @@
 
     ```javascript
     // bad
-    function setSidebar() {
+    function setSidebar () {
       $('.sidebar').hide();
 
       // ...stuff...
@@ -1237,7 +1437,7 @@
     }
 
     // good
-    function setSidebar() {
+    function setSidebar () {
       var $sidebar = $('.sidebar');
       $sidebar.hide();
 
@@ -1272,7 +1472,7 @@
     $($sidebar[0]).find('ul');
     ```
 
-    **[[⬆]](#TOC)**
+  **[[⬆]](#TOC)**
 
 
 ## <a name='es5'>ECMAScript 5 Compatibility</a>
@@ -1287,16 +1487,60 @@
   - **Yup.**
 
     ```javascript
-    function() {
+    function () {
       return true;
     }
     ```
 
-    **[[⬆]](#TOC)**
+  **[[⬆]](#TOC)**
 
 
 ## <a name='performance'>Performance</a>
 
+   - Prefer `this.foo = null`.
+
+    ```javascript
+    Foo.prototype.dispose = function dispose () {
+      this.property_ = null;
+    };
+    ```
+
+    Instead of:
+
+    ```javascript
+    Foo.prototype.dispose = function dispose () {
+      delete this.property_;
+    };
+    ```
+    In modern JavaScript engines, changing the number of properties on an object is much slower than reassigning the values. The delete keyword should be avoided except when it is necessary to remove a property from an object's iterated list of keys, or to change the result of `if (key in obj)`.
+
+
+   - Closures
+
+    Yes, but be careful.
+    The ability to create closures is perhaps the most useful and often overlooked feature of JS. Here is a good description of how closures work .
+
+    One thing to keep in mind, however, is that a closure keeps a pointer to its enclosing scope. As a result, attaching a closure to a DOM element can create a circular reference and thus, a memory leak. For example, in the following code:
+
+    ```javascript
+    function foo (element, a, b) {
+      element.onclick = function() { /* uses a and b */ };
+    }
+    ```
+
+    the function closure keeps a reference to `element`, `a`, and `b` even if it never uses element. Since element also keeps a reference to the closure, we have a cycle that won't be cleaned up by garbage collection. In these situations, the code can be structured as follows:
+
+    ```javascript
+    function foo(element, a, b) {
+      element.onclick = bar(a, b);
+    }
+
+    function bar(a, b) {
+      return function() { /* uses a and b */ }
+    }
+    ```
+
+    * * *
   - [On Layout & Web Performance](http://kellegous.com/j/2013/01/26/layout-performance/)
   - [String vs Array Concat](http://jsperf.com/string-vs-array-concat/2)
   - [Try/Catch Cost In a Loop](http://jsperf.com/try-catch-in-loop-cost)
@@ -1354,38 +1598,6 @@
 
   **[[⬆]](#TOC)**
 
-## <a name='in-the-wild'>In the Wild</a>
-
-  This is a list of organizations that are using this style guide. Send us a pull request or open an issue and we'll add you to the list.
-
-  - **Airbnb**: [airbnb/javascript](https://github.com/airbnb/javascript)
-  - **American Insitutes for Research**: [AIRAST/javascript](https://github.com/AIRAST/javascript)
-  - **ExactTarget**: [ExactTarget/javascript](https://github.com/ExactTarget/javascript)
-  - **GoodData**: [gooddata/gdc-js-style](https://github.com/gooddata/gdc-js-style)
-  - **How About We**: [howaboutwe/javascript](https://github.com/howaboutwe/javascript)
-  - **MinnPost**: [MinnPost/javascript](https://github.com/MinnPost/javascript)
-  - **ModCloth**: [modcloth/javascript](https://github.com/modcloth/javascript)
-  - **National Geographic**: [natgeo/javascript](https://github.com/natgeo/javascript)
-  - **Razorfish**: [razorfish/javascript-style-guide](https://github.com/razorfish/javascript-style-guide)
-  - **Shutterfly**: [shutterfly/javascript](https://github.com/shutterfly/javascript)
-  - **Userify**: [userify/javascript](https://github.com/userify/javascript)
-  - **Zillow**: [zillow/javascript](https://github.com/zillow/javascript)
-
-## <a name='translation'>Translation</a>
-
-  This style guide is also available in other languages:
-
-  - :de: **German**: [timofurrer/javascript-style-guide](https://github.com/timofurrer/javascript-style-guide)
-  - :jp: **Japanese**: [mitsuruog/javacript-style-guide](https://github.com/mitsuruog/javacript-style-guide)
-
-## <a name='guide-guide'>The JavaScript Style Guide Guide</a>
-
-  - [Reference](https://github.com/airbnb/javascript/wiki/The-JavaScript-Style-Guide-Guide)
-
-## <a name='authors'>Contributors</a>
-
-  - [View Contributors](https://github.com/airbnb/javascript/graphs/contributors)
-
 
 ## <a name='license'>License</a>