Let’s Code: Test-Driven JavaScript

James Shore presents a fascinating screencast
on rigorous, professional JavaScript development

Browse the Catalog

Latest Live Episodes

  1. Styled and Tested

    Wed, 22 Oct

    Now that we’ve figured out all our weird cross-browser iframe incompatibilities, we’re able to re-enable our CSS tests and fix our page. We forget a few things, but the smoke tests catch them for us. A few improvements later, everything’s working as it should.

  2. Unstylish Safari

    Mon, 20 Oct

    Now our “join us” button is showing up without any styles in Safari. It’s just weird. I spend many hours (off camera) working on it... and figure it out! It’s a bug in Safari related to mixed-case IDs. We gradually re-enable our tests and work around the bug.

  3. Well and Truly Stumped

    Wed, 15 Oct

    Our latest CSS test is failing in Safari, and I’m at a loss. I hack away at it for a while (mostly off-camera), but it has me well and truly stumped. That happens. I set aside that test for now and move on to the footer instead. We get that working and then run into another Safari error on the “join us” button. What could be wrong?

Latest Specials

  1. Quixote: CSS Unit Testing

    Fri, 3 Oct

    On the Recorded Live channel, we’ve been working on a proof-of-concept suite of CSS unit tests. The concept’s been proven. Now it’s time to turn that work into a general-purpose open source library: Quixote. I’m conducting a virtual hackathon October 13-16 starting at 10am PDT (GMT-7) to build the library. Join us!

  2. Front-End Frameworks: React (Part II)

    Fri, 5 Sep

    We conclude our look at React, the front-end library from Facebook. In this part, we investigate React’s architecture and design constraints by building a real app. How well does React deal with architectural approaches that it wasn’t designed for? How does it coordinate far-flung components? What about lock-in, complexity, and testing? We answer it all.

  3. Front-End Frameworks: React (Part I)

    Fri, 1 Aug

    React is the hot new library for building user interfaces from Facebook. It boasts an innovative virtual DOM and bucks the trend by eschewing templates. How well does it work for real-world apps? We dive deep with a two-part series. In this first episode, we get React up and running and look at the fundamentals of automation, modularity, and testing.

An in-depth screencast about
Test-Driven JavaScript

What our viewers are saying:
I will be using it as *the* goto reference for
any JS development for some time to come.
It has the right number of details that you don’t get by
reading book but only working with exceptional people.
I like the variety of technologies used and the
complete integration of them shown together.
I like seeing *all* aspects of the development:
the dead ends, the surprises, the wins, etc.
Quality is excellent, and I love that I can
download them and not have to stream them.

JavaScript Needs Test-Driven Development

If you’ve programmed in JavaScript, you know that it’s an… interesting… language. Don’t get me wrong: I love JavaScript. I love its first-class functions, the intensive VM competition among browser makers, and how it makes the web come alive. It definitely has its good parts.

It also has some not-so-good parts. Whether it’s browser DOMs, automatic semicolon insertion, or an object model with a split personality, everyone’s had some part of JavaScript bite them in the ass at some point. That’s why using test-driven development is so important.

What is Test-Driven Development?

Test-driven development (TDD) is a technique for ensuring that your code does what you think it does. It’s particularly relevant for JavaScript, with its cross-browser incompatibilities and hidden gotchas. With TDD, you express your intentions twice: once as a test, and once as production code. If the two approaches don’t match, your tests fail, and you’ve caught a bug.

TDD is a great way of catching the majority of programming errors. It’s not perfect, of course—in particular, it can’t tell you when your assumptions are wrong—but it’s very good at catching the kinds of bugs JavaScript is prone to.

Who am I?

I’m James Shore. I’ve been building applications using test-driven development and other Agile techniques for over 13 years. I’m a recipient of the Agile Alliance’s Gordon Pask Award for Contributions to Agile Practice and I wrote a book called The Art of Agile Development.

What You Get

This screencast series focuses on rigorous, professional web development. That means test-driven development, of course, and also techniques such as build automation, continuous integration, refactoring, and evolutionary design. We support multiple browsers and platforms, including iOS, and we use Node.js on the server. The testing tools we’re using include NodeUnit, Mocha, expect.js, Karma, and PhantomJS.

All videos are DRM-free, viewable on the web and downloadable, and all source code is included.

The “Live” Channel

The series consists of three main channels. “Recorded Live” episodes are a live recording of an application as it’s developed, with commentary. I edit out dead-ends and time spent in research so each episode is focused and meaningful. Each “Live” episode is about 15 minutes long and comes out twice per week, on Monday and Wednesday.

The application itself is a real-time multi-user drawing application, developed from scratch and continually enhanced in each episode.

Monthly Specials

In addition to the “Live” episodes, you also get a special “Lessons Learned” or “The Lab” episode every month.

“Lessons Learned” episodes are for people wanting a refresher, a quick reference, or who simply want to catch up. They provide a distilled look at a specific topic, such as automating Lint, testing a Node.js server, or automating cross-browser testing.

“The Lab” is about exploration and experimentation. These episodes examine topics that don’t fit into the other two channels.

I have learned so much more than I expected.
I really enjoy your approach to screencasting and
wish the series wouldn’t end some day.