subscribe via RSS
The Archives
If you'd rather browse articles by series or category, then click here.
- Saff Squeeze: Example 1
- Refactoring Just Enough
- TDD: You're Probably Doing It Just Fine
- TDD: For Those Who Don't Know How to Design Software
- A Guard Clause Is Maybe a Tiny Parser
- Which Kinds of Tests Should I Write? Revisited
- Revealing Intent: A Tiny Example
- 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?
- The Saff Squeeze
- Polynomial Kata in 46 Commits
- Modularity and Performance
- Zero to nodejs on Linux
- Reading stdin and The Kotlin DSL for Gradle
- Breaking Through That First TDD Block
- Edit, Then Execute
- How I Wish I Had Some Unit Tests! An Example
- How to Write Tests For Framework Extensions?
- Abstract Test Cases, 20 Years Later
- 11ty By Intention
- Removing Duplication Deftly 1
- Deciphering An 11ty Error Message
- Too Many Ifs? Maybe.
- Simulating Failure in Collaboration Tests
- A Natural Microflow in TDD
- 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
- Gradle Won't Run My Spock Tests
- The World's Shortest Article on (test && commit) || revert
- From Zero To NUnit With Visual Studio Code
- Removing RVM Completely
- Who Tests the Contract Tests?
- Organizing Integration Tests: I Keep It Simple
- I Learned Some sed
- Keep Dependency Injection Simple
- Renaming Magically With zmv
- The Myth of Advanced TDD
- Guard Rails, Not Prison Bars
- Getting Started with Contract Tests
- When Subclasses Are Ready To Die
- Taking a Pragmatic View of Isolated Tests
- Deploying Jekyll to Heroku using GitLab CI
- No More Boilerplate Code
- Tests Don't Have Special Permission to Repeat Themselves
- How Not To Write Golden Master Tests
- A Tiny Cohesion Risk
- How Reuse Happens
- How a Smell in the Tests Points to a Risk in the Design
- Relative Include Paths and the Slow, Certain March Towards Legacy Code
- Clearing Up the Integrated Tests Scam
- Designing the Entry Point
- Injecting Dependencies, Partially Applying Functions, and It Really Doesn't Matter
- How To Recover From the Integrated Tests Scam
- Null: Design Tool
- 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
- Clean Up Those Nasty Junk Drawers
- Surviving Legacy Code with Golden Master and Sampling
- "I Like Mocks, But I Distrust Spies"
- Let Code Flow Towards Better Design
- Abstraction: The Goal of Modular Design
- Refactoring CSS: Not Impossible
- How TDD Affects My Designs
- The Curious Case of Tautological TDD
- Musings on Refactoring as Waste
- Google Spreadsheet as a Test-First Demo Environment
- Putting An Age-Old Battle To Rest
- Beyond Mock Objects
- Losing time to Faraday
- The Eternal Struggle Between Business and Programmers
- The Pain of Implicit Dependencies
- Listening to your code does not mean conducting a seance
- Primitive Obsession Obsession
- Modularity. Details. Pick One.
- Demystifying the Dependency Inversion Principle
- 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
- 10 Ways to Kill Your Design
- From dependent tests to independent tests to independent assertions
- Stop. Write a Learning Test.
- Refactor Your Way to a Dependency Injection Container
- Rescuing Legacy Code by Extracting Pure Functions
- Detecting Changes in Third-Party Code
- When should I remove duplication?
- Writing Contract Tests in Java differently
- Contract Tests: An Example
- Adding behavior with confidence
- A Model for Improving Names
- The Continuum of Names: an example
- Code Rejects Inheritance-Based Reuse: An Example
- Beware the Integrated Tests Scam (was Integrated Tests Are a Scam): No conflict with GOOS
- Use Your Singletons Wisely: Ten Years Later
- Injecting dependencies doesn't have to hurt
- 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
- "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
- What your tests don't need to know will hurt you
- 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
- Persistence Last
- JUnit: A Starter Guide