subscribe via RSS
Series
Feature
An Overview
- Adventures in 11ty
- Beware the Integrated Tests Scam (was Integrated Tests Are a Scam)
- Dependency Inversion Principle (DIP)
- Evolutionary Design
- Improving Names
- Microtechniques
- Mock Objects
- Not Just Coding
- Programming Without Blame
- Refactoring
- Removing Duplication Deftly
- Simple Design
- Surviving Legacy Code
- Test Doubles
- The Little Things
- Tutorials
- What's Not To Like About This Code?
If you're looking for a blog post and don't find it here, then you might find it at my other blog.
Adventures in 11ty
Beware the Integrated Tests Scam (was Integrated Tests Are a Scam)
- Which Kinds of Tests Should I Write?
- How I Wish I Had Some Unit Tests! An Example
- How to Write Tests For Framework Extensions?
- Abstract Test Cases, 20 Years Later
- Simulating Failure in Collaboration Tests
- You Don't Hate Mocks; You Hate Side-Effects
- A Contract Is Just An Understanding
- Who Tests the Contract Tests?
- Organizing Integration Tests: I Keep It Simple
- Getting Started with Contract Tests
- Taking a Pragmatic View of Isolated Tests
- Clearing Up the Integrated Tests Scam
- How To Recover From the Integrated Tests Scam
- Contract Tests: An Example
- Beware the Integrated Tests Scam (was Integrated Tests Are a Scam): No conflict with GOOS
- "Integration Tests are a Scam" is a Scam
- Using Integration Tests Mindfully: A Case Study
- Not Just Slow: Integration Tests are a Vortex of Doom
- Surely the Mars rover needed integrated tests! (Maybe not?)
- Interlude: Basic Correctness
- Part 3: The Risks Associated with Lengthy Tests
- Part 2: Some Hidden Costs of Integrated Tests
- Beware the Integrated Tests Scam (was Integrated Tests Are a Scam)
- In brief: Contract Tests
Dependency Inversion Principle (DIP)
- Modularity and Performance
- No More Boilerplate Code
- How Reuse Happens
- Relative Include Paths and the Slow, Certain March Towards Legacy Code
- Designing the Entry Point
- Injecting Dependencies, Partially Applying Functions, and It Really Doesn't Matter
- Null: Design Tool
- Abstraction: The Goal of Modular Design
- Beyond Mock Objects
- The Pain of Implicit Dependencies
- Demystifying the Dependency Inversion Principle
- 10 Ways to Kill Your Design
- From dependent tests to independent tests to independent assertions
- Refactor Your Way to a Dependency Injection Container
- Code Rejects Inheritance-Based Reuse: An Example
- Use Your Singletons Wisely: Ten Years Later
- Injecting dependencies doesn't have to hurt
Evolutionary Design
- TDD: For Those Who Don't Know How to Design Software
- What is 'the Right' Amount of Refactoring?
- What is Refactoring?
- Stepping Around a TDD Roadblock
- Which Kinds of Tests Should I Write?
- Polynomial Kata in 46 Commits
- Modularity and Performance
- Emerging Implementations of An Emerging Interface: An Example
Improving Names
- The Power of Precise Names: An Example
- Clean Up Those Nasty Junk Drawers
- Putting An Age-Old Battle To Rest
- A Model for Improving Names
- The Continuum of Names: an example
Microtechniques
- A Guard Clause Is Maybe a Tiny Parser
- Which Kinds of Tests Should I Write?
- Edit, Then Execute
- Breaking Through Your Refactoring Rut
- The World's Shortest Article on (test && commit) || revert
- I Learned Some sed
- Renaming Magically With zmv
Mock Objects
Not Just Coding
- TDD: You're Probably Doing It Just Fine
- Breaking Through That First TDD Block
- Too Many Ifs? Maybe.
- Simulating Failure in Collaboration Tests
- A Contract Is Just An Understanding
- The Eternal Struggle Between Business and Programmers
Programming Without Blame
- Refactoring Just Enough
- TDD: You're Probably Doing It Just Fine
- TDD: For Those Who Don't Know How to Design Software
- Which Kinds of Tests Should I Write? Revisited
Refactoring
- TDD: For Those Who Don't Know How to Design Software
- A Guard Clause Is Maybe a Tiny Parser
- Refactoring Test Doubles: From Stubs to Parsing
- The Power of Precise Names: An Example
- How Tests Support Refactoring
- Investing Wisely in Architecture Through Refactoring
- A Matter of Interpretation: Mock Objects
- What's Not To Like About This Code? An Experiment.
- What is 'the Right' Amount of Refactoring?
- What is Refactoring?
- Why Refactoring Is Not Always a Code Smell
- Stepping Around a TDD Roadblock
- Which Kinds of Tests Should I Write?
- Polynomial Kata in 46 Commits
- Removing Duplication Deftly 1
- Deciphering An 11ty Error Message
- Breaking Through Your Refactoring Rut
- Emerging Implementations of An Emerging Interface: An Example
- Modularity. Details. Pick One.
Removing Duplication Deftly
Simple Design
- TDD: For Those Who Don't Know How to Design Software
- A Guard Clause Is Maybe a Tiny Parser
- Revealing Intent: A Tiny Example
- Refactoring Test Doubles: From Stubs to Parsing
- The Power of Precise Names: An Example
- Investing Wisely in Architecture Through Refactoring
- A Matter of Interpretation: Mock Objects
- What's Not To Like About This Code? An Experiment.
- What is 'the Right' Amount of Refactoring?
- What is Refactoring?
- Why Refactoring Is Not Always a Code Smell
- Polynomial Kata in 46 Commits
- Modularity and Performance
- 11ty By Intention
- Removing Duplication Deftly 1
- Too Many Ifs? Maybe.
- Breaking Through Your Refactoring Rut
- You Don't Hate Mocks; You Hate Side-Effects
- Choosing Tools for Test Doubles
- Where the Hell Is My Port?! An Adventure in Elm
- Emerging Implementations of An Emerging Interface: An Example
- A Contract Is Just An Understanding
- The World's Shortest Article on (test && commit) || revert
- Organizing Integration Tests: I Keep It Simple
- Keep Dependency Injection Simple
- The Myth of Advanced TDD
- Guard Rails, Not Prison Bars
- When Subclasses Are Ready To Die
- Taking a Pragmatic View of Isolated Tests
- No More Boilerplate Code
- Tests Don't Have Special Permission to Repeat Themselves
- The Curious Case of Tautological TDD
- The Eternal Struggle Between Business and Programmers
- Modularity. Details. Pick One.
Surviving Legacy Code
- Taking a Pragmatic View of Isolated Tests
- Relative Include Paths and the Slow, Certain March Towards Legacy Code
- Surviving Legacy Code with Golden Master and Sampling
- The Eternal Struggle Between Business and Programmers
- Demystifying the Dependency Inversion Principle
Test Doubles
- Simulating Failure in Collaboration Tests
- You Don't Hate Mocks; You Hate Side-Effects
- Choosing Tools for Test Doubles
- Organizing Integration Tests: I Keep It Simple
- The Myth of Advanced TDD
- Getting Started with Contract Tests
- Taking a Pragmatic View of Isolated Tests
- The Curious Case of Tautological TDD
- Beyond Mock Objects
The Little Things
- Zero to nodejs on Linux
- Reading stdin and The Kotlin DSL for Gradle
- Breaking Through That First TDD Block
- Gradle Won't Run My Spock Tests
- Removing RVM Completely
Tutorials
- Saff Squeeze: Example 1
- The Saff Squeeze
- Polynomial Kata in 46 Commits
- Zero to nodejs on Linux
- Reading stdin and The Kotlin DSL for Gradle
- From Zero To NUnit With Visual Studio Code
- I Learned Some sed
- Deploying Jekyll to Heroku using GitLab CI
What's Not To Like About This Code?
All Other Topics
- A Natural Microflow in TDD
- How Not To Write Golden Master Tests
- A Tiny Cohesion Risk
- How a Smell in the Tests Points to a Risk in the Design
- What Good is Subclass to Test, Anyway?
- Your Tests Are Dragging You Down
- Your Constructors are Completely Irrational
- A Real-Life Contract Test
- You Have To Know When To Stop
- Learning Tests for POSTing Email from Mailgun
- IDEA Crashes on Launch on Yosemite
- Gaining Confidence in Code that Generates HTML
- "I Like Mocks, But I Distrust Spies"
- Let Code Flow Towards Better Design
- Refactoring CSS: Not Impossible
- How TDD Affects My Designs
- Musings on Refactoring as Waste
- Google Spreadsheet as a Test-First Demo Environment
- Losing time to Faraday
- Listening to your code does not mean conducting a seance
- Primitive Obsession Obsession
- The Liskov Substitution Principle Demystified
- Inquisition By Contract
- Publish posts later with Jekyll/Octopress
- Announcing a New Book
- A new twist on an old pattern
- Stop. Write a Learning Test.
- Rescuing Legacy Code by Extracting Pure Functions
- Detecting Changes in Third-Party Code
- When should I remove duplication?
- Writing Contract Tests in Java differently
- Adding behavior with confidence
- JMock v. Mockito, but not to the death
- Stub your data access layer; it won't hurt
- When is it safe to introduce test doubles?
- RSpec, have_tag(), Spec::Matcher and Nokogiri
- What your tests don't need to know will hurt you
- Persistence Last
- JUnit: A Starter Guide