In this episode Jon explores what happens when constructors and factories start getting a bit too complex and you need to formalize options for creating an instance of your exciting business object.

Released on May 16 2012 - 15 minutes

In this episode Jon talks about various ways to create an object instance, ans shows you how you can solve the confusion that can occur when you have too many constructor overloads - using the Factory Pattern.

Released on May 14 2012 - 12 minutes

Working our way through SOLID principles, Jon tackles the Open/Closed principle and Liskov's Substitution. Along the way we discuss how to facilitate change and extension in an API's inheritance scheme.

Released on May 04 2012 - 22 minutes

Designing a Conceptual Model is not easy, and quite often we can engineer ourselves into a very tricky spot with types that do multiple things for multiple reasons. In this episode, Jon takes apart System.DateTime - the poster child for "doing too much" (even the name has two concepts) in an effort to drive home the need for Single Responsibility and Type Clarity.

Released on April 30 2012 - 20 minutes

During the recording of Episode 4 (Inversion of Control) we asked Jon to "lead people along and show them the need" for using Inversion of Control with Dependency Injection. We expected a rough, hard-coded factory-style of thing, but no, Jon built a small, functional IoC container from scratch. We decided to include it here because it's fascinating to watch and... he's Skeet!

Released on April 28 2012 - 16 minutes

Our code is getting looser and our hard-coded dependencies are making future maintenance less-frightening - but we are now faced with a new problem: getting a new object is becoming a bit of a pain as we need to pass in all the dependencies! This can be a nightmare - and it's a good thing we have Inversion of Control containers to help us out. In this episode Jon refactors his code to make use of a home-spun IoC container, and shows concisely how he's helping his future self maintain his large Noda Time project.

Released on April 26 2012 - 15 minutes

Using interfaces is accepted by many as something "you should just do". But why? What do interfaces do for you? How are they better then just using basic object construction? In this episode Jon uses Noda Time (his OSS project) and shows you how the use of interfaces has helped him surmount the perils of System.DateTime in .NET.

Released on April 26 2012 - 20 minutes

We start the series off with a bang - tackling a design pattern that plagues most developers - no matter the language. The Singleton is reviled by many - mostly because it's nearly impossible to do it correctly. In this episode Jon takes it on and shows you not one, not two - but SIX different ways to do a Singleton. And talks about various pitfalls along the way.

Released on April 26 2012 - 35 minutes

Using interfaces is a great way to loosen up your code's various dependencies - but how do you go about putting together an application that effectively uses that interfaces? One pattern than many developers like is Dependency Injection, and Jon explains how this patterns works in a real-world project: Noda Time. You get to see how this pattern is used in the wild to make code more flexible and maintainable.

Released on April 26 2012 - 15 minutes

There are many ways to build apps on top of NodeJS, however many developers like to use frameworks that others have built up, following some basic patterns. In this episode we take a look at 3 of the more popular ones: ExpressJS (a Sinatra clone), Geddy (which is a tad more structured), and TowerJS - a full blown Rails clone with some extra fluff baked in.

Released on April 18 2012 - 22 minutes

If you've ever seen a demo of NodeJS it's likely you've seen a demo of persistent connections between the server and client using socket.io - the basic chat app or IRC clone. In this episode we take a look at how bleedingly simple it is to hook up socket.io and play around.

Released on April 18 2012 - 22 minutes

Javascript is a confusing language with many confusing terms. In this episode we try to show some common misconceptions about synchronous vs. asynchronous coding and how they sometimes relate to thread-blocking issues. Node a single-threaded, single-process environment, understanding these issues is paramount!

Released on April 17 2012 - 18 minutes

Every application needs to work with data at some level, and as you might expect: there are many choices when it comes to Node. We take a cursory look at the Big 3: Redis, MongoDB, and Postgres - showing what each of them is all about and then how you can use them with Node. We wrap up with a demonstration of why this isn't a singular choice - showing how Redis and Postgres can work together to make a very compelling user experience.

Released on April 17 2012 - 34 minutes

Event-driven programming is at the heart of working with NodeJS, so we pushed this relatively advanced episode right to the front as EventEmitters are used *all over* the framework.

Released on April 17 2012 - 18 minutes

In this episode we take a quick lap around NodeJS in an effort to show you why you might care about this new framework. We discuss advantages to Node, installation, day to day testing and the very basics of what Node is all about.

Released on April 17 2012 - 25 minutes