Articles by Jeff of Langr Software Solution Colorado Springs, Colorado


All articles are written by Jeff Langr unless otherwise noted. All of the articles on this page were either published in print magazines, at other sites, or submitted to conferences.

2001, August: Upsides & Downsides in Houston

10 Jan 2024 (Medium)

A pair-teaching stint with Michael Feathers over two decades ago reveals a chance encounter with the Enron scandal, as well as unearths some ethical feelings and confessions.

2010: PrizCon and a life-saving book

14 Dec 2023 (Medium)

Dan Wiebe ran a prison ministry in central Ohio to help inmates learn about software development. His group landed on Java as the language of choice, and my book Agile Java as their text. As a result, I ended up being asked to deliver the keynote for the possibly-first-ever in-prison technical conference in 2010. This article tells the story of my day in prison, as well as how my book saved the life of an inmate.

1981: Geeks Inc.

05 Dec 2023 (Medium)

Some old stories are better off left forgotten. This is one of them. A silly tale about geeks publishing an underground newspaper.

1981: Geeks Gone Bad

29 Nov 2023 (Medium)

A tale about my first and last hacking misadventure, plus a few moral lessons for modern-day folk.

1980: Small Functions

20 Nov 2023 (Medium)

How a terminal constraint during my formative years led to my finding value in shorter functions.

1983: Grace Hopper on the Window Sill

13 Nov 2023 (Medium)

In 1983, as a student programmer for the University of Maryland, I had the opportunity to catch the tail end of a Grace Hopper speech. Little did I expect her to come sit on a window sill next to me and chat.

DIY command-line info retrieval

10 Nov 2023 (LinkedIn)

If you're frequently working at the command line, you can accomplish one more thing while you're there: the storage and retrieval of small bits of information (in addition to the commands you already recall from command-line history). Read this article for a few more guidelines on setting up your shell as a simple, safe information store.

1982: Human-Paper-Human-Computer Interfaces

09 Nov 2023 (Medium)

My first introduction to the University of Maryland included a stop at the the Armory building, where I saw firsthand what modern computing meant to Maryland in 1982: A sea of paper, printouts, and queues. Had I picked the wrong major?

Prescriptive Agile: Stuck in Shu

24 Aug 2023 (Industrial Logic)

The agile manifesto tells us we must regularly reflect and adapt, and they mean it---we really are supposed to moving on to better ways of doing things. That means discarding bad practice, such as the often-frustrating daily standup meeting. This blog post for Industrial Logic, written by Nick Goede and me, uses shu ha ri as a metaphor to discuss your team's need to advance beyond rote practice.

The Myth About Severance Packages

27 Jul 2022 (Medium)

A blunt article about layoffs and severance packages. If you're not already aware, severance packages aren't about giving you a fair shake, they are about protecting the company. Specifically, they exist to get you to agree to not speaking negatively about them. In this public service article, I support my claim using a story from my own past.

Good Writing, Code and Otherwise

20 Jul 2022 (Medium)

Plenty of articles exist that describe the similarities between expository writing and code writing. Most miss the key point that writing—both code and not code—needs to be a process of continual editing in order to create quality product. This article touches just a bit more on that point.

PRs--Shift Left, Please (Part Two)

16 Mar 2022 (Medium)

In the prior article PRs: Shift Left, Please (Part 1), I made the claim that the pull request (PR) process itself is inherently ineffective and inefficient. Its emphasis on minimizing human interaction puts the PR process rightmost on a scale from favoring individuals and interactions to favoring tools and processes. By definition, then, the PR process is not agile. (“So what?,” you respond.) This article explores the “what” regarding the realities of the PR process, which can erode your culture, is inherently ineffective, and is inherently inefficient.

PRs--Shift Left, Please (Part One)

15 Mar 2022 (Medium)

The pull request (PR) process seems an ideal way to ensure that our systems retain high quality. Using pull requests can "promote cooperation, participation, and collaboration" within teams using it. Yet the PR process is the least colalborative out of all the review options available to you, and probably the poorest choice as a result. This Medium article is Part 1 of a two-parter. Part one overviews the PR process, then makes the claim that PRs are poorly done and flat-out not agile. This sets the stage for part 2, in which I discuss the problems that not being agile creates.

Why Bad Code Exists

22 Feb 2022 (Industrial Logic)

No one sets out to write bad code, so how does it get there? This post, written for the Industrial Logic blog by Tim Ottinger and me, explores a half-dozen legitimate reasons why we end up with code that is going to be more difficult to understand and maintain.

Two Rules for Mobbing Success

25 Apr 2019 (Ranorex)

In this post, I provide two key rules for making mob programming a successful and enjoyable way to work. You’ll figure out most of the rest of the guidelines for mobbing yourself: Things like respect for your teammates, guidelines about people coming and going, and so on. But these two rules–while simple to employ–aren’t necessarily obvious, and they’ll make all the difference in the world between a tedious, protracted mobbing session and something you’ll actually enjoy quite a bit.

One Thing At a Time

18 Feb 2019 (Ranorex)

In this post, I present OTAAT: One Thing At A Time, one of the most effective habits you can adopt as a software developer. From tackling stories to designing tests to refactoring, doing more than OTAAT is a guaranteed way to waste time. I’ll talk about how OTAAT instead helps makes life easier in general.

Does Mobbing Really Speed Us Up?

05 Nov 2018 (Ranorex)

I keep hearing from teams who are mobbing, where everyone is in the same room with a WIP limit of one, that “we go faster.” Really! How is that possible? In this post, I talk about my use of mobbing and pairing in training environments, then segue into a discussion of the value of minimizing WIP. Finally, I present a long list of reasons why mobbing might actually allow teams to go faster.

The Value of Failing Tests

30 Oct 2018 (Ranorex)

“A test that passes with no change to your classes is always cause for humility and pause.” We learn red-green-refactor for a reason–it’s not just “green-refactor.” In this post, I talk about the various reasons why you might see tests pass (green) when expecting them to fail. You’ll learn why it’s important to stick to that TDD rhythm.

The Only Coding Standard You’ll Ever Need

13 Sep 2018 (Ranorex)

Yes, coding standards are often a source of discontent within a team… but if you can’t get past agreeing on a few simple things, I suspect that portends something. In this post, I talk about the value, or lack, of having coding standards. I present a set of recommendations for deriving “agile standards,” but ultimately distill all standards down to a singular concept.

Just What Is DevOps?

30 Aug 2018 (Ranorex)

There’s no such thing as a free lunch, or free-expensive-steak dinner. You might have to listen to someone ramble about DevOps for hours while not being able to tell you what it is. In this post, I get to vent a little with a story about a steak dinner dominated by blather. I present a few thoughts about what DevOps is, since I can’t seem to find a concise definition anywhere (or get one at a steak dinner).

Humility: The Lost Value in Agile Development

29 Aug 2018 (Gurock)

XP presented four values as the basis for its approach to software development. Humility is perhaps the 5th, missing value. In this post, I offer some thoughts on what it means to be humble. I relate humility to the unease that many seasoned developers feel about TDD–its insistence of building only the software needed to that point in time.

Insights from the TDD Community

21 Aug 2018 (Ranorex)

Check out We Do TDD for numerous great stories about test-driven development from people, teams, and companies that test-drive their software. In this post, I talk about Dave Schinkel’s site that features interview questions and answers from a good number of TDD practitioners. I highlight some answers to questions about interesting TDD topics.

Find the Right TDD Approach for Your Testing Situation

16 Aug 2018 (Ranorex)

No, there’s no one “right” way to practice TDD, though there are plenty of ways that technically are not TDD. In this post, I talk about some of the variant ways of approaching test-driven development (TDD). I first introduce two distinct ways of describing TDD. I then discuss “assert-first,” “one assert per test,” and how tests are best named (or not).

Agile Hiring

26 Jul 2018 (Ranorex)

Don’t create a long laundry list of technical buzzwords for hiring. There’s a better, more agile approach. I present six major points to consider when hiring someone for your agile team: three job requirements essentials, and three important aspects to consider during the hiring process.

Raspberry Jam Gets Thin in the Pool

16 Jul 2018 (Ranorex)

“The more you spread it, the thinner it gets,” said the late Gerald Weinberg. I talk about the massive growth in the number of software developers worldwide, and how as a result developers have on average less experience than ever before. I talk about some ways in which we might thicken up that jam.

Why You Need at Least Three Sets of Eyes on Your Code

09 Jul 2018 (Ranorex)

Passive review after code (PRAC) is largely a waste of time. In this post, I provide some reasons why active review is better than PRAC. I discuss pairing and mobbings as two forms of active rule, and present a core rule for review that focuses on outcome instead of mechanism.

Heading into Ten and Twenty Years of Pragmatism

03 Jul 2018 (PragPub PDF)

With the July 2018 issue, the late PragPub magazine (edited by Michael Swaine) celebrated the beginning of its tenth year. That year also began the 20th anniversary of the publication of Andy Hunt’s and Dave Thomas’s classic book The Pragmatic Programmer. In this article, I talk a bit about what it means to be pragmatic and about how both the book and magazine have helped us be pragmatic over the years.

Postmodern Agile: A Story of Collaborating Beyond Buzzwords

22 Jun 2018 (Ranorex)

A tale about a day in a development team's life where we don’t talk about a process, we just live it, with the singular goal of delivering high-quality software frequently. I've lived that seeming fantasy; you can too.

Balancing Mobbing, Pairing, and Solo Work

21 Jun 2018 (Gurock)

I view modes of working as akin to tools–you want to use the right tool for the right job or situation. In this post, I talk about the distinctions around appropriateness for mob programming and pair programming. I also admit to enjoying the ability to work alone from time to time.

The ABCs of Acceptance Test Design

07 Jun 2018 (Ranorex)

I present seven design principles for the tests you’ll craft as part of practicing behavior-driven development (BDD) or acceptance test-driven development (ATDD). Stick to these principles and you’ll create a body of tests that returns many benefits while allowing you to keep your sanity.

Test-Driven Development: A Love Story?

22 May 2018 (Gurock)

In this post, I wax rhapsodic about TDD… well, maybe not. I don’t love TDD itself; I love the things that TDD enables me to do. I talk about what those things are, along with a bit of my personal history about how I got here.

Convincing Your Team to Adopt TDD

15 May 2018 (Ranorex)

You’ll pick up a number of ideas about how to approach introducing TDD into your team. While TDD is a simple practice to learn (though a challenge to master), getting developers to think they might want to even consider it is not an easy task. I’ll also talk about why resistance is to be expected.

BDD Testing Skills Q&A

15 Apr 2018 (Gurock)

A number of good questions about BDD arose from the Gurock webinar “BDD Testing Skills.” I felt like answering them all, though I did so rather hastily (so don’t expect a lot of clean editing for this “article”).

Why I Practice TDD: Speed and Need

02 Mar 2018 (Ranorex)

Why do TDD at all? My primary reason is because it allows me to go faster, particularly as a system grows. In this post, I talk about some of the reasons why, and iterate some of the high cost of defects along the way.

Can You Have Too Many Tests?

23 Feb 2018 (Gurock)

Yes you can. In this post, I talk about a customer who didn’t realize the pickle they were brining themselves into when they slowly but surely found their way on a path to “too many” tests.

Should We Automate All of Our Feature Scenarios?

08 Feb 2018 (Ranorex)

How behavior-driven development (BDD) can help us come to consensus. I share a story about a customer who found value in BDD, even though we were unable to automate their “specs by example.”

Clarifying Scope with Scenarios in Behavior-Driven Development?

19 Jan 2018 (Gurock)

The values of negotiating around scenarios when doing behavior-driven development (BDD). Rather than delve deep into the narratives (given-when-thens), this focus will help when it comes to negotiating the scope of a given story.

Succeeding With Test-Driven Development at a Distributed Start-up

17 Jan 2018 (Gurock)

My experiences doing test-driven development (TDD) at a small startup: Where did we succeed, where did we fail, and what would I change?

Half of a Third of a Century in TDD

06 Jul 2016 (PragPub PDF)

A reflection on why I’ve found TDD to be an indispensable practice for the past sixth of a century.

Pair Writing Across Time and Space

02 Mar 2016 (AgileConnection)

Written with Tim Ottinger. Much like in pair programming, working with a partner through pair writing provides increased support and valuable immediate feedback. But there are additional obstacles when you and your partner are not collocated. Here are some tips on how you can still implement pair writing successfully when you can’t collaborate in person.

Rule #1 for Distributed Teams–The 2015 Edition

01 Apr 2015 (PragPub PDF)

Jeff revisits his outlook on distributed development and finds it necessary to update one of the Agile in a Flash lists originally written with Tim Ottinger. Along the way he shares some hard-won insights on how to make distributed development teams work.

Unit Tests are FIRST

01 Jan 2012 (PragPub PDF)
Updated reprint (Medium)

Tim Ottinger and I present a breakdown of the FIRST acronym, which presents five guidelines for good quality unit tests.

Succeeding With and Sustaining TDD

01 Dec 2011 (Java Tech Journal)

A laundry list of things you need to look for and monitor in a TDD shop. TDD is a significant investment and challenge; following these recommendations should help you more effectively sustain the practice over time.

Test-Driven Development: A Guide for Non-Programmers

02 Nov 2011 (PragPub PDF)

Want your manager to understand test-driven development (TDD)? This article overviews what TDD is and discusses its cost and benefits. Jeff also presents some thoughts on how non-programmers might understand whether or not their team is doing TDD well.

But We Have These Distributed Folks

01 Oct 2011 (PragPub PDF)
Updated reprint (Medium)

Is “distributed agile” an oxymoron or reality? Tim Ottinger and I talk about distributed teams and agile values, covering a number of do’s and don’ts for agile teams. We also provide a number of communication guidelines for working distributed.

The Only Agile Tools You’ll Ever Need

08 Sep 2011 (PragPub PDF)
Updated reprint (Medium)

Written with Tim Ottinger. What low-tech tools can help in agile, and when and how should high-tech tools be used?

How Virtuous Is Your Code?

01 Aug 2011 (PragPub PDF)
Updated reprint (Medium)

Written with Tim Ottinger. This article is based on the Agile in a Flash card “The Seven Code Virtues.” It presents yet another possible definition for letting us know when code is “good.”

Pair Programming Benefits

06 Jul 2011 (PragPub PDF)
Updated reprint (Medium)

Written with Tim Ottinger. We list over twenty benefits that you can derive from pair programming, categorized as being from the perspective of the team and system, programmers, and managers/project managers.

Pair Programming in a Flash

02 Jun 2011 (PragPub PDF)

Written with Tim Ottinger. We discuss three of our Agile in a Flash pairing cards, covering the rules of pairing, pair programming smells, and what to do when not pairing.

Agile Reflections:A Dozen Years or so of Agile Development Practices

02 May 2011 (PragPub PDF)

Tim Ottinger and I reflect on the various “agile development practices” (perhaps better classified as the technical practices from extreme programming).

Test Abstraction: Eight Techniques to Improve Your Tests

02 Apr 2011 (PragPub PDF)

Written with Tim Ottinger. Using smells that identify problems with respect to abstraction in your unit tests, we whittle down an ugly test (take from open source) into a pair of highly readable, maintainable tests.

Software Volatility

02 Mar 2011 (PragPub PDF)
Updated reprint (Medium)

Written with Tim Ottinger. The final in a series of four articles on Tim's “big ideas” in software development. This article discusses what volatility is, what problems it can create, and how to begin controlling it.


01 Feb 2011 (PragPub PDF)
Updated reprint (Medium)

Written with Tim Ottinger. The third in a series of four articles on Tim's “big ideas” in software development. In this article, we talk about abstraction using the perspective of Robert C. Martin's definition: "the elimination of the irrelevant and the amplification of the essential."

Code Coupling

01 Jan 2011 (PragPub PDF)
Updated reprint (Medium)

Written with Tim Ottinger. The second in a series of four articles on Tim's “big ideas” in software development. In this article, we dig into various kinds of dependencies and present thoughts on how to minimize them.

My Ruby Regrets

08 Dec 2010 (

In a guest blog post for a defunct Ruby learning site, I talk about my experiences building quick’n’dirty scripts in Ruby and Python, and how that’s almost always a mistake.

Cohesive Software Design

01 Dec 2010 (PragPub PDF)
Updated reprint (Medium)

Tim Ottinger and I talk about one of the four “big ideas” in software, cohesion. Cohesion–the principle that “things that belong together should be kept together”–makes code easier to understand, debug, and test.

Shu Ha Ri–Learn, Detach, Transcend: Steps to Agile Mastery

01 Nov 2010 (PragPub PDF)

Written with Tim Ottinger. Our well-meaning agile coach’s maturity model was based, either deliberately or subconsciously, on Shuhari, a Japanese martial arts concept involving three stages of mastery: “first learn, then detach, and finally transcend.”

What Agile is Not

01 Oct 2010 (PragPub PDF)

Tim Ottinger and I present some stories about dogmatists, cowboys, and authoritarians, demonstrating a few ways that your transition to agile can be derailed.

Agile Flash Cards

01 Sep 2010 (PragPub PDF)

Tim Ottinger and I introduce our Agile in a Flash project, and talk about the value of the index cards by presenting three meta-cards.

Agile Documentation: Specification by Example

26 Aug 2009 (InformIT)

A companion piece to Mike Cohn’s book Succeeding with Agile: Software Development Using Scrum. It takes an automated test example from the book and demonstrates how to enhance it to act as clearer documentation on the system’s capabilities.

Working With Design Patterns: Odds and Ends

18 Sep 2008 (

The design patterns book lists 23 design patterns, but that’s just the beginning! Many more patterns exist, including the specification pattern, lazy initialization, object pools, and the utility class pattern.

Working With Design Patterns: Abstract Factory

04 Sep 2008 (

One of the bigger challenges with using design patterns is knowing when to use one pattern over another. The abstract factory creational pattern looks similar to the builder pattern but is used to help solve a different problem.

Working With Design Patterns: Factory Method

28 Aug 2008 (

Your production code isn’t the only place you will find a use for design patterns. The factory method pattern helps you answer a question about how to organize your test classes.

Building a Simple BlackBerry Application Interface

14 Aug 2008 (

Building applications for the BlackBerry involves a few interesting wrinkles. Explore some of these challenges in building a front end for a new BlackBerry unit testing framework.

A Unit Testing Framework for the BlackBerry

24 Jul 2008 (

What do you do when there’s no effective unit testing framework for your programming environment? Why, build your own, of course! Building a simple unit testing framework for the BlackBerry provides some interesting insights into the BlackBerry programming environment.

Working With Design Patterns: Iterator

09 Jul 2008 (

Patterns exist for virtually all common programming challenges, even one as simple as “how to traverse a collection of objects.” The iterator pattern provides a consistent solution for something that programmers do daily.

Working With Design Patterns: State

19 Jun 2008 (

The state pattern can help simplify complex conditional logic by representing individual states as classes, each with its own simple behavior.

Working With Design Patterns: Mediator

05 Jun 2008 (

Objects talking to each other and no one in control? Messages going all over the place? The mediator pattern can help you control the chaos!

Working With Design Patterns: Interpeter

22 May 2008 (

Many of the design patterns lead a double life–the structure of some patterns are exactly alike, but the intent differs. An interpreter is a composite whose purpose is to support interpretation of a simple grammar.

Working With Design Patterns: Chain of Responsibility

07 May 2008 (

The chain of responsibility pattern allows you to emulate a real-life chain of command. In a chain of responsibility, a request moves from handler to handler until someone is able to manage and return it to the client.

Working With Design Patterns: Builder

21 Apr 2008 (

A common theme in design patterns is organizing things so as to separate high-level policy from low-level underlying details. The builder pattern does just that, by allowing a single construction policy to be realized by many different implementations.

Working With Design Patterns: Prototype

02 Apr 2008 (

Like the abstract factory pattern, the prototype pattern helps you adhere to a clean design by moving object creation into a polymorphic hierarchy. When using the prototype pattern, you create objects by making copies of already existing instances.

Working With Design Patterns: Singleton

20 Mar 2008 (

The singleton pattern is one of the simplest in the catalog of design patterns. Lurking beneath its simplicity is the potential for testing trouble!

Working With Design Patterns: Bridge

05 Mar 2008 (

Separating interface from implementation is a fundamental object-oriented strategy, one that’s also the essence of the bridge design pattern. You can use the bridge pattern to help solve the more complex problem of separating tangled hierarchies.

Working With Design Patterns: Adapter

06 Feb 2008 (

Not all design patterns are complex. The adapter pattern provides a simple mechanism for conforming an interface into one that’s more useful for a client application.

Working With Design Patterns: Visitor

28 Jan 2008 (

Visitor is often viewed as a complex pattern that’s often regarded as difficult and troublesome. But the appropriate use of visitor demonstrates what’s at the heart of good object-oriented design.

Working With Design Patterns: Memento

10 Jan 2008 (

The Memento design pattern presents a consistent solution for storing state, allowing you to build undo and redo support in your applications with ease.

Getting Test Doubles in Place

03 Jan 2008 (

Test doubles (aka fakes or mocks) are a great tool that allow for deeper ability to test-drive solutions. The most common way to use test doubles is to pass them via constructors or setters. But there are at least a couple other solutions.

Principles for Agile Metrics

07 Dec 2007 (

Deriving metrics in an agile software development process can be an integral part of managing and improving execution. As with any tool, metrics used poorly can actually damage a project. A set of guiding principles for agile metrics can keep your team on track.

Doing TDD Well

19 Nov 2007 (

TDD is a simple discipline: “a minute to learn, a lifetime to master.” This article offers a number of nuggets on how to improve your mastery of test-driven development.

Tools, Iterations, and Stories

29 Oct 2007 (

Are you focusing on the wrong things? Agile promotes de-emphasizing tools, but as agile grows, tools are becoming more pervasive. Agile centers around iterations, but are you focusing too much on the iteration to the detriment of delivering stories?

Testability and Design

10 Oct 2007 (

Some supporting thoughts around the argument that, in most cases, a good design is also a testable design (and conversely, that an untestable design is not a good design).

Considering Test-After Development

24 Sep 2007 (

Should you write tests first (before you write production code), or should you write tests after you build the production code?

Working With Design Patterns: Null Object

04 Sep 2007 (

Get rid of those pesky “if null” constructs invading and cluttering your code by using the null object pattern!

Working With Design Patterns: Observer

17 Aug 2007 (

A pragmatic example of the observer pattern, which provides an important technique for eliminating dual dependencies.

Working With Design Patterns: Proxy

01 Aug 2007 (

The proxy pattern provides a protection layer for your objects by exposing a stand-in to interested clients. I’ll explore one possible use for the proxy pattern in this article. (Note: The published title of this article is actually Design Patterns: Proxy.)

Working With Design Patterns: Decorator

18 Jul 2007 (

The decorator pattern gives you the flexibility to wrap special behavior around objects. Unlike inheritance, which gives you the ability to predefine specialized behavior, using the decorator pattern allows you to dynamically attach specialized behavior.

Working With Design Patterns: Composite

02 Jul 2007 (

The composite pattern takes advantage of recursion to help produce elegant solutions. This example diverges from the typical examples of the composite pattern.

Working With Design Patterns: Strategy

13 Jun 2007 (

A simple implementation shows how the strategy pattern can be used to swap in varying algorithms.

Copying Arrays in Java 6

29 May 2007 (

Java takes one more tiny step away from its C legacy with this enhancement to version 6.

Working With Design Patterns: Flyweight

14 May 2007 (

Got millions of objects? The flyweight pattern can help!

JavaOne Spotlight: OpenJDK

10 May 2007 (

A brief overview of OpenJDK, officially announced at JavaOne, and its implications.

Working With Design Patterns: Template Method

27 Apr 2007 (

What can we do with duplication? The template method pattern allows us to move common portions of an algorithm to a base class, and leave “holes” to be filled in by derived classes.

Working With Design Patterns: Command

13 Apr 2007 (

Not your usual pattern article. How do we arrive at a command pattern implementation if we’re just test-driving code?

Test-Driving a Java Command Line Application

03 Apr 2007 (

There are a few ways to approach writing unit tests for a Java main method. Should you bother? I think so!

Can Refactoring Produce Better Code?

06 Mar 2007 (

A simple example of how you can refactor some of your longer methods so that they can read well as “high-level policy.” (Hopefully it’s clear from this article’s title that I don’t always have the final say on things like titles and blurbs.)

Working With Design Patterns: Facade

21 Feb 2007 (

Object-oriented languages provide great opportunities to isolate complexity in a system. A facade buries an unwieldy interface behind a simplified one.

Comments on Comments on Comments

20 Feb 2007 (

An emphatic viewpoint on the value of comments, in response to an earlier article on comments by Mike Gunderloy.

Why Pair?: Challenges and Rewards of Pair Programming

07 Feb 2007 (

An article that discusses many of the merits behind pair programming.

Java 5's DelayQueue

18 Jan 2007 (

Discusses the class java.util.concurrent.DelayQueue, first available as of Java J2SE 5.0. The DelayQueue provides a thread-safe blocking queue that requires objects to remain in the queue for a minimum period of time.

Pair Programming Dos and Don’ts

08 Jan 2007 (

Twenty-one specific recommendations for pair programming.

Writing a Simple Automated Test in FitNesse

15 Dec 2006 (

Part three of a three part introduction to acceptance testing using FitNesse.

A Brief Introduction to Agile

12 Dec 2006 (

An overview of agile software development methodologies.

Moving Forward with Automated Acceptance Testing

01 Dec 2006 (

Part two of a three part introduction to acceptance testing using FitNesse.

Java 5’s BlockingQueue

22 Nov 2006 (

A code-based discussion that demonstrates use of the BlockingQueue class found in Java 5’s concurrency packages.

The Need for Automated Acceptance Testing

14 Nov 2006 (

Part one of a three part introduction to acceptance testing using FitNesse.

Crafting Java with Test-Driven Development, Part 13: Nine Reasons Why You Should Be Using TDD

26 May 2006 (InformIT)

In the final installment in the TDD series, I talk about how TDD enables more rapid development.

Crafting Java with Test-Driven Development, Part 12: TDD at Cassatt: An Interview with Jerry R. Jackson

28 Apr 2006 (InformIT)

In the twelfth installment in the TDD series, I ask Jerry Jackson about his experiences with test-driven development at Cassatt.

Crafting Java with Test-Driven Development, Part 11: Making Things Happen

21 Apr 2006 (InformIT)

In the eleventh installment in the TDD series, I show how to trigger behavior on mouse clicks without cluttering the view with logic.

Crafting Java with Test-Driven Development, Part 10: Building the View

14 Apr 2006 (InformIT)

In the tenth installment in the TDD series, I show how to test-drive building a simple view, and emphasize the need for heavy refactoring of Swing code.

Crafting Java with Test-Driven Development, Part 9: Driving a User Interface

07 Apr 2006 (InformIT)

In the ninth installment in the TDD series, I show how it’s possible to drive development of a Swing GUI using TDD.

Crafting Java with Test-Driven Development, Part 8: It’s Just Code

24 Mar 2006 (InformIT)

In the eighth installment in the TDD series, I move the application toward a better design through a series of incremental refactorings. The beautiful part about code is that it’s easily changed, especially if you have tests to be confident about it.

Crafting Java with Test-Driven Development, Part 7: Adding Some Bulk

17 Mar 2006 (InformIT)

In the seventh installment in the TDD series, I add support for dealing the rest of a hold ’em hand. I also discuss the practice of adding “todo” reminders in code.

Crafting Java with Test-Driven Development, Part 5: Handling Exceptions

17 Feb 2006 (InformIT)

In the fifth installment in the TDD series, I show how to write tests for exceptional conditions.

Crafting Java with Test-Driven Development, Part 6: Refactoring Tests

10 Feb 2006 (InformIT)

In the sixth installment in the TDD series, I talk about the need to keep tests as refactored as production code, so as to better document class capabilities and keep maintenance costs low.

Crafting Java with Test-Driven Development, Part 4: Shuffling and Dealing

03 Feb 2006 (InformIT)

The fourth installment in the TDD series ponders a number of ways to test that a deck is shuffled so that cards are dealt in a random order.

Crafting Java with Test-Driven Development, Part 3: Testing Hash Codes

27 Jan 2006 (InformIT)

The third installment in the TDD series follows up on the discussion of building a .equals method by discussing the need (or not) for test-driving a hashCode method.

Crafting Java with Test-Driven Development, Part 2: Testing Equality

20 Jan 2006 (InformIT)

The second installment in the TDD series discusses how to drive out the development of a .equals method using TDD.

Crafting Java with Test-Driven Development, Part 1: Getting Started

13 Jan 2006 (InformIT)

The first installment in a new article series on TDD. This 13-installment series will introduce and discuss test-driven development (TDD) concepts. The series presents the incremental development of an application to play the poker game of hold ’em. Installments will appear roughly every other week for about six months.

Using For Loops in J2SE 5.0

22 Apr 2004 (

A brief article on the foreach loop in J2SE 5.0.

Sweet and Simple (part 3 of 3)

12 Apr 2004 (Software Development Magazine)

The final installment in a series of three articles about the changes in J2SE version 5.0. This installment covers the remaining new features, including foreach, autoboxing, varargs, typesafe enum, static import, and metadata.

The Formatter Class in J2SE 5.0

18 Mar 2004 (

A very brief article that discusses the Formatter class in Java J2SE 5.0. The Formatter class allows for String formatting similar to printf in C; it depends on the availability of the varargs feature in J2SE 5.0.

Making the Grade (part 2 of 3)

12 Mar 2004 (Software Development Magazine)

The second in a series of three articles about the changes in Java J2SE version 5.0. This installment digs deeper into the new generics feature.

Looking at Varargs in J2SE 5.0

11 Mar 2004 (

A very brief article that overviews the varargs (variable arguments) feature in J2SE 5.0.

Tiger Stripes (part 1 of 3)

10 Feb 2004 (Software Development Magazine)

The first in a series of three articles about the changes in Java J2SE version 5.0. This installment overviews the changes and begins a discussion on the generics feature.

Test-Driven Development in C/C++

15 Apr 2003 (Dr. Dobbs)

A lead article from the (defunct) C/C++ Users Journal about how to do test-driven development when working in C. Written with Dr. Robert Koss.

Connecting the Dots

08 Mar 2002 (Software Development Magazine)

An article about using test-driven development in conjunction with GUI development. It demonstrates an approach using Java and Swing to build a small game.

Book Review: Questioning Extreme Programming

08 Mar 2002

A critique of Pete McBreen’s book Questioning Extreme Programming, hosted at Ron Jeffries’ original site on extreme programming.

Enlightened Java Style

12 Feb 2002 (Software Development Magazine)

A solution for what I call “simple style.” Three rules, instead of an entire book, to give you a simple approach for ensuring that your code remains highly readable and maintainable.

Evolution of Test and Code via Test-First Design

01 Jan 2001 (OOPSLA)

Presented at OOPSLA 2001. A simple exposition of how to build code using test-first design. The example produces a class that the author still uses for reading CSV (comma-separated values) files.

Extending the Java 2 Collections Framework

11 Jul 2000 (

Demonstrates a technique for implementing Smalltalk-like blocks in Java.