In December 2010, Brendan Eich talked about Mozilla’s new programming language called Rust (that focuses on safety and concurrency, to replace C++ as Mozilla’s implementation language). He mentions that creating new languages is still important, because they can recycle old research, but repackage it so that it becomes more mainstream-compatible. One example is Clojure that continues the Lisp tradition, but on the Java Virtual Machine (JVM). There are two new aspects to modern language design:

The ECMAScript wiki has two pages with features that might make it into ECMAScript.next:

Update 2011-11-19: Bridging the module gap between Node.js and browsers

JavaScript does not come with support for modules. This blog post examines patterns and APIs that provide such support. It is split into the following parts:

1. Patterns for structuring modules.
2. APIs for loading modules asynchronously.
3. Related reading, background and sources.

This post examines some of the details of how environments are handled in the ECMAScript 5 (ES5) specification [1]. In particular, there isn’t a single “current environment” in ES5, but two: the LexicalEnvironment and the VariableEnvironment. A piece of code at the end exploits these ES5 internals to produce different results on Firefox and Chrome.

This post explains three approaches for extracting information from arrays and objects:

1. for loops,
2. array methods (courtesy of ECMAScript 5 [1]),
3. listing property keys.

It concludes with best practices for applying these approaches.

This post is about converting between primitive values and wrapper objects [1]. Thankfully, one is usually not faced with this kind of task in JavaScript. The most frequent use case is to add properties to a primitive. As a primitive is immutable, you need to convert it to a wrapper object to do so. Read on if you want to see some of JavaScript’s more obscure corners.

Let us start with a short quiz:

What does ({}).valueOf.call(myvar) do?

The Internet Explorer 10 Preview (IE10) comes with many new features, two of them are especially good news for webapp developers:

This post argues that the singleton pattern is usually not needed in JavaScript, because you can directly create objects. It then slightly backpedals from that position and shows you code skeletons that you can use if your needs go beyond the basics.

This post motivates the Singleton design pattern and explains its implementation in Java.

Lifestreams [1] were created in 1996 to correct some of the shortcomings of document management when used for personal information management. Even today, document management is still the dominant way of information management, both conceptually and as a user interface metaphor. Some of the shortcomings are: