This page provides links to the articles of my Design Techniques column in JavaWorld. These articles are based on material developed for my current book project, Interface Design. For related discussion forum topics, visit the Flexible Java Forum.

The Articles
Introduction to "Design Techniques" (February 1998) -- This first installment of the new Design Techniques column introduces the column and discusses the larger issues involved in designing Java programs. In addition, it examines the software development process in general, describes the role of design within that process, and looks at the various and competing goals of a "good" software design. (4,500 words)

Object Initialization in Java (March 1998) -- This article describes in detail the process of object initialization in Java programs. It discusses constructors, initializers, instance initialization (<init>) methods, initialization and inheritance, object images on the heap, and the order in which an object's variables get initialized. It serves as a companion to the regular Design Techniques installment, "Designing object Initialization." (5,000 words)

Designing Object Initialization (March 1998) -- This installment of Design Techniques begins with a quick look at object design fundamentals, then goes on to discuss various approaches to designing initializers and constructors so as to facilitate the proper initialization of objects. (4,000 words)

Designing Fields and Methods (April 1998) -- This article shows how some fundamental software design techniques, like avoiding special data values and minimizing method coupling, apply to Java. (4,000 words)

What's a Method To Do? (May 1998) -- This article shows how to maximize method cohesion while avoiding method explosion. (3,500 words)

Object Finalization and Cleanup (June 1998) -- This article discusses design guidelines that pertain to the end of an object's life. (3,500 words)

The Hotspot Virtual Machine (June 1998) -- This article (published at developer.com) discusses the hotspot virtual machine and how this forthcoming technology impacts Java program design. (2,000 words)

Exceptions in Java (July 1998) -- This article gives an in-depth account of exceptions in the Java language and virtual machine. (6,000 words)

Designing with Exceptions (July 1998) -- This article discusses design guidelines concerning when and how to use exceptions. (3,000 words)

Designing for Thread Safety (August 1998) -- This article discusses design guidelines concerning when and how to make objects thread-safe. (3,000 words)

The Event Generator Idiom (September 1998) -- This article discusses how and when to make a Java class observable. (3,000 words)

The Canonical Object Idiom (October 1998) -- This article proposes and idiom that defines a baseline set of functionality for objects. (2,500 words)

Inheritance versus Composition (November 1998) -- This article discusses how to choose between inheritance and composition. (2,500 words)

Designing with Interfaces (December 1998) -- This article discusses how to use Java's interface. (2,500 words)

Designing with Dynamic Extension (January 1999) -- This article discusses how to use forName() and class loaders in designs. (2,500 words)

Designing with Runtime Class Information (February 1999) -- This article discusses how to use all the information about an object's class that is available at runtime. (3,500 words)

Designing with Static Members (March 1999) -- This article discusses how to use static fields and methods. (1,500 words)

Farewell to 'Design Techniques' (April 1999) -- This final installment of Design Techniques gives a brief history of the column, tracing its development and maturation, a topical index of the column's back issues, links to related discussion forum topics, and a hint of what's to come. (1,500 words)

Recommended Books
In conjunction with my Design Techniques column, I maintain a list of recommended design-related books for Java programmers.