good coders code, great reuse

Posted: 27 Feb 2009 10:12 PM PST

I found a really nice video lecture on JavaScript. I’m a JavaScript journeyman myself so I decided to review it to learn something new. I have written about JavaScript in the past — the previous post on JavaScript was “Learning JavaScript through Video Lectures“.

This lecture is given by JavaScript guru Doug Crockford. He’s the author of JSON data exchange format, JSMin JavaScript minifier and JSLint.

The talk is based on Douglas’s recent book “JavaScript: The Good Parts“. It’s excellent.

The lecture begins with a brief intro of why JavaScript is the way it is and how it came to be so. An interesting point Doug makes is that JavaScript is basically Scheme, except with Java syntax. He talks about the bad and good parts of JavaScript and gives a few examples of common JavaScript problems, their solutions and patterns. Douglas also talks about how he discovered JSON. After the talk there is a 13 minute Q and A.

You’re welcome to watch the video lecture. It’s 1 hour long and it will definitely make your understanding of JavaScript better:

Direct URL: http://www.youtube.com/watch?v=hQVTIJBZook

Here are some interesting points from the lecture:

[09:57] JavaScript was influenced by Scheme, Java and Perl. From Scheme it borrowed lambda functions and loose typing. From Java it took most of the syntax, and from Perl some of its regular expressions. And finally, it derived the idea of prototypal inheritance and dynamic objects from Self. See my previous post on JavaScript for explanation of prototypal inheritance.

[11:38] JavaScript bad parts:

Global variables. Global variables make it harder to run independent subprograms in the same program. If the subprograms happen to have global variables that share the same names, then they will interfere with each other and likely fail, usually in difficult to diagnose ways.
Newlines get converted into semicolons. JavaScript has a mechanism that tries to correct faulty programs by automatically inserting semicolons. It sometimes inserts semicolons in places where they are not welcome. For example:
```
 return {     status: true }; 
```
returns undefined because JavaScript inserts ‘;’ after return.

Correct way:
```
 return {     status: true }; 
```
Operator typeof is not very helpful. For example, “typeof null” is “object”, “typeof [1,2,3]” is also “object”.
Operator + adds numbers and concatenates. The + operator can add or concatenate. Which one it does depends on the types of the parameters. If either operand is an empty string, it produces the other operand converted to a string. If both operands are numbers, it produces the sum. Otherwise, it converts both operands to strings and concatenates them. This complicated behavior is a common source of bugs. If you intend + to add, make sure that both operands are numbers.
Operators == and != do type coercion. Use of the === and !== operators is always preferred.
Too many falsy values. 0, Nan, ” (empty string), false, null, undefined are all false.

[17:25] for … in operator mixes inherited functions with the desired data members (it does deep reflection). Use object.hasOwnProperty to filter out names that belong to object itself:

 for (name in object) {     if (object.hasOwnProperty(name)) {         ...     } }

[22:00] Javascript good parts:

Lambda. Enough said.
Dynamic objects. Just add a property to an object, or remove it, no need for classes and derivation to create a similar object.
Loose Typing. No need for type declarations.
Object Literals. {} for object literals, [] for array literals and // for regexp literals.

[23:00] Two schools of inheritance - classical and prototypal. Prototypal inheritance means that objects can inherit properties directly from other objects. The language is class-free.

[24:35] Realization of prototypal inheritance in JavaScript:

 if (typeof Object.create !== 'function') {     Object.create = function (o) {         function F() {}         F.prototype = o;         return new F();     }; }

Now a newObject can be created by inheriting from oldObject:

 newObject = Object.create(oldObject);

[26:05] Example of global variables and why they are bad and how to solve the problem by using closures.

 var my_thing = function () {     var names = ["zero", "one", ... ];     return function(n) {         return names[n];     }; }();

[29:00] There are four ways to create a new object in JavaScript:

Object literal — var object = { }.
New — var object = new Object()
Object.create — var object = Object.create(old_object).
Call another constructor (use different inheritance model).

[42:42] JSLint. JSLint defines a professional subset of JavaScript. JSLint will hurt your feelings.

[52:00] Q/A: Does strict mode change the behavior or does it take things out? — Can’t have “with” in strict mode, changes the way eval() works, changes error handling.

[53:00] Q/A: What’s going on with DOM? — Ajax libraries fix DOM, these changes should be propagated back into DOM API.

[55:30] Q/A: How do you spell lambda in JavaScript? — function.

[55:54] Q/A: How to solve global variable problem? — Each of compilation unit should be isolated, but there should be a way how they can introduce (link) to each other.

[56:30] Q/A: How do JavaScript objects differ from hash tables, they seem the same to me?

[57:23] Q/A: What’s wrong with HTML 5 and web apps? — They are doing too much and there are way too many of them.

[59:10] Q/A: How come JSON and JavaScript have almost the same syntax? — Doug admits he forgot to include Unicode Line Separator (LS) and Paragraph Separator (PS) control codes as whitespace chars.

[01:00:32] Q/A: Why does JSON require quotes around the property names? — Three reasons: 1. Wanted to align with Python where quotes are required, 2. Wanted to make the grammar of standard simpler, 3. JavaScript has stupid reserved word policy.

[01:02:40] Q/A: Are there any prospects for adding concurrency to the language? — Definitely no threads. Could be some kind of a messaging model.

If you liked this talk, I recommend that you get Doug’s book:

Happy javascripting!