Latest Live Episodes
Up In Flame GraphsMon, 2 Mar
We continue our investigation of our build performance. This time, we use node-inspector to profile our build and Brendan Gregg’s flame graphs for visualization. The flame graph confirms our previous results: our time is spent looking up filenames. But it also shows us that synchronous file access may be the culprit. We start on an asynchronous alternative.
Performance Optimization and ProfilingWed, 25 Feb
Our build takes six tenths of second to do nothing. That’s kind of slow. What’s happening? As always with performance questions, the best way to find out is to profile the code. We start with manual timing tests. Along the way, we discuss how to plan for performance improvements and what kind of targets to set.
A Real Programming LanguageMon, 23 Feb
It’s my favorite thing about Jake compared to its predecessor, make. Its files are written in a real programming language. So when we need to programmatically generate lint build targets, there’s no problem. We just write a loop and use a regex. Now all our server-side linting happens incrementally.
Everything you need for a great development environment in 2015 and beyond. This episode brings all my front-end workflow recommendations together into a complete package that’s updated with my latest recommendations. Topics include reproducible builds, continuous integration, linting, front-end modules, and cross-browser testing.
Front-End Frameworks: AngularJS (Part III)Fri, 2 Jan
We conclude our investigation into AngularJS’s impact on design and architecture. In this episode, we bring in our pre-existing persistence layer and use it to coordinate changes across our application. We also create a custom form field that uses domain-driven validation. Does AngularJS play well with our architecture? Should you use it? We render our verdict.
Front-End Frameworks: AngularJS (Part II)Fri, 5 Dec
We continue our exploration of AngularJS with a look at application design and architecture. Angular assumes simple models that live in “scope” objects. Our sample application, though, has a rich domain layer based on Ward Cunningham’s CHECKS pattern language. How well does Angular handle an approach that’s outside its comfort zone? We investigate.
An in-depth screencast about
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.
What is Test-Driven Development?
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.
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.