A creative-commons book on Backbone.js for beginners and advanced users alike

#Backbone.js Fundamentals: How to write modular JavaScript apps for desktop and mobile

A work-in-progress by Addy Osmani released for free under a CC-license. My extended thanks to these members of the community for their tweaks and contributions.


  • Introduction

  • ####The Basics

  • Models

  • Views

  • Collections

  • Routers

  • Namespacing

  • Additional tips

  • ####Advanced

  • Building RESTful applications with Backbone

  • Stack 1: Using Node.js, Express, Mongoose and MongoDB

  • Modular JavaScript

  • Organizing modules with RequireJS and AMD

  • Keeping your templates external with the RequireJS text plugin

  • Optimizing Backbone apps for production with the RequireJS Optimizer

  • Practical: Building a modular Backbone app with AMD & RequireJS

  • Decoupling Backbone with the Mediator and Facade patterns

  • Backbone & jQuery Mobile

  • Practical: Building a modular mobile app with Backbone & jQuery Mobile

  • ####Testing (todo)

  • Jasmine basics

  • Models

  • Views

  • Collections

  • Routers

  • ####Resources


In this mini-book, I’ll be covering a complete run-down of Backbone.js; including models, views, collections and routers. I’ll also be taking you through advanced topics like modular development with Backbone.js and AMD (with RequireJS), how to solve the routing problems with Backbone and jQuery Mobile, tips about scaffolding tools that can save time setting up your initial application and more.

If this is your first time looking at Backbone.js and you’re still unsure whether or not to give it a try, why not take a look at how a Todo application might be implemented in Backbone and most of the other alternatives before reading further?

The goal of this mini-book is to create a free, centralized repository of information that can help those developing real-world apps with Backbone. If you come across a section or topic which you think could be improved or expanded on, please feel free to submit a pull-request. It won’t take long and you’ll be helping other developers avoid problems you’ve run into before.

##The Basics

###What is Backbone?

Backbone.js is one of a number of JavaScript frameworks for creating MVC-like web applications. On the front-end, it’s my architectural framework of choice as it’s both mature, relatively lightweight and can be easily tested using third-party toolkits such as Jasmine or QUnit. Other MVC options you may be familiar with include Ember.js (SproutCore 2.0), Spine, YUILibrary and JavaScriptMVC.

Backbone is maintained by a number of contributors, most notably: Jeremy Ashkenas, creator of CoffeeScript, Docco and Underscore.js. As Jeremy is a believer in detailed documentation, there’s a level of comfort in knowing you’re unlikely to run into issues which are either not explained in the official docs or which can’t be nailed down with some assistance from the #documentcloud IRC channel. I strongly recommend using the latter if you find yourself getting stuck.

###Why should you consider using it?

Backbone’s main benefits, regardless of your target platform or device, include helping:

  • Organize the structure to your application
  • Simplify server-side persistence
  • Decouple the DOM from your page’s data
  • Model data, views and routers in a succinct manner
  • Provide DOM, model and collection synchronization

In ways, the real question is why you should consider applying the MVC-pattern to your JavaScript projects and the one word answer is simply structure.

If opting to use jQuery, zepto or another querySelectorAll-based selection library to produce a non-trivial application it can become very easy to produce an unwieldy amount of code; that is - unless you have a plan for how you’re going to structure and organize your application. Separating concerns into models, views and controllers (or routers) is one way of solving this.

Remember that if you have experience with structuring applications using the MVVM (Model-View ViewModel) pattern, modules or otherwise, these are also equally as valid but do require you to know what you’re doing. For most single-page applications, I find that the MVC pattern works well so Backbone is a perfect fit for our needs.

##The Basics

In this section, you’ll learn the essentials about Backbone’s models, views, collections and routers. Whilst this isn’t meant as a replacement for the official documentation, it will help you understand many of the core concepts behind Backbone before we build mobile applications with it. I will also be covering some tips on effective namespacing.

  • Models
  • Collections
  • Routers
  • Views
  • Namespacing


Backbone models contain interactive data for an application as well as the logic around this data. For example, we can use a model to represent the concept of a photo object including its attributes like tags, titles and a location.

Models are quite straight-forward to create and can be constructed by extending Backbone.Model as follows:

Photo = Backbone.Model.extend({
    defaults: {
        src: 'placeholder.jpg',
        title: 'an image placeholder',
        coordinates: [0,0]
    initialize: function(){
        this.bind("change:src", function(){
            var src = this.get("src"); 
            console.log('Image source updated to ' + src);
    changeSrc: function( source ){
        this.set({ src: source });
var somePhoto = new Photo({ src: "test.jpg", title:"testing"});
somePhoto.changeSrc("magic.jpg"); // which triggers "change:src" and logs an update message to the console.


The initialize() method is called when creating a new instance of a model. It’s use is optional, however we’ll be reviewing some reasons you may want to use it shortly.

Photo = Backbone.Model.extend({
    initialize: function(){
        console.log('this model has been initialized');
/*We can then create our own instance of a photo as follows:*/
var myPhoto = new Photo();

####Getters & Setters


Model.get() provides easy access to a model’s attributes. Attributes which are passed through to the model on instantiation are instantly available for retrieval.

var myPhoto = new Photo({ title: "My awesome photo", 
                          location: "Boston", 
                          tags:['the big game', 'vacation']}),
    title = myPhoto.get("title"), //my awesome photo
    location = myPhoto.get("location"), //Boston
    tags = myPhoto.get("tags"), // ['the big game','vacation']
    photoSrc = myPhoto.get("src"); //boston.jpg

Alternatively, if you wish to directly access all of the attributes in an model’s instance directly, you can achieve this as follows:

var myAttributes = myPhoto.attributes;

It is best practice to use Model.set() or direct instantiation to set the values of a model’s attributes.

Accessing Model.attributes directly is generally discouraged. Instead, should you need to read or clone data, Model.toJSON() is recommended for this purpose. If you would like to access or copy a model’s attributes for purposes such as JSON stringification (e.g. for serialization prior to being passed to a view), this can be achieved using Model.toJSON():

var myAttributes = myPhoto.toJSON();
/* this returns { title: "My awesome photo", 
             location: "Boston", 
             tags:['the big game', 'vacation']}*/


Model.set() allows us to pass attributes into an instance of our model. Attributes can either be set during initialization or later on.

Photo = Backbone.Model.extend({
    initialize: function(){
        console.log('this model has been initialized');
/*Setting the value of attributes via instantiation*/
var myPhoto = new Photo({ title: 'My awesome photo', location: 'Boston' });
var myPhoto2 = new Photo();

/*Setting the value of attributes through Model.set()*/
myPhoto2.set({ title:'Vacation in Florida', location: 'Florida' });

Default values

There are times when you want your model to have a set of default values (e.g. in a scenario where a complete set of data isn’t provided by the user). This can be set using a property called defaults in your model.

Photo = Backbone.Model.extend({
        title: 'Another photo!',
        tags:  ['untagged'],
        location: 'home',
        src: 'placeholder.jpg'
    initialize: function(){
var myPhoto = new Photo({ location: "Boston", 
                          tags:['the big game', 'vacation']}),
    title   = myPhoto.get("title"), //Another photo!
    location = myPhoto.get("location"), //Boston
    tags = myPhoto.get("tags"), // ['the big game','vacation']
    photoSrc = myPhoto.get("src"); //placeholder.jpg

Listening for changes to your model

Any and all of the attributes in a Backbone model can have listeners bound to them which detect when their values change. This can be easily added to the initialize() function as follows:

this.bind('change', function(){
    console.log('values for this model have changed');

In the following example, we can also log a message whenever a specific attribute (the title of our Photo model) is altered.

Photo = Backbone.Model.extend({
        title: 'Another photo!',
        tags:  ['untagged'],
        location: 'home',
        src: 'placeholder.jpg'
    initialize: function(){
        console.log('this model has been initialized');
        this.bind("change:title", function(){
            var title = this.get("title");
            console.log("My title has been changed to.." + title);
    setTitle: function(newTitle){
        this.set({ title: newTitle });
var myPhoto = new Photo({ title:"Fishing at the lake", src:"fishing.jpg")});
myPhoto.setTitle('Fishing at sea'); 
//logs my title has been changed to.. Fishing at sea


Backbone supports model validation through Model.validate(), which allows checking the attribute values for a model prior to them being set.

It supports including as complex or terse validation rules against attributes and is quite straight-forward to use. If the attributes provided are valid, nothing should be returned from .validate(), however if they are invalid a custom error can be returned instead.

A basic example for validation can be seen below:

Photo = Backbone.Model.extend({
    validate: function(attribs){
        if(attribs.src == "placeholder.jpg"){
            return "Remember to set a source for your image!";
    initialize: function(){
        console.log('this model has been initialized');
        this.bind("error", function(model, error){
var myPhoto = new Photo();
myPhoto.set({ title: "On the beach" });


Views in Backbone don’t contain the markup for your application, but rather they are there to support models by defining how they should be visually represented to the user. This is usually achieved using JavaScript templating (e.g. Mustache, jQuery tmpl etc). When a model updates, rather than the entire page needing to be refreshed, we can simply bind a view’s render() function to a model’s change() event, allowing the view to always be up to date.

####Creating new views

Similar to the previous sections, creating a new view is relatively straight-forward. We simply extend Backbone.View. Here’s an example of a possible implementation of this, which I’ll explain shortly:

var PhotoSearch = Backbone.View.extend({
    el: $('#results'),
    render: function( event ){
        var compiled_template = _.template( $("#results-template").html() );
        this.el.html( compiled_template(this.model.toJSON()) );
        return this; //recommended as this enables calls to be chained.
    events: {
        "submit #searchForm":  "search",
        "click .reset": "reset",
        "click .advanced": "switchContext"
    search: function( event ){
        //executed when a form '#searchForm' has been submitted
    reset: function( event ){
        //executed when an element with class "reset" has been clicked.

####What is el?

el is basically a reference to a DOM element and all views must have one, however Backbone allows you to specify this in four different ways. You can either directly use an id, a tagName, className or if you don’t state anything el will simply default to a plain div element without any id or class. Here are some quick examples of how these may be used:

el: $('#results')  //select based on an ID or other valid jQuery selector.
tagName: 'li' //select based on a specific tag. Here el itself will be derived from the tagName
className: 'items' //similar to the above, this will also result in el being derived from it
el: '' //defaults to a div without an id, name or class.

Note: A combination of these methods can also be used to define el. For example:

tagName: "li",
className: "container"

will use specific tags with a particular className.

Understanding render()

render() is an optional function to define how you would like a template to be rendered. Backbone allows you to use any JavaScript templating solution of your choice for this but for the purposes of this book, we’ll opt for Underscore’s micro-templating.

The _.template method in underscore compiles JavaScript templates into functions which can be evaluated for rendering. In the above view, I’m passing the markup from a template with id results-template to be compiled. Next, I set the html for el (our DOM element for this view) the output of processing a JSON version of the model associated with the view through the compiled template.

Presto! This populates the template, giving you a data-complete set of markup in just a few short lines of code.

The events attribute

The Backbone events attribute allows us to attach event listeners to either custom selectors, or el if no selector is provided. An event takes the form {"eventName selector": "callbackFunction"} and a number of event-types are supported, including ‘click’, ‘submit’, ‘mouseover’, ‘dblclick’ and more.

What isn’t instantly obvious is that under the bonnet, Backbone uses jQuery’s .delegate() to provide instant support for event delegation but goes a little further, extending it so that this always refers to the current view object. The only thing to really keep in mind is that any string callback supplied to the events attribute must have a corresponding function with the same name within the scope of your view otherwise you may incur exceptions.


Collections are basically sets of models and can be easily created by extending Backbone.Collection.

Normally, when creating a collection you’ll also want to pass through a property specifying the model that your collection will contain as well as any instance properties required.

In the following example, we’re creating a PhotoCollection containing the Photo models we previously defined.

PhotoCollection = Backbone.Collection.extend({
    model: Photo

Getters and Setters

There are a few different options for retrieving a model from a collection. The most straight-forward is using Collection.get() which accepts a single id as follows:

var skiingEpicness = PhotoCollection.get(2);

Sometimes you may also want to get a model based on something called the client id. This is an id that is internally assigned automatically when creating models that have not yet been saved, should you need to reference them. You can find out what a model’s client id is by accessing its .cid property.

var mySkiingCrash = PhotoCollection.getByCid(456);

Backbone Collections don’t have setters as such, but do support adding new models via .add() and removing models via .remove().

var a = new Backbone.Model({ title: 'my vacation'}),
    b = new Backbone.Model({ title: 'my holiday'});

var photoCollection = new PhotoCollection([a,b]);

Listening for events

As collections represent a group of items, we’re also able to listen for add and remove events for when new models are added or removed from the collection. Here’s an example:

var PhotoCollection = new Backbone.Collection();
PhotoCollection.bind("add", function(photo) {
  console.log("I liked " + photo.get("title") + ' its this one, right? '  + photo.src);
  {title: "My trip to Bali", src: "bali-trip.jpg"},
  {title: "The flight home", src: "long-flight-oofta.jpg"},
  {title: "Uploading pix", src: "too-many-pics.jpg"}

In addition, we’re able to bind a change event to listen for changes to models in the collection.

PhotoCollection.bind("change:title", function(){
    console.log('there have been updates made to this collections titles');    

Fetching models from the server

Collections.fetch() provides you with a simple way to fetch a default set of models from the server in the form of a JSON array. When this data returns, the current collection will refresh.

var PhotoCollection = new Backbone.Collection;
PhotoCollection.url = '/photos';

Under the covers, Backbone.sync is the function called every time Backbone tries to read (or save) models to the server. It uses jQuery or Zepto’s ajax implementations to make these RESTful requests, however this can be overridden as per your needs.

In the above fetch example if we wish to log an event when .sync() gets called, we can simply achieve this as follows:

Backbone.sync = function(method, model) {
  console.log("I've been passed " + method + " with " + JSON.stringify(model));

Resetting/Refreshing Collections

Rather than adding or removing models individually, you occasionally wish to update an entire collection at once. Collection.reset() allows us to replace an entire collection with new models as follows:

  {title: "My trip to Scotland", src: "scotland-trip.jpg"},
  {title: "The flight from Scotland", src: "long-flight.jpg"},
  {title: "Latest snap of lock-ness", src: "lockness.jpg"}]);

###Underscore utility functions

As Backbone requires Underscore as a hard dependency, we’re able to use many of the utilities it has to offer to aid with our application development. Here’s an example of how Underscore’s sortBy() method can be used to sort a collection of photos based on a particular attribute.

var sortedByAlphabet = PhotoCollection.sortBy(function(photo)){
    return photo.get("title").toLowerCase();

The complete list of what it can do is beyond the scope of this guide, but can be found in the official docs.


In Backbone, routers are used to handle routing for your application. This is achieved using hash-tags with URL fragments which you can read more about if you wish. Some examples of valid routes may be seen below:

Note: A router will usually have at least one URL route defined as well as a function that maps what happens when you reach that particular route. This type of key/value pair may resemble:

"/route" : "mappedFunction"

Let us now define our first controller by extending Backbone.Router. For the purposes of this guide, we’re going to continue pretending we’re creating a photo gallery application that requires a GalleryRouter.

Note the inline comments in the code example below as they continue the rest of the lesson on routers.

GalleryRouter = Backbone.Router.extend({
    /* define the route and function maps for this router */
        "/about" : "showAbout",
        /*Sample usage:"*/
        "/photos/:id" : "getPhoto",
        /*This is an example of using a ":param" variable which allows us to match 
        any of the components between two URL slashes*/
        /*Sample usage:*/
        "/search/:query" : "searchPhotos"
        /*We can also define multiple routes that are bound to the same map function,
        in this case searchPhotos(). Note below how we're optionally passing in a 
        reference to a page number if one is supplied*/
        /*Sample usage:*/
        "/search/:query/p:page" : "searchPhotos",
        /*As we can see, URLs may contain as many ":param"s as we wish*/
        /*Sample usage:*/
        "/photos/:id/download/*imagePath" : "downloadPhoto",
        /*This is an example of using a *splat. splats are able to match any number of 
        URL components and can be combined with ":param"s*/
        /*Sample usage:*/
        /*If you wish to use splats for anything beyond default routing, it's probably a good 
        idea to leave them at the end of a URL otherwise you may need to apply regular
        expression parsing on your fragment*/
        "*other"    : "defaultRoute"
        //This is a default route with that also uses a *splat. Consider the
        //default route a wildcard for URLs that are either not matched or where
        //the user has incorrectly typed in a route path manually
        /*Sample usage:*/
    showAbout: function(){
    getPhoto: function(id){
        in this case, the id matched in the above route will be passed through
        to our function getPhoto and we can then use this as we please.
        console.log("You are trying to reach photo " + id);
    searchPhotos: function(query, page){
        console.log("Page number: " + page + " of the results for " + query);
    downloadPhoto: function(id, path){
        console.log("Invalid. You attempted to reach:" + other);
/* Now that we have a router setup, remember to instantiate it*/
var myGalleryRouter = new GalleryRouter;

Note: In Backbone 0.5+, it’s possible to opt-in for HTML5 pushState support via window.history.pushState. This effectively permits non-hashtag routes such as to be supported with automatic degradation should your browser not support it. For the purposes of this tutorial, we won’t be relying on this newer functionality as there have been reports about issues with it under iOS/Mobile Safari. Backbone’s hash-based routes should however suffice for our needs.


Next, we need to initialize Backbone.history as it handles hashchange events in our application. This will automatically handle routes that have been defined and trigger callbacks when they’ve been accessed.

The Backbone.history.start() method will simply tell Backbone that it’s OK to begin monitoring all hashchange events as follows:


As an aside, if you would like to save application state to the URL at a particular point you can use the .saveLocation() method to achieve this. It simply updates your URL fragment without the need to trigger the hashchange event.

/*Lets imagine we would like a specific fragment for when a user zooms into a photo*/
zoomPhoto: function(factor){
    this.zoom(factor); //imagine this zooms into the image
    this.saveLocation("zoom/" + factor); //updates the fragment for us


When learning how to use Backbone, an important and commonly overlooked area by tutorials is namespacing. If you already have experience with namespacing in JavaScript, the following section will provide some advice on how to specifically apply concepts you know to Backbone, however I will also be covering explanations for beginners to ensure everyone is on the same page.

####What is namespacing?

The basic idea around namespacing is to avoid collisions with other objects or variables in the global namespace. They’re important as it’s best to safeguard your code from breaking in the event of another script on the page using the same variable names as you are. As a good ‘citizen’ of the global namespace, it’s also imperative that you do your best to similarly not prevent other developer’s scripts executing due to the same issues.

JavaScript doesn’t really have built-in support for namespaces like other languages, however it does have closures which can be used to achieve a similar effect.

In this section we’ll be taking a look shortly at some examples of how you can namespace your models, views, routers and other components specifically. The patterns we’ll be examining are:

  • Single global variables
  • Object Literals
  • Nested namespacing
  • Single global variables

Single global variables

One popular pattern for namespacing in JavaScript is opting for a single global variable as your primary object of reference. A skeleton implementation of this where we return an object with functions and properties can be found below:

var myApplication = (function(){
      // ...
    return {
      // ...

which you’re likely to have seen before. A Backbone-specific example which may be more useful is:

var myViews = (function(){
    return {
        PhotoView: Backbone.View.extend({ .. }),
        GalleryView: Backbone.View.extend({ .. }),
        AboutView: Backbone.View.extend({ .. });

Here we can return a set of views or even an entire collection of models, views and routers depending on how you decide to structure your application. Although this works for certain situations, the biggest challenge with the single global variable pattern is ensuring that no one else has used the same global variable name as you have in the page.

One solution to this problem, as mentioned by Peter Michaux, is to use prefix namespacing. It’s a simple concept at heart, but the idea is you select a basic prefix namespace you wish to use (in this example, myApplication_) and then define any methods, variables or other objects after the prefix.

var myApplication_photoView = Backbone.View.extend({}),
myApplication_galleryView = Backbone.View.extend({});

This is effective from the perspective of trying to lower the chances of a particular variable existing in the global scope, but remember that a uniquely named object can have the same effect. This aside, the biggest issue with the pattern is that it can result in a large number of global objects once your application starts to grow.

For more on Peter’s views about the single global variable pattern, read his excellent post on them.

Note: There are several other variations on the single global variable pattern out in the wild, however having reviewed quite a few, I felt these applied best to Backbone.

Object Literals

Object Literals have the advantage of not polluting the global namespace but assist in organizing code and parameters logically. They’re beneficial if you wish to create easily-readable structures that can be expanded to support deep nesting. Unlike simple global variables, Object Literals often also take into account tests for the existence of a variable by the same name so the chances of collision occurring are significantly reduced.

The code at the very top of the next sample demonstrates the different ways in which you can check to see if a namespace already exists before defining it. I commonly use Option 3.

/*Doesn't check for existence of myApplication*/
var myApplication = {};
Does check for existence. If already defined, we use that instance.
Option 1:   if(!MyApplication) MyApplication = {};
Option 2:   var myApplication = myApplication = myApplication || {}
Option 3:   var myApplication = myApplication || {};
We can then populate our object literal to support models, views and collections (or any data, really):
var myApplication = {
    models : {},
    views : {
        pages : {}
    collections : {}

One can also opt for adding properties directly to the namespace (such as your views, in the following example):

var myGalleryViews = myGalleryViews || {};
myGalleryViews.photoView = Backbone.View.extend({});
myGalleryViews.galleryView = Backbone.View.extend({});

The benefit of this pattern is that you’re able to easily encapsulate all of your models, views, routers etc. in a way that clearly separates them and provides a solid foundation for extending your code.

This pattern has a number of useful applications. It’s often of benefit to decouple the default configuration for your application into a single area that can be easily modified without the need to search through your entire codebase just to alter them - Object Literals work great for this purpose. Here’s an example of a hypothetical Object Literal for configuration:

var myConfig = {
    language: 'english',
    defaults: {
        enableGeolocation: true,
        enableSharing: false,
        maxPhotos: 20
    theme: {
        skin: 'a',
        toolbars: {
            index: 'ui-navigation-toolbar',
            pages: 'ui-custom-toolbar'    

Note that there are really only minor syntactical differences between the Object Literal pattern and a standard JSON data set. If for any reason you wish to use JSON for storing your configurations instead (e.g. for simpler storage when sending to the back-end), feel free to.

For more on the Object Literal pattern, I recommend reading Rebecca Murphey’s excellent article on the topic.

Nested namespacing

An extension of the Object Literal pattern is nested namespacing. It’s another common pattern used that offers a lower risk of collision due to the fact that even if a namespace already exists, it’s unlikely the same nested children do.

Does this look familiar?


Yahoo’s YUI uses the nested object namespacing pattern regularly and even DocumentCloud (the creators of Backbone) use the nested namespacing pattern in their main applications. A sample implementation of nested namespacing with Backbone may look like this:

var galleryApp =  galleryApp || {};
/*perform similar check for nested children*/
galleryApp.routers = galleryApp.routers || {};
galleryApp.model = galleryApp.model || {};
galleryApp.model.special = galleryApp.model.special || {};
galleryApp.routers.Workspace   = Backbone.Router.extend({}); 
galleryApp.routers.PhotoSearch = Backbone.Router.extend({}); 
galleryApp.model.Photo      = Backbone.Model.extend({}); 
galleryApp.model.Comment = Backbone.Model.extend({}); 
/*special models*/
galleryApp.model.special.Admin = Backbone.Model.extend({});

This is both readable, organized and is a relatively safe way of namespacing your Backbone application in a similar fashion to what you may be used to in other languages.

The only real caveat however is that it requires your browser’s JavaScript engine first locating the galleryApp object and then digging down until it gets to the function you actually wish to use.

This can mean an increased amount of work to perform lookups, however developers such as Juriy Zaytsev (kangax) have previously tested and found the performance differences between single object namespacing vs the ‘nested’ approach to be quite negligible.


Reviewing the namespace patterns above, the option that I would personally use with Backbone is nested object namespacing with the object literal pattern.

Single global variables may work fine for applications that are relatively trivial, however, larger codebases requiring both namespaces and deep sub-namespaces require a succinct solution that promotes readability and scales. I feel this pattern achieves all of these objectives well and is a perfect companion for Backbone development.

###Additional Tips

####Automated Backbone Scaffolding

Scaffolding can assist in expediting how quickly you can begin a new application by creating the basic files required for a project automatically. If you enjoy the idea of automated MVC scaffolding using Backbone, I’m happy to recommend checking out a tool called Brunch.

It works very well with Backbone, Underscore, jQuery and CoffeeScript and is even used by companies such as Red Bull and Jim Bean. You may have to update any third party dependencies (e.g. latest jQuery or Zepto) when using it, but other than that it should be fairly stable to use right out of the box.

Brunch can easily be installed via the nodejs package manager and takes just little to no time to get started with. If you happen to use Vim or Textmate as your editor of choice, you may be happy to know that there are also Brunch bundles available for both.

####Clarifications on Backbone’s MVC

As Thomas Davis has previously noted, Backbone.js’s MVC is a loose interpretation of traditional MVC, something common to many client-side MVC solutions. Backbone’s views are what could be considered a wrapper for templating solutions such as the Mustache.js and Backbone.View is the equivalent of a controller in traditional MVC. Backbone.Model is however the same as a classical ‘model’.

Whilst Backbone is not the only client-side MVC solution that could use some improvements in it’s naming conventions, Backbone.Controller was probably the most central source of some confusion but has been renamed a router in more recent versions. This won’t prevent you from using Backbone effectively, however this is being pointed out just to help avoid any confusion if for any reason you opt to use an older version of the framework.

The official Backbone docs do attempt to clarify that their routers aren’t really the C in MVC, but it’s important to understand where these fit rather than considering client-side MVC a 1:1 equivalent to the pattern you’ve probably seen in server-side development.

####Is there a limit to the number of routers I should be using?

Andrew de Andrade has pointed out that DocumentCloud themselves usually only use a single controller in most of their applications. You’re very likely to not require more than one or two routers in your own projects as the majority of your application routing can be kept organized in a single controller without it getting unwieldy.

####Is Backbone too small for my application’s needs?

If you find yourself unsure of whether or not your application is too large to use Backbone, I recommend reading my post on building large-scale jQuery & JavaScript applications or reviewing my slides on client-side MVC architecture options. In both, I cover alternative solutions and my thoughts on the suitability of current MVC solutions for scaled application development.

Backbone can be used for building both trivial and complex applications as demonstrated by the many examples Ashkenas has been referencing in the Backbone documentation. As with any MVC framework however, it’s important to dedicate time towards planning out what models and views your application really needs. Diving straight into development without doing this can result in either spaghetti code or a large refactor later on and it’s best to avoid this where possible.

At the end of the day, the key to building large applications is not to build large applications in the first place. If you however find Backbone doesn’t cut it for your requirements I strongly recommend checking out JavaScriptMVC or SproutCore as these both offer a little more than Backbone out of the box. Dojo and Dojo Mobile may also be of interest as these have also been used to build significantly complex apps by other developers.

##Building RESTful applications with Backbone

In this section of the book, we’re going to take a look at developing RESTful applications using Backbone.js and modern technology stacks. When the data for your back-end is exposed through a purely RESTful API, tasks such as retrieving (GET), creating (POST), updating (PUT) and deleting (DELETE) models are made easy through Backbone’s Model API. This API is so intuitive in fact that switching from storing records in a local data-store (e.g localStorage) to a database/noSQL data-store is a lot simpler than you may think.

##Stack 1: Using Node.js, Express, Mongoose and MongoDB

The first stack we’ll be looking at is:

with Jade used optionally as a view/templating engine.

###Reviewing the stack

As you may know, node.js is an event-driven platform (built on the V8 runtime), designed for writing fast, scalable network applications. It’s reasonably lightweight, efficient and great for real-time applications that are data-intensive.

Express is a small web-development framework written with node.js, based on Sinatra. It supports a number of useful features such as intuitive views, robust routing and a focus on high performance.

Next on the list are MongoDB and Mongoose. MongoDB is an open-source, document-oriented database store designed with scalability and agility in mind. As a noSQL database, rather than storing data in tables and rows (something we’re very used to doing with relational databases), with MongoDB we instead store JSON-like documents using dynamic schemas. One of the goals of Mongo is to try bridging the gap between key-value stores (speed, scalability) and relational databases (rich functionality).

Mongoose is a JavaScript library that simplifies how we interact with Mongo. Like Express, it’s designed to work within the node.js environment and tries to solve some of the complexities with asynchronous data storage by offering a more user-friendly API. It also adds chaining features into the mix, allowing for a slightly more expressive way of dealing with our data.

Jade is a template engine influenced by Haml (which we’ll be looking at later). It’s implemented with JavaScript (and also runs under node). In addition to supporting Express out of the box, it boasts a number of useful features including support for mixins, includes, caching, template inheritance and much more. Whilst abstractions like Jade certainly aren’t for everyone, our practical will cover working both with and without it.


For this practical, we’re going to once again look at extending the popular Backbone Todo application. Rather than relying on localStorage for data persistance, we’re going to switch to storing Todos in a MongoDB document-store instead. The code for this practical can be found at:


(See here for the source)

We must first include the node dependencies required by our application. These are Express, Mongoose and Path (a module containing utilities for dealing with file paths.

var application_root = __dirname,
  express = require("express"),
  path = require("path"),
  mongoose = require('mongoose');

Next, create a new Express server. express.createServer() is a simple way of creating an instance of express.HTTPServer, which we’ll be using to pass in our routes.

var app = express.createServer();

After this, connect Mongoose up to a database (in our case, localhost should suffice). Should you require the ability to pass in authentication information, here’s a sample containing all of the supported URL parameters: mongodb://[username:[email protected]]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]


A Mongoose model for any Todo item can now be easily defined by passing a schema instance to mongoose.model. In our case the schema covers a Todo item’s text content, its done state and order position in the overall Todo list.

var Todo = mongoose.model('Todo', new mongoose.Schema({
  text: String,
  done: Boolean,
  order: Number

The configure() methods allows us to setup what we need for the current environment with our Express server. Note that lower down in the configuration are two view/view related lines. The last one explicitly sets the viewing/templating engine to be used as Jade app.set('view engine', 'jade'). We can avoid these if we wish to use plain HTML/JS for our templates instead.

  // the bodyParser middleware parses JSON request bodies
  app.use(express.static(path.join(application_root, "public")));
  app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
  app.set('views', path.join(application_root, "views"));
  app.set('view engine', 'jade')

Should would prefer to switch out Jade for an alternative view engine, this can be done fairly trivially. See the section under ‘Templating’ here: For example, to switch to EJS, you would simply write app.set('view engine', 'ejs')

Express makes use of commong HTTP verbs (get, put, post etc.) to provide easy to use, expressive routing API based on CRUD (Create, Read, Update and Delete). Below for example, we can define what happens when the browser requests the root ‘/’. As a trivial route in this application, it doesn’t do anything particularly exciting, however getters typically read or retrieve data.

app.get('/', function(req, res){
  res.send('Hello World');

Onto something a little more useful and in our next route, navigating to ‘/todo’ will actually render our Jade view ‘todo.jade’, as seen in the callback. Additional configuration values can be passed as the second parameter, such as the custom title specified below.

app.get('/todo', function(req, res){
  res.render('todo', {title: "Our sample application"});

Next, we can see the first of our ‘/api/’ routes.

app.get('/api/todos', function(req, res){
  return Todo.find(function(err, todos) {
    return res.send(todos);

The calback to our next route supports querying for todos based on a specific ID. The route string itself (once compiled) will be converted from ‘/api/todos/:id’ to a regular expression. As you might have guessed, this is a hint that routes can also be regular expression literals if we wished to do something more complex.

app.get('/api/todos/:id', function(req, res){
  return Todo.findById(, function(err, todo) {
    if (!err) {
      return res.send(todo);

Simplarly, we want to support updating todos based on a specific ID as well. The following allows us to query a todo by ID and then update the values of it’s three attributes (text, done, order) easily.

app.put('/api/todos/:id', function(req, res){
  return Todo.findById(, function(err, todo) {
    todo.text = req.body.text;
    todo.done = req.body.done;
    todo.order = req.body.order;
    return {
      if (!err) {
      return res.send(todo);

We’ve so far covered requesting todos and updating them, but a core part of the application requires us to insert (or add) new todos to our data-store. Below we can create new Todo models and simply save them.'/api/todos', function(req, res){
  var todo;
  todo = new Todo({
    text: req.body.text,
    done: req.body.done,
    order: req.body.order
  }); {
    if (!err) {
      return console.log("created");
  return res.send(todo);

We of course also want to support deleting todos (e.g if a todo has been ‘cleared’, it should be deleted). This also works based on a specific todo ID.

app.delete('/api/todos/:id', function(req, res){
  return Todo.findById(, function(err, todo) {
    return todo.remove(function(err) {
      if (!err) {
        return res.send('')

Finally, this last line is to ensure we’re only listening on the port app.js is running.


script.js - updating our Backbone.js app

In the /public/js folder of options 1 (HTML templates) and 2 (Jade) for the practical, you’ll find a version of the Backbone Todo app originally by Jerome Gravel-Niquet. Let’s pay attention to script.js. In order to change the application to work with our new back-end, we’ll need to make some very minor changes to this.

Reviewing window.TodoList (a Backbone Collection), you’ll notice that it has a property called localStorage, which uses the Backbone localStorage adapter in order to facilitate storing data using the browser’s localStorage features.

window.TodoList = Backbone.Collection.extend({

    // Reference to this collection's model.
    model: Todo,

    // Save all of the todo items under the `"todos"` namespace.
    // Typically, this should be a unique name within your application
    localStorage: new Store("todos"),

In order to switch it over to our RESTful backend, we’re going to make use of the url property or function on a collection to reference its location on the server. Models inside of a collection then use url to construct URLs of their own. As all of the CRUD for our RESTful API works on the base route ‘/api/todos’, this is the value we set url to.

    // localStorage: new Store("todos"),
    url: '/api/todos',

This is the only change necessary to our existing Backbone application in order to get things working. Pretty easy, right?


The Jade templates for our application cover declarative markup for both the index (layout.jade) of the application and the main Todo container (todo.jade). It also covers the script-tag templates used for rendering each new Todo item that’s added.

// Todo App Interface

    h1 Todos
      input#new-todo(placeholder="What needs to be done?", type="text")
      span.ui-tooltip-top(style="display:none;") Press Enter to save this task

// Templates
  <div class="todo <%= done ? 'done' : '' %>">
    <input class="check" type="checkbox" <%= done ? 'checked="checked"' : '' %> />
    input.todo-input(type="text", "value"="")

  <% if (total) { %>
    span.number <%= remaining %> 
    span.word <%= remaining == 1 ? 'item' : 'items' %>
    |  left.
  <% } %>
  <% if (done) { %>
      |  Clear
      span.number-done <%= done %>
      |  completed
      span.word-done <%= done == 1 ? 'item' : 'items' %>
  <% } %>


!!! 5
//if lt IE 8
  <html class="no-js ie6 oldie" lang="en"> 
//if IE 7
  <html class="no-js ie7 oldie" lang="en">
//if IE 8
  <html class="no-js ie8 oldie" lang="en">
//if gt IE 8
  <!--> <html class="no-js" lang="en"> <!--
  meta(http-equiv="X-UA-Compatible", content="IE=edge,chrome=1")

  meta(name="description", content="")
  meta(name="author", content="")
  meta(name="viewport", content="width=device-width,initial-scale=1")
  // CSS concatenated and minified via ant build script
  link(rel="stylesheet", href="css/style.css")
  // end CSS


  //! end of #container

    window.jQuery || document.write('<script src="js/libs/jquery-1.6.2.min.js"><\\/script>')

  // scripts concatenated and minified via ant build script
  script(defer, src="js/plugins.js")
  script(defer, src="js/script.js")
  // end scripts

  // Change UA-XXXXX-X to be your site's ID
    window._gaq = [['_setAccount','UAXXXXXXXX1'],['_trackPageview'],['_trackPageLoadTime']];
    Modernizr.load({load: ('https:' == location.protocol ? '//ssl' : '//www') + ''});

  //if lt IE 7


Alternatively, a static version of our index which doesn’t rely on Jade can be put together as follows. See here for the complete file or below for a sample.

 <div id="container">
    <div id="main" role="main">

      <!-- Todo App Interface-->

      <div id="todoapp">
        <div class="title">

        <div class="content">
          <div id="create-todo">
            <input id="new-todo" placeholder="What needs to be done?" type=
            "text" /><span style="display:none;" class="ui-tooltip-top">Press Enter to
            save this task</span>

          <div id="todos">
            <ul id="todo-list"></ul>

          <div id="todo-stats"></div>

    <!-- Templates-->

      <script id="item-template" type="text/template">
      <div class="todo <%= done ? 'done' : '' %>">
      <div class="display"><input class="check" type="checkbox" <%= done ? 'checked="checked"' : '' %> />
      <div class="todo-text"></div><span id="todo-destroy"></span></div><div class="edit"><input type="text" value="" class="todo-input"/></div></div>

      <script id="stats-template" type="text/template">
      <% if (total) { %>
      <span class="todo-count"><span class="number"><%= remaining %> </span><span class="word"><%= remaining == 1 ? 'item' : 'items' %></span> left.
      </span><% } %>
      <% if (done) { %>
      <span class="todo-clear"><a href="#"> Clear
      <span class="number-done"><%= done %></span> completed
      <span class="word-done"><%= done == 1 ? 'item' : 'items' %></span></a></span><% } %>


  <!--! end of #container-->

Practical Setup

We’ve now gone through the major points of developing a RESTful backend using Node.js, Express and Mongoose. Next, let’s make sure you can get your environment setup to run the updated Todo app.


Once you’ve downloaded MongoDB, you’ll need to complete two steps to get it up and running.

Data directories

MongoDB stores data in the bin/data/db folder but won’t actually create this directory for you. Navigate to where you’ve downloaded and extracted MongoDB and run the following from terminal:

sudo mkdir -p /data/db/
sudo chown `id -u` /data/db

Running and connecting to your server

Once this is done, open up two terminal windows.

In the first, cd to your MongoDB bin directory or type in the complete path to it. You’ll need to start mongod`.

$ ./bin/mongod

Next, in the second terminal, start the `mongo

$ ./bin/mongo

That’s it!.

####Express and Mongoose

Option 1 (HTML) and Option 2 (Jade) of the practical download both come with an bash script. This allows you to easily install Express, Mongoose, Jade (and optionally MongoDB if you prefer to) through npm (the node package manager).

  • Make sure you have Node.js installed. If not, you can grab it here
  • Next run $ ./ at the terminal to install the rest of our dependencies. To see the exact contents of the file, see below:

npm install express
npm install mongodb --mongodb:native
npm install mongoose
npm install jade
  • After you’ve installed all of the dependencies for the stack, we can get to cloning the repo containing our practicals and running them. Start by running the below lines:
git clone git://
cd option2
node app.js

For option1 (without Jade), simply cd into option1 and run node app.js from there.

Finally, either of the example apps can now be accessed by navigating to:

  • Option 1: http://localhost:3000/static.html
  • Option 2: http://localhost:3000/todo

That’s it! Whilst there’s a lot more than can be done to expand on the concepts covered so far, the base we’re reviewed should be enough to get you up and running with this stack if you wish to use them with Backbone.

In the next addition to this section (coming soon), we’ll take a look at a stack consisting of Ruby, Sinatra, Haml and more.

##Modular JavaScript

When we say an application is modular, we generally mean it’s composed of a set of highly decoupled, distinct pieces of functionality stored in modules. As you probably know, loose coupling facilitates easier maintainability of apps by removing dependencies where possible. When this is implemented efficiently, its quite easy to see how changes to one part of a system may affect another.

Unlike some more traditional programming languages however, the current iteration of JavaScript (ECMA-262) doesn’t provide developers with the means to import such modules of code in a clean, organized manner. It’s one of the concerns with specifications that haven’t required great thought until more recent years where the need for more organized JavaScript applications became apparent.

Instead, developers at present are left to fall back on variations of the module or object literal patterns. With many of these, module scripts are strung together in the DOM with namespaces being described by a single global object where it’s still possible to incur naming collisions in your architecture. There’s also no clean way to handle dependency management without some manual effort or third party tools.

Whilst native solutions to these problems will be arriving in ES Harmony, the good news is that writing modular JavaScript has never been easier and you can start doing it today.

In this next part of the book, we’re going to look at how to use AMD modules and RequireJS for cleanly wrapping units of code in your application into managable modules.

##Organizing modules with RequireJS and AMD

In case you haven’t used it before, RequireJS is a popular script loader written by James Burke - a developer who has been quite instrumental in helping shape the AMD module format, which we’ll discuss more shortly. Some of RequireJS’s capabilities include helping to load multiple script files, helping define modules with or without dependencies and loading in non-script dependencies such as text files.

So, why use RequireJS with Backbone? Although Backbone is excellent when it comes to providing a sanitary structure to your applications, there are a few key areas where some additional help could be used:

1) Backbone doesn’t endorse a particular approach to modular-development. Although this means it’s quite open-ended for developers to opt for classical patterns like the module-pattern or Object Literals for structuring their apps (which both work fine), it also means developers aren’t sure of what works best when other concerns come into play, such as dependency management.

RequireJS is compatible with the AMD (Asynchronous Module Definition) format, a format which was born from a desire to write something better than the ‘write lots of script tags with implicit dependencies and manage them manually’ approach to development. In addition to allowing you to clearly declare dependencies, AMD works well in the browser, supports string IDs for dependencies, declaring multiple modules in the same file and gives you easy-to-use tools to avoid polluting the global namespace.

2) Let’s discuss dependency management a little more as it can actually be quite challenging to get right if you’re doing it by hand. When we write modules in JavaScript, we ideally want to be able to handle the reuse of code units intelligently and sometimes this will mean pulling in other modules at run-time whilst at other times you may want to do this dynamically to avoid a large pay-load when the user first hits your application.

Think about the GMail web-client for a moment. When users initially load up the page on their first visit, Google can simply hide widgets such as the chat module until a user has indicated (by clicking ‘expand’) that they wish to use it. Through dynamic dependency loading, Google could load up the chat module only then, rather than forcing all users to load it when the page first initializes. This can improve performance and load times and can definitely prove useful when building larger applications.

I’ve previously written a detailed article covering both AMD and other module formats and script loaders in case you’d like to explore this topic further. The takeaway is that although it’s perfectly fine to develop applications without a script loader or clean module format in place, it can be of significant benefit to consider using these tools in your application development.

###Writing AMD modules with RequireJS

As discussed above, the overall goal for the AMD format is to provide a solution for modular JavaScript that developers can use today. The two key concepts you need to be aware of when using it with a script-loader are a define() method for facilitating module definition and a require() method for handling dependency loading. define() is used to define named or unnamed modules based on the proposal using the following signature:

    module_id /*optional*/, 
    [dependencies] /*optional*/, 
    definition function /*function for instantiating the module or object*/

As you can tell by the inline comments, the module_id is an optional argument which is typically only required when non-AMD concatenation tools are being used (there may be some other edge cases where it’s useful too). When this argument is left out, we call the module ‘anonymous’. When working with anonymous modules, the idea of a module’s identity is DRY, making it trivial to avoid duplication of filenames and code.

Back to the define signature, the dependencies argument represents an array of dependencies which are required by the module you are defining and the third argument (‘definition function’) is a function that’s executed to instantiate your module. A barebone module (compatible with RequireJS) could be defined using define() as follows:

// A module ID has been omitted here to make the module anonymous

define(['foo', 'bar'], 
    // module definition function
    // dependencies (foo and bar) are mapped to function parameters
    function ( foo, bar ) {
        // return a value that defines the module export
        // (i.e the functionality we want to expose for consumption)
        // create your module here
        var myModule = {
                console.log('Yay! Stuff');

        return myModule;

####Alternate syntax There is also a sugared version of define() available that allows you to declare your dependencies as local variables using require(). This will feel familiar to anyone who’s used node, and can be easier to add or remove dependencies. Here is the previous snippet using the alternate syntax:

// A module ID has been omitted here to make the module anonymous

        // module definition function
    // dependencies (foo and bar) are defined as local vars
    var foo = require('foo'),
        bar = require('bar');
        // return a value that defines the module export
        // (i.e the functionality we want to expose for consumption)
        // create your module here
        var myModule = {
                console.log('Yay! Stuff');

        return myModule;

The require() method is typically used to load code in a top-level JavaScript file or within a module should you wish to dynamically fetch dependencies. An example of its usage is:

// Consider 'foo' and 'bar' are two external modules
// In this example, the 'exports' from the two modules loaded are passed as
// function arguments to the callback (foo and bar)
// so that they can similarly be accessed

require(['foo', 'bar'], function ( foo, bar ) {
        // rest of your code here

Wrapping modules, views and other components with AMD

Now that we’ve taken a look at how to define AMD modules, let’s review how to go about wrapping components like views and collections so that they can also be easily loaded as dependencies for any parts of your application that require them. At it’s simplest, a Backbone model may just require Backbone and Underscore.js. These are considered it’s dependencies and so, to write an AMD model module, we would simply do this:

define(['underscore', 'backbone'], function(_, Backbone) {
  var myModel = Backbone.Model.extend({

    // Default attributes 
    defaults: {
      content: "hello world",

    // A dummy initialization method
    initialize: function() {
      if (!this.get("content")) {
        this.set({"content": this.defaults.content});

    clear: function() {

  return myModel;

Note how we alias Underscore.js’s instance to _ and Backbone to just Backbone, making it very trivial to convert non-AMD code over to using this module format. For a view which might require other dependencies such as jQuery, this can similarly be done as follows:

”`javascript defi

Related Repositories



:book: A creative-commons book on Backbone.js for beginners and advanced users alike ...



A creative-commons book on Backbone.js for beginners and advanced users alike ...



Real-world example of Backbone's use. Meant to be used in conjunction with ...



A creative-commons book on Backbone.js for beginners and advanced users alike ...



A creative-commons book on Backbone.js for beginners and advanced users alike ...

Top Contributors

addyosmani JustinDrake boushley kjbekkelund aaronmcadam meirish scottwoodall ryanflorence andreymatveev benbabics Stompfrog