James is a freelance web developer based in the UK, specialising in JavaScript application development and building accessible websites. With more than a decade's professional experience, he is a published author, a frequent blogger and speaker, and an outspoken advocate of standards-based development.

James's articles

  1. Multi-threading in JavaScript

    No, you can’t really multi-thread in JavaScript, but James shows the advantages of simulating a multi-threaded environment when dealing with intensive code. Armed with the techniques in this article, the possibilities for what you can achieve with JavaScript are limitless!

  2. DesignFestival: JavaScript Design Patterns Deconstructed

    All sophisticated design patterns throw up the same fundamental question — is there a concrete advantage to using it in the first place? Without understanding the benefits, it could be very easy to think that it’s just a pointlessly verbose and over-engineered solution, or that it’s only following some kind of fashion. But there are real and important benefits to using this kind of pattern, and it isn’t an attempt to make JavaScript “more like” any other language, or to mimic classical inheritance.

  3. JavaScript Design Patterns Deconstructed

    All sophisticated design patterns throw up the same fundamental question — is there a concrete advantage to using it in the first place? Without understanding the benefits, it could be very easy to think that it’s just a pointlessly verbose and over-engineered solution, or that it’s only following some kind of fashion.

  4. DesignFestival: One JavaScript Design Pattern I Can’t Live Without

    I thought it might be interesting to look at a JavaScript design pattern that I use a great deal. I settled on it gradually, over a period of time, absorbing and adapting influences from various sources, until reaching a pattern that offers the flexibility I need. Let me show you an overview, and then look at how it comes together: function MyScript(){} (function() { var THIS = this; function defined(x) { return typeof x != ‘undefined’; } this.ready = false; this.init = function() { this.ready = true; }; this.doSomething = function() { }; var options = { x : 123, y : ‘abc’ }; this.define = function(key, value) { if(defined(options[key])) { options[key] = value; } }; }).apply(MyScript); As you can see from that sample code, the overall structure is a function literal: (function() { … })(); A function literal is essentially a self-executing scope, equivalent to defining a named function and then calling it immediately: function doSomething() { …

  5. One JavaScript Design Pattern I Can’t Live Without

    I thought it might be interesting to look at a JavaScript design pattern that I use a great deal. I settled on it gradually, over a period of time, absorbing and adapting influences from various sources, until reaching a pattern that offers the flexibility I need.

  6. The Ever-Increasing Uses of a Zoom Layout (Part 1)

    In the first of a two-part article, James examines an accessibility technique that benefits low-vision users, and shows how it also has a host of other uses, like providing for handheld devices, serial devices, print media, older computers, and legacy browsers like IE5.

  7. The Angst of Accessibility

    In a follow-up to “The Art of Accessibility”, James considers why accessibility should provoke such a strongly negative response in some. Indeed, why should an issue that’s rooted in improving the user experience, provoke any objection at all?

  8. (More) Assignment in Conditions

    In a follow-up to “Assignment inside a Condition”, James looks at a couple more examples of where this expression syntax can be used, and also highlights a gotcha that can lead to unwanted global variables.