Design Techniques

Design Techniques

Farewell to 'Design Techniques'
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)
Bill Venners, April 1999

Design with static members
In this installment of his Design Techniques column, Bill Venners discusses the ways in which static fields and methods, which exist outside of objects, fit in a design that's object-oriented. (1,500 words)
Bill Venners, March 1999

Design with runtime class information
In this installment of Design Techniques, Bill gives advice on using runtime class information in Java programs. He talks about the method area of the JVM and the structure of Java objects, upcasting and downcasting, polymorphism and dynamic binding, java.lang.Class and reflection, and -- perhaps most importantly -- he reveals how best to ask a hippopotamus to dance. (4,000 words)
Bill Venners, February 1999

Design with dynamic extension
In this installment of Design Techniques, Bill takes a look at a less commonly understood aspect of Java's architecture: dynamic extension. He discusses the two kinds of dynamic extension, forName() and class loaders, and offers guidelines on how to use these tools to make your programs more customizable. (2,500 words)
Bill Venners, January 1999

Designing with interfaces
In this installment of my Design Techniques column, I describe my process to understanding Java's interface. I talk about multiple inheritance and the diamond problem, polymorphism and dynamic binding, separation of interface and implementation as the spirit of Java, and my ultimate epiphany on how we should think about and use interfaces when we design. (3,500 words)
Bill Venners, December 1998

Inheritance versus composition: Which one should you choose?
In this installment of my Design Techniques column, I analyze the flexibility and performance implications of inheritance and composition, and I give guidelines on the appropriate use of each. (2,500 words)
Bill Venners, November 1998

The canonical object idiom
In this installment of the Design Techniques column, I propose "the canonical object" as a Java idiom. The article discusses the fundamental services that all objects in general should offer, shows how objects can offer these services, and names such objects "canonical." (2,500 words)
Bill Venners, October 1998

The 'event generator' idiom
In this installment of the Design Techniques column, Bill proposes the "event generator" as a Java idiom. The article provides a background on the concepts of patterns and idioms, describes the observer pattern, and demonstrates the idiomatic way to implement the observer pattern in Java. (3,000 words)
Bill Venners, September 1998

Design for thread safety
This installment of the Design Techniques column gives you design guidelines that pertain to thread safety. It provides a background on the concept of thread safety and shows several examples of objects that are and are not thread-safe, including two illustrative applets. In addition, the article offers guidelines to help you decide when thread safety is appropriate and how best to achieve it. (3,000 words)
Bill Venners, August 1998

Designing with exceptions
This installment of the Design Techniques column discusses design guidelines that pertain to exceptions. It focuses primarily on how to decide when to use exceptions, and gives several examples from the Java API that illustrate appropriate uses of exceptions. In addition, the article provides some general guidelines that can help you use exceptions in those situations where you've decided they are appropriate. (3,000 words)
Bill Venners, July 1998

Object finalization and cleanup
This installment of the Design Techniques column discusses the design guidelines that pertain to the end of an object's life. Columnist Bill Venners gives an overview of the rules of garbage collection, discusses finalizers, and suggests ways to design objects such that finite resources aren't monopolized. (3,500 words)
Bill Venners, June 1998

What's a method to do?
In this installment of the Design Techniques column, brush up on how -- and why -- to divide a class's functionality among its methods. Ever the minimalist, Bill Venners demonstrates how to maximize method cohesion while keeping the total number of methods to a manageable level. (3,500 words)
Bill Venners, May 1998

Designing fields and methods
This installment of the Design Techniques column shows how some fundamental software design techniques, like avoiding special data values and minimizing method coupling, apply to Java. (4,000 words)
Bill Venners, April 1998

Designing object initialization
This installment of the Design Techniques column 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) :END_SUMMARY
Bill Venners, March 1998

Introduction to "Design Techniques"
This first installment of the new Design Techniques column introduces the column and discusses the larger issues involved in designing Java programs. In addition, we'll examine the software development process in general, describe the role of design within that process, and look at the various and competing goals of a "good" software design. (4,500 words)
Bill Venners, February 1998