Featured White Papers

• Measuring Risk to Improve Java Software Quality
• Do You Really Get Classloaders?
• Pragmatic Continuous Delivery with Jenkins, Nexus, and LiveRebel
• Your Next Java Web App: Less XML, No Long Restarts, Fewer Hassles
• Coding with JRebel, Java Forever Changed
• 2012 Developer Productivity Report: Java Tools, Tech, Devs, and Data

Sponsored Links

• Graph databases are 1000x faster than relational.

  Learn More!

• Career opportunities at Harman- Careers That'll Rock Your Socks Off.

  Learn More!

• Developer-friendly Java PDF libraries by Qoppa Software

  Live Demos

• Stop blaming your app! Diagnose Java performance issues.

  Free tool >

• UrbanCode: Go From Continuous Integration to
  Continuous Delivery

  Learn More!

Sponsored Links

Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs

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)

The Flexible Java Forum

Here is an annotated list of discussion topics at the Flexible Java Forum: