Essential Java Style: Patterns for Implementation

Rating:
Summary: An absolute must
Review: After working on large scale projects, I've picked up a lot of 'bits of style' that have become nessecary to allow others to maintain my code. As well as making the process of debugging and revamping my own and other's code managable.

I also picked up how to recognize the performance gain vs. maintainablity issues and which one was really more valuable.

Then a friend showed me this book. Looking through the book, I found all these things, with names and actual descriptions. All the nebulus things that I had been thinking of was actually written down. Plus some!

I would highly recomend this book to newbee and expert alike. Newbees will learn and practice good style from the begining, and experts will see the validations of what they have been thinking all along.

Rating:
Summary: A must have for the professional Java Programmer
Review: I agree with many of the comments of praise for this book, but there is one feature lacking that would pop it up to five stars: a system for cross-referencing.

Throughout the book Langr compares a pattern to other patterns covered in the book. However, the reference to other patterns is by name only -- no page number to find out more information. Because the patterns are grouped functionally, and not alphabetically, one must go through the time consuming process of searching the index for the pages where the pattern is explained. Even the index is not entirely helpful, since it lists all references to a pattern and one often has to check several times to find where the pattern is discussed, not simply referred to.

The most annoying part for me was the Pattern Summary in Appendix B. Of all places where page numbers for detailed discussion would be appropriate, this is it. Sadly, the table only sumarizes the patterns and one is forced to resort to the index once again.

The format seems to be more suited for a read-through than a true refernce book. I do hope in revisions of this printing, Prentice Hall will rectify this poor organization.

As far as the content of the book goes -- nothing earth-shattering, but it is nice to have all this information collected in one volume. I think every serrious Java developer should give this book a good look.

Rating:
Summary: Interesting but not always practical
Review: I bought this book to get information on how the industry defines appropriate java programming "style".

I found it a strange mix of very basic rules (such as "How do you define a constant variable?" (define a static final class varialbe)) that most people programming in Java for more than 6 months would already know, and detailed information on farily obvious problems (e.g. "What do you sue when elements are frequently added to/removed from the middle or beginning of a collection?"..."Use a LinkedList object").

Having said this, I do think it is a good book for people new to Java looking for a "style" guide. I would recommend this book to previous programmers who are attempting to migrate to Java, or previous Java programmers with mid-level experience (3 months - 1 year). If you are an expert Java programmer, you will probably already know most of what is in this book. Save your money on this one.

Rating:
Summary: Good concise source of important Java and OO concepts.
Review: I come from a similar background as Jeff; COBOL and Smalltalk and I'm just learning Java. The difference between structured/procedural code like COBOL, and true OO code like Smalltalk and Java is significant. I've seen many programmers (including myself) jump to an OO language but still code procedurally. It's a matter of thinking conceptually in objects, and that turns out to be surprisingly difficult for people who have coded procedurally for some time. (This includes Visual Basic, which is not a true OO language). They will think it's OO code, but in reality it isn't, or at least not good OO code.

Jeff's book hightlights the essence of Java from the one-foot level: the actual code. Keeping methods short and sweet is a concept lost on many programmers making the jump to OO. Thinking in terms of patterns of objects interacting with each other is also a change in approach to the way many programmers "intuit" the design of their code.

Learning Java is not as much about learning the syntax as it is about developing object models before you begin coding, and then once you have the model, it's about implementing the methods correctly. I believe Jeff does a nice job of showing us what well formed OO methods really should look and feel like, as well as creating a style framework on which to base an approach to create consistent, reusable code.

Rating:
Summary: Great
Review: I think this book is fantastic. I've used this book for coding standards and just to generally improve coding techniques. While it's not quite as good as Refactoring I think it's a good introductory level book with enough content for intermediate programmers.

Being a code style book it's nice to see well laid out code. The explanations are thorough although sometimes confused. Of course, he dodges the curly brace question.

Rating:
Summary: Good Reference for Java Programming Teams
Review: The "patterns" in the title of this book refers to a collection of coding principles for translating object-oriented designs into Java programs. This is not a design patterns book, but rather a book on Java style, usage, idioms, and best practices.

Because the author comes from a Smalltalk background, the patterns are highly object-oriented. This may be disorienting to developers from a C++ or procedural background, but the longer I program in Java the more I'm convinced that purer OO code is better code. Developers who use UML or object modeling in the design phase will get the most mileage out of this book.

One of the main uses of the book is for use during code reviews. The patterns are named so that you can say "this code should use the Default Value Constant pattern" rather than "I think rule #87 should be applied here". Some of the patterns will be obvious to experienced Java programmers, but are included because many teams have junior programmers who are new to Java. Unfortunately, the book is not organized so that you can quickly find the discussion of a particular pattern. The Pattern Summary does not include page numbers and the Index includes all page numbers where each pattern is mentioned, without bolding or italicizing the pages where the pattern is described.

There are a number of idioms specific to Java that are not covered well in the book. The section on equals does not cover the important case of implementing equals in subclasses and doesn't mention that hashCode should be consistant with equals. There is no coverage of using clone to make copies of objects. In addition, there is a significant amount of outdated and incorrect information. I would recommend using this book in conjuction with another book on Java idioms, such as Effective Java or Practical Java.

Much of the book is distracting because the author continually points out the "deficiencies" of Java. I do agree with many of his comments, but they serve no purpose in this book and quickly become irritating. The frequent comparisons to Smalltalk and C++ are also of little use. I did find that the brace and variable naming conventions did not adhere to Sun's coding conventions, but other than that the book uses standard Java programming style.

Overall, the book is a good one, but I look forward to a new edition that is expanded, corrected, updated, and doesn't have so many useless comments.

Rating:
Summary: Good Reference for Java Programming Teams
Review: The "patterns" in the title of this book refers to a collection of coding principles for translating object-oriented designs into Java programs. This is not a design patterns book, but rather a book on Java style, usage, idioms, and best practices.

Because the author comes from a Smalltalk background, the patterns are highly object-oriented. This may be disorienting to developers from a C++ or procedural background, but the longer I program in Java the more I'm convinced that purer OO code is better code. Developers who use UML or object modeling in the design phase will get the most mileage out of this book.

One of the main uses of the book is for use during code reviews. The patterns are named so that you can say "this code should use the Default Value Constant pattern" rather than "I think rule #87 should be applied here". Some of the patterns will be obvious to experienced Java programmers, but are included because many teams have junior programmers who are new to Java. Unfortunately, the book is not organized so that you can quickly find the discussion of a particular pattern. The Pattern Summary does not include page numbers and the Index includes all page numbers where each pattern is mentioned, without bolding or italicizing the pages where the pattern is described.

There are a number of idioms specific to Java that are not covered well in the book. The section on equals does not cover the important case of implementing equals in subclasses and doesn't mention that hashCode should be consistant with equals. There is no coverage of using clone to make copies of objects. In addition, there is a significant amount of outdated and incorrect information. I would recommend using this book in conjuction with another book on Java idioms, such as Effective Java or Practical Java.

Much of the book is distracting because the author continually points out the "deficiencies" of Java. I do agree with many of his comments, but they serve no purpose in this book and quickly become irritating. The frequent comparisons to Smalltalk and C++ are also of little use. I did find that the brace and variable naming conventions did not adhere to Sun's coding conventions, but other than that the book uses standard Java programming style.

Overall, the book is a good one, but I look forward to a new edition that is expanded, corrected, updated, and doesn't have so many useless comments.

Rating:
Summary: A wonderful book of Java idioms; an introduction to Patterns
Review: This book is composed of short 2-3 page descriptions of some Highly Recommended Programming Practices for the Java language. Some -- like appropriate commenting styles -- will probably be obvious to all but beginning programmers. Others -- like using closures for applying a function to all the elements in a collection -- may be heretofore unimagined concepts (at least for programmers never using other OO languages that have such concepts).

This book is extremely well written. Each concept is framed around the problem that the particular pattern addresses. The concept/pattern is then identified by category and related categories are listed. The mosaic of these mini-patterns provides an extremely gentle introduction to the world of patterns. This would be an appropriate text to read before tackling the seminal GoF book: Design Patterns.

A luxurious amount of the book is dedicated to Collections. And the author carefully shows what operations are available in a limited fashion in the 1.1 JDK and in the enhanced APIs in the 1.2 JDK.

I haven't read the whole book yet. I look forward to reading it over the next few weeks. My only complaint is a less-than-thorough index. However, it is still well-deserving of a five-star rating!

Rating:
Summary: Audience not understood, strong unfounded opinions
Review: Though the book has a comprehensive collection of various patterns, ideas and advices, the audience of the book is not clear. I am a certified Java developer and certified in UML-based OOAD, but found the book elementary, so did my colleagues who have OO experience and have recently started working with Java. Most of the time the book is stating the obvious, in not so lucid manner.

Now for the PARADOX: The programmers who will really want to read this book are experienced souls who want to design better. They will find little value in this book. The other kind hasn't cared so far and therefore surely won't buy this book.

I recommend Mark Grand's Patterns book - Vol I, at least it uses UML well and gives useful examples of Gang-of-Four patterns. For those looking to improve their understanding of OO concepts, read Java in Practice by Nigel Warren.

Another thing is the author has strong opinions which he presents in an almost cunning manner. He mentions in the main text that there was no need to make methods final. The methods are made final to avoid overriding in sub-classes. He then explains in the footnote why they be needed. He calls Java miserably slow, which sounds like such an uninformed and uneducated opinion.

He is trying to make money out of Java, and yet does not miss the opportunity to decisions made in the Java language design. I find that very hypocritical.

I give 2 stars to this book as it is a good collection of various ideas, most of which are not author's original.

Buy the other two recommended books to get better value for your money.

Rating:
Summary: Beware!!! This is not a patterns book!!!
Review: Translation into java of kent beck's smalltalk best practice patterns text. Very useful for training new OO programmer at code reviews, can point them at paticular pattern and say fix it that way. Note that this is a book of _coding_ patterns; if you want architecture, see GoF or Grant. Some overlap with Fowler's refactoring book. Am considering making it required reading for all on my projects.........AP