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.

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.

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 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.

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.

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.

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

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!

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.

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.

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.

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.

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

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.

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

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.

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.

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

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.

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.

Take advantage of Java's CountDownLatch to simplify your multithreaded applications.

The fundamentals of test-driven development can be learned in minutes. As with any discipline, TDD can take a career to master. Using these tips can help developers on this path to mastery.