Rating: 
Summary: Extremely practical !
Review: This book is an excellent style guide for the Java programmer. Your code will really benefit very significantly by following the principles listed. The book starts out about general principles. " Follow standards whenever you write a code ( my favorite! )It talks about formatting conventions. Then naming conventions. Then it talks about documentation conventions, both the internal comments and JavaDoc. Then it really talks about programming conventions. Then it finally gets to packaging conventions. Following principles accessible in this book will make your life easier! You will understand and easily maintainable code.
Rating: 
Summary: Coding style is important
Review: This book is really a set of rules for coding style. It is good for that, and has common sense rules. However for such a SMALL book, you pay a lot. The content fits in 118 pages that might be found on the web in various forms. So the value of the price is of question to me.The benefit of purchasing the book is that it makes it handy to look up a style format if you have questions. That is usually the only time I reach for this book - most of it I have been doing for a while. If you are trying to set a standard in your company/group/etc, and want people to have this, it would be a good one to fill the need. (It is suprising to find out how many people do not know these rules of style). I think that this book could have been published and sold for five dollars (US) - then I would have given it 5 stars. Its price is my only issue - not its content.
Rating:
Summary: An excellent guide to Java coding standards
Review: This book is the marriage of Rogue Wave Java coding standards with those of Scott Amber. Standards are formulated as brief rules with one or more paragraphs of explanation, illustration, and justification. The first part of the book is devoted to general principles. There are just a few of these. For example, "Do it right the first time," that is, follow standards whenever you write code, even "throw-away" code. The second part is devoted to formatting conventions. These have to do with indentation, placement of openning and closing brackets, etc. I second the prohibition against hard tabs--use spaces instead. I've seen code written in an IDE that looks bizarre when viewed in a simple text editor like vi. The third part is devoted to naming conventions. Good naming conventions make code more nearly self-documenting. An example from this part is "Capitalize only the first letter in acronyms." For example, use "loadXmlDocument()" instead of "loadXMLDocument()," where the obvious exception is constant names which should contain only capital letters. Java facilitates a deeper integration of code and documentation (via JavaDoc) than most programming languages. The fourth part is devoted to documentation conventions--both JavaDoc and internal comments. If you have ever struggled with the wording of a JavaDoc comment you will appreciate the authors' no-nonsense advice. The fifth part is devoted to programming conventions. An example from this part is "Do not synchronize an entire method if the method contains significant operations that do not need synchronization," that is, use a synchronized block for the appropriate sequence of statements rather than synchronizing the whole method. The sixth part is devoted to packaging conventions. Package naming conventions are covered in part three. An example from this part is "Maximize abstraction to maximize stability." That is, use "stable abstractions to create stable packages." Consistently following standards such as those offered here will result in simpler, more understandable, more easily maintainable code, a worthy goal.
Rating:
Summary: Excellent summary of coding style and common practices
Review: This book offers a good style reference for programmers to agree upon, enabling them to move on to focus attention on larger issues for discussion. Along with style guidelines, the book offers a good assortment of coding practice suggestions as well. Such as; lazy instantiation of objects, not creating objects that might go unused, and many more. The book consists primarily of concepts most programmers would consider common sense. However, the fact that it pools so many of these relatively simple concepts is what makes it so valuable. For work environments where people care about spending their time debating more architectural and design related issues, this book is a must to snub out any time wasting coding standards bickering. This book coupled with Dov Bulka's 'Java Performance and Scalability' are must-reads.
Rating:
Summary: Good start - Needs a 2nd edition
Review: This book provides a strong basis for establishing the always needed coding standards on every project. But, just as with the classic Elements of Style, it needs an updated edition. One major note that should be addressed is the recommendation on double-checked locking - the fact that this flat out does not work in Java has been well-documented and published on multiple occasions. I look forward to the 2nd edition!
Rating:
Summary: Good start - Needs a 2nd edition
Review: This book provides a strong basis for establishing the always needed coding standards on every project. But, just as with the classic Elements of Style, it needs an updated edition. One major note that should be addressed is the recommendation on double-checked locking - the fact that this flat out does not work in Java has been well-documented and published on multiple occasions. I look forward to the 2nd edition!
Rating: 
Summary: Useful for (but not organized for) begginers and experts
Review: This book shows rules mostly for teams or advanced Java programers; however, some parts can be useful also as a reference for starters or intermediate programers. Those rules are not organized by levels (say, from basic to intermediate, or from simple programs to team projects), but by topics: The book has conventions on formatting, naming, documentation, programming and packaging. Not all the rules and conventions have examples, so you must know the Java language in depth (or have experience in programming) to understand some of them. At the end of the book you'll find a summary of all the 108 rules and a glossary. The summary is convenient for quick reference or reviewing. It will not help you to learn programming. It is a good complement for your favorite Java manual.
Rating:
Summary: A Great Little Book
Review: This is a great little book. It deserves kudos for saying anything at all useful about Java in 128 pages, but the size is actually sufficient to the book's purpose. This is a great introduction to generally recommended coding practices, and an invaluable desktop reference for anyone wanting to write Java that other humans will actually be able to read and understand.
Rating:
Summary: Very comprehensive do's and don'ts!
Review: This is an excellent quality work that can be used to instill quality in others. Don't bother writing up a long list of company do's and don'ts, just hand out this book. It covers coding style, documentation style, and lots of Java tips and techniques. It's exactly what I've been looking for, I just wish someone would write a similar book for HTML, XML, XSL, Transact-SQL, and all the other languages we use at work. This book is very concise, I was able to read it in a day, but it very heavily favored quality over quantity. I can't think of a tip that they left out, and every tip that needed illustration had an accompanying clear example. A perfect work and just what I've been needing.
Rating:
Summary: Messy Code
Review: Two things immediately irk me in this book. First is the sloppy K&R style that I really find irritating to debug: public class MyClass { ... } The curly brackets belong inline so you know where the SCOPE of the code begins and ends like this: public class MyClass { ... } This is much more readable and easier to figure out which brackets go with which statement, especially when you have multi-nested statements! Think of it this way if you write a pascal program you don't write it like this procedure MouseUp(integer Xpos, integer Ypos) begin ... end; The debate over using Tab or spaces is less irritable except when I have to modify a nested class and have to spend alot of time counting spaces when a couple tabs would have cost less time. Also when you use tabs, the block structure really stands out well. The block structure is the whole reason for using the basic C syntax, so if you bland the block by only having two space tabs and hiding the begining curly bracket, the block does not stand out. you can't see the forest for the trees. The other complaint is the lack of Hungarian or an mention of it. Knowing the type by having it in the name of the method, var and class can save hours of time looking for the definition as well as save time naming them. iZipCode tells me right away that the zip is stored as an int and not a string.
| 
