Professional Java Programming

Rating:
Summary: A very good follow-up to Horton's "Beginning Java 2"
Review: I enjoyed Ivor Horton's "Beginning Java 2" title very much, and considered its only weakness to be the fact that it provides light coverage of the advanced topics. However, at over 1000 pages, BJ2 is already plenty long enough!

I was very pleased to see that Wrox came out with a new title which covered many of the advanced topics such as internationalization, creating custom GUI components, Java Native Interface (JNI), and many others. I initially feared that I would not enjoy this title as much as Horton's, but Brett did an excellent job. Although he does not cover J2EE technologies such as JSPs, servlets, and EJBs (I'm about to read "Professional Java Server Programming"), he does cover both client and server topics, many of which are relevant to thin client development. For example, I very much enjoyed his chapters on XML, threads, and internationalization, which is a topic that does not appear to get much attention in most Java books.

One thing that isn't covered in much depth here is object-oriented design, but again, that is covered in detail in another title: "Beginning Java Objects". To anyone new to Java and OO programming, I highly recommend these three titles.

Rating:
Summary: Great coverage of JDK 1.3 client and server topics
Review: I got this book after I read a positive review of it on Java Ranch and I wasn't disappointed. I was mostly interested in the chapters on i18n and XML, and those chapters alone would have made this book worth the money, but I found a lot more useful stuff that I didn't even expect to. I was already kind of familiar with threading having read some other materials on the topic but still found Brett's chapter to be clear and succinct. I like the fact that he minimizes the jargon and clearly explains terms that aren't necessarily obvious to someone like me at a beginner to intermediate level of expertise. I also like the fact that the code segments were short and only contained code relevant to the topic being discussed. The code examples in a lot of books are long and full of code that's not related to the topic, which makes it harder to understand.

Rating:
Summary: Everything not in the standard Java books and then some
Review: I love Arnold and Gosling's "The Java Programing Language" as a basis for learning Java. There are other specialized books that add to a solid foundation in Java, like Lea's "Concurrent Programming" and Fowler's "Refactoring".

What you get in Brent Spell's "Professional Java Programming" is a beyond-the-basics introduction to several Java tools that aren't covered in any of these other must-have books. In fact, this is really several books glued together into a backbreaking 2 inch thick package weighing in at 3 3/4 pounds (1.7 kilos). At least they had the sense not to add the usual throwaway CD to this unwieldy package. But don't be fooled by the size of the book. With the number of topics, each is handled very compactly. The definitions are tight and the examples are well directed, making it a great reference book.

The chapters on layout managers here are the best I've seen. There's also excellent coverage of the twisty MVC GUI widgets: JTree and JTable, with excellent explanations and examples. There's adequate coverage of threading, especially useful for event-based GUI programming. The discussion of performance tuning is a great start on the subject. You also get very good coverage of XML and the associated DOM and SAX parsers. I like Spell's coverage of basic XML and DTDs better than others I've seen, though he doesn't discuss schemas or other more recent developments. I haven't used the sections on security, JDBC or distributed objects, but if I ever need info on these topics, this is where I'll look first.

PS The author cover photos (all with chin on hands!) on all of the Wrox "programmer to programmer" (TM) books are so cheesy that they detract from the solid writing. Don't be fooled -- this is serious, hardcore stuff.

Rating:
Summary: Good Book for Java Programmers
Review: I love Arnold and Gosling's "The Java Programing Language" as a basis for learning Java. There are other specialized books that add to a solid foundation in Java, like Lea's "Concurrent Programming" and Fowler's "Refactoring".

What you get in Brent Spell's "Professional Java Programming" is a beyond-the-basics introduction to several Java tools that aren't covered in any of these other must-have books. In fact, this is really several books glued together into a backbreaking 2 inch thick package weighing in at 3 3/4 pounds (1.7 kilos). At least they had the sense not to add the usual throwaway CD to this unwieldy package. But don't be fooled by the size of the book. With the number of topics, each is handled very compactly. The definitions are tight and the examples are well directed, making it a great reference book.

The chapters on layout managers here are the best I've seen. There's also excellent coverage of the twisty MVC GUI widgets: JTree and JTable, with excellent explanations and examples. There's adequate coverage of threading, especially useful for event-based GUI programming. The discussion of performance tuning is a great start on the subject. You also get very good coverage of XML and the associated DOM and SAX parsers. I like Spell's coverage of basic XML and DTDs better than others I've seen, though he doesn't discuss schemas or other more recent developments. I haven't used the sections on security, JDBC or distributed objects, but if I ever need info on these topics, this is where I'll look first.

PS The author cover photos (all with chin on hands!) on all of the Wrox "programmer to programmer" (TM) books are so cheesy that they detract from the solid writing. Don't be fooled -- this is serious, hardcore stuff.

Rating:
Summary: Everything not in the standard Java books and then some
Review: I love Arnold and Gosling's "The Java Programing Language" as a basis for learning Java. There are other specialized books that add to a solid foundation in Java, like Lea's "Concurrent Programming" and Fowler's "Refactoring".

What you get in Brent Spell's "Professional Java Programming" is a beyond-the-basics introduction to several Java tools that aren't covered in any of these other must-have books. In fact, this is really several books glued together into a backbreaking 2 inch thick package weighing in at 3 3/4 pounds (1.7 kilos). At least they had the sense not to add the usual throwaway CD to this unwieldy package. But don't be fooled by the size of the book. With the number of topics, each is handled very compactly. The definitions are tight and the examples are well directed, making it a great reference book.

The chapters on layout managers here are the best I've seen. There's also excellent coverage of the twisty MVC GUI widgets: JTree and JTable, with excellent explanations and examples. There's adequate coverage of threading, especially useful for event-based GUI programming. The discussion of performance tuning is a great start on the subject. You also get very good coverage of XML and the associated DOM and SAX parsers. I like Spell's coverage of basic XML and DTDs better than others I've seen, though he doesn't discuss schemas or other more recent developments. I haven't used the sections on security, JDBC or distributed objects, but if I ever need info on these topics, this is where I'll look first.

PS The author cover photos (all with chin on hands!) on all of the Wrox "programmer to programmer" (TM) books are so cheesy that they detract from the solid writing. Don't be fooled -- this is serious, hardcore stuff.

Rating:
Summary: Best Java book I've bought in a long time
Review: I really like the premise of this book. Too many of those on the market these days focus on a single topic and are padded with useless, irrelevant material to make them large enough to justify paying $40-$60 for, but this one takes a very different approach. It contains chapters on various different Java-related topics that don't warrant entire books, but that are complex enough to be given an entire chapter. My favorite chapters are the ones on printing, JTree, JTable, and internationalization and security. I was already familiar with the first three topics to some extent, but this book really increased the depth of my knowledge in those areas. The Java 2 security model was something of a mystery to me, but this book does an outstanding job of providing a simple but thorough explanation of it, how it works, and how to use it.

As a previous reviewer noted, not all of the chapters are in-depth, such as the one on distributed programming. That's another area where I was already pretty knowledgeable, but for someone who's only marginally familiar with topics such as socket programming, CORBA, or RMI, this would be a great introduction.

I was also impressed with the chapter on persistence, as it did a good job of summarizing the classes and interfaces in the java.io package and of examining the different persistence options available to a Java program. Some chapters provide an in-depth examination of the topics, others provide good reference material, and a few (like the persistence chapter) offer both.

I would disagree with a previous reviewer who said that this wouldn't be a good book to read from cover to cover, because I learned new things even when reading the chapters that were devoted to topics I already felt pretty knowledgeable about.

Some of the topics covered here haven't been written about anywhere else that I know of, but all of them are well-written and informative.

Rating:
Summary: Don't be scared off by the 'professional' title
Review: I think I have a good understanding of basics of Java, but I almost didn't buy this title because I'm still pretty new to the language. But I got it because I needed to do printing and with Java 1.3 and was very pleasantly surprised with this book. It is very well written with lots of clear example code and with minimal 'jargon'. I haven't read the whole thing yet but I really found the printing chapter clear and easy to understand and I was able to use some of the code unmodified inside my application and some other with very little change. I also have been able to have some questions answered about JTABLE that I had before by flipping to the section in the table chapter of this book. So far its been a really good reference book for me and has chapters on a lot of other things that I will need to know about. Alot of times I'm disappointed with the quality of writing in the programming books I buy but this author is really good at making things simple and clear. Another thing I like about this book is that it covers both client and server topics (but no jsp or servlet info - just stuff like threading and distributed programming etc.) so it isnt limited to just one area of Java.

Rating:
Summary: Most used Java book in my library
Review: I've had this book since it was first printed, and I find myself coming back to it time and again. I've gotten great value from the printing, drag and drop, internationalization....you get the idea. There is a lot of info here that you just don't find in most Java books (and I've read quite a few).

Highly recomended.

Rating:
Summary: A big book that's packed full of useful material
Review: Many titles focus on a single title, and they often seem to be packed full of material that's marginally useful at best and irrelevant at works. In contrast, this one tackles a large number of topics that many Java programmers will need to know about, and for the most part, it manages to cover those topics in more than enough depth to allow the reader to really understand and use the Java technologies that it covers. However, it doesn't just examine those technologies from an academic perspective, but includes lots of clear examples and code that could be very useful. In some cases, the code is appropriate for use directly within an application, while in other cases, utility programs are included that help the reader to understand or use the technology better. The best example of this latter case that comes to mind is in the chapter on layout managers, where the author provides a really useful utility program that makes it easy to play with GridBagLayout and see how modifying the various constraints affects the components within the layout. In that same chapter, he also describes how to create a custom layout manager (it turned out to be easier than I expected) and provides an example of one that's actually pretty useful, at least in the scenario described.   The areas where I felt this book was weak were in the chapters on object-oriented design and distributed objects. While those chapters were ok and easy to understand, they don't provide a great deal of depth, and if you want to know more on those subjects, you should probably look elsewhere, although this book might be a good starting point for a beginner. Overall, though, the chapters provided plenty of depth, and I consider this a really outstanding book. It took me a while to finish it, but it was definitely worth the effort, and I'd recommend it to anyone who has advanced beyond the most basic levels of Java programming.

Rating:
Summary: A good book overall
Review: Overall I'm pretty pleased with this book and would have to say that there are alot more things that I like about it than things I didn't like. As other reviewers have pointed out, the writing is very clear and concise, which is really important for advanced topics like the ones covered here. This book also covers a lot of subjects and mostly examines them in plenty of detail, but not so much detail that it put me to sleep or became irrelevant trivia, as some books tend to do.

Another really nice thing about this book is that it keeps me from having to go out and buy a bunch of other books that each cover one of the topics included in this one. Most of the topics in Professional Java Programming have been covered elsewhere, but it would have cost me alot more money to go buy all those other books than it did for me to just get this one. But even in the case of topics that have been covered elsewhere, this book does a good job. An example of that is its coverage of layout managers, and the description of how GridBagLayout works in particular was the best I've ever read.

I do have a couple of gripes, such as the lack of a CD. Yes, I know that I can download the code from the Wrox web site, but I'd still like to get a CD. I also think the chapter on distributed objects should have been longer or at least the RMI section broken out into its own chapter. I'd like for it to have covered the activation framework, since that's an advanced topic and this is a book on advanced topics. The distributed objects chapter is probably really good if you're new to the subject, but for advanced programmers (which I understand the book is targeted for), it doesn't provide a lot of new information. Overall, though I'm pleased with this title and would recommend it to tohers.