Customer Reviews

Practical Java™ Programming Language Guide

5 star:		(26)
4 star:		(6)
3 star:		(3)
2 star:		(2)
1 star:		(2)

 

 

Practical Java Programming Language Guide used the "essay" style similar to "Effective C++" to explain some issues in Java. It covers General Technique,Object and Equality, Exception Handling, Performance, Multithreading and Class & Interface with total 68 'Praxis'.

This 'essay' style is my favorite. It represents topics in each small 'essay' and you can easily pick up the topic you are interested in without getting lost, or just read the book from cover-to-cover. It is also very useful for checking up something in which you'd like to have more understanding. You won't get bored there!

I would say this book is for intermediate to advance Java programmer. It is not a book to learn how to program in Java, it is a good book to get more understanding with Java. It will help you learn more about Java, become a better Java programmer. I feel like I've learn a lot even with my 4-years professional Java programming experience. Also, if you are new to Java, this book will help you Ace your Java interview:)

Sometimes, as a programmer, we tend to forget the low-level details as to why we do things that way. For example, the difference between "==" and ".equals()", we all know we need to use .equals() to comare Object reference, use "==" for primitive data type. After reading this book, I know more about "why" we did things that way than just "what" to do. That's just a small example, I bet you'll find lots of "ah-ha" monents in reading this book.

One shortcoming I'd like to point out is there are some duplicates in explaining some topic. Maybe the author wanted to emphasis some points but I feel like it is redundant. e.g. both Praxis 11 and praxis 15 talk about how to immplement equals() method which I think only one would be enough. Also, it would be great if the broadth of the topic was expanded some more.

Overall, it is a great book. I've been enjoying reading it and find it very helpful. I am looking forward to something like "More practical Java programming Language Guide" coming...

I find Peter Haggar's *Practical Java Programming Language Guide* to be a very handy companion when doing software design. Since his "Praxes" are largely independent nuggets of wisdom, I can turn to one readily when I am deliberating over a design decision in Java, and seek Peter's advice. I have also read a few of the chapters from beginning to end to gain a deeper grounding in a particular area (e.g., exception handling). In summary, this is a very to-the-point book, full of practical advice for even seasoned Java developers.

I wish I had had this book when I first started learning Java. Peter covers many topics that I have struggled with in great detail. I was just beginning to think I knew Java very well. Thanks to Peter now I do.

This is a pretty good reference, providing a collection of 'praxes' on how to write better code. It covers issues of design, performance, concurrency, readability, and so on. Although not all this material is new to me, it is presented in a format that is easy to thumb through or to use as a reference when making design decisions. One drawback -- I find the text is in places repetitive, where the author reiterates a point in several ways without providing any new insight. So I've found myself skimming in a few places. This does not affect the overall readability and usefulness of this book, though, and I recommend it to intermediate/advanced developers looking for ways to improve their code.

Scott Meyer's books were so useful for C++ and this one takes the same approach for Java. I have already found several tips in here that have been a big help on the job and I have only had the book a few days. I really like the way he goes to the bytecode level to provide performance analysis. I haven't seen any of the other Java books provide this type of approach and information.

'Practical Java' provides a valuable source of information for even the most seasoned Java programmer. It covers topics to a depth that is hard to find elsewhere. I found the chapters on performance and exception handling to be especially enlightening. I would recommend this book to any Java developer who wishes to have a deeper understanding of the Java language.

Compare this book with <<Java Pitfalls>> (refer to my review of <<Java Pitfalls>> as well)

Pros:

*)Covers more language syntax.

*)Explanation is more detailed and clearer.

*)Deep discussion about Equality, Exception Handling, Multithreading, Classes and Interfaces.

Cons:

*)Does not cover Java library, JFC at all.

*)Examples in this book are too simple.

*)Some items are not concise enough.

Suggestion:

Start from this book and read <<Java Pitfalls>> for topics not covered in this book and more complex examples.

This book provides clear, detailed instructions on how to avoid the most common Java programming mistakes -- ones that can lead to erroneous results, thread deadlock, or just poor performance. Best for the beginning or intermediate Java programmer. Much of the material in this book is covered in more detail in Eckel's "Thinking in Java" (still waiting for the 2nd edition!) or Lea's "Concurrent Programming in Java", but this is a much shorter read. One drawback: most of the section on performance improvements is not sufficiently rewarding to be useful by most programmers, and could distract from the more crucial tips offered in other sections.

A waste of your money

I gave this book one star because it fell short of expectations! There's no expert advice here. In fact, it will all seem pretty obvious if you have a solid foundation in Java 2, like the one you get by prepping for the Programmer's Certification or thoroughly reading Bruce Eckel's Thinking in Java (available in print from Amazon, or online).

This is a book worth borrowing for a couple of days. I bet you'll skip most of the sections.

Here is an example of what I mean: the author will write a method using the String "+" operator and another using Stringuffer's append(), benchmark them and show you the bytecodes (oh!). He'll advise you not to create unnecessary objects, not to initialize variables more than once, to avoid synchronization you don't need, and here's the best one: don't throw an exception as a means of ending a loop, use break instead. Come on, these are hardly insights from an "in-the-trenches expert"! Or take the multithreading section: there's less information there than in the JDK documentation.

However, its main defect is not obviety or shallowness, it's its almost lack of coverage of Java 2 features, such as Collections, inner classes, and References (e.g. almost all examples use Vector). This book is highly overrated! Try to see a copy before you buy it.

This book documents all those things every Java programmer should know. Like Scott Meyer's "Effective C++" series, we use it to settle arguments over the 'right-way' to write code (for Java in this case). Not only does it provide an easy to reference list of these 'Praxises' but it explains why. It is much easier to agree on how when the book has explained the why.

I do have to agree some of the negative reviews which state that some of the tips are obvious but I have worked with some well-seasoned Java programmers who still don't get them. If the obvious ones were not included I would be here critizing the book for incompleteness. This book is definitely for all Java programmers.

As future Java versions are released and adopted by the industry, I am hoping to see a "More Practical Java" book like Scott Meyer's "More Effective C++".