Stanley Kubasek has been a Java software developer in the NY/NJ area for the past 7 years. He maintains a software blog, The Pragmatic Craftsman, available from his site http://kubasek.com.
The Rich Engineering Heritage Behind Dependency Injection
Andrew McVeigh takes us on a tour of the rich heritage behind dependency injection, what it represents, and tells us why its here to stay.
NetBeans 6: Matisse Updates
NetBeans 6 delivers great updates to the Matisse GUI builder. Spend a few minutes with Roman Strobl and get an expert briefing on what's new and what has changed. (sponsored)
Introduction to Groovy Part 3
In this, the third and final installation of Andres' Introduction to Groovy series, you learn about how Groovy handles variable numbers of arguments, named parameters, currying, and more about Groovy operators. Including, some new operators.
Easier Custom Components with Swing Fuse
Swing Fuse (actually just Fuse), is a framework designed to make it easier to create your own custom desktop components. In this article, Daniel Spiewak shows you how to get started and provides sample source code you can download.
Benchmark Analysis: Guice vs Spring
Willam Louth shows how he uses JXInsight Probes to investigate probable performance issues with code bases that he is not familiar with. He also highlights possible pitfalls in creating a benchmark, as well as in the analysis of results.Implementation Patterns
| Author(s) | Kent Beck |
|---|---|
| Publisher | Addison Wesley |
| PubDate | 2007, First Edition |
| Reviewer | Stanley Kubasek |
 |
Purchase and help Javalobby |
Table of Contents
|
One Minute Review
Sections
Intent & Audience
The goal of this book is to help you write better code. Better? Communicative, simple and flexible.
The author focuses on programming techniques that enhance communication. Numerous notes and suggestions, taken out of author's own experience, are presented in this book. The author basically tries to tell us what he's learned and what has worked for him.
Intended audience? Any Java programmer. I think this book is more useful to a junior to mid-level Java programmer, though. There are a lot of good suggestions for effective usage and how to make your code better. This book can also be useful for experienced programmers, as it could serve as a refresher of effective usage. In either case, you will learn at least a few new techniques on how to write a more communicative code.
Back to topRelevance of material
This is not a typical "patterns" book. I think it should have a title "Implementation Notes," as it mostly contains author's notes and suggestions. I expected more of "Refactoring" style: a little discussion, followed by a before-and-after code walk through. To me, that style is the most direct, and most unambiguous way to explain patterns. In this regard, I'm disappointed in this book.
This book does contain a lot of excellent suggestions for making your code clearer. In my opinion, if you follow the suggestions in this book, you will become a better programmer.
Rating
First four chapters are excellent. Every programmer should read them. In these four chapters the author presents his case why you should write better code. Backed by his experience and other supporting material. The remaining chapters contains so much excellent information. Only if it was presented in a different form. To me, it did not contain enough examples – this type of information should be driven by examples. At times, I found it hard to continue reading; at times I did not comprehend what the author is talking about; I just felt frustrated at times. Had this information been presented in the form of a typical patterns book, this would be a classic.
| Relevance |   |
|---|---|
| Readability | |
| Overall | |
Chapter highlights
Chapter 1: Introduction
Just like the title says, the author introduces the book and explains what you will find in this book.
Chapter 2: Patterns
In this very short, introductory chapter, the author gives a discussion on patterns. He talks about how you use patterns to write reasonable solutions to common problems. Good, concise, to the point.
Chapter 3: Theory of Programming
This is an excellent chapter: the best chapter in this book, in my opinion.
It starts with a great set of programming values: Communication, Simplicity, and Flexibility. Each of these values is nicely explained. These fundamental values should be learned and followed by every programmer - programming would be much more fun!
The chapter finishes with an even better set of principles. The author covers the following principles: Local Consequences, Minimize Repetition, Logic and Data Together, Symmetry, Declarative Expression, Rate of Change.
Chapter 4: Motivation
In this quick (2 page) chapter, the author gives enough reasons why you should write maintainable code. In my opinion, a lot of programmers don't know that the cost of maintenance is much higher than the cost of initial development. If you're not sure, this chapter should convince you.
Chapter 5: Class
In this chapter, the author goes through patterns that pertain to classes. "Classes are important for communication because they describe, potentially, many specific things." Naming of classes, interfaces, abstract classes and other aspects of dealing with classes are covered in this chapter.
The author gives you a helping hand, tells you how to implement a class so it is easy to understand.
This chapter, to me, was not concrete enough. At times, because of ack of examples, I did not know exactly what the author meant. More examples would help.
Chapter 6: State
In this chapter, the author describes how to communicate the use of state. Patterns such as Indirect Access, Collecting Parameter, and many more are covered in this chapter. The author continues with the style of the previous chapter: free discussion of the patterns, filled with its own insight, and sometimes sprinkled with examples.
Chapter 7: Behavior
How to express the behavior of a program is explained in this chapter. Patterns relating to the flow of messages, message composition, exceptions and exception flows are covered in this chapter.
Chapter 8: Methods
Patterns relating to methods are covered in this chapter. How to create methods, method visibility, overloaded and overridden methods, return types, and many more patterns are explained.
Chapter 9: Collections
In this chapter, the author covers Collections 101. A basic chapter. Useful if you want an intro and performance stats of Java Collections. Otherwise, not a lot of useful information for a seasoned programmer.
Chapter 10: Evolving Frameworks
This chapter focuses on the challenges of framework development. The author focuses on how to maintain framework's flexibility, how to avoid incompatible upgrades, and how to add new functionality without changing any existing functionality. Useful chapter if you're maintaining a framework.
Resources
Refactoring - the best (a classic, some might say) on how to improve the quality of your code without changing it's functionality.
