Articles

A Brief Introduction to Agile (12-Dec-2006)
An overview of agile software development methodologies. Appears at Developer.com.

About Object-Oriented Programming Languages
A blurb I wrote for Object Mentor's best practices overviews. Hosted at Object Mentor's site.

About Test-Driven Development or Test-First Design
A blurb I wrote for Object Mentor's best practices overviews. Hosted at Object Mentor's site.

Adopting XP (Sep-2003)
A brief discussion on how you might approach introducing XP into your shop.

Annotations in J2SE 5.0-Part 1 (11-Feb-2004)
Demonstrates use of the new annotations facility in Java J2SE 5.0. Part 1 of 2.

Annotations in J2SE 5.0-Part 2 (15-Feb-2004)
Demonstrates use of the new annotations facility in Java J2SE 5.0. Part 2 of 2.

Blog Series: Database TDD (ongoing; Sep 2005 to Feb 2006)
Ongoing blog installments that step through building an object-relational layer from scratch using test-driven development.

Book Review: Questioning Extreme Programming (8-Mar-2002)
A critique of Pete McBreen's book Questioning Extreme Programming. The book review is hosted at Ron Jeffries' XProgramming.com site.

Book Review: XP Refactored (3-Jan-2004)
A review of the book Extreme Programming Refactored that once appeared at Amazon.com.

Can Refactoring Produce Better Code? (6-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." Hosted at Developer.com. (Hopefully it's clear from this article's title that I don't always have the final say on things like titles and blurbs.)

Code Comprehension and Test Paraphrasing (3-Apr-2007)
A simple piece on an extremely useful technique I employ and recommend called code paraphrasing. The basic idea: have someone else paraphrase your code, ideally out loud, as a form of maintainability review.

Coding Standards (28-Oct-2003)
A brief discussion about the usefulness of coding standards.

Comments on Comments on Comments (20-Feb-2007)
Hosted at Developer.com. An emphatic viewpoint on the value of comments, in response to an earlier Developer.com article on comments by Mike Gunderloy.

Connecting the Dots (8-Mar-2002)
An article published in Software Development magazine (now part of Dr. Dobbs) about using test-driven development in conjunction with GUI development. The article demonstrates an approach using Java and Swing to build a small game.

Considering Test-After Development (24-Sep-2007)
Written for Developer.com. Should you write tests first (before you write production code), or should you write tests after you build the production code?

Copying Arrays in Java 6 (29-May-2007)
Written for Developer.com. Java takes one more tiny step away from its C legacy with this enhancement to version 6.

Crafting Java with Test-Driven Development, Part 1: Getting Started (13-Jan-2006)
The first installment in a new series at Informit. 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.

Crafting Java with Test-Driven Development, Part 2: Testing Equality (20-Jan-2006)
The second installment in the TDD series at Informit discusses how to drive out the development of a .equals method using TDD.

Crafting Java with Test-Driven Development, Part 3: Testing Hash Codes (27-Jan-2006)
The third installment in the TDD series at Informit 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 4: Shuffling and Dealing (3-Feb-2006)
The fourth installment in the TDD series at Informit 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 5: Handling Exceptions (17-Feb-2006)
In the fifth installment in the TDD series at Informit, I show how to write tests for exceptional conditions.

Crafting Java with Test-Driven Development, Part 6: Refactoring Tests (10-Feb-2006)
In the sixth installment in the TDD series at Informit, 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 7: Adding Some Bulk (17-Mar-2006)
In the seventh installment in the TDD series at Informit, 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 8: It's Just Code (24-Mar-2006)
In the eighth installment in the TDD series at Informit, 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 9: Driving a User Interface (7-Apr-2006)
In the ninth installment in the TDD series at Informit, I show how it's possible to drive development of a Swing GUI using TDD.

Crafting Java with Test-Driven Development, Part 10: Building the View (14-Apr-2006)
In the tenth installment in the TDD series at Informit, I show how test-drive building a simple view, emphasizing the need for heavy refactoring of Swing code.

Crafting Java with Test-Driven Development, Part 11: Making Things Happen (21-Apr-2006)
In the eleventh installment in the TDD series at Informit, I show how to trigger behavior on mouse clicks without cluttering the view with logic.

Crafting Java with Test-Driven Development, Part 12: TDD at Cassatt: An Interview with Jerry R. Jackson (28-Apr-2006)
In the twelfth installment in the TDD series at Informit, I ask Jerry Jackson about his experiences with test-driven development at Cassatt.

Crafting Java with Test-Driven Development, Part 13: Nine Reasons Why You Should Be Using TDD (26-May-2006)
In the final installment in the TDD series at Informit, I talk about how TDD enables more rapid development.

Design Pattern: Proxy (1-Aug-2007)
Written for Developer.com. 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.

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.

Don't Mock Me (21-Dec-2003)
Don't Mock Me (22-Jun-2004)
A discussion of the forces that drive the need for mock objects, as well as the design impacts of introducing mocks. The first link is the original article; the second link is the peer-reviewed submission to the 2004 Agile Developers Conference.

Enlightened Java Style (12-Feb-2002)
A solution published in Software Development magazine (now part of Dr. Dobbs) 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 (Jan-2001)
An article 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. The article is hosted at Object Mentor's site.

Extending the Java 2 Collections Framework (11-Jul-2000)
An article appearing at Gamelan.com, that demonstrates a technique for implementing Smalltalk-like blocks in Java.

The Formatter Class in J2SE 5.0 (18-Mar-2004)
A very brief article written for Gamelan.com (part of Developer.com) 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.

Getting Test Doubles in Place (3-Jan-2008)
Written for Developer.com. 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.

Java 5's BlockingQueue (22-Nov-2006)
Article appearing at Gamelan.com (part of Developer.com). A code-based discussion that demonstrates use of the BlockingQueue class found in Java 5's concurrency packages.

Java 5's DelayQueue (18-Jan-2007)
An article appearing at Gamelan.com (part of Developer.com) that 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.

JavaOne Spotlight: OpenJDK (5/10/2007)
Written for Developer.com. A brief overview of OpenJDK, officially announced at JavaOne, and its implications.

Looking at Varargs in J2SE 5.0 (11-Mar-2004)
A very brief article written for Gamelan.com (part of Developer.com) that overviews the varargs (variable arguments) feature in J2SE 5.0.

Maintenance Development (19-Oct-2006)
How do we best deal with maintenance programming?

Making the Grade (part 2 of 3) (12-Mar-2004)
The second in a series of three articles published in Software Development magazine (now part of Dr. Dobbs) about the changes in Java J2SE version 5.0. This installment digs deeper into the new generics feature.

Moving Forward with Automated Acceptance Testing (1-Dec-2006)
Part two of a three part introduction to acceptance testing using FitNesse. Hosted at Developer.com.

The Need for Automated Acceptance Testing (14-Nov-2006)
Part one of a three part introduction to acceptance testing using FitNesse. Hosted at Developer.com.

Pair Programming Dos and Don'ts (8-Jan-2007)
An article appearing at Developer.com. Twenty-one specific recommendations for pair programming.

Pair Programming Observations (9-Jan-2005)
A discussion about resistance to pair programming that also touches on many of the benefits of pairing.

Patterns and Alexander (15-Apr-2004)
A brief reflection on software design patterns, Christopher Alexander, and architects.

Polymorphic Enums in J2SE 5.0 (12-Feb-2004)
A follow-up to Typesafe Enum: Using enum in J2SE 5.0 (Tiger), this article shows an advanced technique for creating polymorphic enum constants.

Principles for Agile Metrics (7-Dec-2007)
Written for Developer.com. 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.

Small Methods: Nine Benefits of Making Your Methods Shorter (20-Jan-2004)
A list of nine benefits of making your methods shorter.

Sustainable Pace (06-Oct-2003)
A discussion of the XP practice known as "Sustainable Pace." (née 40-hour week)

Sweet and Simple (part 3 of 3) (12-Apr-2004)
The final installment in a series of three articles published in Software Development magazine (now part of Dr. Dobbs) 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.

Test-Driven Development in C/C++ (15-Apr-2003)
A lead article in C/C++ Users Journal about how to do test-driven development when working in C. Written with Dr. Robert Koss.

Test-Driving a Java Command Line Application (3-Apr-2007)
There are a few ways to approach writing unit tests for a Java main method. Should you bother? I think so! Hosted at Developer.com.

Testability and Design (10-Oct-2007)
This article discusses some supporting ideas for this argument that, in most cases, a good design is also a testable design (and conversely, that an untestable design is not a good design). Hosted at Developer.com.

Tiger Stripes (part 1 of 3) (10-Feb-2004)
The first in a series of three articles published in Software Development magazine (now part of Dr. Dobbs) about the changes in Java J2SE version 5.0. This installment overviews the changes and begins a discussion on the generics feature.

Tools, Iterations, and Stories (29-Oct-2007)
A brief article written for Developer.com. 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?

Typesafe Enum: Using enum in J2SE 5.0 (12-Nov-2003, updated 20-Jan-2004)
Demonstrates use of the new typesafe enum facility in Java J2SE 5.0.

Using For Loops in J2SE 5.0 (22-Apr-2004)
A brief article written for Gamelan.com (part of Developer.com) that discusses the foreach loop in J2SE 5.0.

What Can Go Wrong With XP (Sep-2003)
Some of the pitfalls to watch out for when adopting XP.

Why Pair?: Challenges and Rewards of Pair Programming (7-Feb-2007)
An article written for Developer.com that discusses many of the merits behind pair programming.

Working With Design Patterns: Adapter (6-Feb-2008)
Written for Developer.com. 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: Bridge (5-Mar-2008)
Written for Developer.com. 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: Composite (2-Jul-2007)
Written for Developer.com. 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: Decorator (18-Jul-2007)
Written for Developer.com. 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: Facade (21-Feb-2007)
Written for Developer.com. Object-oriented languages provide great opportunities to isolate complexity in a system. A facade buries an unwieldy interface behind a simplified one.

Working With Design Patterns: Flyweight (14-May-2007)
Written for Developer.com. Got millions of objects? The flyweight pattern can help!

Working With Design Patterns: Memento (10-Jan-2008)
Written for Developer.com. The Memento design pattern presents a consistent solution for storing state, allowing you to build undo and redo support in your applications with ease.

Working With Design Patterns: Null Object (4-Sep-2007)
Written for Developer.com. Get those pesky "if null" constructs invading and cluttering your code by using the null object pattern!

Working With Design Patterns: Observer (17-Aug-2007)
Written for Developer.com. The observer pattern is an important concept in eliminating dual dependencies.

Working With Design Patterns: Prototype (2-Apr-2008)
Written for Developer.com. 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)
Written for Developer.com. 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: Strategy (13-Jun-2007)
Written for Developer.com. A simple implementation shows how the strategy pattern can be used to swap in varying algorithms.

Working With Design Patterns: Template Method (27-Apr-2007)
Written for Developer.com. 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: Visitor (28-Jan-2008)
Written for Developer.com. 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.

Writing a Simple Automated Test in FitNesse (15-Dec-2006)
Part three of a three part introduction to acceptance testing using FitNesse. Hosted at Developer.com.

Writing 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? Hosted at Developer.com.

XP Pros & Cons: Reflecting on XP Experiences (27-Apr-2005)
Correspondence with an associate about my experiences with XP.