Essential Java Style: Patterns for Implementation

by Jeff Langr and Jeff Lnagr

The definitive style guide for writing readable, maintainable Java code With Essential Java Style, developers finally have a Java style guide that offers detailed patterns for real-world... This description may be from another edition of this product.

• Format: Paperback
• Language: English
• ISBN: 0130850861
• ISBN13: 9780130850867
• Release Date: August 1999
• Publisher: Prentice Hall PTR
• Length: 277 Pages
• Weight: 0.55 lbs.
• Dimensions: 0.8" x 6.0" x 9.0"

Customer Reviews

useful reference for code reviews and as team standard.

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

A must have for the professional Java Programmer

After OO analysis and UML artifacts lies a programmer with a computer and an hopefuly an IDE faced with making decisions on how to implement a design. That person needs this book.Beginners and experienced developers alike will benefit from this book because it uses concise examples to explain coding techniques for easier maintenance of source code and better performance. Occasionally, the author describes and example of "BAD" code to illustrate how not to solve a problem and then describes "GOOD" code. Using compare and contrast in this manner helped make the patterns more meaningful and easier to remember.

A book every manager should buy their developers

As soon as your star, ego-swollen developer signs on, you should hand them anything by Booch and also this book. Then quiz him or her. Get your developers on track from day one and prevent the spaghetti code and maintenance nightmare you'll be nursing in two years.This is an unusually complete pattern guidebook which contains very specific, practical coding gems applicable in any language conducive to object-oriented development e.g. Java, C++, Powerbuilder, and yes, with enough sweat, even VB. It is not a "Patterns for Idiots" book, and it's not the definitive JDK reference, but it sits right in front of me on my desk (with several earmarks).As a consultant, I'm constantly mulling through others' bad code, and in the back of my mind I'm always thinking "Who was the idiot who taught these folks to code! " The examples in this book will point developers in the right direction, regardless of their background.The format is excellent, and what I like best about this book is that the author clearly explains when to use a particular pattern and WHY. For example, "What's the difference between a HashTable and HashMap?" Simple question... but when and how to use each one is clearly explained for both JDK 1.1 and 1.2It is also an excellent "bridge" book for bringing developers from another language into Java, and it lays an excellent foundation for developers of any experience level.Kudos to Mr. Langr... now please hurry with an "Essential XML Style" book.

very readable practical solutions for improving code

A straightforward catalog of coding guidelines presented in pattern form. This one is much better written than the other books I've read in the Java patterns / idioms space. Concrete examples help greatly to explain the relatively simple concepts. I thought it was good enough to recommend introducing in our shop as a review guideline.

A wonderful book of Java idioms; an introduction to Patterns

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!