Farewell to 'Design Techniques'
JavaWorld columnist closes with a brief history of his column, hints at what's to come
By Bill Venners, JavaWorld.com, 04/01/99
Page 4 of 5
Basically, my opinion is that good designs and code strike a balance between flexibility, performance, and other concerns,
but lean heavily toward flexibility. I believe that flexibility should rarely be sacrificed in the name of performance. Therefore,
the guidelines and idioms I presented in the Design Techniques column were aimed primarily at helping achieve flexibility in Java code and designs. The upcoming book, Flexible Java, will have the same focus.
Why flexibility?
Why do I feel that flexibility is generally the most important quality you can give to your designs and code? The reason is
that, as one of my managers used to put it, "software is a living product." Code isn't static. It is constantly being tweaked,
enhanced, fixed, and so on, by a team of programmers, a team that is usually in constant flux itself.
The code is like a magical text that is constantly expanding and contracting, changing shape on the behest of a group of elite
high priests and priestesses who know how to care for the thing. Flexibility is important precisely because the code must
constantly be changed, day to day, month to month, year to year. The more flexible the code is -- that is, the easier it is
to understand and change -- the more smoothly and efficiently this fundamental activity of software development can take place.
So, flexibility is the prime focus of the guidelines and idioms I presented in the Design Techniques column. I hope the articles in this column have helped the software development conversation in many corners of the world,
and that they continue to do so in the future. As always, the previous issues of JavaWorld will remain online, so you should always be able to get to Design Techniques material.
Index of 'Design Techniques' articles
Here is an annotated list (in chronological order) of all the articles published in the Design Techniques series:
- Introduction to 'Design Techniques' (February 1998) -- The first installment of the 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, such as 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)
- 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 an 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)
Here is an annotated list of discussion topics at the Flexible Java Forum: