Node 0.7.12: Prepare for 0.8!

Node 0.7.12 is here, and Isaac Schlueter said Node 0.8.0 will be released later this week:

Please try out this release. There will be very virtually no changes between this and the v0.8.x release family. This is the last chance to comment before it is locked down for stability. The API is effectively frozen now.

That means it’s crunch time! Efforts have been made to preserve support for binary addons that use libeio and libev, but libev will be officially deprecated in 0.8 and gone in 0.9.

The 0.6 era feels like halcyon days – a time when Node received a huge amount of attention from the mainstream technology press, and stronger than ever developer interest. I’d like to wish the core team the best of luck with the 0.8 release.

nd

Back in April, TJ Holowaychuk released mad(1), an alternative manual page system based on Markdown. Now Russ Frank has released nd (License: MIT, npm: nd), which is similar to mad but focused on displaying documentation for npm modules and is written in JavaScript.

Typing nd module will display the documentation associated with module. The project’s readme contains lots of tips for finding documentation within modules and displaying it, and it also points out that it supports Windows – it’ll run fine in the standard cmd.exe command interpreter.

futoncli

If you’re working with CouchDB, then futoncli (License: Apache 2.0, npm: futon) by Nuno Job may be useful. It’s a command-line tool for managing CouchDB, and is based on the author’s nano database driver.

Once installed, the futon binary will accept commands, and configuration can be persisted to the ~/.futoncliconf file. The author has made a video of futoncli to demonstrate the main features.

Nijiko’s Bootstrap Extensions

Nijiko Yonskai sent us two new Bootstrap extensions: Notifications (GitHub: Nijikokun / bootstrap-notify, License: Apache 2.0) and Toggle Switches (GitHub: Nijikokun / bootstrap-toggle, License: Apache 2.0).

The Notifications extension uses the same look and feel as Bootstrap’s built-in alerts, but displays them as popups instead. It works like a typical jQuery plugin:

$('.notifications').notify({
  message: { text: 'Here is a simple message' },
  type: 'success'
}).show(); // for the ones that aren't closable and don't fade out there is a .close() function.

The Toggle Switches extension turns checkboxes into a larger more graphical switch that looks a bit like the iOS UISwitch. The author has included the required CSS as well.

IndexedDB Polyfill

The current state of client-side databases is confusing, mainly because there are major browsers that still don’t support IndexedDB. However, the IndexedDB Polyfill (GitHub: axemclion / IndexedDBShim, License: GPL2/BSD) by Parashuram Narasimhan allows browsers that still support Web SQL Database to use Indexed Database API instead. It also works with the author’s JQuery IndexedDB Plugin.

Including this polyfill on a page allows applications to use window.indexedDB as a single point into the IndexedDB API. The author has written some additional material about the plugin on his blog:

• IndexedDB polyfill
• IndexedDB Polyfill - Under the covers

Backbone UI

Backbone UI (GitHub: perka / backbone-ui, License: MIT) by Joe Stelmach allows Backbone models and collections to be displayed as UI components. By using data binding, the UI is kept up-to-date, and it’s pretty easy to change the components using CSS.

The authors have attempted to make it work more closely with the DOM rather than using HTML templates. This is possible in part due to Joe’s Laconic library. The focus is on JavaScript-heavy client-side applications rather than traditional server-side generated templates.

The documentation includes a sample to-do list application, and the source is surprisingly easy to follow and concise.

So far in JS101, our examples have mentioned this and functions that take advantage of its behaviour, like Function.prototype.apply and Function.prototype.call. However, before approaching other aspects of the language, we should first address this and execution contexts.

Methods and Functions

In this article I refer to both methods and functions. Method is defined in the ECMAScript specification as follows:

… function that is the value of a property.

NOTE When a function is called as a method of an object, the object is passed to the function as its this value.

We typically think of functions as a standalone subroutine, while methods are properties of an object that happen to be functions. This nomenclature is used widely within the community.

Execution Context

According to the ECMAScript 5.1 specification, an executing program is formed of “execution contexts”. These execution contexts support the language constructs we need to manage scope – the visibility of variables and function declarations from other parts of a program.

The execution context contains references to various elements that enable state within a program to be managed according to the current logical scope – for the exact details, see Execution Contexts in the specification. What we’re interested in is how the current value of this is determined.

Global Context and Constructors

Try running the following code in Node or a browser:

function add(x, y) {
  console.log(this);
  return x + y;
}

add(1, 1);

The second line will cause the global context to be displayed: global in Node, or window in a browser. If I inserted 'use strict' after the line that reads function add..., then this would be undefined instead.

Now consider what happens when a constructor is executed:

function Shape() {
  this.x = 0;
  this.y = 0;
}

var shape = new Shape();

When control enters the Shape constructor as a result of new Shape(), the this value will refer to the current object. Keep this in mind when writing object-oriented code: if a function is called as a method on an object, or by using new, then the value of this will be the current instance of the object, otherwise it will be the global context (or undefined in strict mode). The lesson here is the value of this is dependent on how a function is called.

Common Mistakes

Be careful when nesting functions inside methods. Read the following example and try to figure out the value of this inside checkBounds:

function Shape() {
  this.x = 0;
  this.y = 0;
}

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;

    function checkBounds() {
      if (this.x > 100) {
        console.error('Warning: Shape out of bounds');
      }
    }

    checkBounds();
  }
};

var shape = new Shape();
shape.move(101, 1);

The checkBounds function is defined inside the move method, but the console.error line will never be reached. This is because the value of this will be set to the global context, which is correct according to the specification but understandably confusing and represents a common source of bugs.

Fortunately, this is a value so we can reference it by using another variable:

Shape.prototype = {
  move: function(x, y) {
    var self = this;

    this.x += x;
    this.y += y;

    function checkBounds() {
      if (self.x > 100) {
        console.error('Warning: Shape out of bounds');
      }
    }

    checkBounds();
  }
};

Here self now points to the ThisBinding assigned when move executes, so checkBounds will work the way we intend it to. The name self can be anything, but it’s a popular convention. It’s not a reserved word, but your editor may highlight it.

Summary

When working with this, remember the following rules:

• It’s set based on how a function is called: new MyConstructor or myObject.method() will refer to an instance, while this inside a function refers to the global context
• Strict mode causes this to evaluate to undefined instead of the global context inside functions
• this can be referenced by a variable, and self is the conventionally used name

If you want to read lower-level details on this topic, start by looking at how the ECMAScript 5.1 specification defines the algorithms that are used to determine this for various situations: entering global code, executing eval code, and entering functions.

WebModular

WebModular is a modular synthesiser built using JavaScript and the Web Audio API. It’s a bit like the Google Doogle for Robert Moog’s birthday, except it’s a bit more powerful. This synth includes a pair of VCOs, VCFs, VCAs, envelopes, LFOs, and a ring modulator. It’s also got a little mixer built-in, and a keyboard. The keyboard has CV and gate outputs.

It’s a mind-blowing piece of work, and makes me wonder if we’ll ever see the likes of the Korg and Yamaha iOS apps ported to browsers.

Intravenous

Intravenous (GitHub: RoyJacobs / intravenous, License: MIT, npm: intravenous) by Roy Jacobs is an inversion of control library for browsers and Node. It’s distributed as a CommonJS module, but it’ll also work with AMD and in browsers without AMD. The idea behind this library is to reduce coupling between components by using a system of containers that help manage object lifecycles and manage their relationships. Containers can be nested, which seems like it would help manage objects in single page applications.

Containers are created, then services are registered with them, then classes can be defined along with their dependencies:

var container = intravenous.create();
container.register('logger', loggerClass);
container.register('someGlobalData', { data: 'hello' });

function ExampleClass(logger, someGlobalData) {
  /* use logger here */
}

ExampleClass.$inject = ['logger', 'someGlobalData'];
container.register('ExampleClass', ExampleClass);

There’s a lot more to it, but the author has written detailed examples in the project’s documentation.

Sindre’s Grunt Tasks

Sindre Sorhus has been writing quite a few Grunt tasks:

• grunt-recess – lint and minify CSS or LESS using Twitter’s RECESS module
• grunt-sass – Compile SASS and SCSS using libsass
• grunt-sizediff – Show the difference between file sizes in the current git branch and a branch/commit
• grunt-shell – Run shell commands

Countly

Countly (GitHub: Countly / countly-server, License: Countly Community Edition License) from the Countly team based in Turkey is a mobile analytics server that has SDKs for iOS and Android. The web interface and API are separated into two applications – the front-end is built with Express, and the API is a lightweight server. MongoDB is used to store data and sessions. The Express application is a fairly straightforward monolithic implementation.

In terms of client-side code, the Express app uses ejs for templates, and jQuery UI.

The authors have included an installation script, bin/countly.install.sh, which helps get the server-side component up and running. If you want to try it out without installing it, there’s a demo on count.ly.

Prelude.ls

Prelude.ls (GitHub: gkz / prelude-ls, License: MIT, npm: prelude-ls) by George Zahariev is a functional programming library written with LiveScript, which is a bit like a more functional CoffeeScript.

The author has provided examples of every single function the library provides in both JavaScript and LiveScript. All functions are curried, so supplying an incomplete list of arguments will return a partially applied function:

var takeFour = take(4);
takeFour('hello there'); //=> 'hell'

The API feels quite lightweight in places because certain functions accept objects where a function might be used in similar libraries:

reject([false, true], {a: 0, b: 1, c: 0});
//=> {a: 0, c: 0}

The author has included tests written with LiveScript.

fibonacci-async

fibonacci-async (License: MIT, npm: fibonacci-async) by Enno Boland is a response to certain well-known blog posts berating Node’s performance at potentially unfair benchmarks. It’s an asynchronous C++ Fibonacci series generator, which strikes me as something potentially useful as an educational example for those interested in writing Node addons.

Broom

Broom (License: MIT, npm: broom) by Bolgov Roman is an “application-level flow control library”. It’s designed to help split applications into small modules that can be executed in parallel or in serial. The intent is to help avoid using too many deeply nested callbacks, but to also make it easier to write tests.

The reason I think Broom is interesting is the author has combined flow control concepts with separation of concerns to address program design at a high level. Although there are a lot of flow control libraries, I think we need more effort in application architecture.

cmbn

cmbn (License: MIT, npm: cmbn) by Gamaiel Zavala allows client-side assets to be served from a single URL. It comes with middleware that will work with Express. Rather than making requests to several CDNs, URLs can be generated that look like this:

http://cmbn.us/~cj;require.js,1.0.8,require.min.js/~gg;jquery,1.7.2,jquery.min.js

The author suggests using this with CloudFlare CDN to improve performance.

archie

archie (License: Apache 2.0, npm: archie) by Ian Macalinao is an “archetype system”. Given a folder, archie will replace values within each file, then output a new folder with these changes. It can be used as a command-line tool like this:

archie gen -a simple -n myproject

The author has based this module on Apache Maven, which uses archetypes for project templating.

Templato

Templato (License: MIT, npm: templato) by Vadim Demedes is a unified API for several templating modules that also works in browsers. It currently works with EJS, Eco, Jade, and Mustache.

The author has included Mocha tests, and these will run in a browser as well.

Joconut

Joconut (License: MIT) by Vadim Demedes is an alternative implementation of Chris Wanstrath’s pjax plugin. Joconut is about 1K smaller (I compared them both gzipped and minified myself), and it also loads JavaScript and CSS automatically.

Adding Joconut to a page will cause requests to the current host to load using $.ajax. To maintain history, it uses history.pushState, and degrades to onhashchange. Several internal events can be bound to, which is useful for things like error handling:

$.joconut.on('error', function() {
  alert('Error while loading new page!');
});

Stupid jQuery Table Sort

Stupid jQuery Table Sort (GitHub: joequery / Stupid-Table-Plugin, License: MIT) by Joseph McCullough is a simple table sorting plugin based around Array.prototype.sort:

As long as you understand basic JavaScript sorting, you can make this plugin do as much or as little as you want.

Callbacks can be supplied for custom sorting based on type. In Joseph’s example, he’s set a th class of type-date, then passed in a date callback:

$('#complexTable').stupidtable({
  'date': function(a,b) {

jQuery.pushevent

jQuery.pushevent (License: GPL) by “yeikos” helps manage the order events will be fired. This example causes the order of the events to be swapped:

$('button').on('click.first', function() {
  alert('1');
}).on('click.second', function() {
  alert(2);
}).pushEvent('click.second');

The author also sent in two more plugins:

• jQuery.placeholder – A placeholder attribute implementation
• jQuery.unparam – Uses decodeURIComponent to convert URL param strings into objects

The ECMAScript 5.1 specification defines the behaviour of calling “built-in” constructors as if they were functions. That means not only can new Array(1, 2) be used, but also Array(1, 2):

When Array is called as a function rather than as a constructor, it creates and initialises a new Array object. Thus the function call Array(...) is equivalent to the object creation expression new Array(...) with the same arguments.

– 15.4.1 The Array Constructor Called as a Function

Object() is documented as performing a type conversion, and String() also does this:

var a = new String(1);
// { '0': '1' }
var b = String(1);
// '1'

The Date constructor technically performs a type conversion, but this is sometimes a source of confusion for beginners who just want a readable string representation of a date:

var a = new Date(2012, 0, 1);
// Sun, 01 Jan 2012 00:00:00 GMT
Date(2012, 0, 1)
// 'Sun Jun 10 2012 11:28:03 GMT+0100 (BST)'

In the first case, a Date object is returned, in the second a primitive string value is returned instead.

Returning Objects from Constructors

In section 13.2.2, the behaviour of returning objects from constructors is defined:

If Type(result) is Object then return result.

This prevents the constructor from returning an instance, so another object can be returned instead.

function Shape() {
  return {
    x: 1, y: 1
  };
}

Shape.prototype = {
  move: function() {}
};

var shape = new Shape();
shape.move();
// TypeError: Object #<Object> has no method 'move'

It’s possible to use instanceof to determine if the constructor has been called as a function:

function Shape() {
  if (this instanceof Shape) {
    // An object is being instantiated
  } else {
    return {
      a: 'b'
    };
  }
}

Shape.prototype = {
  move: function() {}
};

var shape = new Shape();
shape.move();

Shape(); // Returns { a: 'b' }

jQuery uses a similar approach to instantiate jQuery.Event objects without requiring the new keyword:

jQuery.Event = function( src, props ) {
  // Allow instantiation without the 'new' keyword
  if ( !(this instanceof jQuery.Event) ) {
    return new jQuery.Event( src, props );
  }

This factory-style behaviour may suit certain APIs – Dojo also uses it in NodeList.

Conclusion

Calling built-in constructors as functions is used for type conversion, but some constructors behave as if the new keyword had been used. To avoid bugs caused by missing new keywords, try to remember that these forms are not equivalent.

When writing constructors, this behaviour can be exploited to create factory-like APIs. That’s because it’s possible to detect when a constructor has been called as a function.

To read more about this topic, searching the ECMAScript specification for “called as a function” is a good starting point.

Physijs Tutorial

Jerome Etienne has written some introductory tutorials on physics and WebGL. In 3D Physics With Three.js and Physijs, he discusses using Physijs with his tQuery project.

The tutorial includes creating a world with lighting, textures, object spawning, and using collision events.

SCION

SCION (License: Apache 2, npm: scion) by Jacob Beard is an implementation of State Chart XML (SCXML).

SCXML provides a declarative markup for Statecharts, a powerful modelling language for developing complex, timed, reactive, state-based systems, and can offer elegant solutions to many problems faced in development of JavaScript-based applications across various domains.

The project’s documentation demonstrates how to use SCXML to implement drag and drop in browsers using XML. SCION can load this XML with scion.urlToModel, then interpret it and connect the relevant event listeners in an asynchronous callback. The project also works with Rhino 1.7R3.

mmd

mmd by Alex Lawrence is a small patch to enable AMD modules to function when an AMD implementation isn’t available (or perhaps desired). When the author sent us this project he lamented the fact it’s 143 characters long – three characters over a tweet’s limit.

Can anyone make it shorter?

Sorting - We’re Doing It Wrong

Rodney Rehm has written a detailed guide to sorting in JavaScript: Sorting - We’re Doing It Wrong. He covers sorting different types, sorting strings, sorting DOM elements, boosting jQuery’s performance, and more besides.

The post has some interesting comments about the finer points raised in the article, and Rodney has included some benchmarks on jsPerf.

Node 0.8 will be released soon:

v0.8 is around the corner. There’s only 1, maybe 2 more 0.7 releases, and then we’re going stable. Test your stuff against master now!

– @nodejs

The API changes are relatively straightforward, as we’ve seen with previous Node releases.

If you’ve been following our Windows and Node posts, then of particular interest is the move to node-gyp as the addon build system. This makes building addons easier for Windows users, but at the same time more people are starting to bundle binaries. I’ve found a few node-gyp modules that build successfully in Windows while researching articles for DailyJS, so hopefully the transition won’t be too painful.

Domains will be included in 0.8 – notice how the documentation already refers to 0.8. I remember reading about domains in Ryan Dahl’s Node v0.8 roadmap:

Domains provide a lightweight isolation mechanism for all i/o related to a particular network connection (e.g. an incoming http request). If an unhandled error is encountered, all i/o local to that particular domain is canceled and all handles are cleaned up.

Isaac Schlueter said it’s likely that 0.8 will include V8 v3.10 rather than 3.11. The last time I checked, Node 0.6 was on V8 3.6.6.25, and since then V8 has seen performance improvements, bug fixes, and better ECMAScript 5 conformance.

Preparations

• If you’re a module author, now is a good time to migrate node-waf projects to node-gyp
• If possible, tag or branch the last working 0.6 version of your modules so people can still install a legacy version – it’s awkward to run multiple versions of Node in Windows
• Ensure your test suites pass, and follow the API changes to convert legacy code
• Update your package.json files to refer to the correct version of Node under the engines property

Boxcars

Boxcars (npm: boxcars) by Azer Koçulu is a library for fetching remote or local resources:

boxcars('http://google.com', '/var/log/foo.log', 'http://github.com')(function(error, homepages) {
  // Prints the homepage of google.com
  console.log(homepages[0]);
});

It can also be used to define collections of resources, or cache them through preloading. The author has included tests written with his highkick and lowkick modules.

password-reset

password-reset (License: MIT/X11, npm: password-reset) by James Halliday is middleware for dealing with password resets that will work with Express.

It’s built with James’ pony module which sends emails, and a full example including the required Express routes is included in the project’s documentation.

Kraken

Kraken (License: MIT, npm: kraken) by Przemek Matylla is a client for the Kraken Web Optimizer.

Image URLs or uploads can be optimised using this module, and a Kraken Account is required to use it.

Kraken itself was built with Node, and there are a few details about their implementation on the Kraken About page.

jQuery++

jQuery++ (GitHub: jupiterjs / jquerypp) from Chicago-based JavaScript consulting firm Bitovi, is a collection of DOM and event-related jQuery plugins. The project’s site has a tool for creating a single file that contains all of the plugins that you want, but they can also be loaded using an AMD module loader like RequireJS.

Highlights include a CSS3 version of $.fn.animate, a text range plugin, swipe gesture support, and a version of jQuery.event.fix that uses ECMAScript 5 getters.

There are discussions about the project on Hacker News:

• Introducing jQuery++ (bitovi.com)
• jQuery++ (jquerypp.com)

Wtwui

Wtwui (GitHub: wtw-software / wtwui, License: MIT) from WTW Software is a collection of UI widgets influenced by UIKit by TJ Holowaychuk. It currently includes a dialog, overlays, tooltips, and a confirmation box. It’s built using AMD, so each component can be loaded using RequireJS.

The project is tested with Jasmine, and it includes a build script built with Node.

jSignature

jSignature (GitHub: willowsystems / jSignature, License: MIT) is a fork of brinley / jSignature with additions and tweaks by Daniel Dotsenko.

jSignature allows signatures to be captured in a browser, and works on touchscreen devices as well. Older version of IE are supported by FlashCanvas. A special effort has been made to capture smooth-looking signatures, and it supports extra editing options like undoing the last stroke.

The inheritance examples we looked at last week used the form Rectangle.prototype = new Shape(). The reason I like this example is it shows how powerful prototypes are, despite their simplicity. The downside is the constructor for the parent object is executed, which isn’t always what’s desired.

ECMAScript 5 introduced Object.create, which creates new objects based on a prototype object and an additional set of properties.

The main differences between B.prototype = new A(); and B.prototype = Object.create(A.prototype) are as follows:

• The constructor, A isn’t called, so B remains uninitialised until instantiated
• Object.create accepts a second argument that causes Object.create to behave as if Object.defineProperties was called

Using Object.create

Last week’s Shape example could be rewritten to use Object.create:

function Shape() {
  this.x = 0;
  this.y = 0;
  console.log('Shape constructor called');
}

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;
  }
};

// Rectangle
function Rectangle() {
  console.log('Rectangle constructor called');
  this.x = 0;
  this.y = 0;
}

Rectangle.prototype = Object.create(Shape);

Now rectangles can be created with var rect = new Rectangle() and the original Shape constructor won’t be called. This leaves us with a cleaner prototype chain, but what if we still want to call the previous constructor? In this particular example, calling the Shape constructor is desirable because we’ll avoid duplicating some initialisation code.

Calling Constructors

By using the Function.prototype.call or apply methods, it’s entirely possible to call another constructor even when using Object.create. For example:

function Shape() {
  this.x = 0;
  this.y = 0;
  console.log('Shape constructor called');
}

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;
  }
};

// Rectangle
function Rectangle() {
  console.log('Rectangle constructor called');
  Shape.call(this);
}

Rectangle.prototype = Object.create(Shape.prototype);

The fact call and apply take a this parameter (known as ThisBinding in the ECMAScript specification) allows us to reuse constructors where required.

No Inheritance: Object.create(null)

By passing null to Object.create, objects can be created that don’t inherit from anything. By default Object.prototype is used, which has several built-in methods. What if we don’t want to inherit from Object.prototype?

function Shape() {
}

Shape.prototype = Object.create(null);

var shape = new Shape();
console.log(shape.toString);

In this example, undefined will be printed – objects created using the Shape constructor inherit from null.

Notice that this is not equivalent:

function Shape() {
}

Shape.prototype = null;

var shape = new Shape();
console.log(shape.toString);

This should print something like [Function: toString] rather than undefined.

It’s interesting to think about exactly why this is useful. In An Object is not a Hash, Guillermo Rauch discusses how the properties of Object.prototype can be used to potentially cause security issues, and Object.create(null) was suggested as a suitable means for creating a “clean” object to avoid the problem.

Another point is performance. These Object.create(null) benchmarks demonstrate iterating over various objects, and the Object.create(null) tests run faster than object literals.

However, be very careful when using this approach because so many libraries expect objects to have the standard methods.

The Second Argument to Object.create

According to the Annotated ECMAScript 5 Object.create documentation, passing a second argument behaves as if Object.defineProperties had been called. This method requires a bit of knowledge before it can be used – the properties have to be passed in the expected format.

In this example, Rectangle inherits from Shape and gets a property called animate at the same time:

Rectangle.prototype = Object.create(Rectangle.prototype, {
  animate: {
    value: function() {
      this.animating = true;
    }
  }
});

var rect = new Rectangle();

Now rect.animate() can be called, just like any other method. Notice that the second argument is in the form { propertyName: { value: function() {} } } – the value property is important and I haven’t arbitrarily picked it. These properties are known as property attributes.

Property attributes can be “named data” and “named attribute” properties. These additional flags can be applied to named data properties:

• writable: Determines if the property is writable
• enumerable: Should this property be included in for-in enumeration?
• configurable: If false, attempts to delete or change the property’s attributes will fail

Although this is new to ECMAScript 5, it adds a much desired level of control to properties and their definition.

Getters and Setters

Property attributes allow JavaScript to support getters and setters with a lightweight syntax:

function Rectangle() {
  this._animating = false;
}

Rectangle.prototype = Object.create(Shape.prototype, {
  animating: {
    get: function() {
      console.log('Rectangle.prototype.animating get');
      return this._animating;
    },

    set: function(value) {
      console.log('Rectangle.prototype.animating set');
      this._animating = value;
    }
  }
});

var rect = new Rectangle();

rect.animating = true;
console.log(rect.animating);

In this example I’ve renamed animating to _animating, but it can still be accessed using rect.animating because I’ve defined an animating property with a get and set method.

This makes it possible to track whenever this value is changed, as illustrated by the console.log calls.

In JavaScript implementations that don’t include Object.create, this second argument may not be supported. The ECMAScript 5 compatibility table by Kangax has a wide range of compatibility tests that can help you decide if it’s safe to use it.

Update Notes

This article has been updated using feedback from the following readers:

• Sean – Accuracy issues
• Marcel Laverdet – Object.create(null)
• Ghasem Kiani – Issues with my “super” example (removed)
• Ti – typo (active should have been animating)

TypedFunc

TypedFunc (License: MIT, npm: TypedFunc) by Christopher de Beer is an interesting library for creating typed functions in JavaScript. By using a chainable API, functions can be created that will validate their inputs automatically:

var TypedFunc = require('TypedFunc');

var setName = (new TypedFunc()).throws('string', {}, function(name) {
  console.log('Setting name:', name);
  return name;
});

setName('alex');
setName(1);

The last call, setName(1), will raise an exception like this:

Error: Invalid Function type. Should return string but returned number.

TypedFunc can also support Node’s function(err, value) style of callbacks, rather than throwing an exception.

HTML5 Rubik’s Cube

This HTML5 Rubik’s Cube by Diego Ferreiro Val uses YUI and CSS transformations to create a 3D Rubik’s Cube. It can also solve itself, and the arrow buttons will undo or redo the last move.

The author has written a detailed tutorial about how he developed it here: Tutorial: Rubik’s cube with HTML5 (CSS3 + JavaScript).

Backbone-Require-Boilerplate

I know there’s a lot of boilerplates out there, but Greg Franko has put a lot of effort into Backbone-Require-Boilerplate (License: MIT).

It’s designed to encourage sharing code between desktop and mobile sites, and includes a recent version of RequireJS that supports loading non-AMD libraries.

Windows has event logs with three categories: System, Application, and Security. These are known as “sources” in Windows terminology, and since NT 4.0 it’s been possible to create custom sources as well. Pretty much every version of Windows I’ve ever seen has included an Event Viewer utility, which can be used to view and manipulate logs.

Event logs are useful in Windows for the same reasons as syslog in Unix. Logging messages from background services is one of the most obvious examples, particularly as Node seems like a promising platform for developing Windows services.

In Node this requires an addon, because native bindings are needed to communicate with the eventlog service. Windows Event Log Js (GitHub: jfromaniello / windowseventlogjs, License: MIT, npm: windows-eventlog) by José F. Romaniello is one such addon.

On a related note, José has also written a great tutorial on how to create Node addons for Windows using Visual Studio, it’s got detailed instructions and screenshots with full sample code: Writing your first native module for node.js on Windows.

To use this module open cmd.exe and install the module:

npm install windows-eventlog

Now create a simple script to write some test messages:

var EventLog = require('windows-eventlog').EventLog
  , logger = new EventLog('dailyjs-logs');

logger.log('Hello from DailyJS');

This won’t run yet, however. Start another cmd.exe, but this time right-click the icon and select “Run as administrator”:

Now the example above should run correctly. Open Event Viewer, then select “Windows Logs”, “Application”, and look for logs with the source dailyjs-logs (assuming you didn’t change it). You should see something like this:

If portability with existing Unix software is required, then check out José’s transport for Winston that uses this module.

Blade

Blade (License, npm: blade) by Blake Miner is a Jade-inspired template compiler:

In Blade, there are no “mixins” or partial templates. There are only functions, and they work just like regular JavaScript functions that you’ve come to know and love.

It’s based on PEG.js and UglifyJS. I think it’s extremely interesting to see a Jade-like PEG (parsing expression grammar), which is in blade-grammer.pegjs.

The functions that Blade produces take a callback that gets an error and HTML, so in that sense the API feels idiomatic:

tmpl({
    'nav': {
        'Home': '/',
        'About Us': '/about',
        'Contact': '/contact'
    }
}, function(err, html) {
    if(err) throw err;
    console.log(html);
});

The author has also included Express middleware, client-side support, and there are some simple unit tests as well.

HighKick

HighKick (npm: highkick) by Azer Koculu is a lightweight test runner. It’ll take a module and execute any method that starts with test, which is more similar to the CommonJS Unit Testing specification than most of the popular Node test frameworks.

Functions can be run before and after each test, or the entire module. There’s also an asynchronous mode for running tests asynchronously.

Azer has been using it to test his own modules, so you can check out some of his examples on GitHub.

Spellcheck

Spellcheck (License: MIT, npm: spellcheck) by Brian White is an asynchronous Hunspell addon. This is the same library that OpenOffice uses, as well as Chrome.

You’ll need dictionaries and affix files to get it to work, and the author has provided a link to these at the OpenOffice Wiki, under Dictionaries.

jquery.cookieConsent

jquery.cookieConsent (License: MIT) by Tom Ashworth is a drop-in plugin for satisfying new EU policies regarding cookies. By running $.cookieConsent(), this plugin will display a banner. Once the banner is clicked, a cookie called cookieConsent will be set so the banner won’t need to annoy the visitor again.

The irony of setting a cookie to hide a message informing users about the use of cookies is amusing, but that’s not Tom’s fault so much as the nature of the beast.

Timing

Timing (GitHub: creativecouple / jquery-timing, License: MIT) by Peter Liske is a wrapper around setTimeout and other timer functions. It has a chainable API, so it’s easy to create complex scenarios without too much code:

$.wait(1000,'myQueue').now(first).wait(1000).now(second);

Tagit

Tagit (GitHub: hailwood / jQuery-Tagit, License: CC BY-SA 3.0) by Matthew Hailwood uses jQuery UI’s Autocomplete to present an alternative way of entering lists. Features include:

• Automatically adding partially typed tags if the control loses focus
• Friendly behaviour when deleting tags
• Sortable items using drag and drop

The sortable version only requires a single option to work:

$(selector).tagit({ tagSource: ['one', 'two', 'three'], sortable: 'handle' });

It’s quite easy to theme this plugin, and the author has kindly bundled quite a few CSS files.

Inheritance Chains and Constructors

As we saw last week, JavaScript objects have a prototype property, which is designed to facilitate inheritance. An object’s prototype property can be set to an instance of another object to create an inheritance chain:

function Shape(name) {
  this.x = 0;
  this.y = 0;
  this.name = name;
  console.log('Shape constructor called');
}

Shape.prototype = {
  move: function(x, y) {
    this.x += x;
    this.y += y;
  },

  toString: function() {
    return 'name: ' + this.name + ', at x: ' + this.x + ', y:' + this.y;
  }
};

// Rectangle
function Rectangle(name) {
  this.name = name;
  console.log('Rectangle constructor called');
}

Rectangle.prototype = new Shape();

var rect = new Rectangle('Player 1');
rect.move(1, 1);
console.log(rect.toString());
console.log(rect instanceof Rectangle);

Running this will display the following output:

Shape constructor called
Rectangle constructor called
name: Player 1, at x: 1, y:1
true

Notice that both the Shape and Rectangle constructors are called. This is because of the line Rectangle.prototype = new Shape(); – the parent object’s constructor isn’t actually automatically called as a result of new Rectangle(). This is why I’ve duplicated the this.name = name line in both constructors.

Also notice that rect.move and rect.toString call the methods from Shape.prototype. When the interpreter checks for a property, it will examine the current object for it. If no such property is found, the prototype for the object is checked, and so on. This is the prototype chain:

First the object mentioned directly is examined for such a property; if that object contains the named property, that is the property to which the reference refers; if that object does not contain the named property, the prototype for that object is examined next; and so on.

– Annotated ECMAScript 5.1

Calling Parent Methods

If we wanted Rectangle to have a different move method, but reuse the original in Shape, then it’s entirely possible to do so using Function.prototype.apply:

Rectangle.prototype.move = function(x, y) {
  console.log('Super method called');
  Shape.prototype.move.apply(this, arguments);
};

Even though Shape.prototype.move.apply looks complicated, it’s actually very simple if we break it down:

1. We want to call the move method from Shape
2. This method is stored in Shape.prototype.move
3. Since this is a Function, there are several methods available to us (functions are objects!)
4. The apply method in particular allows us to call the function without creating a new instance
5. It also allows us to provide our own value for this, and an array of arguments

The arguments object is created by the interpreter when a function is executed. The this object is a whole other story – so far I’ve been assuming you have intuitively understood what it is, but we’ll look at it in more detail in the next part.

References

• Annotated ECMAScript 5.1
• MDN documentation for apply

tablesort.js

tablesort.js (GitHub: tristen/tablesort, npm / Ender: tablesort) by Tristen Brown is a dependency-free sorting library for HTML tables. tablesort.js can be invoked stand-alone via new Tablesort(document.getElementById('table-id')) or $('#table-id').tablesort() method from within Ender.

Olivier Vaillancourt has written a small review of tablesort.js for use in Ender on Twitter Bootstrap tables.

Moment.js

Moment.js (GitHub: timrwood/moment, npm / Ender: moment) by Tim Wood is small, yet very comprehensive date and time handling library.

Moment.js was mentioned last year on DailyJS but it now has a simple Ender bridge allowing you to pack it neatly into Ender builds for use via $.ender(). Plus, it’s an absolutely fantastic library for anything date/time related so it’s worth mentioning again. Be sure to scan the docs to see just how much this library can do.

$.moment().add('hours', 1).fromNow(); // "1 hour ago"

// manipulate
$.moment().add('days', 7).subtract('months', 1).year(2009).hours(0).minutes(0).seconds(0);

// parse dates in different formats
var day = $.moment("12-25-1995", "MM-DD-YYYY");

var a = $.moment([2010, 1, 14, 15, 25, 50, 125]);
a.format("dddd, MMMM Do YYYY, h:mm:ss a"); // "Sunday, February 14th 2010, 3:25:50 pm"
a.format("ddd, hA"); // "Sun, 3PM"

// operate on different 'moment' objects
var a = $.moment([2007, 0]);
var b = $.moment([2008, 5]);
a.diff(b, 'years'); // 1
a.diff(b, 'years', true); // 1.5

The project maintainers also follow a rigorous release methodology, making great use of git branches, something that is not often found on smaller open source libraries.

jwerty

jwerty (GitHub: keithamus/jwerty, Licence: MIT, npm / Ender: jwerty) by Keith Cirkel is a small keyboard event handling library which can bind, fire and assert key combination strings against elements and events.

$.key('ctrl+shift+P', function () { [...] });
$.key('⌃+⇧+P', function () { [...] });

// specify optional keys
$.key('⌃+⇧+P/⌘+⇧+P', function () { [...] });

// key sequences
$.key('↑,↑,↓,↓,←,→,←,→,B,A,↩', function () { [...] });

// pass in a selector to bind a shortcut local to that element
$.key('⌃+⇧+P/⌘+⇧+P', function () { [...] }, 'input.email', '#myForm');

// use `$.event` as a decorator, to bind events your own way
$('#myinput').bind('keydown', $.keyEvent('⌃+⇧+P/⌘+⇧+P', function () { [...] }));

// use `$.isKey` to check a key combo against a keyboard event
function (event) {
    if ( $.isKey('⌃+⇧+P', event) ) { [...] }
}

// use `$.fireKey` to send keyboard events to other places
$.fireKey('enter', 'input:first-child', '#myForm');

SelectNav.js

SelectNav.js (GitHub: lukaszfiszer/selectnav.js, npm / Ender: selectnav.js) by Lukasz Fiszer is a small library that will convert your website’s navigation into a <select> menu. Used together with media queries it helps you to create a space saving, responsive navigation for small screen devices. SelectNav.js is inspired by TinyNav.js for jQuery.

ender-events and ender-assert

ender-events (GitHub: amccollum/ender-events, Licence: MIT, npm / Ender: ender-events) and ender-assert (GitHub: amccollum/ender-assert, Licence: MIT, npm / Ender: ender-assert) are two packages by Andrew McCollum, previously bundled in his node-compat library. ender-events gives you an implementation of the NodeJS EventEmitter class in your browser, while ender-assert gives you a browser version of the NodeJS assert module.

Andrew also has a tiny extension to Bonzo, the DOM utility included in Ender’s starter pack (The Jeesh), named ender-remove that simply triggers a ‘remove’ event when nodes are removed from the DOM. Which can be helpful for performing clean-up actions.

Categorizr.js

Categorizr.js (GitHub: Skookum/categorizr.js, Licence: MIT, npm / Ender: categorizr) by Dustan Kasten is a JavaScript port of the Categorizr PHP script by Brett Jankord.

Categorizr gives you $.isDesktop() $.isTablet() $.isTV() $.isMobile() methods to determine the current device.

Arbiter

Arbiter (GitHub: iamdustan/arbiter, Licence: MIT, npm / Ender: arbiter) also by Dustan Kasten is a tiny library for managing the HTML5 history interface via pushState(), using AJAX requests to load new content upon request.

I’ve been surveying popular Node modules and the nodejs Google Group to find common portability issues people have found when testing modules in Windows.

For the most part, Node code seems very portable – there are only a few problem areas that seem to crop up frequently. Let’s take a look at these problems and the solutions so we can write code that runs everywhere.

Platform-Specific Code

Despite Node code’s inherent portability, there are times when platform-specific code is required. This is dealt with in Node’s core modules like this:

var isWindows = process.platform === 'win32';

if (isWindows) {
  // Windows-specific code
}

This example is based on path.js.

For more detailed information on the operating system, the os module can come in handy.

File System

Windows can actually accept backslashes or forward slashes as a path separator. This means you don’t need to change all of your require calls to use different slashes; most things should just work. There are a few cases where we need to be careful, however, particularly if a path name is absolute or it’s going to be displayed somewhere.

One common issue I’ve found is where the developer has made certain assumptions about the structure of absolute paths. In a commit to Express, Fixed absolute path checking on windows, we can see where the authors have adapted a method called isAbsolute to support Windows:

exports.isAbsolute = function(path){
  if ('/' == path[0]) return true;
  if (':' == path[1] && '\\' == path[2]) return true;
};

Isaac Schlueter recommends using path.resolve to make relative paths absolute in a cross-platform way.

When dealing with fragments of paths, using path.join will automatically insert the correct slash based on platform. For example, the Windows version will insert backslashes:

var joined = paths.join('\\');

Notice that JavaScript strings require two backslashes because one acts as an escape, so when working with Windows path names don’t be surprised if there are lot of double slashes.

Another big source of Windows issues is fs.watch. This module is routinely used by programs that watch for file system changes. Node’s documentation makes it clear that the API isn’t portable, so the slower but more compatible fs.watchFile can be used instead.

In this patch for the Derby web framework, we can see where the developers opted to branch based on process.platform to use fs.watchFile in Windows, but fs.watch elsewhere.

Text Interfaces

Be aware that not everybody has a super-fancy UTF-8 terminal that supports colours. Certain programs depend on text output, but people may have trouble seeing it correctly if your program relies on symbols their terminal or font doesn’t support.

Mocha is a good example of such a program, and in the issue Ability to configure passed/failed checkmarks for the spec reporter, we can see where someone has struggled to read the output with cmd.exe.

Environment

Assuming certain environmental variables will exist (or mean the same thing) on every platform is a good way to create portability headaches.

James Halliday’s Browserify had its fair share of Windows issues, which was problematic due to several other popular modules depending on it.

This commit to Browserify demonstrates a fix Christopher Bennage submitted that replaces calls to process.env.HOME with the following:

var home = (process.env.HOME || process.env.USERPROFILE);

I tried this in Windows 7 and found process.env.HOME wasn’t set, but process.env.USERPROFILE worked as expected.

Sockets

Node’s TCP sockets are portable, but Unix domain sockets are not. However, Windows has named pipes. The following code is almost exactly the same as the Unix equivalent, it just has a different path to the named pipe:

var net = require('net');

net.createServer(function(socket) {
  console.log('Connected');
}).listen('\\\\.\\pipe\\named-pipe-test');

Notice the escaped backslashes – forgetting to insert them here will raise a confusing EACCESS error. In node/test/common.js, there’s a branch based on platform to set the name of the pipe so it works in Windows and Unix:

if (process.platform === 'win32') {
  exports.PIPE = '\\\\.\\pipe\\libuv-test';
} else {
  exports.PIPE = exports.tmpDir + '/test.sock';
}

References