The Weekly Iteration
Learn to write better code in less than 30 minutes a week.
The Weekly Iteration is our video series where we explore new frameworks and languages, dig in to advanced coding patterns, and share the techniques we use on projects to build robust and maintainable applications. We're currently on a break from recording new episodes, but be sure to check out the many videos we've released previously.
Videos
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe discuss the Open Closed Principle. Also mentioned was polymorphism, the composite design pattern, decorators, factory method, and chain of responsibility. Finally, you might be interested in the immutable data...
Ben Orenstein and Joe Ferris
Ben and Joe cover "S" from SOLID, which stands for "Single Responsibility Principle," often abbreviated as "SRP." We show examples of why you might choose to obey this principle, as well as how the principle relates to [cohesion], Tell, Don't...
Ben Orenstein and Joe Ferris
Ben and Joe discuss Joe's recommendations for RSpec best practices. You can read Joe's original blog post, peruse our style guide's testing section, or review our summarized best practices for RSpec. You might also want to read about the mystery...
Ben Orenstein and Joe Ferris
Ben and Joe do a little live coding, demonstrating how to extract a Null Object from an existing class in order to encapsulate conditional logic related to nothingness. If you'd like to play along, we have two exercises for practicing Null...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe demonstrate the ping-pong approach to pair programming. They alternate back and forth, writing test for each other to pass. You'll also get a glimpse into the problem-solving tactics of thoughtbot developers as they...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe take a look at the Haskell version of Noodle, a zsh history analyzer. We cover some interesting Haskell nuggets in the implementation. If you'd like to see more, we recommend Learn You a Haskell. You can also see...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe showcase the most interesting parts of the Clojure implementation of Noodle, a zsh history analyzer. During the episode, we go through a few interesting Clojure-y bits of the implementation. If this tickles your...
Ben Orenstein and Joe Ferris
The Law of Demeter.
Ben Orenstein and Joe Ferris
In this video, Ben and Joe illustrate the steps to safely extracting new classes. You'll learn a reliable, repeatable process for creating new classes and moving functionality into them without risking bugs in your application or failures in your...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe tackle a highly useful but lesser known method from Ruby's Enumerable module: inject. While watching, you'll see how inject is just an abstraction over certain types of recursion. We'll use examples to demonstrate...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe discuss the an OO design principle known as Tell Don't Ask. They walk through a number of examples, discuss its subtleties when using MVC, and cover query and command methods. Original blog post PragProg blog post on...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe refactor some code submitted by a subscriber in our forum. Starting with a controller action containing complex business logic adding up to more than fifty lines, they extract a class to encapsulate that logic, using...
Ben Orenstein and Joe Ferris
In this episode, Joe and Ben discuss a fairly advanced example of refactoring. You'll dive into the good, the bad, and the ugly of code before and after being rewritten. The new code uses a number of design patterns, including the Builder...
Ben Orenstein and Chris Toomey
In this video, Chris shows off his highly-efficient programming workflow. Ben and Chris discuss shell optimizations, advanced vim operators, using Dash for fast documentation lookup, and configuring Alfred to make darn near everything...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe discuss several different types of coupling in code. While watching, you'll learn about three different types of coupling: Pathological Coupling, Global Coupling, and Control Coupling. You'll learn what these...
Ben Orenstein and Joe Ferris
In this episode, Ben and Joe discuss why abusing nil is unfriendly to your fellow developers, and dive into some of the other ways of representing nothingness. While watching, you'll learn how nil can be contagious, confuse a domain, and violate...