Title
Author
Publisher
ISBN
Reviewed by
Review text
Category

Your search returned 217 matching documents



Effective Java:Programming Language Guide
by Joshua Bloch, Joshua Bloch


Prentice Hall PTR
second edition
May 2008
384 pages
Reviewed by Campbell Ritchie, June 2008
  (10 of 10)


I had been waiting for this 2nd edition for ages, and I have not been disappointed by it.

Everything is there:

* Why you don't concatenate Strings repeatedly
* Confusion between "L" and "l" and "1"
* How to get floating-point arithmetic wrong
* Why you avoid returning null
* Why you always use library classes.
These few previous points ought to be taught to even the rawest beginner, but the remainder of the book is only suitable for the more experienced programmer. Bloch takes a tour de force through all the features of the language. Some chapters are about general programming, including the methods inherited from java.lang.Object, others about specific features like concurrency.

he book is completely up to date for Java 6. It is clear and easy to read, although dense with information, so one cannot skim through it. Bloch pulls no punches. He tells us the features he likes and which he doesn't. He warns against using finalize() and clone() and calls classes like StringTokenizer, and the older concurrency mechanisms obsolete.

Anybody who wants to understand the workings of the language, to get up to speed and write code which really works: you're not borrowing my copy. Buy your own and you will be really pleased with it.

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
second edition
May 2008
384 pages
Reviewed by Michael Ernest, May 2008
  (10 of 10)


This updated edition has plenty to recommend it. The chapter "Substitutes for C Constructs" is replaced by two new ones, "Generics" and "Enums and Annotations." Some existing items are amended to reflect these constructs. Some new ones promote the use of concurrency over traditional Java threads.

All in all, the second edition boasts 78 items compared to the first edition's 57 items. As before, the justifications driving each item are lucid and compelling, and much, much more valuable in my mind when used to assert confidence in a proven technique. I understand some people come to Effective Java as a primer. I can see how it woud be useful as such, but the arguments laid out seem to me more valuable once you've fumbled a bit on your own.

One item ("For instance control, prefer enum types to readResolve") amounts to a retraction; I consider it a sign of strength, that the book has so little to apologize for.

Sometimes you want answers on best practice from the best authority you can find. If you have a better source than Google's Chief Java Architect, share! I remain impressed by and indebted to Bloch for his simple, elegant style. I've been waiting for a long time to read his take on these new topics. Thank you Josh!

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
second edition
May 2008
384 pages
Reviewed by Jeanne Boyarsky, July 2008
  (10 of 10)


The second edition of "Effective Java" is almost like a completely different book from the first. There were new chapters addressing Java 5 topics such as generics, enums and autoboxing. Existing patterns were rewritten for Java 5/6 - both conceptually and for the code examples. For example, overloading now address varargs. The number of items grew from 57 to 78 as well and the author removed the old ones that are obsolete.

As a reference, chapter one provided a table to quickly find items on Java 5. The appendix provided a cross mapping to find items from the first edition in this copy.

For those new to "Effective Java", it is meant for intermediate to advanced Java developers. It provides best practices, recipes and idioms for working with Java. The author is good about listing both advantages and disadvantages to choose when to apply a tip.

When thinking about my favorite chapter, I have trouble picking just one. I'm torn between the concurrency and enum chapters. The book goes beyond the common "use enums over constants" and goes into things like EnumBitSets.

I learned a lot reading the first edition of this book and learned just as much reading the second. If you have the first edition, but this one anyway. And if you haven't read the first edition, get your hands on the latest copy!

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
1 edition
June 2001
272 pages
Reviewed by Peter Tran, August 2001
  (10 of 10)


Have you ever overridden the equals() method, but not have it work correctly? Do you miss some of the C constructs and wonder how you can do the same thing in JAVA? Have you ever wished you could come up with better design for your classes?

Then this book is for you. First, this is definitely not a book for beginners. I'm not saying you have to be a guru to appreciate the material presented. I made a lot of the same mistakes Joshua pointed out in his book early in my JAVA career. For example, the check list for Item 7: Obeying the general contract when overriding equals, will more than pay for the book when you don't have to spend several hours trying to figure out why your equals() implementation isn't working. (If my manager is reading this review, let it be known that this book wasn't available a year ago, and implementing equals() correctly isn't trivial!) The book is littered with examples of actual design patterns used in the JDK library, and the material is very up-to-date with references to the JDK 1.4.

Anyone aspiring to write good JAVA code that others will appreciate reading and maintaining should be required to own a copy of this book. This is one of those rare books where the information won't become obsolete with subsequent release of the JDK library. A definite must-have for any JAVA developer/programmer.

Discuss book in the Saloon — More info at Amazon.com


Head First Servlets & JSP
by Kathy Sierra, Bert Bates, Bryan Basham, Kathy Sierra, Bert Bates, Bryan Basham


O'Reilly
second edition
March 2008
911 pages
Reviewed by Ulf Dittmer, May 2008
  (8 of 10)


The second edition of this classic book about the Java Servlet and JSP API continues the tradition of other Head First titles that liven up the text with pictures, hand-scribbled notes, questions&answers and other devices to engage the reader's brain. Never having read a Head First book before, this reviewer was pleasantly surprised by how well this works. Even though the book is much thicker than I consider healthy for a tech book (over 800 pages), it's an easy read thanks to the lively prose and varied content elements.

The book is billed as a preparation aid for the SCWCD exam, but it also serves as a general introduction to Servlets and JSP. I found it easy to read individual chapters (e.g. on the Expression Language, servlet filters or custom tags) by themselves to refresh knowledge on particular topics. It's made clear which exam objectives are covered in each chapter, and there are exam-style questions and answers that go with the text, plus a brand-new mock exam with as many questions as the actual exam has.

I recommend this book as a tutorial -- not as a reference -- to anyone needing to come up to speed with servlets/JSP, or in need of learning aspects of it he hasn't used before. (Disclaimer: The author of this review was one of the tech reviewers of the book.)

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
July 2004
886 pages
Reviewed by Marc Peabody, February 2006
  (10 of 10)


Over at the JavaRanch Saloon's Web Component Certification (SCWCD) forum, Head First Servlets & JSP dominates as the book of choice. It appeals to both those with and those without Java EE experience and I'm constantly amazed at how quickly everyone learns using this book. The SCWCD testimonies that say "I passed!" are most often appended with "Thank you, Head First, for such a wonderful book!"

A couple points about what to expect:
* This is no crammer's book. You will get more than book smarts -- you will understand the significance of the questions and objectives to real world Java enterprise programming.
* Nor is this book a flowery tutorial. This is hardcore programming wisdom. It would take you at least two years of real-world, painful, trial-and-error experience to gain the equivalent knowledge on your own. That's just stupid.

I passed the SCWCD exam years ago (before Head First Servlets & JSP existed) but now I am going to upgrade my certification to the latest version. I have never been so confident for an exam before. I am soooo ready!

Discuss book in the Saloon — More info at Amazon.com


Core Java(TM) 2, Volume II--Advanced Features
by Cay S. Horstmann, Gary Cornell, Cay Horstmann, Gary Cornell


Prentice Hall PTR
8 edition
April 2008
1056 pages
Reviewed by Michael Ernest, May 2008
  (10 of 10)


In my review of Professional Java JDK 6 Edition, I said I didn't think one book could cover so many topics and serve the reader well. This volume is an exception that proves the point.

It is a monster book, easily several months of steady work to get through, and an useful reference afterwards as well. It is well put together, clearly written, methodically presented. I wouldn't put it down if that were possible. The coverage is broad and the examples are interesting. The topics also feel complete, not because they are thorough, but because they leave off right where intermediate-level programmers could work out most details on their own.

I read the first and second editions years ago. I must say this title is a case study in steady, disciplined, tireless improvement and refinement of the original. It's 990 pages, but I haven't come across a useless sentence yet. The authors haven't just added on. They've refined their examples, improved and replaced others. Most importantly, they've realized a format that puts boilerplate and API tables to the side, allowing the reader to focus on the concept at hand. Complete code listings are presented in a way that's easy to pass over in favor of the files available by download.

If you need lots of code work on different topics to urn Java into your fingertips -- and there is no better way to do it -- this book is an excellent choice

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
7th edition
December 2004
1024 pages
Reviewed by David O'Meara, April 2005
  (8 of 10)


I've always been impressed with the quality of the 'Core' series and happily this book is no exception.

My first impression of "Core Java 2, Volume 2 - Advanced Features" (7th Edition) was that the book contained too much information and was too small for the task it had set itself. However it didn't long for me to revise this perception.

Java 5 includes a huge number of new features. This book does its best to expose you to the new features and doesn't give a definitive example for each part, but provides at least enough so you know what they're for and can spot them in the wild. The examples strike the right balance between length and detail so that you're onto the next topic before getting bogged down in the current one. There is a good mixture of code snippets and full source included, though sometimes I felt the excess could have been trimmed for a few of them.

Personally I loved the coverage of Threading, Collections, Security and XML, but there was enough in each chapter to make it worth reading.

This is an excellent resource for any programmer looking for a quality Java 5 text, although you'll want to consider pairing it with volume one if you lack programming experience. Whether you have experience with the features in the new version or not, the depth of information makes it an important book to add to your bookshelf.

Discuss book in the Saloon — More info at Amazon.com


Pro Spring 2.5
by Jan Machacek, Jessica Ditt, Aleksa Vukotic, Anirvan Chakraborty


Apress
1 edition
August 2008
920 pages
Reviewed by Mark Spritzler, December 2008
  (9 of 10)


8 1/2, but since we only have 8 or 9, I liked it enough to make sure I rounded up instead of down.

I highly recommend this book to learn Core Spring. It is the only book currently out by Dec 08 that covers version 2.5. Other books still only cover 2.0

I found the writing easy to understand, I found that they covered the material very well with good examples. They cover a lot of material and leave you with great in-depth knowledge in each of those Spring technologies.

Now, I don't agree with everything they say in the book, but it isn't that they are wrong, but that I just disagree with certain statements. For example, in a Note section they stated that "They do not encourage the use of annotations on the objects you will persist using Hibernate." Using JPA Annotations, from an ORM tool expert, is a best practice and makes your life so much easier, in my opinion, and many other ORM experts. This note should have been left out of the book, unless they wanted to fully cover why.

Discuss book in the Saloon — More info at Amazon.com


Programming Groovy: Dynamic Productivity for the Java Developer
by Venkat Subramaniam


Pragmatic Bookshelf
1 edition
April 2008
318 pages
Reviewed by Ernest J. Friedman-Hill, May 2008
  (7 of 10)


We live in an increasingly informal and familiar world. Perfect strangers want to call me by my first name, and waiters pull up a chair and join me at table while I hear about today's specials. Perhaps it's inevitable, then, that technical books like "Programming Groovy" are becoming commonplace.

This is a reasonable, if informal, introduction to the Groovy language. Although I haven't had the opportunity to do much with Groovy myself, I suspect that this book wouldn't help if I painted myself into a newbie's corner; I would want a more detailed language guide to refer to.

On a personal level, I didn't like this book. The author's conspiratorial winks and constant insistence that he understands what I know, want, and need, grated on me throughout. Because in fact, he did not know that I wanted more detail, more rigor, more formality, than he was offering. He did not know that I wanted a description of the Groovy language itself, rather than repeated assurances that it's "just like Java" interspersed with multiple demonstrations of the ways in which it's more assuredly not. He did not seem to know (as all authors of scripting-language books seem not to know) that modern IDEs completely obviate the need to type Java syntax in manually.

It's not my cup of tea, but if you do a lot of texting, or have a Twitter account, I'm betting you'll love this book.

Discuss book in the Saloon — More info at Amazon.com


Java Fundamentals I and II (Video Training)
by Deitel and Associates Inc.


Prentice Hall PTR
1 edition
March 2008
128 pages
Reviewed by Marc Peabody, May 2008
  (6 of 10)


First off, this didn't work in my DVD player. I had to play it from the computer. Small bummer.

This was basically fourteen hours of staring at code already written in a NetBeans editor while a faceless (and somewhat monotone) voice explained how the code works. The mouse pointer moves around or highlights some text to point out a particular area of code, the lessons sometimes shift to JavaDoc or a diagram, and you see Paul's face while he gives the intro and summary of each lesson but it wasn't enough to keep me engaged.

Most if not all of the examples come from the book Java How to Program by Deitel and Associates, also around a hundred bucks. Personally, I'd prefer the book. If I'm staring at a pre-existing code sample, it's easier to read on paper. This does come with a small supplemental book with code samples but it's black and white, whereas the Java How to Program is in beautiful color.

Overall, this LiveLessons DVD pack isn't horrible - I simply think the Deitel book is a better value and I can only recommend this DVD product if you have two hundred dollars to spend and you wish to buy both the Java How to Program book and purchase this LiveLessons as a supplemental to break up the pace of your reading (it's a big book).

Discuss book in the Saloon — More info at Amazon.com


Groovy Recipes: Greasing the Wheels of Java
by Scott Davis


Pragmatic Bookshelf
1 edition
March 2008
250 pages
Reviewed by Michael Ernest, May 2008
  (8 of 10)


I got this book after hearing the author speak at JavaOne. His talk covers the content of the first chapter along with a few other items, but I didn't mind. It was quite helpful to read through the points and examples he made and try them out at my own pace.

The book is driven by a series of insights rather than complete, formal coverage. I found this approach very useful to getting started and experimenting. The writing is clear, light-hearted, and relaxed, especially in the beginning.

Towards the end of the book, the explanations wane a bit. The sample code is more often given without an introduction, beyond the section header. I was less sure what was going on in some of these cases, as I had gotten accustomed to picking things up very quickly in the beginning. The explanations that followed these code bits were good enough, but I missed that sense of the author's energy from beginning to end of each section.

I don't understand at all why it's called Groovy Recipes. There aren't any. The examples illustrate very well the power of this tool, but I didn't see anything that amounts to, say, the Groovy way to mine a web page, create an IM interface, read mail, etc. If you are looking for code you can apply immediately to some series of problems, this isn't the one.

Discuss book in the Saloon — More info at Amazon.com


Kicking Butt with MIDP and MSA: Creating Great Mobile Applications (Java Series)
by Jonathan Knudsen


Prentice Hall PTR
1 edition
January 2008
432 pages
Reviewed by Mark Spritzler, December 2008
  (9 of 10)


When it comes to MIDP and J2ME books, there is no better author than Jonathan Knudsen. It was about 4-5 years ago that he published his first J2ME book, and it was that book that I learned J2ME very quickly.

Jonathan is one of those writers that can break down a technology to its simplest parts and then explain it to us so that we get it quickly.

In "Kicking Butt" Jonathan does it again. Keeping us up to date with the latest developments of J2ME. It is great to see him back with this new book to teach the next generation of J2ME developers.

The only thing I wish I saw was the part about device manufacturers not implementing specs 100% and making some parts of J2ME (Bluetooth comes to mind) a heck to work with and figure out what is wrong, when it comes down to a company not implementing the Spec completely, but claiming it does.

Discuss book in the Saloon — More info at Amazon.com


Hibernate Made Easy
by Cameron McKenzie


Self published
1 edition
2008
434 pages
Reviewed by Mark Spritzler, July 2008
  (9 of 10)


Hibernate is a subject dear to my heart. It is a database tool that I would not live without. However, it has a steep learning curve. In Hibernate Made Easy, author Cameron McKenzie does a great job in getting someone who is brand new to Hibernate, up and running quickly and understanding the basics of Hibernate to effectively take on its learning curve.

Keep in mind when reading this book, that in order to keep it simple, some alternative solutions are not discussed. This is a book to get you started. So it didn't mention that you can have Hibernate automatically search your classpath for @Entity classes, but used addAnnotatedClass() method calls. This is ok, and might be fixed by the time you buy the book.

Now, there are many pieces to the Hibernate puzzle and Cameron manages to pick the subjects that are the necessary building blocks to move on to the more advanced topics. If you are just learning Hibernate, I highly recommend this book to take you on the path of righteousness.

Discuss book in the Saloon — More info at Amazon.com


The Object-Oriented Thought Process
by Matt Weisfeld


Addison-Wesley Developer's Library
third edition
2008
pages
Reviewed by Campbell Ritchie, October 2008
  (6 of 10)


A little book for experienced programmers, their managers, etc., to explain how one does things "differently" in object-oriented programming. It is easy and entertaining to read, and explains the basics of object-orientation, so might also be suitable for teachers of computing.

It shows what the object-oriented way is, with classes, objects, hiding, encapsulation explained. Later chapters explain how to send objects across networks, why databases are usually not object-oriented, etc. There are many illustrations with Java code, and "translations" to Visual Basic and C#. The chapter about design patterns barely scratches the surface, and the section on anti-patterns is so short I think it ought to have been omitted.

Unfortunately some of the code fragments incorporate errors, mostly obvious to the experienced Java programmer, which would prevent compilation. There is detailed discussion of a "Cabbie" class and how it relates to Cars and Customers, but there are two odd bits of design: a static companyName field and a no-arguments constructor. Fuller discussion of these peculiarities would have made the book more useful. Access control is discussed, but there are mistakes about what private and protected mean in Java.

There are less than 3 dozen references altogether, and they are arranged strangely, and the most interesting quote (page 181) has no source cited and was difficult to find from its keywords in the index.

Although I enjoyed the book, I thought it was badly marred by the points I mentioned.

Discuss book in the Saloon — More info at Amazon.com


JavaFX Script: Dynamic Java Scripting for Rich Internet/Client-side Applications
by James L. Weaver


Apress
1 edition
October 2007
200 pages
Reviewed by Ulf Dittmer, February 2009
  (5 of 10)


JavaFX Script ("JavaFX" henceforth) is a new way to develop client-side Java GUI applications, comprised of a more declarative code syntax, and some new ways to couple behavior to code. That being the case, it (and by extension, this book) has two audiences: developers proficient in Java who want to learn about JavaFX, and web developers interested in building rich client applications who may not know much (or any) Java.

Falling into the first group, this reviewer thinks neither group is well served by the book. Java developers don't need much introduction to basic concepts; they'd be better served by comparisons between how things are done in plain Java, and how they are done in JavaFX, plus an overview of the new features JavaFX brings to the table. Neither is included in the book. Non-Java developers will struggle when trying to understand Java syntax and concepts, JavaFX concepts and parts of the Java class libraries all at once.

Most of the book is taken up by presenting various JavaFX concepts using a single medium-sized example GUI application (that builds word search puzzles, although that's really besides the point). Where some concepts don't fit that application, small additional examples are used. This does help in understanding what's going on, since the code can simply be run, and the effects of certain constructs be observed, if the text leaves something unclear.

Discuss book in the Saloon — More info at Amazon.com


Next Generation Java Testing: TestNG and Advanced Concepts
by Cedric Beust, Hani Suleiman


Addison-Wesley Professional
1 edition
October 2007
512 pages
Reviewed by David O'Meara, January 2008
  (6 of 10)


The first thing to note about the book Next Generation Java Testing is that while it does indeed cover advanced testing concepts in Java, these concepts are largely geared towards the use of the free TestNG (www.testng.org) product, and I think it is worth being aware of and accepting this from the beginning. The book contains valuable information on testing alone, just not enough to make it worth while if you're not interested in at least evaluating TestNG.

Possibly unfairly, this book will be judged based on a comparison between JUnit and TestNG themselves, rather than being able to judge the book on its own merits. The TestNG product is aimed at a complete redesign of the Java unit testing process, so it surprised me that the only real discussion on JUnit was a nod towards them in the first chapter, and a mention that some of the TestNG features had been incorporated into JUnit. Strange then that there wasn't greater effort placed on comparing and contrasting their tool against the industry standard.

When treated as a stand-alone book, it is a good reference for TestNG, and if you have already evaluated the product and would like to use it then this is a good book to help you do that. It won't, however, help you make this decision, and while the TestNG product has some intriguing features and different ways to test than that of JUnit, I believe you'll already need to be experienced in JUnit to get full use of both the book and the product.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
October 2007
512 pages
Reviewed by Jeanne Boyarsky, November 2007
  (7 of 10)


"Next Generation Java Testing" has a subtitle: "TestNG and Advanced Concepts." This isn't surprising given the creator of TestNG is an author, but is important to realize. It starts with 6.5 pages on why TestNG is better than JUnit 3.8. Then only two paragraphs on JUnit 4. This has been a pet peeve of mine for some time. It's like comparing the current version of C# to Java 1.3 and then saying Java is worse because it doesn't have generics.

I liked the code snippets in the TestNG sections as they focused on relevant pieces. The examples were to the point. Especially the performance and J2EE sections. I liked the concepts described in chapter 2 (over 100 pages.)

The authors describe open source libraries that integrate with TestNG. I liked this coverage although JMock could have used a code example for comparison (easyMock had one.) Ant targets were provided for the code coverage examples.

Chapter seven is titled "digressions." Some quotes from the text on this: "pet peeves, rants, annoyances and musings", "much ... very tangentially relevant", "some ... outright irrelavant." I agree with some and disagree with some. I think this chapter would have been better as a series of blog posts than a chapter in a book.

If you are using/planning to use TestNG and can ignore the rants, this is a good book.

Discuss book in the Saloon — More info at Amazon.com


Test Driven: TDD and Acceptance TDD for Java Developers
by Lasse Koskela


Manning Publications
1 edition
October 2007
470 pages
Reviewed by Jeanne Boyarsky, January 2008
  (10 of 10)


"Test Driven" is geared toward Java developers interested in writing better JUnit tests. Despite the title, it is useful whether you want to write test first or test last.

The first part of the book covers the softer aspects of testing such as how to decide what tests to write first and spikes. The rest of the book covers writing tests for common Java components including servlets, data access code and Swing. Examples were for things that we frequently want to test. They included "hard" things such as testing times and threaded code.

I particularly liked the sections on design and testing patterns. There was good coverage of different JUnit extension libraries with examples including dbunit, jmock, easymock, jemmy and abbot. There was also a full chapter on FIT.

I got a sense of "in the trenches" realism from the book. Tradeoffs of techniques were clearing mentioned. The chapter on adopting TDD shows the experience of someone who has done it many times. The section on how to fight resistance really spoke to me.

This is the first book I have read using JUnit 4, which was useful for reading well written tests. While there is an appendix "tutorial" on JUnit 3.8 and 4.0 (two page annotated classes), you really should feel comfortable with one version of JUnit before reading this book. While a few sections pertained to specific technologies, such as Spring, the concepts apply to everyone. I highly recommend this book.

Discuss book in the Saloon — More info at Amazon.com


Core Java, Volume I--Fundamentals
by Cay S. Horstmann, Gary Cornell


Prentice Hall PTR
8th edition
September 2007
864 pages
Reviewed by Jeanne Boyarsky, October 2007
  (9 of 10)


"Core Java, Volume I -- Fundamentals" is meant to teach Java to developers who already know another language. Or as they put it, "serious programmers ... with a solid background in a language other than Java." This is important as the book assumes a knowledge of programming concepts. As such, the authors can explain OO rather than how a loop works. The syntax diagrams and flow diagrams offer concise explanations.



This edition (the eighth of the book) covers Java 6. I liked that each section was updated to reflect changes to the languages. The authors didn't just tack on some chapters about the new features. They integrated features as they made sense. More importantly, they updated existing examples to reflect the way they would be written if they were initially written today. This gives the reader appropriate exposure as to when to use new features. At the same time, the authors point out what was added in Java 1.4 so you can use it with an older version. There was even a screenshot of Windows Vista in the getting started section.

The book is about 800 pages. Some of this is long classes and API extractions. The authors do highlight important code snippets with explanations first, so it is possible to skip these parts. I did like the feature of the API extractions that showed when methods were introduced.

The authors explain Java in practice well including caveats. There are a few carefully labeled sections that are quite advanced. (proxys and new classloaders.) This is definitely not just an intro book! There was a bit of premature optimization. I don't see a need to worry about whether ArrayList is efficient unless it is a problem. At the same time, it is important to know why things work the way they do.

I recommend this book if you are looking to learn Java or have only used certain pieces of it. Just be sure to read the TOC carefully as the authors branch out. For example, the inheritance chapter covers var args and reflection.

Discuss book in the Saloon — More info at Amazon.com


Scripting in Java - Languages, Frameworks and Patterns
by Dejan Bosanac


Addison-Wesley Professional
1 edition
August 2007
552 pages
Reviewed by Ulf Dittmer, November 2007
  (6 of 10)


This book aims to be an introduction to combining Java with scripting by presenting popular Java-based scripting languages, making the case for when and how to use scripting and Java, explaining the prevalent APIs, and showing some useful patterns of how to make it work.

A full third of the book is taken up by introducing scripting APIs, namely the Apache Bean Scripting Framework (BSF) and the javax.script package found in Java 6 and its non-yet-released web scripting component.

Another quarter is used for an introduction to Groovy, and many examples are written in that language; so if for some reason Groovy is of no interest to the reader that might be a drawback. JavaScript and (to a lesser degree) PHP are the other languages being used.

While just about everyone interested in the subject will find something (or a few somethings) of interest in this book, it doesn't feel like a coherent whole. It touches authoritatively on a number of subjects, amongst which the reader will choose which ones are applicable to him, and ignore the remainder. The style is technical, and even through the author seeks to present motivation repeatedly as to why to use scripting with Java, this becomes a bit tedious after a while. Overall the book is quite readable, though, and the numerous code examples interspersed with the text help provide some out-of-the-box applicability of the concepts presented.

Discuss book in the Saloon — More info at Amazon.com


Ant in Action
by Steve Loughran, Erik Hatcher


Manning Publications
second edition
July 2007
600 pages
Reviewed by Jeanne Boyarsky, April 2008
  (8 of 10)


"Ant in Action" is really the second edition of "Java Development in Ant." I think the original title was more descriptive as the book focuses more on process, tools and techniques than most Ant books. For example, they introduce continuous integration and why you would want to write unit tests. Not that the Ant coverage isn't good -- it's excellent -- just that the book is so much more.

Like most Ant books the authors don't rehash the excellent online manual and API. For those new to Ant, features are clearly described with good examples and good descriptions of "what happens if _____." The flow diagrams helped visualize concepts nicely.

For those who have been using Ant, there are margin notes about what was added in 1.6/1.7 along with coverage of Ivy. I liked the Java 6/JEE 5 examples. The techniques for writing reusable/maintainable code and extending Ant provided significant value. I was a little disappointed it used JUnit 3.8. The authors explained why and I understand. I still would have liked to see it as this book will still be used when JUnit 4 is in wider use.

Coverage of related tools is also useful. It's good to know what libraries to look into to increase productivity with Ant. I've been using Ant for complex builds for three years and still had a page of take away points from this book. I recommend it for the valuable information and techniques.

Discuss book in the Saloon — More info at Amazon.com


Google Web Toolkit: GWT Java Ajax Programming
by Prabhakar Chaganti


Packt Publishing
1 edition
February 2007
248 pages
Reviewed by Jeanne Boyarsky, April 2007
  (8 of 10)


"Google Web Toolkit: GWT Java AJAX Programming" - I learned a lot about GWT reading this book. The book assumes you know Java and web programming (HTML/JavaScript/Web packaging) well. Some of the examples use other technologies such as JDBC and XPath, but they are understandable without this knowledge.

I liked the examples as they were things you would want to do. The examples range from self contained form tasks to a full widget. The examples appeared to be "complete" with a description before each section. While there are explanations at the end of the example, some examples are really long. One example has 3.75 pages of getters and setters. Some examples emphasize business logic more than GWT. Other examples were really good. I think the examples get better if you read the book a few times. I was having trouble following the large code segments at the beginning and it got easier once I understood GWT. Basically, you should feel comfortable learning from code.

I wasn't always that clear on what objects/APIs were available in different scenarios, but the GWT API online provides that information nicely. I'd like the book shows me how to do something rather than just repeat what is online. I think this book and the website complement each other nicely by providing different perspectives.

All in all, I am happy with the book. It helps jump into GWT and provides a useful resource to learn by example.

Discuss book in the Saloon — More info at Amazon.com


Professional Java JDK 6 Edition
by W. Clay Richardson, Donald Avondolio, Scot Schrager, Mark W. Mitchell, Jeff Scanlon


Wrox
1 edition
January 2007
741 pages
Reviewed by Michael Ernest, May 2008
  (6 of 10)


Professional Java attempts something I don't think one book can do well, which is to say something useful on every topic. This book's sections include: updates to JDK 5; project methodologies; design patterns; build tools; persistence tools; UIs; web applications; JNI; EJB 3; SOA; security; and packaging and deployment. It wants to be a "one-stop shop," and that's fine, but I can't tell who the target shopper is.

Topic coverage varies wildly, in writing style, quality and in the effectiveness of sample code to illustrate the point. Too many descriptions are verbose and phrased in the passive voice. Some code samples seem like a brief sketch rather than a compelling example. Still other samples seem mostly boilerplate code that speeds up the page-turning but doesn't illuminate. And sometimes the text abruptly changes diction, for example from objective description to a "follow-along" coaching style. Some sentences sound like the author left them in as to-do reminders.

The result is a thick book that, for me, is sometimes tedious or exhausting to read. I think it would have been helpful to credit each author by chapter, if only to know when the presentation style might change so much. Also, a concerted effort at paring things down, and keeping the diction clear and active, throughout the text, would make it more readable and worth referencing.

This book might be handy if you just need many topics covered in one place.

Discuss book in the Saloon — More info at Amazon.com


iText In Action - Creating and Manipulating PDF
by Bruno Lowagie


Manning Publications
1 edition
December 2006
656 pages
Reviewed by Ulf Dittmer, March 2007
  (9 of 10)


The iText project is one of the -or maybe the- most popular Java library for creating PDF documents. This book, written by one of the principal developers, shows in great detail how iText can be used for working with PDFs. It touches on topics ranging from text, images, graphics, tables and fonts to forms and fields, interactive content, digital signatures, and web applications. Each aspect is explained with numerous examples that can be applied to real-world problems right away.

The book also delves into the underlying PDF internals and PostScript details, and shows off capabilities that are not commonly used, yet make for impressive documents.

The style is light and easily approachable, and if a particular subject is not of interest to the reader, it can usually be just skimmed over (or entirely skipped) without impacting the understanding of later chapters.

This reviewer recommends the book for everyone using iText as a companion to the -quite extensive- online documentation that is available as well. It covers many features of PDF that a casual user of Adobe Reader would not even think were possible, and for which the javadocs alone are not sufficient introduction.

Discuss book in the Saloon — More info at Amazon.com


BIRT: A Field Guide to Reporting
by Diana Peh, Alethea Hannemann, Nola Hague


Addison-Wesley Professional
1 edition
November 2006
704 pages
Reviewed by Jeanne Boyarsky, January 2007
  (9 of 10)


"BIRT: A Field Guide to Reporting" is a great tutorial for learning how to use BIRT. BIRT (Business Intelligence and Reporting Tools) is described including its relationship to Eclipse. After covering how to install BIRT, the book goes into great detail on how to use the report designer.

The target audience should be familiar with HTML, SQL and JavaScript as stated in the introduction. The book describes functions used, but you are expected to know the basic syntax.

As expected, the book covers how to use each of the features of BIRT. They are all described with step by step instructions. There are also a few tutorials walking you through the process from start to finish. I liked the "how to" style for tasks.

The book includes tips on how to plan a report and what to consider. It also includes common code snippets that you may want to use and lists available functions.

I was particularly impressed with the abundance of screenshots and the excellent glossary. If you are thinking about using BIRT, this book is a valuable addition to your library.

Discuss book in the Saloon — More info at Amazon.com


Java 6 Platform Revealed
by John Zukowski


Apress
1 edition
July 2006
240 pages
Reviewed by Henry Wong, October 2006
  (9 of 10)


A few interesting points about this book.

This book assumes knowledge of Java up to Java 5. In fact, it assumes deep knowledge of Java. You will be treated as an experienced developer that needs to get up to speed with Java 6.

This book covers enough to get you started. You will understand what changes were made, and how to use the new or changed features (with code snippets). Anything more complex requires a bit of research into the Java documentation -- of which you will be provided the JSR to obtain the information.

This book is short. At slightly above 200 pages, it can be read in a single sitting.

These points may give an impression that this is not a useful book. This is not the case. In fact, I was very impressed with it. The purpose of this book is to get the reader up to speed on Java SE 6, and as quickly as possible. In this regard, it does the job very well.

The chapters discusses the core classes, I/O classes, AWT/Swing, JDBC, XML support, Web Services support, along with some interesting enhancements, such as the Compiler API, Scripting API, and new Annotations. The chapters are also written in a fashion that can be read independently -- so if you are only interested in databases, you can jump right to the JDBC chapter.

I highly recommend this book for any experienced developer considering a move to Java 6. Beginners should look elsewhere.

Discuss book in the Saloon — More info at Amazon.com


Sun Certified Web Component Developer Study Companion
by Charles Lyons


Garner Press
1 edition
July 2006
640 pages
Reviewed by Marc Peabody, August 2006
  (9 of 10)


The more experience you have, the more you'll appreciate the layout of this book, as the information is very structured with little foofoo noise. The design is especially helpful for learning class APIs, the web.xml, and standard actions. SCWCD Study Companion is certainly the best book on the market for those last few times you need to skim through everything the day leading up to the exam.

Each chapter ends with some superb questions, about 15 or so. Each question has a definite purpose to your learning process. The questions truly help enforce what important points you should remember from the chapter and what silly (though important) tricks to look out for in the exam. You can tell that the author put a copious amount of time into writing thoughtful questions.

My only complaint with the book is that, in my opinion, it's weak on Design Patterns. I've always felt that the online pattern catalogues were the best study resource for these anyway, so it's not a huge deal.

Charles Lyons' SCWCD Study Companion comes with a companion of its own: an online mock exam (also available for purchase separately). The mock exam has lots of tricky questions, so be sure you're ready first. It will certainly make you more aware of what to look out for in the real exam. In fact, it feels just like a real Sun exam except without the nasty drag and drop my-answers-disappeared bug (thank goodness!).

Upon completion, you can review the answers with explanations at your leisure, even days later. And get this - the bloke actually wrote the mock and its underlying engine himself, so his hands are very well in it and any errata will be fixed promptly. Few exams are so living as this.

The question most people will be asking is how this book compares to Head First Servlets & JSP (HFSJ). It's smaller and easier to carry. I find, though there are fewer pictures and jokes, I can make it through more topics before my brain starts to hurt. I think this is because the material is so well organized that my brain doesn't have to defrag it all afterward. HFSJ may be more fun to read, but those that want just the down and dirty might better appreciate Study Companion. The Study Companion makes a better reference book, a better book for subsequent reads, and is much easier to transport between work and home.

If you can afford two books, definitely get both the Study Companion and HFSJ. If you can only afford one, choose the one that best fits your style of learning.

Discuss book in the Saloon — More info at Amazon.com


Managing and Customizing OpenCms 6
by Matthew Butcher


Packt Publishing
1 edition
June 2006
256 pages
Reviewed by Gregg Bolinger, December 2006
  (8 of 10)


CMS, or Content Management Software, has been around for a while. Over the years, Perl and PHP CMS solutions have reigned supreme. In the past couple of years, a few Java based CMS solutions have started to compete. One of the forerunners is OpenCMS.

Managing and Customizing OpenCms 6 does a decent job of taking the reader through the install process of OpenCMS, creating and publishing content as well as several of its customizable features. There are plenty of screenshots to guide the reader and the author writes in a style that is not over the top technical so it's easy to understand.

I did expect a bit more depth from the book considering the TOC but wasn't really disappointed by the content. A colleague was actually implementing OpenCMS for a client and found the book quite useful during the process.

Discuss book in the Saloon — More info at Amazon.com


Java Concurrency in Practice
by Brian Goetz, Tim Peierls, Joseph Bowbeer, David Holmes, Joshua Bloch, Doug Lea


Addison-Wesley Professional
1 edition
May 2006
384 pages
Reviewed by Ulf Dittmer, July 2007
  (8 of 10)


Java has had multi-threading capabilities from the beginning, but with the arrival of multi-core and multi-processor CPUs on desktops everywhere, and the broad range of new concurrency features in Java 5, there are no excuses any more not to take advantage of multithreading. Getting it right can be tricky, though, and that's where this book comes in.

It explains not just the features of the Java virtual machine and the class libraries that help implement concurrent applications, but also serves as an introduction to the problems arising in multi-threaded code in general. That can range from the small -how to share a class variable between threads - to the large - how to structure applications to take advantage of concurrency. More specialized chapters deal with threading in GUIs (important for Swing developers), how to maximize performance while retaining thread safety, and how to test concurrent code.

All concepts are explained with plenty of code examples that show what is and what isn't thread-safe. If several ways to solve a concurrency problem exist, their functional and performance differences are investigated, and -where possible- quantified. Engineering consists of tradeoffs everywhere, and this book makes clear how those between functionality, performance and thread safety can usefully be made.

Everyone not having had the benefit of CS 401 "Issues in Concurrency" will get a lot out of this book. And those who did will learn how to properly implement concurrent applications in Java.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
May 2006
384 pages
Reviewed by Lasse Koskela, June 2006
  (9 of 10)


I've been doing most of my recent consulting in technology companies building systems that deal with concurrency, which is part of the reason why this book ended up on my desk -- I wanted to upgrade my know-how on the new concurrency features in Java 5 and a brand new book from recognized authors in the field sounded like a great source of information beyond the javadocs. And it is.

I'd almost call this the current bible on Java concurrency. At less than 400 pages it's relatively compact and still manages to properly cover a lot of ground. The text is easy to understand and avoids "difficult" words better than Doug Lea's "Concurrent Programming in Java", although it's been a couple of years since I read Lea's earlier book.

What I really like about the book is the thorough discussion on not just the API but also on the underlying theory. In other words, you're not just reading about the new synchronizer objects, thread factories or the executor architecture -- you're also getting the low-down on a lot of what's happening inside the JVM.

This, on the other hand, also makes the book somewhat less approachable as it might be if the authors would just give you the "tutorial". I did have hard time figuring out some sections on the first time around but I can't say it was because of the authors' writing. In any case, definitely not a course book for Java Programming 101.

It was a positive surprise to see the authors dedicating a chapter for testing multithreaded code. I would've wanted to read more on the topic, but the material in this one chapter is already a huge help in helping the reader to understand some important differences between unit testing the logic and the concurrent behavior of Java code.

I'm giving a big thumbs-up for "Java Concurrency in Practice". Besides the couple of pages in my copy having print quality problems (the copy we have at the office doesn't, so it's probably a one-off case), I don't have much negative things to say about this book. If you're looking for an advanced title on concurrency programming in Java, you won't go wrong with this one.

Discuss book in the Saloon — More info at Amazon.com


Agile Java Development with Spring, Hibernate and Eclipse
by Anil Hemrajani


Sams
1 edition
May 2006
360 pages
Reviewed by Balaji Loganathan, February 2007
  (9 of 10)


Bought and read this book from Safari-O'Reilly online.

The title itself gets the mood on. This book will help you to understand and get started with Spring-Hibernate-Eclipse kind of projects.

This book is definitely a best shot for beginners in JEE.

Its not complete reference for every topics the author addresses, but will sure give you extended overview on XP, Agile etc.,

If you want to get started with your spring project immediately then this book is worth buying.

This book doesn't cover Spring AOP - Hmm.. Its a pity.

Its interesting to see the chapters that start with a discussion between programmers and client.

Getting the sample code up and running is also just a click of a Ant build button.

Configuring Eclipse/Spring/ANT have been covered in detail while many other key technologies were just started and finished on a single page.

The appendix were quite useful, like AMDD, XP cheatsheet

Most commonly used technologies in JEE were addressed, so you can get to know what JEE is all about.

Altogether i recommend this book for Beginners and Intermediates to get know the beautiful world of JEE.

Discuss book in the Saloon — More info at Amazon.com


Beginning POJOs: From Novice to Professional
by Brian Sam-Bodden


Apress
1 edition
March 2006
424 pages
Reviewed by Ernest Friedman-Hill, March 2006
  (8 of 10)


Missourians -- residents of the "Show Me State" -- will appreciate this book on Java development with "Plain Old Java Objects." In a fast-paced 10 chapters, Brian Sam-Bodden builds a complete application. He starts with a detailed design, installs tools like Eclipse and Ant, and before you know it he's implemented the persistence and business tiers. Screenshots and detailed instructions will help you get your environment installed in no time.

The first five chapters of the book are astonishingly linear, with each technology choice presented as a fait accompli. In this day of political correctness and cultural relativism, authors bend over backwards to consider alternatives to every decision. Sam-Bodden's approach was refreshing. Eclipse, Ant, Hibernate, EJB3 on JBoss. Take it or leave it.

I was almost disappointed when he considers alternative implementations of the business and presentation tiers. Still, showing how to use Tapestry and especially Spring offsets the raised eyebrows some of you might have about using EJBs -- although the EJB3 specification lets you use POJOs to implement the business layer.

From this point, the book gets more conventional, with the traditional tacked-on chapter about testing that nevertheless asks you to do testing as an integral part of development.

Although the technology choices may stretch your definition of "lightweight," this is still the best book on end-to-end development of enterprise applications that I've seen. If you'd like someone to show you how things are done, this book is for you.

Discuss book in the Saloon — More info at Amazon.com


POJOs in Action
by Chris Richardson


Manning Publications
1 edition
January 2006
456 pages
Reviewed by Michael Ernest, January 2006
  (7 of 10)


This is not an "action" guide like Manning's guides on Spring or Hibernate, although it is good work. Richardson shows some practical extension of Fowler's notes on enterprise applications. His coverage of existing frameworks -- JDO, Hibernate, Spring, iBATIS -- creates a helpful context for what's out there and how to evaluate their benefits and limits. It also pursues a few examples for illustration, so it's not just concepts or high points.

To fully appreciate this book, you need to read Fowler on enterprise applications. To take advantage of it, you need experience with at least one persistence framework, and probably a book on that topic as well.

It is a solid, valuable and easy-to-read work, but it is not the 'Action' book I expected. "POJOs in (Lightweight Persistence) Design" is more like it. I downrated this book on the misleading title. It's a disservice to the beginner and intermediate audience -- even some advanced types -- who will expect more immediate gratification.

Discuss book in the Saloon — More info at Amazon.com


Pro Apache Ant
by Matthew Moodie


Apress
1 edition
November 2005
360 pages
Reviewed by Jeanne Boyarsky, March 2006
  (9 of 10)


Ant is one of those technologies that has an excellent manual and API online. This sets a higher standard for a book so as not too just duplicate the Internet content. "Pro Apache Ant" meets this challenge.

The author walks you through a good number of the Ant tasks with examples and tips. The attributes are provided for common tasks, so you have a physical reference. The author refers you to the manual for some of the less common tasks. A summary of ant-contrib is provided since it is such a standard library. The author points to the Internet for a list of optional tasks.

This book assumes you know Java and the packaging process. In other words, you should know what a jar and war are to understand the sample application.

After walking through the common tasks and incrementally building a sample build.xml, the author delves into some more advanced topics. Included are how to refactor a build file, accommodate large projects, custom tasks, mappers and how to use the Ant API from a Java program.

The book doesn't have any fluff. It starts with an introduction to Ant and Ant's benefits. After a detailed explanation of how to install Ant, you see the first Ant task. I recommend "Pro Apache Ant" if you are getting started with Ant or want to know how to use it more powerfully.

Discuss book in the Saloon — More info at Amazon.com


Wicked Cool Java
by Brian D. Eubanks


No Starch Press
1 edition
November 2005
248 pages
Reviewed by Katrina Owen, October 2007
  (6 of 10)


Wicked Cool Java reads like a blog. I'd probably visit the blog regularly. Some days I'd skim, some days I'd read through thoroughly, and occasionally I'd bookmark for future reference. I'd probably go to the blog and do searches now and then when attempting to approach new (to me) problems, and I'd browse the archives some days while procrastinating.

Topics covered range from generics and String manipulation to MIDI and harmonics, from graphs and graphics to scientific applications, from semantics to logic, artificial intelligence and neural networks to programming lego robots.

I'm sure every single bit covered is Wicked Cool to someone... though it is difficult to imagine any one person finding ALL of it to be Wicked Cool. Except maybe the author, who expresses an admirable amount of enthusiasm and interest!

The target audience is people who have a good basic familiarity with Java, and are ready to see what wonders will pop out if you poke it in unexpected places.

If you are very new to programming, a lot of the discussions might be difficult to follow.

Discuss book in the Saloon — More info at Amazon.com


No Starch Press
1 edition
November 2005
248 pages
Reviewed by Jason Menard, March 2006
  (6 of 10)


"Wicked Cool Java", by Brian D. Eubanks, bills itself as "an idea sourcebook" for Java developers who are "looking for interesting and useful APIs or for project ideas." This book serves as an introduction to a hodge-podge of APIs covering a breadth of topics. Eubanks devotes sections of the book to such overarching topics as processing XML and HTML, the semantic web, scientific and mathematical applications, graphics and data visualization, and multimedia among others.

I do have a couple of problems with the book. The first two chapters are "Java Language and the Core API" and "String Utilities." Given the stated objectives of the book, I have a hard time seeing where the first two chapters fit in. My other gripe is that URLs aren't given for most of the APIs under discussion. Instead the author expects us to visit the book's website for this information. While this isn't a big problem, it certainly is annoying.

Complaints aside, I did enjoy reading about many of the APIs that I was unfamiliar with. The text does inspire me to want to try out some of the material presented therein, which is after all what Eubanks was trying to accomplish. So while I might not call it "Wicked Cool", "Kinda Cool" might be a bit more appropriate.

Discuss book in the Saloon — More info at Amazon.com


No Starch Press
1 edition
November 2005
248 pages
Reviewed by Mark Spritzler, January 2006
  (7 of 10)


So what should I make of Wicked Cool Java. This Book has a bunch of "Code Bits, Open-Source Libraries, and Project Ideas", and it does. However, some of the bits and libraries might not be of interest to me or you at this moment, and just cool to look at, but misses on the wicked side.

There are core Java stuff, String stuff, parsing stuff, Math neuro net stuff, RSS feeds, and more. So, there isn't any one thing that is covered completely throughout the book. This is where I think this book misses. Because you might use an example and not use another till years later, or never.

I'd rather do a Google search. These items could be split into articles and posted on one web site.

Discuss book in the Saloon — More info at Amazon.com


Beyond Java
by Bruce A. Tate


O'Reilly
1 edition
September 2005
200 pages
Reviewed by Mark Spritzler, November 2005
  (8 of 10)


First I have to laugh. Because this is one of those books where the author is either trying to get people mad, just to see their reactions, or they really know what's going on and are the first to say so, and therefore be burned at the stake. Or they are just morons who have no clue. I think after a number of reviews have come in for this book, I think you will find all of them cover the above three.

First, this book makes me think and makes me want to look further into Ruby on Rails and continuation servers. They sound interesting. Second, some of the things Bruce says in this book seem to contradict themselves when it comes to him sounding off at Java's shortcomings.

First he says he doesn't like the "verbosity" of generics (Java 5.0), then he talks about having to use Iterators and the code you have to write to loop through Collections (Java 1.4). Meaning that for his argument, he'll use Java with version 1.4, and in another he'll use Java 5.0 But only to "prove" his argument. He jumps back and forth. I can do that in any language, use a fault in a much older version to use in an argument about the version today.

I think some of his "pluses" for using Ruby is because he hasn't used a dynamic typed language before, and not seeing the trade-offs and other maintenance problems that come with dynamic typing. We'll have to see.

I also respect Bruce, because I really enjoyed his Better Faster Lighter Java book.

Buy this book for the entertainment value from either side, the I want to beat him up, to I completely agree with him 100%. Either way you will have fun reading it.

Discuss book in the Saloon — More info at Amazon.com


Pro Apache Beehive
by Kunal Mittal, Srinivas Kanchanavally


Apress
1 edition
August 2005
240 pages
Reviewed by David O'Meara, December 2005
  (6 of 10)


I was quite impressed with the way this book was presented. While there were some sections that weren't quite right for me, overall the introduction sections and lead up, examples and prose all hit the spot and as such it was an enjoyable book to read.

The book provides a "from the ground and upwards" introduction to Beehive so it does not require any prior knowledge to get started. This isn't too surprising for a framework with a comparatively smaller user base. It also has a very nice introduction to the available Beehive tools so that you can start working efficiently.

While it is not approached as a Beehive marketing exercise (and this was a relief), I was a little confused between the BEA and Beehive offerings in the earlier sections. Maybe it is of worth for people moving to Beehive, but at the point where you're still confused about the starting concepts I found it a bit distracting.

While I wasn't a complete fan of the framework itself, the instructions and examples provided make this a very useful book if you intend to give Apache Beehive a go yourself.

Discuss book in the Saloon — More info at Amazon.com


Eclipse IDE Pocket Guide
by Ed Burnette


O'Reilly
1 edition
August 2005
127 pages
Reviewed by David O'Meara, November 2005
  (8 of 10)


The most common comment from the people I showed this book to was "I wish I had it when I started using Eclipse".

While this is a very small book, the contents have been selected to give you a best start with the main features of the Eclipse IDE. The topics are short but concise and include scattered tips for the points of interest.

If you're just starting with this IDE, the Eclipse IDE Pocket Guide will give you a great head start and will continue helping you as a lovely reference to refer back to as the features become familiar. Having all of these critical features pointed out earlier will save you a lot of bother in the future, since you'll be annoyed if you only find out about them much later by accident or experimentation!

Experienced users are less likely to get much from it though. The authors made a decision between content and size, and I feel they chose to stick with a smaller, simpler book than I would have expected. There is a final section on places to go for more information, but it just refers to various community sites.

I wish I had this book when I started using Eclipse.

Discuss book in the Saloon — More info at Amazon.com


Professional BlackBerry
by Craig J. Johnston, Richard Evers


Wrox
1 edition
July 2005
308 pages
Reviewed by David O'Meara, November 2005
  (6 of 10)


One of few Blackberry books available, "Professional Blackberry" has much of its content aimed at hosting BES servers and integrating handhelds while the other offerings concentrate on the handhelds themselves and largely treat the server as a black box.

There is still a little time taken to cover features on the handheld such as developing Java applications and using the Plazmic Media Engine for enhanced content, but these are provided as the last two chapters. While they are fine as an introduction, you will need to look for other sources for developing your own content for the Blackberries.

There is a lot to know, and setting up any server is a complicated business, so I have to admit I was a little surprised by the size of the book. At around 300 pages with a third dedicated to appendices, it lacked the depth I was expecting in many areas. The coverage of the combinations of backend possibilities had plenty of useful information, but they were all mixed together and would be difficult to refer to if you were only interested in a single set up.

Overall this isn't a bad effort and a useful book for the task, but I'm hoping later versions will be fleshed out a little more.

Discuss book in the Saloon — More info at Amazon.com


Pro J2ME Polish
by Robert Virkus


Apress
1 edition
July 2005
472 pages
Reviewed by Mark Spritzler, September 2005
  (8 of 10)


When you first learn J2ME, you learn about this fantasy world where all devices follow the J2ME specification to a tee. But in the real world, because of the interpretive nature of the specifications, no two devices really implement the specification exactly the same. So this requires either targeting a particular device or have many versions of you app to run on different devices.

Man what a pain. But that is where J2ME Polish comes to the rescue. J2ME Polish provides pre-compiler directives to allow you to write code such that J2ME Polish's build script can automatically create different versions for you on the fly however you want. There is a lot more to J2ME Polish than just that, but this is a book review.

So let's get to that review. Well, first Robert Virkus is J2ME Polish, well he is the architect and lead programmer for J2ME Polish. Who better to write a book about it? Consider this book the hard copy of the manual for J2ME Polish. If you are going to use J2ME Polish, then this book is a must. It is the reference book that you will need to find anything you need to know about J2ME Polish.

Now, it isn't really a read all the way through the book and you can be J2ME Polish expert. You really need to be actually using J2ME Polish at the time, to better grasp what is being explained. The book can be hard to understand, not because of the writing, but because J2ME Polish is feature rich and there is lots to learn.

I highly recommend using J2ME Polish and buying this book if you will be developing for more than one device, and also to get their cool looking GUI screens, rather than MIDP 2.0 High Level GUIs.

Discuss book in the Saloon — More info at Amazon.com


Java Puzzlers : Traps, Pitfalls, and Corner Cases
by Joshua Bloch, Neal Gafter


Addison-Wesley Professional
1 edition
July 2005
304 pages
Reviewed by Ernest Friedman-Hill, November 2005
  (9 of 10)


First, let's get this out of the way: you're not as smart as you think you are. Seriously. You don't know everything about Java. It's possible, however, that these authors do.

"Java Puzzlers" shows you more tricky corners of the Java language than you ever expected could exist. Not odd behaviors of obscure API classes, not failings of a particular implementation, but known consequences of the language specification itself. Each puzzler, written in an engaging and often humorous style, gives you a chance to figure things out for yourself before lowering the boom to let you know that, once again... you're wrong.

If you read this book and take its message to heart, you'll learn to avoid the dark alleys of Java, making sure your programs will never inadvertently become puzzlers for you or those who come after you.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
July 2005
304 pages
Reviewed by John Wetherbie, August 2005
  (9 of 10)


This is a fun book that's educational, too! The purpose is to help the reader learn about traps you can fall into coding in Java through the use of code puzzles. There are 95 puzzlers with each puzzle and associated solution discussion running two to three pages each. Appendix A provides a quick summary of the various traps identified in the book and the puzzlers in which they appeared. Appendix B describes the optical illusions scattered throughout the book.

In general each puzzler has a very short description of what the program appears to do and the program itself. It is your job to figure out what the program actually does and more importantly why. The following page is a discussion of why the program actually does what it does. Important points and traps to avoid are bolded in the discussion. Note that some of the puzzlers depend on you having Java 1.5.

Bloch and Gafter want you to think about and be aware of the language features and APIs you are using along with having fun. Read the description and the code, determine what the code does, run the code, and then, in most cases, rethink your analysis. Then read the solution and think about what the authors are saying. Go read the sections of the Java Language Specification or other references mentioned in the solution.

Truly an enjoyable book!

Full Disclosure: I received a free copy of this book for review.

Discuss book in the Saloon — More info at Amazon.com


Pro Hibernate 3
by Dave Minter, Leff Linwood


Apress
1 edition
June 2005
242 pages
Reviewed by Mark Spritzler, September 2005
  (8 of 10)


So you are starting off with Hibernate and you want a book to learn from. If you want the basics and get up an running pretty quickly, then this book works well for you. If you intend to do some complex stuff that is using more underneath tools of Hibernate, then this book might be too surface for you.

I enjoyed the book and recommend it as a beginner's book just starting off. I think the examples and writing style make it an easy to read and understand book. But I also think it stays to high level with Hibernate. Hibernate has an interesting learning curve. The basic simple mappings are easy, but once you get more relational and complex, then the learning curve steepens. I would have liked to have seen this book delve into the more "gotchas" that everyone learning Hibernate always fall into, but it doesn't.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
June 2005
242 pages
Reviewed by Valentin Crettaz, August 2005
  (8 of 10)


The task of mapping objects to tables in a relational database (O/RM) has been the focus of many research projects as the O/RM problem domain is a very complex area that has long been short of efficient solutions. A host of vendors and open-source communities have tackled the O/RM problem and have come up with solutions, such as EJB, Toplink and JDO, which were either considered successful or inefficient depending on a wide range of subjective and objective point of views.

To the rescue comes the third release of the famous Hibernate framework, which is said to provide today's most elegant O/RM solution. I take as a proof the fact that the upcoming EJB 3.0 specification is heavily based on the design concepts underlying the Hibernate framework. The first part of this book focuses on presenting the basics of Hibernate 3 while the second part provides more detailed content that shows how to create mapping files, to query objects using HQL, SQL and the Criteria API, to use events, interceptors and filters, to manage sessions, etc. Minter and Linwood also explain how to fit Hibernate into an existing environment and how to upgrade from previous Hibernate releases.

In summary, intermediate and advanced Java developers who have good working knowledge of database management and who are in need of a powerful and cutting-edge O/RM solution will be very well served with this comprehensive, yet somewhat slim, APress reference.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
June 2005
242 pages
Reviewed by Gregg Bolinger, July 2005
  (9 of 10)


I have several Apress "Pro Series" books and have yet to be disappointed. Pro Hibernate 3 is no exception. Dave Minter and Jeff Linwood do a superb job of getting the reader comfortable with the open source Object Relational Mapping tool, Hibernate.

Starting off with a simple example, the authors show you everything you need to create your first Hibernate application. From there you are shown more complex mappings, how to use the Session object, DAO pattern, Criteria API, well, you can read the TOC.

The book is very well written, clear, concise, and easy to read. The book is full of code and mapping examples that all work (yes, I tested them) with the exception of chapter 10 which points you to a download of the source. I have one complaint and that is between chapters 2 and 3 I felt I was flipping pages back and forth between the two chapters in order to get all the source code I needed for the example. Note also that the book lists required libraries for running Hibernate applications but seemed to miss one, asm.jar. So make sure you have that in your classpath if you are using the latest stable release of Hibernate.

If you are new to Hibernate or maybe you've used it minimally in the past, you'll find this book very informative and useful not only as a learning tool, but as a reference when you run into snags throughout the development of your applications.

Discuss book in the Saloon — More info at Amazon.com


Maven - A Developer's Notebook
by Vincent Massol, Timothy M. O'Brien


O'Reilly
1 edition
June 2005
220 pages
Reviewed by Jeanne Boyarsky, August 2005
  (7 of 10)


"Maven - A Developer's Notebook" is good for covering the surface of how to do a build in Maven. There is great explanation on the installation of Maven and building Java projects. Coverage of reporting and writing plugins was also good.

Coverage of building WARs was fair. It would have been nice to see a JSP or resource files in the example, rather than just code. Noticeably absent was how to build an EJB project and an EAR. And while the book demonstrates connecting to CVS/Subversion, it could use an example on checking out code.

The book assumes some knowledge of the build process in Java, but not too much. Specifically, it is not necessary to know Ant. For those who do use Ant, common pitfalls are mentioned (without saying they are from Ant.)

In developer's notebook style, the book reads quickly and goes through a series of labs. The authors are good about explaining what things mean and going through the build output. The list of Maven plugins is very useful in finding out what exists.

The book is well thought out, clear and excellent for what it covers. However, I think they tried to cover too much in too little room and wound up having to leave out some key areas. If you were only creating jars or WARs by yourself, I would give this book a 9. But for J2EE and teams, it gets a 7 because it needs the documentation to supplement.

Discuss book in the Saloon — More info at Amazon.com


Beginning J2ME: From Novice to Professional
by Jonathan Knudsen, Sing Li


Apress
third edition
April 2005
480 pages
Reviewed by Ernest Friedman-Hill, March 2006
  (7 of 10)


J2ME is a jungle of configurations, profiles, and APIs. A beginner's book might soar over the jungle like an exotic bird, pretty but insubstantial. Such a book would see everything from a 20,000 foot view. You'd see the lay of the land, but wouldn't get your feet wet.

Another approach would be for the authors to grab their machetes and start hacking their way in, following a particular path. You'd get all dirty and sweaty and get a lot of experience, but not necessarily understand exactly how you got there.

This book decidedly takes this latter path. After a brief introductory chapter, it concentrates on the core APIs and the most commonly implemented configuration and device profile. Although there's plenty of practical information on tools and lots of code examples, as a reader unfamiliar with J2ME, and someone who doesn't own a Java-enabled phone, I felt disoriented. As an introduction to J2ME programming, I felt the book was lacking in background and motivations.

Striking a balance between the two approaches I described might be a fool's errand. Therefore you would probably need one book from each category to really get involved in J2ME development.

Discuss book in the Saloon — More info at Amazon.com


Apress
third edition
April 2005
480 pages
Reviewed by David O'Meara, August 2005
  (6 of 10)


I have to admit that I didn't really enjoy this book, however it is still a good book and worth considering if you are looking for an introduction to J2ME. I found that I didn't really connect with the writing style and therefore the process of reviewing this text was a bit more laborious than I had hoped.

"Beginning J2ME Third Edition" provides an update on the latest J2ME technologies and gives it good coverage, with a comparison to the older technologies (so no problems if you're stuck a few versions behind). I also felt that the samples sometimes wandered between being too small and not exercising the given point through to being too large and burying the example in pages of code.

In the end maybe I was just disappointed in what I felt was cursory coverage from two good authors.

It's not all bad news though. The samples are still very useful and the coverage of some areas that I had found confusing in other books was much clearer here.

Maybe my impression of this book was affected by my lack of connection to the text. There may be better books out there, but I've found they too have limitations and may not be as up to date as this one; you'll have to weigh this with your requirements. I guess I'm still waiting for something else.

Discuss book in the Saloon — More info at Amazon.com


Apache Jakarta Commons : Reusable Java Components
by Will Iverson


Prentice Hall PTR
1 edition
February 2005
360 pages
Reviewed by Jeanne Boyarsky, April 2005
  (8 of 10)


"Apache Jakarta Commons" shows the reader the power of the Commons libraries. It provides a very brief overview of the available components and goes into detail on 12 of them. APIs are explained through both class diagrams and description. The author provides best practices, warnings and project ideas. The book gets started right away, on page three.

The code examples are clear and well commented. The consistent coding standard throughout the book helps with readability. The author highlights differences between the sample code and "real apps."

The book is meant for experienced Java programmers. The author assumes readers have knowledge of JSPs, Servlets, Swing and UML. Most importantly, he assumes readers are comfortable with learning by reading through code. Readers are not assumed to have knowledge of the specialized topics such as XPath or encryption.

Note that this 325-page book is really a 201-page book. Appendix A is the entire API of the Commons lang project -- word for word. I found the printed API to be difficult to read since the methods tend to run into each other. Since the other Commons projects have APIs online only, readers have to be comfortable using the online JavaDoc anyway.

This is the type of book that readers will find either valuable or minimally useful. For those who like bound versions, this book gets you started quickly. For those who like online documentation, the UML diagrams are the primary benefit given the online JavaDoc and code samples.

Discuss book in the Saloon — More info at Amazon.com


Murach's Beginning Java 2, JDK 5
by Doug Lowe, Joel Murach, Andrea Steelman


Mike Murach & Associates
1 edition
January 2005
782 pages
Reviewed by David O'Meara, March 2005
  (8 of 10)


This book is aimed at someone learning to use Java for the very first time starting with version 1.5. There are sections that will be useful to people moving to Java 1.5 from a previous version, but there are probably better books if this is what you need.

Murach's "Beginning Java 2, JDK 5" is set out like a text book, where it is mainly designed to be read cover to cover, possibly skipping a couple of chapters on the way. It starts very slowly, guiding you through your initial steps and spends the first few chapters building a basic knowledge of the Java language. As long as you bother to do the exercises after each chapter you should have a solid foundation to work on.

I was disappointed that (possibly due to the library size) the javadocs weren't included; it's just my preference, but I spent hours flipping pages while learning the language.

However, it is nice that the 'required reading' is extended by devoting a chapter each to topics such as collections, threads and Swing to name a few.

Unfortunately it is not set out like a reference book so it may be harder to find topics when you need to refer to them later, but the book will certainly give you a solid beginning and be a valuable resource in your first year of programming Java.

Discuss book in the Saloon — More info at Amazon.com


AspectJ Cookbook
by Russell Miles


O'Reilly
1 edition
December 2004
354 pages
Reviewed by Valentin Crettaz, May 2005
  (8 of 10)


Undeniably, AOP has gained a significant momentum in the academic world over the past years and is increasingly acquiring ground and broad support in industrial settings as well. Until now we have experienced four editions of the AOSD conference, the publication of a dozen books dedicated to AOP as well as the birth of numerous frameworks, libraries and languages, such as AspectJ which is commonly considered as the most popular and mature AOP language. The increasing popularity of AspectJ is directly proportional to the growing need for a consolidated AOP code base that shall help people solve their everyday programming tasks.

In AspectJ Cookbook, Russell Miles has successfully put together more than 350 pages of high quality material freshly unloaded from his AOP backpack just for you. Sure as hell you already have a dozen versions of the logging aspect in your pockets, but do you know how to efficiently validate method parameters, how to transparently remote a class using RMI, how to implement GoF patterns in a non invasive way, and how to seamlessly enable caching in your code?

Aside from the fact that this book could have contained twice its page count, it is a pure product of a pragmatist for pragmatists. You won't find endless and tiring stories, just a fair load of ready to use AOP code organized along O'Reilly's famous problem/solution/discussion cookbook format. If you are still wondering whether AOP will take off some day, stop thinking and start acting.

Discuss book in the Saloon — More info at Amazon.com


Lucene in Action
by Erik Hatcher, Otis Gospodneti


Manning Publications
1 edition
December 2004
456 pages
Reviewed by Ulf Dittmer, May 2007
  (9 of 10)


The Lucene library is a powerful text indexing and retrieval engine. While it's not a complete search solution, its multifaceted API makes it easy to build one based on it. The examples shipping with it make it easy to get started with, but they only show a small excerpt of what the library is capable of. Without a guide, it's easy to overlook important details and helpful features.

That's where this book fits in. It devotes lengthy chapters to the two core activities of indexing and searching, and it offers multiple examples of how the library accomplishes those. It also explains the multiple extension points that it API offers, allowing a user to customize many aspects of its operation.

Further chapters discuss ports of Lucene to other languages, indexing rich document formats like Word, HTML, RTF and PDF, introduce the Lucene Sandbox which collects a variety of user contributions, and case studies of some advanced and uncommon usages.

The book is slightly outdated (it covers version 1.4, while 2.1 is released now), but with such a powerful API it's probably better to start out by using not all of its features anyway. A small gripe of this reviewer is that some advanced features are only hinted at, leaving the reader to piece the remainder together himself. But -- given the plentitude of material Lucene offers -- that's probably unavoidable, and doesn't detract from a book that must be considered indispensable by serious users.

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
December 2004
456 pages
Reviewed by Valentin Crettaz, March 2005
  (9 of 10)


The advent of the Internet has brought the humanity to a new era where information has become the keystone of many businesses and human activities. The bad news is that the process of retrieving accurate information is often tedious and imprecise. Undoubtedly, we are all information addicts. We need relevant information and we need it now. Many companies, such as Yahoo!, Altavista, Google and some open-source movements, are striving to devise new algorithms and to create cutting edge tools whose primary goal is to ease the pain of retrieving information needles in the Internet and desktop haystacks.

This book is 100% dedicated to the Lucene search engine library, which one of those free medications that can considerably ease your pain of providing information retrieval support. The authors, who are both committers of the Lucene project, make an outstanding job of presenting the library and describing how to incorporate it into your system in order to leverage its flexible and powerful indexing and searching capabilities.

This book is the most comprehensive and up-to-date reference work on Lucene available on the bookshelves. It is targeted at developers of any level in strong need of powerful indexing and information retrieval support that can be plugged into the various lightweight and heavyweight systems they are developing. If you ever need to provide a search functionality to your users, the best advice I can give you is to grab this book and learn how to leverage Lucene's potential.

Discuss book in the Saloon — More info at Amazon.com


Java Developer's Guide To Eclipse
by Jim D'Anjou, Scott Fairbrother, Dan Kehn, John Kellerman, Pat McCarthy, Sherry Shavor, Jim D'Anjou, Dan Kehn, Scott Fairbrother, John Kellerman, Pat McCarthy


Addison-Wesley Professional
second edition
November 2004
1136 pages
Reviewed by Thomas Paul, January 2005
  (9 of 10)


The first edition of this book was excellent for plug-in developers and helpful, although not vital, to all others. Two things make this new edition even better than the first edition. First, plug-in development in Eclipse is now easy and so well explained in this book that there is no reason not to try it. Have you ever worked with an IDE and thought, "why isn't this function available in the pop-up menu" or "why doesn't it have this feature"? Developing a plug-in will allow you to customize Eclipse to provide the missing feature and this book will clearly explain exactly how to do that. Second, the section of the book that deals with developing with Eclipse has been improved with detailed chapters on team development including using CVS as well as an excellent example of integrating with Tomcat to develop an E-Commerce application.

The book is divided into two sections. The first 200 pages deal with using Eclipse and cover everything from the basics to complex team development issues. The next 600 pages cover everything you need to know about extending Eclipse. The book ends with 200 pages of exercises that give detailed, step-by-step examples. Five exercises deal with using Eclipse while the rest show examples of extending Eclipse. It is a big book that covers a lot of material but it covers it clearly and with plenty of examples. If you buy one Eclipse book, this should be it.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
May 2003
896 pages
Reviewed by Thomas Paul, June 2003
  (8 of 10)


The authors of this book are part of a core IBM group formed to share knowledge of the Eclipse universal IDE. The first part of this book deals with using Eclipse from a Java developers point of view. I found this was not any more helpful than the documentation available on the Eclipse web site. Eclipse works extensively with plugins that can be integrated into the Eclipse environment to provide new functionality. I would have liked to see something on some of the more popular plugins such as those used to run application servers. Even a list of where to go to get plugins would have been helpful. Unfortunately, this part of the book only covers the basics of what comes with Eclipse and does not discuss any existing plugins.

The second part of the book, about 450 pages, covers writing your own plugins. This part of the book is excellent. It covers not just the basics, but virtually everything you need to know to write plugins. Whether you wish to code a new toolbar, editor, specialized view, or wizard, it is all covered in this section. With this book you will be writing plugins in a fraction of the time you would have otherwise spent. The book also contains exercises which allow you to test your new knowledge.

If your only goal is to use Eclipse then you don't need this book. If your desire is to write plugins then I wouldn't even try without it.

Discuss book in the Saloon — More info at Amazon.com


Working Effectively with Legacy Code
by Michael Feathers


Prentice Hall PTR
1 edition
October 2004
456 pages
Reviewed by Jeanne Boyarsky, November 2004
  (10 of 10)


"Working Effectively with Legacy Code" is a very valuable resource. The author defines "legacy code" as "code without tests." It doesn't matter whether the code was written last week or ten years ago. There is more emphasis on old code that nobody understands, mainly because it is messier and harder to work with.

The examples in the book are mainly in C, C++ and Java, but there are a couple in C# and Ruby. While it is essential to know one of these languages, the author provides enough information to understand the others. When a technique only applies to a certain language, it is clearly indicated.

The author shows how different diagrams can help you learn how to understand code. In addition to UML, there are dependency and effect sketches. The author uses these to show how to think about understanding and refactoring. Other tools, such as refactoring browsers and mocks are explained.

Speaking of refactoring, there are "dependency breaking techniques" (aka refactorings) with step-by-step instructions (Martin Fowler style) throughout the book. There are also explanations of why patterns and design rules exist. Most importantly, there are lots and lots of cross-references and an excellent index.

Working with legacy code isn't fun, but this book helps make it as painless as possible. With the split emphasis between psychological/understanding/techniques and refactoring, this book is both a great read and an excellent reference.

Discuss book in the Saloon — More info at Amazon.com


Java Reflection in Action
by Ira R. Forman, Nate Forman


Manning Publications
1 edition
October 2004
300 pages
Reviewed by Thomas Paul, December 2004
  (10 of 10)


There are only a handful of books that every Java programmer should own. This book manages to enter into that elite group of books by providing exceptional coverage of an area of Java programming that is generally poorly covered and often misunderstood. Reflection is a topic that many programmers know about but don't truly understand. Reflection can provide simple ways to get out of complex problems, which makes it well worth knowing. Reflection is one of those tools that you never knew you needed until you learn it.

The authors have been working with reflection for years. They attack reflection in small pieces, making each topic crystal clear before moving on. In keeping with the "action" from the title, the authors show examples of each aspect of reflection, breaking down each line of code with complete explanations.

The book starts with the basics of reflection, looking at how to examine a class at runtime and dynamically load it. The book then moves on to demonstrating how to use the Proxy class. Later chapters show how to examine the call stack, customize class loaders, and transform one class into another. Performance is covered with a chapter that gives some good examples of benchmarking the cost of using reflection. The book ends with a look at the impact of Java 1.5 on reflection.

The best advice I can give is, buy this book. You will be amazed at the things that you didn't know you could do with Java.

Discuss book in the Saloon — More info at Amazon.com


Pro Jakarta Velocity: From Professional to Expert
by Rob Harrop


Apress
1 edition
August 2004
370 pages
Reviewed by Thomas Paul, November 2004
  (9 of 10)


Velocity is an open source template framework designed to simplify the task of generating text-based output. The Velocity documentation available from Apache is short, low on examples, and leaves holes. This book fills in the gaps and gives excellent coverage of the many features that are available with Velocity.

The book starts with an introduction to Velocity and then explains how to install and configure it. The author then discusses the Velocity Template Language, examines its shortcomings, and demonstrates how to get around them. Best practices are covered early in the book. Although Velocity is normally thought of as a web-based framework, the author doesn't let us forget that it can be used for both stand-alone and web applications and gives us detailed chapters on both. Velocity tools are well covered including Anakia, which can be used to transform XML. The Velocity architecture is explained as well as ways to extend that architecture.

The examples are well thought out and give good coverage of the features of Velocity. The most interesting part of the examples is how little work it is to integrate Velocity into a well-designed framework. The author shows how Velocity fits into both Struts and Spring, demonstrating that Velocity is not meant to replace these frameworks but rather to simplify content generation in any framework. I can strongly recommend this book for anyone interested in Velocity. For anyone not interested in Velocity, the question is, why not?

Discuss book in the Saloon — More info at Amazon.com


Core Java 2, Fundamentals
by Cay Horstmann, Gary Cornell


Prentice Hall PTR
7th edition
August 2004
784 pages
Reviewed by Thomas Paul, December 2004
  (7 of 10)


This is the seventh edition of this book and in some ways it hasn't changed much since the first edition. The first edition was aimed at C++ programmers who were looking to transition to the new language. The seventh edition is still fast-paced and detailed and aimed for the experienced programmer. The authors assume that you already know the basics of programming even if it isn't with an object oriented language. The book might make a fairly good college textbook but not as a first language.

The book covers the main areas that you would expect in an introductory Java book with a few surprises. The book gives a little bit of the history of Java and shows how to install and run Java from the console and Eclipse (but not NetBeans). There is an early introduction to reflection but exception handling isn't covered until well into the book. Swing is covered in a fair level of depth. J2SE 5.0 changes are covered throughout the book with the many examples written to show off the new additions to the language. Threading and Collections are not covered.

Overall this is a well written book who is the target audience? How many C++ programmers can be left that don't already know Java? For an introductory tutorial this book may be a bit too advanced. Through seven editions, Core Java has changed little other than to reflect language changes. Perhaps it's time to rethink the franchise.

Discuss book in the Saloon — More info at Amazon.com


Building Portals with the Java Portlet API
by Jeff Linwood, David Minter


Apress
1 edition
August 2004
393 pages
Reviewed by Valentin Crettaz, April 2005
  (9 of 10)


Information is as vital to success-striving companies and individuals as blood is to living creatures. As far as productivity is concerned, it is critical that heterogeneous corporate information systems (such as, email systems, ERP, CMS, CRM, databases, etc.) be organized in a way that allows employees at any level of the organization to seamlessly exploit and manage the massive amount of stored and generated data. This book introduces the value proposition of corporate portals when it comes to dealing with the problematic of efficient information organization and management.

Building on their long experience of developing corporate portals, the authors demonstrate how to create JSR 168 (Java Portlet API) compliant enterprise portals. They first introduce basic portlets concepts and go on explaining how to create, package, deploy and configure portlets, how to let users personalize them, how to provide single sign-on security, and how to expose portlets to the outside world or to make use of remote web service portlets. A couple of other interesting topics are also touched upon, such as creating RSS, syndication and search portlets, using portlets with JSP and servlets and integrating portlets with JSR 170 (Java Content Repository API) compliant content management systems.

If you find yourself routinely switching among several different applications to carry out your daily activities and you are dreaming at night of a single entry point to all your information systems, remember that this book is not an expenditure, it's an investment !

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
August 2004
393 pages
Reviewed by Thomas Paul, December 2004
  (8 of 10)


Portals are becoming more popular as companies are looking for a single web-based entry point into their various applications. Java provides a standard portal model with JSR 168. This book is a thorough introduction into JSR 168 that will help get portal developers up to speed into this relatively new specification.

The first seven chapters an excellent introduction into developing portlets. Response and request objects are covered in detail. The portlet life cycle is clearly explained. Deployment descriptors are discussed. Integrating with Servlets and JSPs is described. The remainder of the book covers more advanced topics. Anyone working with a portal knows the problems with providing single sign-on to multiple applications. The authors discuss this issue giving several examples. The authors cover syndication, searching, personalization, web services, content management, and more.

My only complaint with the book is that it uses the Apache Pluto portal, which is not in final release yet. Pluto is an open source portal but it is complicated to distribute content to it (you are forced to use Maven). When the book explains how to distribute portlets to Pluto it gets a little confusing because the authors need to explain multiple configuration files, some of which are exclusive to Pluto. Other than this one problem, the book gives a solid introduction to developing a portal providing detailed information of both the basics and many advanced concepts. Clearly the authors understand portal development and know how to pass that information on to their readers.

Discuss book in the Saloon — More info at Amazon.com


Java Garage
by Eben Hewitt


Prentice Hall PTR
1 edition
August 2004
480 pages
Reviewed by Thomas Paul, November 2004
  (4 of 10)


Headache. That is what I got when I picked up this book. Too cute. Too many short sentences. Sentence fragments. Headache. Recipes. My 12-year-old daughter's instant messages.

First thing to note is this is a beginner's book although you won't find that in the description. Second is that I blame this on "Head First Java". You know when a successful TV show comes out and the other networks copy it? You know how they never do it right? It's as if someone saw "Survivor" and decided it was a success because people ate bugs so they made a show where people ate bugs to win. "Head First Java" uses humor to help focus the mind on difficult concepts. This book uses humor to be cool(?), funny(?) but most of the time it is just annoying, which is a shame because there is some good information and some of it is well presented. I assume the author is trying to be amusing and be less like a traditional technical book but he fails at the former and overachieves at the latter.

At one point in the book the author suggests that if you still have questions that you should get Zoloft and take up a hobby like gardening. I think it's a little odd for an author to suggest that his readers are in need of anti-depressants but if forced to read this book, it may not be a bad idea. cya.

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
1 edition
August 2004
480 pages
Reviewed by Johannes de Jong, November 2004
  (5 of 10)


It's becoming a trend in computer books to try and put a personal "stamp" on the book by adding humor and/or personalized "information". The danger of doing so is that the reader might end up not liking the book because of this "extra baggage". This was the case for me with Java Garage, which actually is a pity because once I looked past it, I found some very useful information, like the Java Development tools and the FAQ chapters for instance, but I'm afraid that overall I'm not very positive about this book.

I personally do not much care for a book that compares computer languages. Mr. Hewitt regularly compares Java with C#. Another "sin" in my eyes is when the author starts explaining something and then tells me that the how's and why's will be explained in the next book. Why bother to mention it at all then.

More time could also have been spent on the layout and/or editing. The book is full of errors and the code because of the tabbing is downright unreadable at places.

This book gets great reviews from others so it might all come down to me not liking the format, but I honestly can say that I can not recommend anybody to spend their hard earned cash on this book.

Discuss book in the Saloon — More info at Amazon.com


Hibernate In Action
by Christian Bauer, Gavin King


Manning Publications
1 edition
August 2004
408 pages
Reviewed by Jason Menard, May 2005
  (9 of 10)


Data persistence is quite naturally at the heart of most enterprise applications. There are a myriad of choices the Java developer faces in choosing a persistence mechanism. JDBC and EJBs have long been the standard options, along with relative newcomer JDO, and various commercial Object/Relational Mapping (ORM) solutions. All of these have their place, but they also come with some baggage as well. Enter Hibernate, a popular open-source solution for ORM designed to meet some of the perceived shortcomings of the more traditional Java persistence mechanisms.

Manning's "Hibernate In Action", written by two members of the core Hibernate team (including the project's founder), takes the reader step-by-step through the process of getting up and running with Hibernate. The book begins with an introduction to issues involved in object / relational persistence. Naturally, Hibernate addresses each concern raised with this topic. Right from the beginning I couldn't help but get the feeling that the authors were trying to sell me something. The rest of the book however proceeds in typical Manning "In Action" style by diving into the nuts and bolts of what it takes to get up and running using Hibernate. An example application, an online auction application, is used throughout the book to illustrate the implementation of a Hibernate solution. The examples are clear and easy to follow, and serve adequately to prepare the reader to implement Hibernate in their own applications.

"Hibernate In Action" has to be considered the definitive tome on Hibernate. As the authors are intimately involved with the project, the insight on Hibernate that they provide can't be easily duplicated. That said, the authors' own, often controversial, opinions on common design practices (DTOs for example) are sprinkled liberally throughout the text, and this may turn off some readers. Still, if your project is going to be using hibernate or is considering using Hibernate, this book is a must-have.

Discuss book in the Saloon — More info at Amazon.com


Java 2, v5.0 (Tiger) New Features
by Herbert Schildt


McGraw-Hill
1 edition
July 2004
216 pages
Reviewed by Lasse Koskela, August 2004
  (8 of 10)


If you already know Java and want to utilize the impressive array of innovations contained in Java 2, v5.0, this book is for you." That's actually from the back cover of the book and I have to say I fully agree. Schildt has brought us many useful titles and "Java 2, v5.0 (Tiger) New Features" is no exception.

The delightfully small book (a hair below 200 pages) packs just enough information to upgrade your know-how to the level of the latest Java version. Each topic (generics, autoboxing, enums, for-each, static imports, varargs, annotations, formatter, scanner) is explained clearly and concisely with expressive code samples. Schildt even lets you in on how the compiler handles some of these syntax enhancements, which I especially enjoyed reading about. The major features of each new addition is discussed in more detail and the less common methods are given a one-sentence description, which suits me, personally, quite well as long as I agree with what's common and what's not.

Talking about agreeing on what's common, the only real gripes I have with "Java 2, v5.0 (Tiger) New Features" is that the author completely by-passes the addition of java.lang.instrument and java.lang.management packages, only mentioning that those have been added. I would've certainly expected to read at least a page worth of overview on the actual services those packages provide.

In summary, I'd say you can't go wrong with this book. It's not a "complete reference" nor is it intended to be. It's a quick path to knowing just enough to feel comfortable diving into Java code written "Tiger style".

Discuss book in the Saloon — More info at Amazon.com


Decompiling Java
by Godfrey Nolan


Apress
1 edition
July 2004
280 pages
Reviewed by Valentin Crettaz, October 2004
  (8 of 10)


Fascinated by the Java lady? Ever wanted to ask her out but never dared to? Get this book and take a shot. After discussing some legal and moral issues and telling you how to protect yourself, this book will teach you how to approach her and ask her out politely. Then, it will delve into the most intimate details of her bytecode attributes and show you how to manipulate them efficiently. Also, the author briefly describes a couple of free and commercial tools you can use to play with her. The book goes on describing techniques you can exploit to protect her sources from being seen by anyone. Such techniques include: obfuscation, encryption, server-side execution, digital rights management, fingerprinting, native implementation and many more. The second half of the book is fully dedicated to designing and implementing a working Java decompiler from scratch using the JLex and CUP (i.e., Java implementations of lex and yacc).

Basically, I very much appreciated the way I have been introduced to this wonderful and charming lady. Our chat was both enjoyable and enlightening. However, the date was over when the whole thing started to get interesting and I admit that 250 pages left me hungry. I would have liked to see a couple more concrete examples discussed and analyzed in minute details. Nonetheless, this book is a very good introduction to the topic and would satisfy both beginner and medium Java developers willing to peek beneath the lady's bytecode veil.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
July 2004
280 pages
Reviewed by Lasse Koskela, September 2004
  (7 of 10)


"Decompiling Java" is an interesting piece of work. In just 250 or so pages, you'll go through legalities related to decompiling Java code, learn the basics of Java's class file format, get a brief run-down of tools available for decompiling and obfuscating Java code, all the way through different methods employed by obfuscation tools. Finally, Nolan goes through the design of a basic Java decompiler implementation using JLex and CUP open source compiler compiler tools.

The brevity of the book is both its best and worst characteristic. It's great because I certainly wouldn't have wanted a bible on copyright and patent laws in different parts of the world, but it's unfortunate because the topic you're interested in is bound to be slightly too superficial or detached from the rest of the book. For example, I would've liked to read a lot more about the actual class file format and the internals of a JVM in the book itself instead of having to read from a specification on the web. On the other hand, the author managed to light some bulbs in my head along the way and I actually enjoyed reading his text - especially the chapter about creating a decompiler using JLex and CUP (which I've also found a bit too intimidating to actually look into).

In summary, "Decompiling Java" is a good overview of decompilation in Java and it has a couple of real gems inside, but if you're looking for a manual for dissecting class files or the JVM, it might not the book you're looking for.

Discuss book in the Saloon — More info at Amazon.com


JUnit Recipes: Practical Methods for Programmer Testing
by J.B.Rainsberger, Scott Stirling


Manning Publications
1 edition
July 2004
752 pages
Reviewed by Lasse Koskela, October 2004
  (10 of 10)


J.B. recently replied jokingly, "buy them their own copies", to my mentioning that my team would be all over my copy of "JUnit Recipes" like vultures if I was to leave it on the desk at work. I have to say that's not a bad idea. In fact, that's what you should do if you're determined to make your development team learn how to write effective unit tests in those non-trivial settings you inevitably encounter out there.

"JUnit Recipes" is, as its name implies, not a tutorial for writing JUnit tests although it does start small with some 50 pages of basic conventions and fundamentals of writing JUnit tests. Instead, it's a huge collection of little recipes for tackling those everyday problems developers around the world encounter when trying to unit test their applications. Real world solutions to real world problems. The book is divided into chapters by coarse-grained topics such as organizing test suites, test data, XML, EJB's, JDBC, etc. all the way to testing web components and J2EE applications. The last hundred or so pages of the book talk about some more exotic topics such as unit testing design patterns, using certain popular JUnit Extensions such as GSBase and JUnit-Addons.

The recipe approach fits the domain perfectly. One doesn't need to reach 30 some pages of prose before "getting it", which is the case with certain types of books discussing other problem domains. The recipes go straight to the meat of the subject with concise and clear problem statements and then quickly proceed to show how to go about solving them. The formatting of the provided code snippets is excellent as usual, with strong visual highlighting of important sections and careful indentation.

Joe has managed to put out something that I believe will be known as the unofficial JUnit bible for years to come. What are you waiting for?

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
July 2004
752 pages
Reviewed by Ernest Friedman-Hill, September 2004
  (9 of 10)


Sometimes the tiniest things are the most useful. Nails, screws, paperclips and post-its are all small, simple objects that are used a thousand different ways. So it is with JUnit -- a small and really very simple testing tool that can find its way into every corner of your Java development.

Rainsberger's book is a compendium of those thousand ways that JUnit can be used (well, OK, more like 130 ways). Each recipe starts with a solid motivation and includes a worthwhile discussion afterwards. You quickly realize that the author is sharing hard-won experience with you on every page. There are sections on testing standalone code of every description, as well as detailed sections on testing servlets, EJBs, and other less tractable components.

I've been using JUnit for years, but I picked up quite a few useful tips from this enjoyable book. Highly recommended.

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
July 2004
752 pages
Reviewed by Dirk Schreckmann, August 2004
  (10 of 10)


"Wow!" on two accounts: 1. I'm actually giving a 10 horseshoe rating to a book, and 2. "JUnit Recipes" is a very thorough and comprehensive encyclopedia of excellent advice and examples on almost every coding sitution I've ever wanted to test with JUnit.

J. B. Rainsberger has compiled a 700 page collection of scores of excellent recipes written in pattern-like fashion, clearly laying out testing problems in wont of solutions and the practical recipes for solving the problems, including annotated code examples, step-by-step instructions, and plenty of quality explanations.

"JUnit Recipes" is destined to be a classic, and has earned a most prominent place on my bookshelf, as I'm certain I'll be referencing it frequently for new and better ideas on formulating JUnit tests.

What's that? You'd like to borrow my copy of "JUnit Recipes?" No, get your own.

Discuss book in the Saloon — More info at Amazon.com


Official Eclipse 3.0 FAQs
by John Arthorne, Chris Laffra


Addison-Wesley Professional
unknown edition
July 2004
432 pages
Reviewed by Thomas Paul, October 2004
  (8 of 10)


This book is for Eclipse plug-in developers. It is broken up into chapters with each chapter covering about 20 questions. The first three chapters seem a bit unnecessary as they cover a general overview of Eclipse. Most plug-in developers probably don't need the answers to those questions and most developers not trying their hand at plug-ins won't need the answers to the remaining 300 questions.

Starting with chapter 4, the book covers many of the questions that plug-in developers will have. The main sections are broken up into a look at the basics of the Rich Client platform including JFace and SWT and specifics on the Eclipse IDE platform. Workbench, editors, perspectives, and views are covered in the general part. The next part goes into more specific details of the Workspace and Resources API and the Java Development Tool API, among other topics. The questions are arranged well so rather than a random collection of questions, each chapter is very readable. Supporting screen shots and source code are provided as needed. The questions selected cover many of the more confusing areas of plug-in development. The answers are well written and easy to follow.

The book includes a CD that can be installed as an Eclipse plug-in so that the answers will always be nearby even when a co-worker borrows your copy of the book. Overall, this book is a valuable aid to have nearby while doing plug-in development.

Discuss book in the Saloon — More info at Amazon.com


Java Studio Creator Field Guide
by Gail Anderson, Paul Anderson


Prentice Hall PTR
1 edition
July 2004
368 pages
Reviewed by Thomas Paul, November 2004
  (9 of 10)


Sun's Java Studio Creator makes use of JavaServer Faces (JSF) to allow visual development similar to Microsoft's Visual Studio. It is an easy to use IDE that allows you to drag and drop components, validators, and converters to build a web application. Much of the code required is automatically generated by the tool. This book a well-written and easy to follow step-by-step tutorial that will teach you how to use the IDE and quickly create web applications.

The book starts with a chapter on Java that can be easily ignored. The next chapter gives a quick introduction to the IDE. The authors demonstrate many of the basic techniques and show how to use the visual features to create navigation for a multi-page web site. The third chapter discusses each of the JSF components that are available in the IDE. Chapters four and five demonstrate how to use these components to build a web application. The examples are simple but show how to integrate the generated code with generated beans. Chapters six and seven show how to integrate Web Services and databases into your application. Chapter eight looks at internationalization and writing custom validators. The final chapter covers debugging.

If you have a copy of the software and want to utilize it to the fullest then this book is well worth buying. If you don't have the software then look at ISBN 0131499947 to purchase the book and the software together.

Discuss book in the Saloon — More info at Amazon.com


SWT : The Standard Widget Toolkit, Volume 1 (The Eclipse Series)
by Steve Northover, Mike Wilson


Addison-Wesley Professional
1 edition
July 2004
592 pages
Reviewed by David O'Meara, May 2005
  (8 of 10)


There are a couple of down sides to this book but there is no doubt the authors know their material, not too surprising given their senior positions in the Eclipse project! The book has so many warnings, pointers and hints it's hard to imagine developing SWT without it.

Each topic is highlighted with useful, concise code fragments which will be invaluable to anyone using SWT; you may find half of your application has been written for you. It's also good to see the emphasis placed on SWT run on Windows, X and Macintosh systems, the difference in behaviour and most of all how to avoid decisions that will allow your application to work on one of these but not be transferable. You can't avoid learning this as each point eventually comes back to this.

Maybe my expectations were a little off, but I was expecting more of a teaching or reference resource (eg. it doesn't include an API listing), but what you get is an in-depth discussion on the major areas of SWT. It may also be harder to read if you don't already have experience building UIs.

While Volume 1 doesn't cover everything, it is unlikely there will be a comparable resource for developing an SWT application even if the next volume doesn't arrive.

Discuss book in the Saloon — More info at Amazon.com


Java Transaction Processing
by Mark Little, Jon Maron, Greg Pavlik


Prentice Hall PTR
1 edition
July 2004
448 pages
Reviewed by Jeanne Boyarsky, July 2004
  (9 of 10)


"Java Transaction Processing" explains how to use different types of transactions in Java and J2EE programs. The authors state the audience is architects and senior developers. I agree and would recommend beginners read a different book first. There isn't any fluff in this book. They even separate the history into an appendix. The transaction coverage is quite thorough.

The introduction leaps right into transaction concepts. They range from the simple (ACID) to the complex (heuristics.) If you don?t understand anything in this introduction, read it again. The rest of the book assumes an understanding of all these concepts.

The authors balance the complex concepts with a large number of visuals. The most common are flowcharts and UML class/interaction/state diagrams. In chapter one, there are 31 diagrams (in 60 pages) alone. The authors provide an interaction diagram for most code snippets to give you a visual feel.

For J2EE topics, the authors provide a brief overview of the topic and end with a detailed example. They also cover features of technologies in the JCP. And what book would be complete without a chapter on web services? The authors include the alternatives and an excellent comparison of each.

The authors include many real world issues, best practices and tradeoffs. There is even an appendix on considerations when buying a transaction implementation and lessons learned. I spotted two minor editing typos, but they don't get in the way. I recommend this book to anyone who uses transactions.

Discuss book in the Saloon — More info at Amazon.com


Just Java 2
by Peter van der Linden, Peter van der Linden, Peter van der Linden


Prentice Hall PTR
6 edition
July 2004
848 pages
Reviewed by Dirk Schreckmann, August 2004
  (9 of 10)


I wish I'd had a copy of Peter van der Linden's "Just Java 2" when I first began to learn Java programming. This is the best introductory Java book I've read. It's also an excellent reference for experienced developers, with twenty-eight chapters of clear and concise explanations on J2SE topics, plus coverage of some J2EE topics, including JDBC, networking, servlets and JSPs, XML and web services.

If you're not quite sure how some part of the Java language or API works, if perhaps a new feature in Java 5, such as generics or auto-boxing (sorry, no coverage on annotations), is unfamiliar territory, you will understand it and how to use it after reading Peter's explanations. On every page, it shows that Peter understands what experienced developers should know, as he explains the purpose, mechanism and use of topic after topic, providing very informative breadth and depth.

If you're brand new to programming, you'll likely want to get hold of another introductory programming resource, and use "Just Java 2" as *the* reference for gaining a strong understanding of Java programming concepts.

Alas, the book no longer includes a CD with example code and miscellaneous utilities. The back cover of the book suggests that all the example programs are available at http://afu.com/jj6, but they aren't, yet. Don't despair. I'd bet they'll be available soon.

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
5th edition
December 2001
1136 pages
Reviewed by Marilyn de Queiroz, February 2003
  (9 of 10)


The fifth edition of Peter van der Linden's book is an excellent introduction to Java 2. I found this book to be not only an informative and well-written view of Java, but also relaxed and amusing. At the end of each chapter is a section called 'Some Light Relief'.

The author now introduces Java to the beginning programmer as well as bringing the book more up to date by covering the new items in Java 1.4. He explains OOP concepts in plain English and uses illustrations. Small code snippets are used to demonstrate where needed, and he even builds a small webserver to demonstrate networking. He covers topics such as running servlets and JSPs on Tomcat, Java Beans, EJBs, networking, sockets and IO, including the new IO classes, advanced Thread topics, and RMI after he covers the basics of Java.

This book is not meant for people who are looking for a text to help them pass the Sun certification exams, but it will certainly help with understanding how the language works. In addition, the author has added exercises to help you consolidate and expand on what you have learned in each chapter.

The book also includes a CD which contains not only the sample programs developed in each chapter, but dozens of useful Java programs and utilities such as decompilers and obfuscators. It also contains a C/C++ editor and compiler, TCL, Perl and Python language kits and a number of Windows utility programs and shareware.

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
fourth edition
December 2001
1136 pages
Reviewed by Paul Wheaton, January 2000
  (9 of 10)


My favorite all purpose Java book. When I started with Java, I browsed over 30 books and read twelve. At the time, Just Java 1.1 had just come out and it was the one that made everything click in my head. Now, whenever I want to try something new, or I want a refresher on some part of Java, this is the book I turn to first. The author has an excellent sense of humor and a way of writing that makes the topic seem obvious. The author is also a Java kernel developer, so you can be sure he knows what he's talking about. Be sure to look for "alternative material" on the CD :)

Discuss book in the Saloon — More info at Amazon.com


Eclipse: Building Commercial-Quality Plug-ins
by Eric Clayberg, Dan Rubel


Addison-Wesley Professional
1 edition
June 2004
800 pages
Reviewed by Dirk Schreckmann, September 2004
  (9 of 10)


When I first approached developing a JUnitFaces plug-in for Eclipse 3.0, as I'd never before developed an Eclipse plug-in, I quickly found myself bombarded by a lot of new things to figure out - many of which are not well-covered in the on-line documentation. As luck would have it, I got a copy of "Eclipse: Building Commercial-Quality Plug-ins" and it covers everything. In this book, the authors, Eric Clayberg and Dan Rubel, provide step-by-detailed-step instructions on what seems like every design and implementation consideration surrounding developing high quality plug-ins for Eclipse, and its commercial big brother, IBM's WebSphere Studio Workbench. These lessons include liberal and effective use of code examples, annotated screenshots and diagrams.

While reading "Eclipse: Building Commercial-Quality Plug-ins" and developing a JUnitFaces plug-in for Eclipse 3.0, I repeatedly found myself thinking things like: "Wow! That wasn't in the on-line documentation," "That's good to know," and "I wouldn't have done that correctly the first fifty times, if I hadn't just read a great explanation about it."

I'll be referring to this book as "The Eclipse Plug-ins Development Bible" every time I pull it off the shelf for reference while plugging away at my plug-in project.

If you're developing a plug-in for Eclipse or WebSphere Studio Workbench, and you'd like it to work, but you don't have this book, get a copy, now.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
June 2004
800 pages
Reviewed by Ernest Friedman-Hill, September 2004
  (9 of 10)


As the title suggests, this massive tome is intended as a guide to best practices for writing Eclipse plug-ins. I think in that respect it succeeds handily.

If you've been living in a hole: Eclipse is a phenomenally successful, infinitely extensible open-source Java IDE. By many estimates, 60% or more of Java developers are using it. Not everyone realizes that Eclipse has a big brother: IBM's commercial WebSphere Application Developer (WSAD) is a branded version of Eclipse bundled with an enormous range of add-ons (or "plug-ins", as they're more properly called.) IBM maintains a certification program, the "Ready For WebSphere" (RFWS) label, which involves meeting a suite of requirements and tests aimed at making an Eclipse plug-in into a best-of-breed tool that works well in the WSAD environment.

In a methodical, workmanlike way, Clayberg and Rubel wend their way through the components of a professionally-produced plug-in, with an eye towards qualifying for the RWFS certification. There is no fat to be trimmed here. Instead, this book focuses on enumerating everything from the solid underpinnings to the little touches that make a plug-in into a dependable, useable tool.

The book includes many screen shots and some nice UML diagrams. It's nicely up to date, as the step-by-step instructions and screen shots pertain to the recently-released Eclipse version 3.0 .

Before you even think about distributing a plug-in you've written, read this book.

Discuss book in the Saloon — More info at Amazon.com


Java 1.5 Tiger : A Developer's Notebook
by David Flanagan, Brett McLaughlin


O'Reilly
1 edition
June 2004
200 pages
Reviewed by Ernest Friedman-Hill, January 2005
  (8 of 10)


The foreword to this new O'Reilly series explains that a "Developer's Notebook" is the raw scribbling of an "Alpha Geek" as he or she examines some exciting new technology. That pretty much describes "Java 1.5 Tiger." It's raw, it's scribbling, and it's exciting nonetheless.

At a slim 177 pages, this is one of the shorter general Java books you're ever likely to see. There isn't a lot of fat between these covers. Over the faint blue graph-paper lines and the cute faux coffee stains, the concise text covers just the biggest new features in JDK 1.5: generics, varargs, autoboxing, annotations, printf, enumerations. Many of the plentiful code examples are sensible and give you a realistic idea of how to use a feature. Some of them, unfortunately, are rather contrived and don't make much sense.

My main brickbat for "Java 1.5 Tiger" is the very high incidence of typos, more in the text than in the code. Raw scribbling is one thing, but accuracy is important, too; a programming book demands it. My main bouquet is that I learned a lot from reading it, and honestly, you can't do much better than that.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
June 2004
200 pages
Reviewed by Jeanne Boyarsky, August 2004
  (10 of 10)


"Java 1.5 Tiger: A Developer's Notebook" has all the information and quality we have come to expect from O'Reilly However, the developer's notebook series has a very different style than the animal books. The book was a true page-turner and I read all 171 pages in two days.
This book really looks like a notebook complete with notes in the margins, graph paper and coffee cup stains! There is also plenty of room in the margins for the reader to add notes. This book is informative, useful and looks really cool!

A guru narrates the book. He tells you about Java 1.5 and answers your questions. Each chapter discusses several labs in a task/how to I do that?/what about ... format. It is like the author walks you through doing the labs. It really does read like a conversation. As the authors put it: "All lab, no lecture."

The code examples begin on page two and are prevalent throughout the book. The authors give warnings about common pitfalls and tasks that you cannot do -- just like you would expect a guru to do. The authors also give opinions and recommendations.

The book assumes a working knowledge of java 1.4 (or earlier.) This is especially important in the concurrency section. There is excellent cross-referencing so the chapters and tasks can be read in almost any order. I would not give a 10 unless a book was amazing. This one earned it!

Discuss book in the Saloon — More info at Amazon.com


The Definitive Guide to SWT and JFace
by Rob Warner, Robert Harris


Apress
1 edition
June 2004
684 pages
Reviewed by Lasse Koskela, August 2004
  (9 of 10)


I won't be needing another SWT book in a while... "The Definitive Guide to SWT and JFace" is indeed definitive and proved to be a nearly perfect choice for starting my journey inside Eclipse's much hyped GUI toolkit(s).

The book starts from scratch, explaining the history and motivation for a different approach to a GUI toolkit (SWT's native peer widgets vs. the emulated widgets of Swing, etc.), proceeding to your typical Hello World app with a single window and a single label, and ends up covering most everything I can think of needing to build even a relatively complex GUI using SWT and JFace. The book is a huge tome, partly because it includes listings of all the various methods provided by the classes introduced along the way. On one hand, it's a good thing because the book is pretty much all you need (i.e. a decent replacement for Google ;), and on the other hand, the book would be a lot more pleasant to read if you'd drop a few hundred pages...

One thing I specifically liked about the book is that the authors have done a good job employing screenshots where needed -- especially in the chapter about layouts.

Anyway, I'm giving this book 9 horseshoes and will definitely recommend it for anyone looking to learn SWT. I'm not a GUI developer and the book works for me as an introduction, tutorial, and a reference.

Discuss book in the Saloon — More info at Amazon.com


Java Cookbook: Solutions and Examples for Java Developers
by Ian Darwin, Ian Darwin


O'Reilly
second edition
June 2004
862 pages
Reviewed by Valentin Crettaz, August 2004
  (9 of 10)


Ever gotten tired of wading through endless reference books or crawling the web seeking for small code snippets that solve common and ever-recurring problems? Don't look further, this book is for you. In this second and revamped version of the Java Cookbook, you will find tons of very valuable resources for your everyday programming tasks. The author, a long-time practitioner, adopts a "learn-by-example" approach by providing small code recipes which cover almost all APIs from the 1.4 version as well as some new killer features of Java 5.

The number of subjects the author delves into is truly impressive. Apart from the traditional topics like effective string manipulation, threading, I18N and L10N, GUIs, RMI and networking, I/O and file system operations, and many more, the author also focuses on external devices and serial/parallel port programming, electronic mail, reflection and introspection, graphics and sound, pattern matching, generics, autoboxing, packaging and how to use Java with other languages.

I really enjoyed reading this very helpful resource and I would definitely recommend it to Java programmers of any level in urgent need of some code ammo to put in their backpack.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
January 2001
882 pages
Reviewed by Cindy Glass, October 2001
  (8 of 10)


This book assumes that you know some Java, but that you have a particular problem that you need to solve. You could either post the question at JavaRanch, or look it up in this book. The format is great! It is organized with a specific problem, a quick explaination of the solution to the problem, and an in detail discussion of the solution including samples and complete code as needed.

The topics range from fairly simple things such as dealing with Strings, to complex things such as using RMI, XML, sending e-mail with Java etc. His overview of Servlets and JSP was great.

There was a lot of code that you could borrow and use, but no CD with the book, however it was all available on his website.

On the whole, this book will be one of the ones that gets references over and over. It has something for everybody.

Discuss book in the Saloon — More info at Amazon.com


J2ME Games with MIDP2
by Carol Hamer


Apress
1 edition
June 2004
304 pages
Reviewed by Thomas Paul, October 2004
  (9 of 10)


I really enjoyed this book. The author does a solid job of explaining everything you need to know to write games for MIDP devices. If you are familiar with Jonathan Knudsen's book on J2ME (probably the best book on the subject), this book expands the single games chapter into a fun and interesting book.

The book starts with a quick sample showing us how to use the Sun IDE and how to run our games on the emulator and how to download our games to a phone. The author shows a couple of example games, a maze and a jumping game, that give a good overview of the basic techniques games use on MIDP devices. She then expands those examples by showing proper use of threads and shows how to play tones and music during a game. Storing information (such as high scores or user preferences) is demonstrated. Downloading game enhancements such as new levels for a dungeon game are also demonstrated. The book is full of well-commented code samples (worth stealing) that show the techniques being discussed.

The author of this book has a nice, easy to read style of writing. Her enthusiasm for the topic comes through and makes you wants to try the many sample games. If you have been spending too much time on enterprise programming then playing around with some MIDP games might be just the antidote and this book will get you started on the fun.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
June 2004
304 pages
Reviewed by Mark Spritzler, August 2004
  (4 of 10)


Well, I have been putting off this review for a week and a half now. I have a difficult time when I have to post a bad review. I feel bad for the author, and all the time that they put into writing these books.

I was really looking forward to reading this book, as a couple of friends of mine want to write a mobile device game. I thought I would be able to learn how in this book.

In J2ME Games with MIDP2, the authors attempts to teach us how to use the Game API package that is included in MIDP2.0. Unfortunately, the book spends way too much time giving code, than in really explaining the best ways to use the API. I'd say 1/2 of the book is just code. Plus the code has so many comments that it makes it very difficult to read the code. I would have suggested printing snippets, and describing it with prose.

The games that are samples are pretty cool, and I think they are great examples that could have been put to better use.

If you get Jonathan Knudsen's book on J2ME, also printed by Apress, you can learn just as much, but only in 22 pages.

Discuss book in the Saloon — More info at Amazon.com


Better Faster Lighter Java
by Bruce A. Tate, Justin Gehtland


O'Reilly
1 edition
May 2004
262 pages
Reviewed by Valentin Crettaz, August 2004
  (9 of 10)


Next year, Java will finally get a second digit in its age. Over the past 10 years, Java has become one of the most popular language on earth. Popularity is usually a positive sign but it often hides a double-edged sword as an ever increasing indigestible amalgam of (*cough* reusable *cough*) Java libraries/frameworks flood developers everyday. No one will argue that it becomes increasingly difficult to make the right decisions when it comes to choosing existing libraries/frameworks for developing new products and/or refactoring older ones.

Don't worry, you are not alone. Bruce Tate and Justin Gehtland have made a tremendous effort of popularizing some fundamental principles that, when applied consistently, can considerably ease your life. They introduce the following basic principles: "Keep it simple", "Do one thing and do it well", "Strive for transparency", "You are what you eat" and "Allow for extension". They also show how two famous open-source frameworks, Spring and Hibernate, elegantly apply these five principles. Finally, they take their own "better-faster-lighter-java" medication by applying it on the Simple Spider project and show how the latter can easily be integrated into the infamous jPetStore application.

I definitely enjoyed reading this book even though it is not necessarily about pure coding. However, I would like to warn entry-level programmers as they might not enjoy the occasional philosophical tone. As well, they might not have had the chance to be frustrated yet which is THE assumption the authors make.

Discuss book in the Saloon — More info at Amazon.com


How Tomcat Works
by Budi Kurniawan, Paul Deck


BrainySoftware.com
1 edition
April 2004
458 pages
Reviewed by Balaji Loganathan, September 2004
  (9 of 10)


This is best book to sit and read near by a fire but additionally you need a computer with you from time to time. I was very much pleased with the way author had described the interior design of Tomcat with reference to Catalina from a very simple component to the complex one. This book will sure help you to learn the big picture of Tomcat and its components and will also help you to run sample application servers.

It is highly recommended to download the code and use them as reference while reading and testing the chapters. This book covers both Tomcat 4 and 5 with a tiny note what has been changed from Tomcat 4 to 5.

I also liked the UML diagram and the collaboration diagram at the beginning of each/some chapters, this gives you the big picture of the package/class structure before you get into the very detail of every java class

After reading this book, if you happen to see some runtime errors from Tomcat, you will sure be able to say where and why it is happening

The book also act as a best documentation for entire Tomcat package, which you will not get even if you spend days on Tomcat website.

I would also recommend this book to any java programmer who want to see how a complex tool like Tomcat was build, which in-turn can help you to apply that knowledge while building your own in-house software.

Discuss book in the Saloon — More info at Amazon.com


Java Testing and Design
by Frank Cohen


Prentice Hall PTR
1 edition
March 2004
544 pages
Reviewed by Andrew Monkhouse, April 2004
  (9 of 10)


This book is an excellent guide to testing web applications and web services, and will benefit all readers from someone just starting testing, through to experienced testers trying to test a particular service.

The first third of the book describes testing in general, and how it can be applied to web applications. The second part tackles different connectivity methods, from HTTP through XML & SOAP; from one off messages, through testing sequences of messages (including maintaining session data), from user testing, through performance testing. Each chapter describes the issues and the potential problems with testing, then provides a clearly detailed description of testing using the PushToTest open source test tool. The final third of the book details some case studies of tests that Mr. Cohen has been asked to devise.

My biggest concern with this book is that, despite it's title, it really has very little to do with Java. The tests definitely apply to applications written in Java, and java classes can be used by Mr. Cohen's test application, however the book equally applies to testing any networked service, regardless of the language it was written in! Of lesser concern is that there is practically no discussion about testing outside PushToTest testing framework (not a big concern since PushToTest is open source).

This does provide excellent insights into testing, and easy to use tools and explanations for performing the tests. I have no hesitation in recommending this book to anyone involved in testing networked applications.

Discuss book in the Saloon — More info at Amazon.com


OOP DeMystified
by Jim Keogh, Mario Giannini


McGraw-Hill
1 edition
March 2004
288 pages
Reviewed by Dirk Schreckmann, April 2004
  (8 of 10)


OOP DeMystified is an excellent book, targeted at programmers new to object-oriented programming, that clearly explains the fundamental concepts of object-oriented thinking and programming, in the same manner as we use around the JavaRanch Saloon and as I've used for teaching at work for years.

The entire book, and most of the explanations, are short, complete, clear and to the point. Each chapter is followed by well-targeted review questions, that help the reader verify whether they've understood what should be understood. After reading the book, new programmers are sure to come away confident and feeling, "Object-Oriented programming - I get it!" I loaned the book to three new programmers before writing this review. They all "get it" now.

This book is not intended to replace a standard introductory programming book. It's not full of complete syntax examples and explanations or programming exercises. OOP DeMystified is designed to be a very good supplement to a course or book on object-oriented programming.

In this reviewer's opinion, a couple of the explanations weren't perfect and could use reworking. Despite that, as mentioned it's an excellent book and I'd recommend this book to any programmer new to object-oriented thinking, to supplement their studies.

Discuss book in the Saloon — More info at Amazon.com


McGraw-Hill
1 edition
March 2004
288 pages
Reviewed by Gregg Bolinger, March 2004
  (8 of 10)


McGraw Hill/Osborne has a book series coined DeMystified and have recently extended the series into the computer science area. The books target readers who want to learn complex subjects in an easy non-technical manner without formal training and who have limited time.

OOP DeMystified succeeds whole heartedly in this attempt. Beginning with the basics of an object and continuing on into classes, polymorphism, inheritance, collaboration, interfaces, and all the other ideas central to the OOP philosophy, this book uses real world examples like a Person or a Sales Order Form to help the reader understand the underlying concepts of Object Oriented Programming.

There are a few code examples in both C++, Java, and at one point even C# to help solidify the ideas trying to be expressed but nothing over the top or complicated.

The only real problem I had with this book is that sometimes, in the attempt to leave out the "technical jargon" ideas and concepts were overly explained and seemed to get a bit wordy making the concept more complicated than need be but overall this book stood behind its promise to be "concise the thorough..."

I would recommend this book to anyone needing a very basic concept of Object Oriented Programming. The book is written somewhat as a text book with quizzes as the end of each chapter. I think this book would be a good supplement to any OO language programming course but definitely needs a code centric book so that the concept may be backed up with working examples.

Discuss book in the Saloon — More info at Amazon.com


Pro Jakarta Commons
by Harshad Oak


Apress
1 edition
February 2004
304 pages
Reviewed by Thomas Paul, September 2004
  (8 of 10)


Jakarta Commons is a collection of generally unrelated but useful classes that can be incorporated into any Java project. In general, the documentation available is limited at best and in some cases is limited to little more than the Javadoc from the API. This lack of good documentation has helped to prevent the widespread acceptance of the Commons classes. This book will help to address that major shortcoming of the Jakarta Commons.

This book is an introduction to the most commonly used classes found in Jakarta Commons. Not all the components are covered. For example, Betwixt, Jelly, Jexl, and Codec are barely mentioned. However, the components that the author discusses are the most useful and are generally well covered. The book starts off slowly with an introduction to Jakarta Commons and then a brief and incomplete look at the Lang component. This chapter will give you no more than a flavor of what is available. The Logging component is well covered although I would probably never use it and the coverage of the Validator component should have concentrated solely on implementation outside of Struts and left Struts explanations to books on Struts. The remaining chapters cover the more useful components including Digester, Pooling, BeanUtils, and FileUpload and do a great job of explaining the components and providing realistic examples of usage.

Anyone who is writing Java code should be interested in the Jakarta Commons and anyone who is interested in Jakarta Commons should have a copy of this book. It will serve both as a good introduction to Commons components and a reference to using those components.

This earned 4 stars on Amazon. The book is published by Apress.

Discuss book in the Saloon — More info at Amazon.com


Hardcore Java
by Robert Simmons Jr


O'Reilly
1 edition
January 2004
400 pages
Reviewed by Valentin Crettaz, May 2004
  (5 of 10)


My first thought when I saw this new book on O'Reilly's web site was: "Well, there must be some really cool Java hacks hidden behind this rather evocative title."

Basically, it's one of those books where you expect the next page to actually delve into the real matter and give you some crispy details. My personal impression after finishing it was that the content was a little lightweight for deserving to be qualified as "hardcore", but maybe I'm being too harsh. The author handles a good deal of "advanced" topics, such as the effective use of Collections and nested classes, constants, immutable types, reflection, proxies and the four different flavors of references. Also qualified as hardcore, the novelties introduced by the upcoming Java 1.5 release are also part of the story...

I have always regarded O'Reilly's books as high-quality work (and I still do), but I have never been able to find 50 typos in any of their books before. I'm inclined to interpret this fact as if the book had been rushed to press to be on the shelves before JDK 1.5 comes out. I just wish the book had been more thoroughly proofread.

On a more positive note, I'm quite sure medium and advanced Java programmers will be able to distill valuables tips and tricks from this book. On the companion web site, the author also provides the sources of all the examples illustrated in the book.

Discuss book in the Saloon — More info at Amazon.com


XDoclet in Action
by Craig Walls, Norman Richards


Manning Publications
1 edition
December 2003
600 pages
Reviewed by Ajith Kallambella, December 2003
  (9 of 10)


An invaluable book about an indispensable framework!

Remember your first J2EE Hello World app? Just to make that client work, you had to write the remote and home interfaces, and a deployment descriptor. If you wrote the Web version, add web.xml to your list. Let's not forget those configuration files for your app/web servers. Now, think of a framework that fabricate all the nuts and bolts for you -- generating deployment descriptors, EJB homes, remotes, app server files, struts-config.xml and more. No, you are not day dreaming, XDoclet can do all and more!

Quoting several opportunities that exist for automated code generation, authors introduce XDoclet framework as an indispensable tool that actually works! Focusing on every day J2EE development, chapters in "Enterprise Java" section talk about the application of XDoclet in EJB layer and Web application layer. Following are chapters in the "Other XDoclet applications" category that introduce advance applications such as code generation for persistence frameworks, JMX, SOAP/WebServices and mock objects. The concluding section on "Extending XDoclet" deals with custom code generation and XDoclet patterns.

Abundant practical help and many working examples are offered throughout the book including the process of tool adoption for J2EE efforts that are already underway. The working J2EE application that is included in the book can be used as a reference implementation.

In essence, this book does more than just teaching -- it helps you realize the benefits of XDoclet in days and start saving valuable time and money.

Discuss book in the Saloon — More info at Amazon.com


Java Open Source Programming: with XDoclet, JUnit, WebWork, Hibernate
by Joseph Walnes, Ara Abrahamian, Mike Cannon-Brookes, Patrick A. Lightbody


Wiley
1 edition
November 2003
480 pages
Reviewed by Thomas Paul, March 2004
  (6 of 10)


What a good book this might have been. It isn't awful but it could have been so much better. The premise of the book is to take the "Pet Store" and improve it by using several open source tools. The first part of the book discusses each of the tools with brief explanations and sample code. The second part takes us through the development process showing how to use the tools that were discussed earlier.

The good parts of the book are mostly in the second half. The authors apply each of the tools, explain test-driven development, demonstrate how and when to refactor code, etc. The integration of the different tools is made naturally so that it doesn't seem that the authors are trying to squeeze a tool in just to demonstrate it. The bad parts: this book desperately needs editing, both technical and for grammar. It is very distracting to see so much improper English usage including run on sentences, sentence fragments, and noun-verb disagreement. On the technical side, there are so many errors in the code that I doubt very much will actually compile, let alone run. Typical errors include methods declaring to return a value and not returning anything, closing files before they are used, and using variables that are not declared.

If you are interested in the technologies discussed and can debug the code in the book, there is a good amount of value. But it could have been so much better.

Discuss book in the Saloon — More info at Amazon.com


Enterprise J2ME: Developing Mobile Java Applications
by Michael Yuan


Prentice Hall PTR
1 edition
November 2003
480 pages
Reviewed by Lasse Koskela, November 2003
  (8 of 10)


"Enterprise J2ME" is a toolbox for mobile Java developers involved in developing enterprise-scale applications. A lot of focus is given on available alternatives (both general approaches and product offerings, open source and commercial) for handling the problem of spotty and low-bandwidth connectivity, and on technologies for communicating between the mobile client and enterprise systems. Furthermore, plenty of sample code is available illustrating these techniques in the form of several full-blown sample applications downloadable from the companion website.

The book has packed a lot of coverage into less than 500 pages. This inevitably means that many subjects are bypassed rather quickly, referring to sample code for details. Fortunately, Yuan has found a reasonable balance and managed to include sufficient detail in those subjects that interest me the most (networking, on-device databases, XML and web services, and security). I would say that this book is best used as a reference for a mobile application architect wondering what her choices are. On the other hand, the focus on particular products -- proprietary APIs may render some sections of the book outdated once standardization becomes reality in those areas (which Yuan explicitly and repeatedly predicts).

All in all, "Enterprise J2ME" is definitely the most comprehensive resource to date for enterprise Java developers having to deal with the new world of smart clients and packs a whole bunch of valuable information and tips for actual implementation.

Discuss book in the Saloon — More info at Amazon.com


Art of Java Web Development
by Neal Ford


Manning Publications
1 edition
November 2003
624 pages
Reviewed by Thomas Paul, March 2004
  (8 of 10)


This book is about using frameworks for developing Java web applications. The author gives a thorough overview of some of the most popular frameworks and discusses the pros and cons of various web architectures. The discussion is almost exclusively in the Servlet/JSP realm with little discussion of back end applications servers. The audience that will find this book most useful are those who have some experience with Java web development and are looking to expand their knowledge of modern web architectures.

The first part of the book is a discussion of Java web architecture in general with a concentration on MVC architecture. The second part is an examination of some of the most popular frameworks in use today. This part is interesting as the author demonstrates the same application developed in the various frameworks. The section finishes with a list of criteria to use when evaluating any framework for your own development projects. The final part is a discussion of best practices in various aspects of a web architecture such as resource management, performance, and debugging. This section reads almost as a series of articles.

The book is not really a how-to guide to using the various frameworks. I had trouble getting a couple of the examples working exactly as provided and some of the discussion was a bit confusing. But the overall view of how to choose and then incorporate a framework into a well designed architecture makes the book a very worthwhile read.

Discuss book in the Saloon — More info at Amazon.com


Contributing to Eclipse - Principles, Patterns, and Plug-Ins
by Erich Gamma, Kent Beck


Addison-Wesley Professional
1 edition
October 2003
416 pages
Reviewed by Ernest Friedman-Hill, September 2004
  (9 of 10)


"Contributing to Eclipse" is a great read. More importantly, as someone who is in the middle of their first major Eclipse plugin development project, I learned a lot -- even though I've previously read every other available book on the topic. Gamma and Beck take you through the development of a fairly sophisticated plugin, step by step. Perhaps most welcome, the plugin they develop isn't a syntax-highlighting text editor (an example that's already been done to death,) but a set of tools for running JUnit tests on Java code!

This is the only book I've seen that discusses testing and Test-Driven Development of plugins, a must for serious plugin developers. As you'd expect from the developers of JUnit, they use JUnit to test every piece of functionality they add. Surprisingly, even though you'd expect some confusing in writing about using JUnit to test a JUnit plugin, there's none. Gamma and Beck are both excellent writers, and they know this subject matter inside out.

A word of warning: this is neither an introduction to nor a reference for Eclipse plugin programming. I don't think I would have gotten nearly as much from this book if I hadn't read "Eclipse in Action" and "The Java Programmer's Guide to Eclipse" first. But if you've gotten beyond the novice level with Eclipse, I guarantee you'll learn something by reading this book.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
October 2003
416 pages
Reviewed by Nathan Pruett, November 2003
  (9 of 10)


Eclipse is the name of both an open source IDE and the extensible framework that it is built upon. A little experience of using Eclipse as an IDE, and a desire to extend the framework further are needed for this book. Before you know it, you'll be developing your first plug-in. Of course, it's a 'Hello World', but it introduces the concepts you need to go on to bigger and better things. The 'bigger and better' thing the book provides is a JUnit plug-in that performs automatic unit tests during builds. The authors don't just teach you how to build a plug-in, but how to build a plug-in that 'plays well with others' and allows for your plug-in to be extended in the future. Wrapping up the book are a collection of 'pattern stories' describing some of the design patterns used in Eclipse. The clear writing style and the flow of topics will help you get up to speed and writing plug-ins in no time. If you need further details on a topic ample references to the Eclipse documentation or other books that will help you on the subject are provided. All-in-all this book is a great resource for anyone that wants to extend the functionality of Eclipse.

Discuss book in the Saloon — More info at Amazon.com


Java Regular Expressions: Taming the java.util.regex Engine
by Mehran Habibi


Apress
1 edition
October 2003
280 pages
Reviewed by Thomas Paul, March 2004
  (9 of 10)


This book is an excellent introduction to regular expressions in general and the Java regex package in particular. The author assumes that the reader has no experience with regular expressions so even if the subject is completely new to you, you will be able to follow along easily.

The book approaches the topic in a clever way that makes it both an excellent tutorial as well as an excellent reference to keep nearby. The first chapter covers regular expression syntax. The second chapter looks at the two main classes, Pattern and Matcher, and discusses each of the methods in these classes. The way the information is presented makes it a perfect tutorial, as the methods are introduced in a sensible order that allows the detailed discussion to build. At the same time, since each method is discussed with excellent description and examples, it serves as a useful reference. Chapter three looks at some advanced topics such as groups, qualifiers, and lookaheads. In chapter four the author gives us some advice and chapter five demonstrates some useful examples. The books ends with a reference, summarizing the topics discussed in the first two chapters.

Other than a few minor misprints and one slightly confusing group example early on I could find nothing to complain about. Any Java programmer interested in learning regular expressions will find this book extremely useful. It is hard to imagine that there could be a better book on regular expressions than this one.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
October 2003
280 pages
Reviewed by Ernest Friedman-Hill, February 2004
  (9 of 10)


An old-fashioned regular expressions education starts with a Big Scary Table listing every metacharacter. Newbies often run away screaming when faced with this explosion of punctuation, never to return.

Help has arrived in this small, accessible book. Rather than starting out with the Big Scary Table, Habibi appeals to the reader's intuition, and demonstrates several regex applications before even mentioning punctuation marks. By the time that fragments of the Big Scary Table do arrive, the reader has already seen fully worked examples and learned techniques for developing a regular expression for a given problem.

Instead of the Big Scary Table, this book uses small tables that make understanding complex regular expressions easy. There are tables which break up regular expressions into pieces, each row pairing one chunk of the expression with a clear explanation. Other tables show the steps involved in developing a complex regex. The honest explanation of each step makes these tables valuable real-life case studies.

After describing regular expressions themselves, the book presents a practical overview of the java.util.regex API. There's also a separate chapter on advanced features, and a final chapter showing fully-worked practical applications.

The only flaw in this book is a slight bias toward Java on Windows systems. A reader working the examples on Linux would have minor problems the author doesn't mention.

Overall, I'd strongly recommend this book to anyone new to java.util.regex, whether or not they have previous regular expressions experience.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
October 2003
280 pages
Reviewed by Dirk Schreckmann, February 2004
  (9 of 10)


I've had this book a bit over a day. Yes, I've read the entire book. It is that good.

As I first approached it, I was afraid of this book. It's so easy to explain regular expressions in terribly dry and technical ways. Max, the author, doesn't do that.

Don't fear your painful memories of the wordy, boring, and expensive text books read during university studies. This book won't bring them back. Max has again demonstrated his excellent, clear and concise writing skills with Java Regular Expressions.

This book is not some boring reference or cookbook of regular expressions, excellent ones of which can be found for free on the internet. Instead, this book provides excellent explanations detailing techniques on how to understand and create regular expressions - object-oriented techniques at that! This is not your father's procedural regex reference.

New to java.util.regex? Buy this book, not that other one.

(Note: I'm a difficult reviewer. I won't give a 10 horseshoe review, excepting two classics that come to mind - Thoreau's Walden and Orwell's 1984.)

Discuss book in the Saloon — More info at Amazon.com


JUnit in Action
by Vincent Massol, Ted Husted


Manning Publications
1 edition
October 2003
384 pages
Reviewed by Thomas Paul, December 2003
  (9 of 10)


I think we can all agree that unit testing is a good thing that can be painful to implement. The main problem with unit testing is building tests that are easy to run and maintain. That is where JUnit enters the picture. JUnit simplifies the task of creating unit tests and this book simplifies the task of understanding and using JUnit.

The book starts with the basics of using JUnit but then moves on to explaining the intricacies of JUnit. UML diagrams clearly show the flow of control within JUnit and your unit tests. The author gives a good description of how to integrate JUnit with Ant, Maven, and Eclipse. The book also shows how to do unit testing of Servlets and JSPs which can be much more complex to test. The author demonstrates both the use of Cactus as well as the use of mock objects for J2EE testing. In fact, the best part of the book is that the author helps you determine how to decide what type of testing strategy is right for your application.

I thoroughly enjoyed this book and found the author's comments clear and insightful. The author supplies plenty of code samples with explanations of not just how but why we do our testing a certain way. The author's own experience is passed on to us with his "best practices". Anyone who is writing Java code should read and understand this book. The quality of the code you produce will vastly improve.

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
October 2003
384 pages
Reviewed by Jason Menard, November 2003
  (9 of 10)


If you've ventured into a bookstore lately, you may have noticed that the number of titles available on agile methodologies is multiplying more rapidly than the populations of some third-world countries. Leafing through any one of these titles while sipping an espresso in the bookstore's coffee bar, you'll quickly figure out that repeatable, automated unit tests are a good thing, and that JUnit is the unit testing framework most often used for Java unit testing. A couple of mochachino grande's later, and you've read enough to convince you that your continued survival rests on writing these automated unit tests. Unfortunately, and before your caffeine buzz even wears off, you're struck with the realization that while you're motivated and ready to go, you're just not sure exactly how to go about writing tests for many of your J2EE components.

"JUnit in Action" picks up where these other texts leave off. This is not a book on test-driven development, and it's not a book trying desperately to convince you of the value of tests. The book's goal is to demonstrate exactly how to write comprehensive unit tests for the various components of your J2EE applications. Writing tests for servlets, filters, JSPs, taglibs, database components, and EJBs are all covered in detail, as are testing strategies using mock objects and Cactus. Not only are you shown how to write the tests, but also how to write testable code. Along the way, the author points out useful best practices and how to use design patterns to improve your tests and the code you are testing. Code examples are thoroughly documented throughout the text in order to illustrate the techniques being discussed.

"JUnit in Action" is the definitive how-to manual for unit testing J2EE components. Pick up one of the other books if you're looking for something more motivational, but when you're ready to sit down and bang out some code, you'll want this book at your side.

Discuss book in the Saloon — More info at Amazon.com


Core Java Data Objects
by Sameer Tyagi, Michael Vorburger, Keiron McCammon, Heiko Bobzin, Keiron McCannon


Prentice Hall PTR
1 edition
September 2003
576 pages
Reviewed by Thomas Paul, December 2003
  (6 of 10)


Java Data Objects (JDO) is an alternative to JDBC that allows you to treat rows from a database as Java objects. The simplicity of JDO removes many of the complications involved with developing JDBC applications. This book does a decent job of covering the JDO specification and explaining how to properly use JDO. The book starts with an introduction to JDO and shows some examples of how to write code with JDO. The section on the object lifecycle isn't clearly explained having too much concentration on lists and not enough on explanations. The following chapters do a decent job of explaining the pieces of JDO. In addition to the basics, the book covers using JDO in a J2EE environment with a look at Enterprise JavaBeans, security, and transactions. A later chapter shows a comparison of JDO and JDBC. The authors wrap up with some tips, take a look at what might be coming in the future, and show a case study.

The authors do not look at any JDO implementations, which leaves their explanations in essence, hanging in mid-air. Although they show how to code in JDO they don't show what a programmer needs to do to hook their code in to a database. This means that without further reading, you can't run any of the examples supplied. Although the book is not bad and might be worth a read, it is not as clear or as well written as one might like.

Discuss book in the Saloon — More info at Amazon.com


Bluetooth Application Programming with the Java APIs
by C Bala Kumar, Paul J. Kline, Timothy J. Thompson


Morgan Kaufmann
1 edition
September 2003
498 pages
Reviewed by Lasse Koskela, November 2003
  (9 of 10)


My prior knowledge about Bluetooth can be described with one word --superficial. Therefore, I hail the authors for making a brave move. The book is not just an introduction to the Bluetooth Java APIs but also an introduction to the whole Bluetooth architecture and terminology. The fact that a lot of space is used to explain the underlying protocols specified in the Bluetooth specification can be both a godsend and a sleeping pill. For me, it was a godsend.

The book starts with a brief overview to what Bluetooth is as a technology. Then, JABWT (Java API for Bluetooth Wireless Technology) and how is it positioned in the field of various J2ME technologies is explained to set the architectural vision into the reader's mind. This section of the book is a very pleasant read, giving out just the right amount of information.

Next, the authors continue by tackling each main acronym one at a time using a recurring pattern: introduce technology, introduce API, illustrate with snippets of sample code. This section covers approximately half of the length of the book and can be labeled "the meat". Some portions, such as the chapters about service records, are slightly too detailed for my liking (as someone new to the whole Bluetooth scene), but mostly, the content is straightforward and easy to grasp.

After having discussed all the big things in Bluetooth for Java, two sample applications are introduced. The full source code for examples throughout the middle chapters has been included as appendices for the reader's comfort. Also, the Bluetooth APIs have been included as appendices, which I personally would've left out but also don't mind having it there. Finally, the book contains one chapter that seems somewhat displaced, providing guidance for implementing/porting the JABWT on a device.

As a closing remark, I feel that this book is a wonderful piece of work and well worth reading for developers new to Bluetooth technology and the related Java APIs. Its approach suited me perfectly.

Discuss book in the Saloon — More info at Amazon.com


Java 2 Developer Exam Cram 2 (Exam CX-310-252A and CX-310-027)
by Alain Trottier


Que
unknown edition
August 2003
480 pages
Reviewed by Andrew Monkhouse, October 2003
  (6 of 10)


This is potentially a good book for SCJD candidates, however it fails in a number of key areas.

The major problem is that this book was published in September 2003, however it is written for an assignment that Sun have not issued to candidates since April 2003. This means that the book does not touch on two important aspects of the newer assignments (raw file I/O and executable jar files), plus some of the suggestions in the book are explicitly disallowed in the newer assignments.

There are also a number of problems with the sample code provided in the book. In particular the locking code is faulty (worth 20% in the assignment), the server code does not match the requirements of the locking code, and the example of thread safe code isn't thread safe. Also, although sockets were described in detail as being one of two ways of meeting the assignment requirements, object serialization over sockets (required if you use sockets in the assignment) was not described. Hopefully these will be fixed in the errata, however at the time of review there was no errata page, and the author was unaware of these issues when I raised them with him.

On the positive side, the author provides information on areas where candidates often go beyond the specifications, although making it clear that such work is unnecessary. Also the author provides a good introduction to the ancillary work developers must do - the application analysis and design.

Discuss book in the Saloon — More info at Amazon.com


A Programmer's Guide to Java Certification
by Khalid Azim Mughal, Rolf Rasmussen, Khalid Azim Mughal, Rolf Rasmussen


Addison-Wesley Professional
second edition
August 2003
672 pages
Reviewed by Thomas Paul, October 2004
  (9 of 10)


If you are studying to become a Sun Certified Programmer for the Java 2 Platform 1.4 this book will help you to receive not just a passing grade but an excellent understanding of the intricacies of the Java programming language. Mughal and Rasmussen aren't satisfied with simply giving you a minimal understanding of Java so that you can pass a test. They are interested in helping you to understand the language at a deeper level. After all, it is much easier to pass the certification exam when you actually understand the material rather than when you have simply memorized a lot of details.

I'll give you an example of the level of detail that the book covers. Section 5.2 of the book covers Selection statements. The section starts with a description of the if statement followed by an activity diagram which explains the flow of the statement. The authors then show a simple example followed by a clear explanation of the if statement. Then they do the same with if-else, this time using several examples. The same level of detail follows for the switch statement, again providing clear text, with a simple activity diagram, followed by several well explained examples. Finally, the section ends with several review questions. What this means is that this book can serve you well even after you have passed the certification exam. You will be hard pressed to find a better written reference.

The book covers all the information you need to pass the certification exam and covers the material needed to connect all the pieces together. The included CD has several mock exams with questions that will help you understand the type of questions that you will face on the actual exam. If you do well on the mock exams you will do well on the real thing. Overall, this is an excellent book for studying for the Java certification. But it is such a good reference that you will want to keep it nearby even after you have passed the certification.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
second edition
August 2003
672 pages
Reviewed by Andrew Monkhouse, September 2003
  (9 of 10)


This is an excellent book for experienced programmers who wish to learn how to program in Java and, in so doing, study for the SCJP exam.

Since this book is targeted at the experienced programmer, it does not attempt to spoon feed the reader. Whatever topics are under discussion are explained quickly and concisely, then sample code is supplied to demonstrate the topics. It seems assumed that the experienced programmer will be able to correlate the sample code back to the discussion, as the code is not pulled apart line by line.

The book uses ample UML diagrams to describe class hierarchies, state transitions, and event sequences, however they are not relied upon within the text, so someone not familiar with UML will not be disadvantaged.

Someone who wishes to learn Java beyond the bare minimum required to pass the SCJP will benefit from the author's additional information provided. For every topic in the SCJP, the authors have picked topics that are related and are likely to be useful to a Java programmer.

A word of warning to potential purchasers though: this book will not spoon feed you, you will not get hints about the exam questions, and you will have to be prepared to experiment with the supplied code and textual descriptions of code. The author's do cover all the exam objectives, but they do not focus on getting you passed: they focus on teaching you how to program with Java.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
August 1999
688 pages
Reviewed by Tony Alicea, October 2000
  (10 of 10)


I have to say that I liked the book very much. It is not for beginners that don't know programming already, but instead it is for those (especially C) programmers that prefer that the new programming language be presented in a more formal manner.
The book's style is academic and I would see it being used in a four-year University college in a Java class for students of Computer Science. The review questions, which are dispersed over the chapters, are really good, and the answers are very well explained in an appendix.
This is a book that goes way beyond of what is strictly necessary to pass the Sun Certified Programmer for the Java 2 Platform examination, which is something I like. (I don't believe in 'bare minimums'.)
The few times that I had to e-mail the authors, their reply came promptly and to the point, including code examples. This is not what you usually get with other books. Some books don't even have an errata web page. This one, of course, does, with credits to all who helped them.

Discuss book in the Saloon — More info at Amazon.com


Eclipse: Step-by-Step
by Joe Pluta


MC Press, LLC
unknown edition
August 2003
376 pages
Reviewed by Margarita Isayeva, January 2004
  (9 of 10)


When I started to learn my first computer language, I was provided with a tome of technical documentation, where all the operators were listed in the alphabetic order with all the intricacies of their working explained. I wouldn't probably be as much lost if I were brought on another planet -- there I would at least know where is the left and where the right. Then some kind soul lent me a book written in more human style, so I could begin to orient myself along the four sides of the world...

I wish my early days I had a book like this! If you are confident in your learning abilities, and prefer to find your own path, there are books about Eclipse that you will enjoy more. But if you feel lost and looking for help, you will find it in this book. You will get your personal guide, who will never let you get lost, but will walk you through the foreign planet explaining what is this or that thing you are passing.

The book covers all the basic tasks: starting a project, editing/importing programs, compiling, debugging and troubleshooting. Each example is provided with a program on CD, so you do not have to type your own if you do not want to, and you can learn how to use Eclipse even if you know no Java at all. Each step you need to make is listed, explained, and for each step there are screenshots that illustrate what your screen should look like. If you installed Eclipse from CD, you will never have to wonder why your screen doesn't look like it is supposed to.

In "Agile Software Development" Alistair Cockburn defines three stages of learning. In the following stage learners need one procedure that work, "they copy it, they learn it", and they need a very detailed description of this procedure. In the next, detaching stage, people learn several ways to do the job along with advantages and shortcomings of each. In the third, fluent stage, they forget about procedures, as they do not need them.

This book is determinately and rigorously written for the first group of learners, and it should be appreciated as such.

Discuss book in the Saloon — More info at Amazon.com


MC Press, LLC
unknown edition
August 2003
376 pages
Reviewed by Thomas Paul, August 2003
  (9 of 10)


So you download Eclipse and start it up and stare at the screen in confusion. Or maybe you haven't even figured out how to start it up. Don't worry. Just get a copy of this book and you will be using Eclipse like an old ranch hand in no time. Many books for the novice claim that they will teach you something but they hit "magic happens here" moments that leave you lost. You won't find any of that in this book. The title of this book is "Step By Step" and that is exactly how this book teaches Eclipse.

The book assumes that you know nothing about Eclipse. After showing how to download, install, and start up Eclipse, the book takes a tour of the basic features that every programmer will need to know in order to code, test, and debug their programs. It starts by explaining what a "perspective" is in Eclipse terms and examining the most commonly used ones. The book then takes a look at a few simple Java programs, showing how to code and debug them.

This book is geared for novice users and is not meant as a reference. If you are familiar with IDEs and don't feel lost when using them then this book is probably going to be too basic for you. But if you are new to IDEs and like a lot of hand holding then this book will help you to work comfortably with the product.

Discuss book in the Saloon — More info at Amazon.com


Jakarta Pitfalls
by Bill Dudney and Jonathan Lehr


Wiley
1 edition
July 2003
283 pages
Reviewed by Thomas Paul, October 2003
  (9 of 10)


I have to admit that I am a big fan of antipattern books. There are many ways to code an application but a few of those ways will cause problems in the long run both in debugging and maintenance. This book looks at four of the most popular Jakarta applications, JUnit, Cactus, Struts, and Ant, and shows the most common problems that you encounter when using these applications. The book gives a chapter each to Ant and the two testing applications JUnit and Cactus but the majority of the book is dedicated to Struts.

Each chapter looks at several programming mistakes and then discusses ways to revise your code to fix these mistakes and make your code more robust. The problems with certain coding styles are well explained with clear reasoning as to why you don't want to code a particular way. Corrective solutions are well documented with plenty of code samples to show both before and after images.

Although the chapters on testing and Ant are good, the heart of the book is the chapters on Struts. The authors discuss potential problems using Actions, ActionForms, and the Struts tag library. Some problems can just make your code more difficult to maintain while others can introduce intermittent bugs that are very difficult to diagnose. Anyone who is using Struts should absolutely read these chapters, as it will save you from making some simple mistakes that could cause a lot of long-term pain in your development.

Discuss book in the Saloon — More info at Amazon.com


Wiley
1 edition
July 2003
283 pages
Reviewed by Salman Halim, August 2003
  (8 of 10)


This book goes over issues that plague developers when they are using the Jakarta technologies. These problems are usually the result of a lack of experience but can also be caused by there not being enough time to refactor code. The pitfalls are not farfetched and I did recognize a few in my current code!

The book covers three main Jakarta topics; specifically, they are: testing (Cactus and JUnit), Struts (ActionForms, Actions and TagLibs/JSPS) and Ant. One thing it covers for each of the categories is copy/paste code: avoiding code duplication by extracting common code into separate modules, something that may not happen to a developer EVERY situation but won't be too foreign.

The layout of the pitfalls is quite useable: the situation giving rise to each pitfall is explained, followed by a concrete example demonstrating the pitfall -- this helps clarify how this sort of thing COULD actually happen and isn't just a hypothetical problem the authors concocted. Following that is a description of the solution as well as a step-by-step procedure to FIX existing code that's fallen prey to same (this is nice). Then, finally, the broken example introduced earlier is fixed.

The code examples in this book are QUITE extensive and it is good that they are available online so one doesn't have to type them in! Some of the examples contain generic code that is immediately reusable by developers and so has practical rather than merely instructive use also.

Discuss book in the Saloon — More info at Amazon.com


Algorithms in Java Part 5 Graph Algorithms
by Robert Sedgewick


Addison-Wesley Professional
third edition
July 2003
528 pages
Reviewed by Gregg Bolinger, October 2003
  (10 of 10)


Robert Sedgewick continues his discussion on algorithms in java with the second book of his Algorithms in Java series. Graph algorithms is Part 5.

My favorite aspect of this book is the fact that Robert talks about algorithms in a very generic sense. As algorithms should be discussed. But then he shows me how to use and construct these algorithms using a language that I am familiar with; Java.

Robert wastes no time jumping right into the topic of discussion. And from cover to cover there are code samples, illustrations, graphs, and very understandable explanations.

Anyone reading this book better know what they are getting into. This book assumes more than intermediate knowledge of the Java language, but assumes nothing about your knowledge of graph algorithms. So be prepared to be intrigued, a little confused at times, but most of all, educated.

Discuss book in the Saloon — More info at Amazon.com


Test Driven Development: A Practical Guide
by David Astels


Prentice Hall PTR
1 edition
July 2003
592 pages
Reviewed by Jason Menard, August 2003
  (7 of 10)


Test-driven development (TDD) is one of the hot topics in the recent "agile revolution". Unfortunately, there aren't too many texts currently available that take an in-depth look at the subject. David Astels jumps into the fray with his new book, "Test-Driven Development: A Practical Guide", in order to help fill that void. Giving a nod to Kent Beck's "Test Driven Development By Example", Astels views his work as a complement to Beck's, focusing on the practical techniques and tools necessary to best make use of TDD.

The book first touches on some topics fundamental to TDD, such as refactoring, programming by intention, and of course the basic theory behind TDD. Appendices further flesh out this material by addressing extreme programming and agile modeling.

Although other members of the xUnit family are looked at, this book is squarely focused on JUnit and Java. As such, the text goes into detail about using JUnit, including the API, and how to go about the task of writing tests. Along with the JUnit coverage, the reader is presented with information on several JUnit extensions and JUnit related tools designed to aid the TDD process. Where this book really shines is in its coverage of mock objects and techniques for testing GUIs.

The meat of this book rests in a very detailed walkthrough of a project using TDD. Astels leads the reader through every test and every refactoring along the way, from inception to the finished product. This is probably the next best thing to sitting down for a pair-programming session with a TDD guru.

Unfortunately, there are a couple of complaints I feel the need to point out. The project presented is a Swing application that persists its data in a flat file. There is no coverage provided for testing web based enterprise applications. While mention is made of DatabaseChecker, a test utility suitable for simple database tests, Astels chose not to have the example project use a database for persistence. As a consequence of this decision, this common task is left unaddressed.

Despite these omissions, there is still much to be gained from this book. I feel a reader may obtain the most benefit by downloading the sample code and working through the example project step-by-step along with the text. If you are interested in a practical guide to TDD, this book is definitely worth a look.

Discuss book in the Saloon — More info at Amazon.com


Java Persistence for Relational Databases
by Richard Sperko


Apress
1 edition
July 2003
318 pages
Reviewed by Jason Menard, August 2003
  (6 of 10)


As the title indicates, this book takes a look at different methods in Java for persisting data to a relational database. JDBC, EJB CMP 2.0, ODMG 3.0, JDO, open source frameworks (Hibernate and Castor), and commercial frameworks (TopLink, CocoBase) are all given a look. The author touches on rolling your own persistence framework, and throws in a little bit about relevant design patterns and unit testing.

Overall this book left me with more questions than answers. Often we are told what the capabilities of a given library or framework are, but not how to make use of those capabilities. Frequently we are teased with a bit of information, only to be told that we need to go to another source to find anything of substance. Just as often, a promising topic such as unit testing the persistence layer is left inadequately addressed.

If you are looking for a broad overview on the book's subject, then this book may be for you. However, while this book ostensibly should help a manager or developer choose a persistence method suitable for his project, I'm afraid no guidelines are given as to when one particular method may be preferable to another. Although we can't expect a book such as this to be all encompassing, many sections in this book urge the reader to look elsewhere for more information. In this case, that might not be such bad advice.

Discuss book in the Saloon — More info at Amazon.com


AspectJ in Action
by Ramnivas Laddad


Manning Publications
1 edition
July 2003
512 pages
Reviewed by Valentin Crettaz, August 2003
  (9 of 10)


This is the third book on Aspect-Oriented Programming (AOP) with the AspectJ programming language. AOP is a new programming approach that complements the traditional object-oriented approach by allowing developers to modularize crosscutting concerns of an application, such as security, logging, tracing, etc, into "aspects". Such a mechanism provides for a better maintainability of the code and allows programmers to reuse aspectual modules in multiple applications.

By adopting a hands-on approach, this book is committed to be a very practical reference for aspect-oriented programmers. The author did a wonderful job of introducing the new AOP trend. So far, no other book succeeded to present the challenges of AOP so well as the author of this book does.

In the first part, the author presents the basic syntax of AspectJ and goes on with more advanced concepts of the language. The second part is dedicated to presenting simple applications of AspectJ in monitoring (logging, etc), policy enforcement and optimization (pooling, and caching) techniques. The third part delves into more advanced applications of AOP and AspectJ, such as patterns and idioms, thread safety, authentication and authorization with JAAS, transaction management, and implementing business rules with JESS. Finally, the author explains how to use Ant and the AspectJ compiler to build applications efficiently.

In summary, this book provides a very good resource for both people starting to learn AOP and AspectJ and experienced AOP programmers who wish to deepen their knowledge in this new area.

Discuss book in the Saloon — More info at Amazon.com


Jess In Action
by Ernest Friedman-Hill


Manning Publications
1 edition
July 2003
480 pages
Reviewed by Michael Ernest, October 2003
  (9 of 10)


I first came across Jess in the late 90's, rummaging around the net. I could use the tools after a little work, but most of the comments and insights surrounding Jess seemed expert-driven, and I backed off the idea of using Jess to teach for the lack of material helpful to a beginner.

Jess in Action changes all that. It's a clean, well-written book. From my view anyone with some Java experience and some programming background could learn Jess and use it for complex projects by using this book. I found the principles of rules-based programming well laid-out, the examples engaging, and the flow very comfortable.

I found some very minor flaws in the presentation -- some forward references, a style that slips into jargon now and then -- but on the whole the book is useful. You'll read it more than once, if you grasp the power of the tool that's been put in your hands.

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
July 2003
480 pages
Reviewed by Thomas Paul, August 2003
  (9 of 10)


This book is not about rules engines, although it does have a brief introduction to rules engines. This book is about Jess, a rule-based system written in Java. If you are interested in learning what kind of problems Jess can be used to solve and how to use Jess to solve these problems then this book will answer your questions.

The book is divided into two sections. The first section is a tutorial on Jess. This section covers the Jess syntax and demonstrates how to write rules for Jess. The tutorial is clearly written with some simple examples that do a good job of helping to make Jess understandable. The tutorial even shows how to do some optimizations for rules.

The rest of the book covers some fairly complicated applications written using Jess. The author refers to this section as a cookbook and the examples are complex enough and explained so well that it could easily serve this purpose. The best part of this section is that it will help someone who isn't familiar with rules engines develop ideas about how they might implement a rules engine to solve their own business requirements. The examples themselves cover integrating Jess with Java both in typical client based applications and J2EE web based applications.

If you are interested in using Jess as a possible solution to your business needs then this book is a virtual necessity. I couldn't imagine trying to use Jess without this book.

Discuss book in the Saloon — More info at Amazon.com


Java Frameworks and Components: Accelerate your Web Application Development
by Michael Nash


Cambridge University Press
1 edition
June 2003
490 pages
Reviewed by Ernest Friedman-Hill, January 2004
  (4 of 10)


Inside this 470-page book is a collection of decent short essays struggling to get out. Unfortunately, in its present state, it contains a wealth of redundant material. Nash begins by spending 55 pages defining frameworks and touting their benefits, and then moves on to another 50 page chapter entitled "Application Frameworks: What do they provide and what are the benefits?" Similarly, two 30-page chapters on the process of choosing between frameworks are separated by an 80 page catalog of synopses of more or less randomly chosen frameworks, libraries, and development tools. This book is badly in need of editing.

Curiously, the chapters in the middle of the book are entirely unrelated to choosing application frameworks. There are long treatises about open source (including over thirty pages of annotated software licenses,) about development methodologies, about design patterns, and even about IDEs. Why all this material appears in this book is a mystery to me; again, an editor could have helped.

The last two chapters of the book, which concern best practices and case studies, are a bit better and certainly more on topic. Readers interested in the Struts, Cocoon, Expresso, or Turbine application frameworks will benefit from the comparative study in the final chapter.

"This book is a practical tool for Java programmers," Nash claims in the frontispiece. I find it hard to imagine a typical Java programmer having much use for this dreary, heavy-handed tome. A manager new to software development might find it of more value.

Discuss book in the Saloon — More info at Amazon.com


Java Development on PDAs: Building Applications for Pocket PC and Palm Devices
by Daryl Wilding, McBride


Addison-Wesley Professional
1 edition
June 2003
256 pages
Reviewed by Salman Halim, July 2003
  (8 of 10)


The book compares and contrasts development in Java on both Palm and PocketPC PDAs. For each topic covered, the book explains how it's implemented in Palm (MIDP) and how it's done in PersonalJava (PocketPC). Right off the bat, one notices that there is very little difference between standard Java 1.1.8 and PersonalJava; however, Java for the Palm is different (this makes sense, given that most Palm devices have fewer resources).

This is NOT a Java teacher. It covers the API for PDAs and assumes that the reader has enough Java experience to be able to work with statements like "PersonalJava supports the full set of AWT layouts."

One nice touch is that the book doesn't just describe how the reader can write code for each of the systems -- along with going into some detail about what is needed to set up an inexpensive (almost free) development environment on a desktop, the book also comes with (updated and) downloadable Ant scripts to aid in converting code to PDA Jar files: point the Ant build file to your code and it'll not only compile the code for the PDA, but even has a task to create a shortcut to execute it on the PDA (for PocketPC systems).

Recommendation: If you have a Palm, get the book. If you have a PocketPC, see what you can dig up on the Internet first -- if you're stuck, get the book.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
June 2003
256 pages
Reviewed by Thomas Paul, July 2003
  (8 of 10)


Doing development for PDAs is a bit complex as different PDAs support different J2ME implementations. The two main J2ME implementations available for PDAs are MIDP, which is available on most Palm devices, and PersonalJava, which is available on most PocketPC and Windows CE devices. This book covers both of these implementations and explains the differences in clear and concise language. The book is relatively short at about 200 pages but it covers the material in sufficient depth to get you started in developing for both environments.

The book starts by explaining the different configurations and points out which are available on which devices. After showing us how to create a test environment, the author discusses the coding issues involved with devices with limited memory and speed. The next few chapters discuss developing a user interface, storing data, networking, and accessing web services. The differences between MIDP and PersonalJava are pointed out in each section with plenty of code samples demonstrating these differences.

The book is written assuming a basic knowledge of Java and J2ME. You don't even need a PDA to run the provided code (although how to get your code on your PDA is discussed). The book serves mostly as a tutorial although it could be used as a reference as well. Although there are several books out that cover developing for MIDP, there is very little information available for PersonalJava and for comparing MIDP with PersonalJava. This book fills that slot nicely.

Discuss book in the Saloon — More info at Amazon.com


MIDP 2.0 Style Guide for the Java 2 Platform, Micro Edition
by Cynthia Bloch, Annette Wagner


Addison-Wesley Professional
1 edition
June 2003
288 pages
Reviewed by Thomas Paul, July 2003
  (8 of 10)


If you are designing Java programs to run on cell phones or PDAs then you will want to keep this style guide nearby. This will not teach you how to code but it will teach you how to design your MIDlets so that they will be usable. You will find lots of samples of good design and bad design plus plenty of recommendations to help you to write usable MIDlets.

The book starts with some basic guidelines (make your code simple, predictable, and efficient) and a description of the minimum MIDP hardware (tiny screen, limited input, two colors, and little memory). The authors then get into the main focus of the book, designing MIDlets. Starting with screen layouts, they take us through the different items you can place on a screen such as lists, text fields, forms, commands, etc. The focus is not on how to code but on how to make these items usable. The book also covers issues such as push, security, and touch input from the usability point of view.

There is no doubt that this book will be the standard for designing programs for MIDP devices. This book can help you avoid a lot of simple (and not so simple) mistakes that you may not notice until you get to usability testing. You could write your MIDlets without this book but why not save yourself some headaches.

Discuss book in the Saloon — More info at Amazon.com


Inside Java 2 Platform Security - Architecture, API Design and Implementation
by Li Gong, Gary Ellison, Mary Dageforde


Prentice Hall PTR
second edition
June 2003
384 pages
Reviewed by Junilu Lacar, June 2003
  (7 of 10)


This book will help you understand what considerations were made during the development of the Java 2 security architecture. You get real insider information since the authors Gong and Ellison have been chief and lead security architect, respectively, for the Java 2 development team. It is concise yet fairly detailed at times, and about as fun to read as the JLS, if you're into that sort of thing. It is not a how-to book so don't expect to find any detailed examples. It only covers the J2SE platform security. Security on other platforms and technologies like J2EE and J2ME are discussed briefly in the last chapter. Even though I wouldn't really go buy the book, I hope Sun makes it available in some form on their website like they did with the JLS because it does have some useful information.

Discuss book in the Saloon — More info at Amazon.com


Using and Understanding Java Data Objects
by David Ezzio


Apress
1 edition
June 2003
456 pages
Reviewed by Ernest Friedman-Hill, January 2004
  (6 of 10)


This book is loosely divided into three parts: a conceptual overview, an API tour, and some application case studies. The overview is dense and would be scary for someone new to persistence.

The API section is the largest. One chapter is devoted to each key JDO interface. These chapters read like heavily annotated Javadocs; the subheads roughly correspond to the interface methods. Each chapter is accompanied by a UML diagram of a single class; a listing would be more useful.

The case studies are the best part of the book. Each is filled with practical advice for using JDO in a particular environment (servlets, EJBs, Swing). This material could save you countless hours of frustration.

One thing this book lacks is code. When code does appear, it's an Ant build file, or a class showing how to use the "transient" keyword, or something else peripheral to the main topic. There is essentially no real JDO code at all until the case studies at the end of the book.

Also noticeably missing is an introductory tutorial. There's no "Hello, JDO" program here. Many programmers want to see a basic program like this; its absence is disappointing.

This would make a good second book on JDO -- a reference you could turn to for details after you already knew your way around. You may also want a book with more code and tutorial content, and the writing is rough, but the case studies are full of great advice.

Discuss book in the Saloon — More info at Amazon.com


Head First Java
by Bert Bates, Kathy Sierra


O'Reilly
1 edition
May 2003
650 pages
Reviewed by Pauline McNamara, January 2004
  (9 of 10)


I wish this book had been around a few years ago when I first starting learning to program with Java. It's perfect. Aimed at not-quite-raw beginners with a little scripting experience, Head First Java hits the target. It covers the basics (and some) well enough for ambitious beginners too. If you're not new to Java you won't be disappointed either - while explaining programming concepts Sierra and Bates pass on lots of insight. You'll learn not only the what and the how, but also the why, as if a brilliant friend were sitting down with you at the computer, talking you through each point. Over coffee. Reassuring you about the slippery parts (with stuff like "don't worry about [insert tougher concept here] that comes later"). Lots of exercises keep you and your brain busy, with enough variety to pick the ones that suit you. True to the book's subtitle, "Your Brain on Java - A Learner's Guide", the authors prove that using conversational tone, lots of graphics, goofy humor and examples that you can relate to are really what make it stick, AND enjoyable. If it had a little thinner errata list and a little thicker index I'd call it flawless. Do your brain a favor and feed it this book.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
May 2003
650 pages
Reviewed by Thomas Paul, November 2003
  (10 of 10)


Who do Kathy Sierra and Bert Bates think they are? Don't they know that learning a programming language is supposed to be hard? Don't they know that it is supposed to involve suffering? Apparently not, as they have written a complete introduction to Java that is fun to read and easy to understand. If we don't stamp this out now, students will start expecting their teachers to be entertaining!

The book is an excellent introduction to Java. It covers all the typical topics of a basic introductory text and some extra including serialization, networking, and distributed computing. Each topic is covered in a fun way with important information highlighted. The authors use stories, fake interviews, pictures, nd assorted other clever techniques to catch your imagination and make the opics memorable. There are plenty of exercises (with answers) to help you check to be sure you understood each chapter. And there are plenty of fun programs to code including a cool music machine instead of the typical "reverse a String" exercises.

If you are looking for a traditional text then this book is definitely not for you. Instructors should think carefully whether this book fits in with their style of teaching. This book is not for everyone but if you want to learn Java and object oriented programming in fun and unique way then this is the book you want. Now I just have to figure out how to keep it away from my students.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
May 2003
650 pages
Reviewed by Johannes de Jong, June 2003
  (10 of 10)


Have you ever had the feeling that you simply missed the finer points of a subject that you studied? That was the case with me with Java and OO in general.

Gartner reckons that only 3 of every 10 programmers with my kind of background will make the "technology switch" from procedural to OO. This book can change that prediction.

The best way for me to describe this book is by using the teacher at school that we all have encountered in our school careers. You know the one that enthusiastically drew the most elaborate drawing on the black board to explain his point, the one that simply generates interest in his subject purely because of his sheer love of the subject he teaches. Now imagine that teacher in book form. The Head First way, you're favorite teacher in a book.

This book made me finally grasp some of the key concepts of OO that one needs to know to be able to fully use the capabilities Java has to offer.

If you are a Java programmer that has problems understanding the finer points of the language and OO in general I suggest you go out and buy the book.

I want to end with a word of caution. This book, because of its uniqueness, might not appeal to everybody. I suggest you browse the book before buying. You will immediately know if the book is for you.

(This review is based on the draft version of the book)

Discuss book in the Saloon — More info at Amazon.com


Eclipse In Action
by David Gallardo, Ed Burnette, Robert McGovern


Manning Publications
7th edition
May 2003
380 pages
Reviewed by Corey McGlone, June 2003
  (8 of 10)


For anyone that doesn't know about it, Eclipse is an IDE that is freely available and is usable for really just about anything. It's designed for versatility and it succeeds brilliantly. Of course, with increased versatility usually comes increased complexity. Eclipse In Action is written with Java developers in mind and leads you through the major functionality and extensibility of the IDE through in depth examples. The examples are great and have a nice depth (they don't feel as contrived as most examples in books like this). This has some definite benefits -- you feel like you're getting real-life experience by doing examples and it makes the book smoother to read front to back. However, there is a drawback -- this book doesn't always make a handy reference to put on the shelf. To figure out how something works, sometimes I find myself looking back a chapter or two to see how the example works so that I can work forward. I found that this book lent itself to being read straight through rather than picking put chapters to read individually. I found the book easy and enjoyable to read, although you'll probably want to be sitting in front of your computer working along to get the most out of it. The technical information is dead on and I found few mistakes -- the editing is done very well. I'd definitely recommend this book to anyone that wants to get the most out of Eclipse.

Discuss book in the Saloon — More info at Amazon.com


The Complete Java 2 Training Course
by Deitel and Deitel


Prentice Hall PTR
5th edition
May 2003
1500 pages
Reviewed by Salman Halim, June 2003
  (8 of 10)


This package includes the full-color text "Java How to Program, Fifth Edition". The book has been reviewed elsewhere on this forum.

Running the multimedia portion (after installation) launches the default browser, although it requires IE. I simply copied/pasted the main URL into IE. Wouldn't work. Turns out a startup page downloads an ActiveX plugin that is required for the presentation links to work -- this then quickly goes on to the main page of the book's text so can be easily missed. So, not only must IE be installed on your machine, it must be the default browser! A beginner (on a system someone else configured with Netscape, for example) might have given up. This does only happen once.

The entire book's contents are available online -- there is also a very good search capability. I closed the actual book in the middle of the third chapter since the references in the text are all hyperlinked and the code examples are not only all voice-annotated but can actually be executed!

The post-assessment exams (proper HTML forms) for each chapter are a good touch and mesh in well with the end-of-chapter exercises. A total score for the test on a per-chapter basis would have been nice, though.

Final comments: the book and multimedia work well together. Read the sections of text in the book, but keep the multimedia version open -- the code examples really shine online.

Discuss book in the Saloon — More info at Amazon.com


Java Database Best Practices
by George Reese


O'Reilly
1 edition
May 2003
304 pages
Reviewed by Jason Menard, June 2003
  (8 of 10)


JDO or EJB? JDBC? BMP or CMP? EJB BMP with JDBC and JDO on a RDMS?

Have you ever been caught up in the alphabet soup of Java database programming APIs? Have you ever questioned which approach might be best suited for your particular application? Sure you pride yourself on your skills in crafting some pretty mean EJBs, but is that the best path to head down with your latest project? O'Reilly's new book "Java Database Best Practices" attempts to answer these questions and more.

For such a relatively thin book (267pp), it touches on a wealth of topics vital to the subject at hand. Reese lends his insights concerning database architectures, database design, transaction management, and persistence methods using JDBC, EJB, and JDO. While this isn't intended to be an introductory tome, you are also not expected to be proficient with all these APIs. As such, the latter third of the book contains tutorials on relevant J2EE APIs, JDBC, JDO, and SQL.

Reese does not exhaustively go into detail on every topic, each of which could probably warrant its own book. Rather he arms us with just enough information to make informed decisions about which method might best serve our applications. Aside from merely determining which set of APIs might be best suited in a given situation, Reese also points out several best practices to help guide us in design and implementation (for example, "use join tables to model many-to-many relationships").

I do have a couple of small complaints about the book. For one, "best practices" are highlighted throughout the text, but they are not enumerated or indexed in any manner. An enumerated list of these best practices would be welcome. Secondly, MVC purists will likely cringe at the JSP examples. While the architecture shown (JSPs as view and control, database access through taglibs) may be valid for small web applications, I don't feel it should be highlighted as a "best practice", particularly for enterprise applications. None of these complaints are major however, and do not overly detract from the value of the book.

"Java Database Best Practices" accomplishes what it sets out to do. This is a book that might be handy to have to pass around your development team in the design phase to get you all on the same page when making some critical choices. This book could also well serve those, such as managers perhaps, seeking a broad survey of Java database programming. I also feel that this book would make an excellent companion text for a college database programming course using Java. While "Java Database Best Practices" won't make you an expert with all of these APIs, it will certainly point you in the right direction.

Discuss book in the Saloon — More info at Amazon.com


Java Data Objects
by David Jordan and Craig Russell


O'Reilly
1 edition
April 2003
380 pages
Reviewed by Ernest Friedman-Hill, January 2004
  (8 of 10)


Java Data Objects is simple and straightforward, and solves a real problem in an elegant way. Conveniently, this also serves as a description of this enjoyable book from some of the key JDO specification team members.

JDO is a recently standardized API for transparent object persistence. A standalone reference implementation is available, as are quite a few commercial and open-source versions that piggyback on relational databases and other storage solutions. JDO's popularity is growing rapidly because of its simplicity, ease of use, and scalability. "Java Data Objects" is a timely and practical treatment of this new API.

After a clear and accessible overview, this book first presents JDO in a tutorial style using a simple but nontrivial example application. Later chapters fill in the details where needed: for instance, a whole chapter is dedicated to the difficult topic of object identity.

The motivations behind JDO's development are explained well, and comparisons to other object-persistence solutions, including EJB container-managed persistence, are fair and balanced. One of this book's few flaws is that despite the authors' important roles on the standards committee, the rationale behind some of JDO's more puzzling properties are left unexplained. In particular, JDO requires that only a small subset of the standard Collections be supported by a JDO implementation, but this book doesn't explain how this subset was chosen.

All in all, an excellent tutorial and reference that will have you up and running with JDO in no time.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
April 2003
380 pages
Reviewed by Chris Mathews, May 2003
  (8 of 10)


The first thing to note about this book, is that it was written by David Jordan and Craig Russell, who happen to be key members of the JDO Expert Group (Craig was also the Specification Lead). This obviously built up my expectations for the book and I am happy to say that I was not disappointed.

This book does a great job explaining JDO in a vendor independent and portable manner. The first few chapters provide a high level overview of the JDO API and Architecture, read these if you just want to know what all the hype is about. The rest of the book is dedicated to describing all aspects of JDO in detail and clearly explaining how to apply them. JDO concepts are demonstrated throughout with the use of a single problem domain, which makes the numerous code examples flow easily and consistently.

My only major complaint deals with the final two chapters of the book, which focus on how to use JDO in application server environments. They are easily the weakest chapters of the book. I found myself questioning much of the advice given in these chapters and some of the terminology used was outdated. Ultimately, I feel that this book would have been better served without the final two chapters.

Despite some minor flaws, I would consider Java Data Objects is the definitive book on JDO. Anyone that is interested in JDO shouldn't miss this book.

Discuss book in the Saloon — More info at Amazon.com


Technical Java: Applications for Science and Engineering
by Grant Palmer


Prentice Hall PTR
1 edition
April 2003
496 pages
Reviewed by David O'Meara, June 2003
  (6 of 10)


While reading this book I kept wavering between enjoying the information presented and wondering what it was trying to accomplish. It begins with sections dedicated to people moving from C, C++ and Fortran, but there isn't enough coverage and it doesn't say much more than "Java is not so different".

The sections on differential equations, integration and Fourier transformations are useful, but some of the examples get caught up explaining more about the problem than the solution. At times you may be learning more about fluid dynamics than technical programming.

There are also short sections on IO, GUIs and web based applications that may be useful as an introduction to the topics in Java, but you would get better coverage of the IO and GUI features in a beginners book.

There are plenty of examples of technical problems presented in the book, but I can't see it persuading C or C++ developers to make the move to Java.

The book does get the message across that Java is a great choice for building technical programs, but you might be better off with the combination of a beginner Java book for the syntax and a language neutral book for the algorithms.

If Java is going to be accepted for building scientific and engineering programs, more technical books need to be written using Java as the reference language. I'm not sure this book counts, but it might be a place to start.

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
1 edition
April 2003
496 pages
Reviewed by Simeon Pinder, June 2003
  (9 of 10)


This book is not directed at typical java developers but more for scientific programmers predominantly using other languages to write numerical analysis applications. Don't get it twisted though, there's lots of information here for java developers writing numerical analysis code. Many science and engineering programmers think java is too slow and is ill suited for "hard core" numerical analysis. This book is clearly written and dispels many misconceptions concerning java and its math capabilities.

For starters, there are transition chapters for traditional numerical analysis programmers from C, C++ and Fortran, which highlight differences to be aware of if you make the switch. Next up are a few chapters on java basics and syntax for the uninitiated, while communicating sound OOP practices. The author makes the switch look a little too easy, but ok. Following was an exciting chapter pitting the innate java math libraries against the big numerical analysis three (C, C++ and Fortran). That was cool.

The next eight chapters were worth the purchase off the bat. Complete with clear descriptions, use case examples and implementation code (I'm a big fan!) for numerical analysis techniques involving matrix operations, solving differential equations and Fourier transforms to name a few. The math isn't trivial. As a java developer holding B.S. degrees in Computer Science and Molecular Biology, I have many colleagues who misunderstand java and its capabilities. This book, by a NASA engineer of 18 years, demonstrates how java addresses their analytical needs.

Discuss book in the Saloon — More info at Amazon.com


Logging in Java with the JDK 1.4 logging API and Apache Log4j
by Samudra Gupta


Apress
1 edition
April 2003
336 pages
Reviewed by Thomas Paul, May 2003
  (8 of 10)


This book covers the two most popular logging APIS, the one built in to JDK 1.4 and the Apache log4j. The book starts with a brief introduction to logging and why we should care about it. The rest of the book is divided into two parts, each discussing one of the two APIs. The final chapter covers best practices and a brief comparison of the two APIs. The sections on the logging APIs are divided into two parts, the first discussing the features of the API and the next discussing how to create your own custom components to extend the API.

The book is very well written. The author does a nice job of combining the discussion with code examples to make the topics clear. He uses UML diagrams appropriately to help the reader understand how a log request flows through the many classes. He clearly explains each of the classes in the logging frameworks and how to properly use them. The discussion of log4j ends with a chapter on the log tag library written for use with JSPs.

Overall this is a very good book. If you are doing no more than very basic logging then this book is probably a lot more information than you need. But if you want to incorporate logging into your development projects in more than just a very basic way or if you are interested in comparing in detail the two APIs, you will find this book useful.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
April 2003
336 pages
Reviewed by Mark Spritzler, June 2003
  (8 of 10)


Well I thought I was going to be able to knock down a few trees on the Ranch, and sell them, when I read the title of this book.

Instead, I learned how to implement the two most popular logging APIs for Java. Now they are so very similar, just different names for classes that do identical tasks. However, Log4j has some more features. The book also explains all the different sources, filters, and formatters that you can incorporate in your apps to log when logging is needed, and present the information best needed to be logged.

Now I know what you are thinking, why write a book about logging, I mean the APIs for basic logging are very simple. But throw that thought right out the window or barn. Samudra does a great job of explaining the ins and outs of logging and some best practices.

I would highly recommend this book if you want to learn these APIs. If you already have experience with them, then you might be bored.

If we had .5 point ratings then I would have put this book as an 8.5.

Discuss book in the Saloon — More info at Amazon.com


Unit Testing in Java
by Johannes Link, Peter Froehlich


Morgan Kaufmann
1 edition
April 2003
325 pages
Reviewed by Jason Menard, February 2004
  (8 of 10)


Johannes Link's "Unit Testing in Java: How Tests Drive the Code" bills itself as "a practical introduction to unit testing for software developers." Link's book is very comprehensive and touches on most of the topics a developer will need to know about before setting off on his own, including some topics that have not been addressed in similar titles.

The first half of the book addresses basic techniques for unit testing. The author is a proponent of eXtreme Programming and test-driven design, and those concepts are explored as they relate to unit testing. This first part of the book is quite exhaustive and contains in great detail pretty much everything you would expect. One pleasant surprise here was a nice chapter on inheritance and polymorphism as it relates to unit testing. Link offers some excellent advice on this rarely addressed topic.

Once you've mastered the basic techniques, Link kicks it up a notch and addresses some more advanced topics relevant to our day-to-day lives as Java developers. The book discusses unit testing persistent objects, web applications, and GUIs, as well as rarely examined topics such as concurrent programs and distributed applications. As if that weren't enough, Link throws in an outstanding chapter on the role of unit tests in the software process which is necessary reading if you are attempting to integrate the book's practices into your own organization.

"Unit Testing in Java" isn't an overly large book, but it is certainly a dense book. The tone is academic and some of the phrasing is awkward, although it should be kept in mind that it is a translation from German. I like to think of "Unit Testing in Java" more as a text to be studied, rather than as a reference. However, there is so much that is good in here, that it is definitely worth the effort spent reading it.

Discuss book in the Saloon — More info at Amazon.com


Morgan Kaufmann
1 edition
April 2003
325 pages
Reviewed by Frank Carver, July 2003
  (9 of 10)


This book starts by covering general techniques in unit testing, including when and why to do it, how to know if you are doing it right, and how it integrates with other development practices. This is good stuff, but mostly also covered in other books. The section on Mock Objects is especially well done though, illuminating an often misunderstood topic area.

The latter half is where this book shines. It tackles some of the really tough areas and does it very well. Singletons, database persistence, asynchronous services, concurrent and distributed systems, web applications and graphical user interfaces; all these are often skipped over as "too hard to test". If you've ever found yourself thinking something like that, you need this book.

This book is a translation from a German original. Although the translators have done a tremendous job with the technical content, sometimes a phrase or section title, especially in the initial introduction can seem very unusual. Don't be put off by the quirky language in the early chapters, the meat of the book is well worth reading and putting into practice. This book is a masterly example of how to convert programming theory into solid, practical advice.

Discuss book in the Saloon — More info at Amazon.com


Sun Certified Enterprise Architect for J2EE Study Guide (Exam 310-051)
by Paul Allen, Joseph J. Bambara


McGraw-Hill
1 edition
March 2003
648 pages
Reviewed by Ajith Kallambella, May 2003
  (8 of 10)


More is better and that's where this book comes out as a winner!

Chapters cover all objectives and are neatly organized. Every chapter concludes with a small test and a "Two minute drill" that is great for last minute reviews (and index cards!). "Exam watch" sections are interspersed throughout the book to draw your focus on test specific issues and "Scenario-Solution" sections present potential design/architectural issues with solutions in a quick to read format. Many chapters include exercises for problem solving and essay-type answering required for the final part of certification. A sample case study of a securities trading system helps the readers to prepare for part II assignment.

Here's where the "more" factor comes in - the accompanying CD contains a large collection (250+) of questions in the form of two simulated tests. One can register free on their website to download an additional test. The testing software not only includes detailed answers for every question, but will also generate a score report to help you identify your weak areas. The CD also contains code samples referenced in the book and all chapters in electronic (pdf) format. That's very helpful for someone on the run!

This book is much more than a certification guide. It can very well be used as a complete J2EE quick reference guide. Some of the extras packed in the book include XML coverage in Common architectures/protocols section, a great OOAD/UML refresher, lots of J2EE best practices and tips, introductory coverage of JCA and working code for many design patterns. The "On the Job" sections present the reader with some interesting real-life architectural scenarios.

Some code samples are two to three pages long, and one of them has a three-page output listing!! Perhaps that's the only not-cool thing about the book.

Discuss book in the Saloon — More info at Amazon.com


Bluetooth for Java
by Bruce Hopkins and Ranjith Antony


Apress
1 edition
March 2003
352 pages
Reviewed by Mark Spritzler, April 2003
  (6 of 10)


Last year we had some chickens on the farm eat some bad feed and it turned their teeth blue. Ol Doc Martin called it a bad case of bluetooth.

This book is not about some dental problems. It is about a new type of wireless networking that uses radio waves for two or more devices to communicate.

The first four chapters explain Bluetooth. Its Java APIs and how it all works. While I believe I learned how to discover available devices in the area, connect and discover their services, I feel that the writing of these chapters could have been clearer. I found it difficult and tedious to comprehend the concepts.

In chapter 5 they give two very good examples of Bluetooth and Java in action. they demonstrate all the aspects of setting up Bluetooth connections and finding out the capabilities of devices in the area. the only downfall of this chapter is that their diagram pictures are out of order and don't match their descriptions.

The later chapters start to delve deeper into more specific types of Bluetooth environments and products in the market. Such as using a Bluetooth simulator, Bluetooth security, micro blue target, Ericsson Blipnet, and Bluetooth with Jini.

Overall, I was disappointed. I thought I would come away with great new knowledge. Instead I came away with a confused look on my face. I couldn't grasp the concepts. Maybe it was at a higher level than Intermediate, or maybe it was just me.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
March 2003
352 pages
Reviewed by Thomas Paul, July 2003
  (9 of 10)


Bluetooth is a short range wireless communications protocol. JSR-82 is an API for Java that allows Bluetooth enabled devices talk to each other using Java programs. Using Bluetooth, a PDA could talk to a printer to get a document printed or two Bluetooth enabled PDAs could exchange Java objects. Even if you know nothing about Bluetooth or wireless communications, this book will give you enough information to get started.

The book starts with an examination of Bluetooth and the terminology you need to understand Bluetooth enabled devices. It then gets into the basics of the Bluetooth API for Java and developing programs using J2ME MIDP. Chapters cover creating a Bluetooth print server, passing objects between Bluetooth devices, and securing messages between devices. The authors discuss the PC software available to simulate Bluetooth devices so that you can develop an application without having two Bluetooth devices sitting on your desk. The final chapters covers topics such as Jini and Ericsson BlipNet. The book contains many well commented code samples demonstrating how to use the Bluetooth API.

The book is very clear and concise. It reads as if it was written by a couple of enthusiastic Bluetooth developers anxious to share the technology. And they do an excellent job of doing exactly that. I started the book knowing almost nothing about Bluetooth but now I feel confident that I can develop Bluetooth pplications. If you have any interest in Bluetooth then I can recommend this book as an excellent resource.

Discuss book in the Saloon — More info at Amazon.com


Java 2 Programmer Exam Cram 2 (Exam CX-310-035)
by William Brogden and Marcus Green


Que
unknown edition
March 2003
416 pages
Reviewed by Jason Menard, March 2003
  (8 of 10)


Not everyone seeking certification is new to Java and object oriented programming. For more experienced developers, it can often be tedious to wade through a certification guide suitable for the Java beginner. It is this audience that is particularly well served by Brogden and Green's book.

This book is concise. There is little effort wasted in going into more detail than necessary in the explanation of concepts the reader should already be familiar with. What you get is the information needed to pass the exam, and little else.

Among the highlights are test taking tips, handy alerts which stress material likely to be covered by exam questions, where to go to find additional resources, and a tear-out "Cram Sheet" presenting a condensed collection of relevant facts. The book comes with a CD containing practice tests and an electronic version of the text.

Each chapter concludes with a set of sample questions testing the material taught in that chapter. Two comprehensive example tests round out the book. This brings up my only real complaint, which is that the end-of-chapter questions have the answer immediately following each question, instead of in a separate section away from the questions.

If you are an experienced OO or Java developer planning to take the exam, or if you are seeking a companion for another exam guide, this is the book for you. The included electronic version of the book is very much appreciated and something more publishers should take note of.

Discuss book in the Saloon — More info at Amazon.com


Mastering AspectJ
by Joseph D. Gradecki, Nicholas Lesiecki


Wiley
1 edition
March 2003
456 pages
Reviewed by Valentin Crettaz, May 2003
  (8 of 10)


Mastering AspectJ is the second book on the AspectJ programming language, a seamless extension to the Java programming language. This book does a great job of showing how aspect-oriented programming (AOP) nicely complements current object-oriented techniques. The authors first introduce important AOP concepts, and explain how AspectJ reifies these concepts into a concrete and powerful programming language that brings AOP capabilities into the Java language.

Plenty of code examples demonstrate how to best use AspectJ in real-world projects, and how to integrate AspectJ with current software development tools and techniques. Furthermore, the authors provide exhaustive tutorials on how to use AspectJ with well-known IDEs, such as Eclipse, JBuilder, NetBeans, Forte, and Emacs. It is worth noting that this book is really about aspect-oriented programming. As a designer, you won't see any serious techniques for modeling aspects, as research on the subject is still ongoing. However, there is a very interesting chapter on how to apply an aspect-oriented version of the Observer design pattern to existing code without modifying the original system.

The book finally provides an impressive list of links to interesting AOP resources, and the whole code is made available on the companion web site. On the downside, some chapters would have needed a little more proofreading and technical editing, but the overall tone is good. To date, this is the most complete and interesting resource about the AspectJ programming language.

Discuss book in the Saloon — More info at Amazon.com


LDAP Directories Explained
by Brian Arkins


Addison-Wesley Professional
1 edition
March 2003
432 pages
Reviewed by Gregg Bolinger, April 2003
  (8 of 10)


If you ever want to know what LDAP Directories are this is the book for you. If you want to know how to use LDAP Directories, find another book.

The first half of the book explains what LDAP Directories are, how they differ from databases and how they are similar to databases. It contains information on where LDAP came from, why the protocol emerged and what has made it so successful. Not to mention chapters dedicated to LDAP Namespaces, DNS, object structure, and object naming.

The second half of the book was just as intriguing as the first. It discusses the 3 most successful LDAP implementations; OpenLDAP, Active Directory, and Netscape's Directory Server. Sections 2 talks about the advantages of each and the limitations of each and how they compare with one another.

The only thing I felt lacking from this book was a good explanation of how LDAP stores it's data on disk physically and how it achieves such good read and search performance. And I don't understand why there are 2 elephants on the cover.

Discuss book in the Saloon — More info at Amazon.com


Java Extreme Programming Cookbook
by Eric M. Burke and Brian M. Coyner


O'Reilly
1 edition
March 2003
352 pages
Reviewed by Frank Carver, October 2003
  (8 of 10)


This book covers a very similar selection of tools and techniques to "Java Tools for Extreme Programming" by Hightower and Lesiecki, and in a broadly similar way. Both use the currently fashionable idea of Extreme Programming (XP) to attract readers to a collection of short pieces about a bunch of useful tools for Java programming.

The XP stuff is covered quickly at the start, the meat of the book is in the "recipes", which walk you through configuring and using tools such as Ant, JUnit, Cactus etc. to build, unit-test and manage the development of a Java project.

The tools and tips the authors have chosen to include are a good representation of current practice, but I have a few reservations about the organization and structure of the book. My biggest worry is whether the target reader is actually likely to find many solutions. The authors seem to assume that everyone will pore over the several pages of "contents" at the front of the book every time they hit an obstacle, but in my experience they are just as likely to flip through pages or head for the index at the back, neither of which works particularly well. Worse than that, they may never think to look in the book in the first place - the "Extreme Programming" in the title may help it sell, but it's not something that jumps to mind when you are struggling to get Ant to deploy a web application to Tomcat.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
March 2003
352 pages
Reviewed by Jessica Sant, April 2003
  (7 of 10)


Java Extreme Programming Cookbook consists of a bunch of "recipes" for helping you to build and test Java programs through XP. Each recipe consists of a Problem, Solution, Discussion and a "See Also" pointer to where you can find more information about the topic. The recipes cover the following opensource technologies: Ant, JUnit, HTTPUnit, Mock Objects, Cactus, JUnitPerf and XDoclet.

Want define a classpath using Ant? Check out recipe 3.7. Wanna test a form in your web application? look at recipe 5.9. This book gives a bunch of good strategies to commonly encountered problems, but it's by no means a complete reference to the different technologies. But it will definitely get you started, and you'll be able to apply these different recipes to your own development environment.

The organization of the recipes and consistency between the chapters is where this book lost points in its rating. Want to know how to run JUnit with Ant? look in the Ant chapter. Want to know how to run HTTPUnit with Ant? Look in the HTTPUnit chapter. The Cactus chapter has a nice recipe about ?When not to use Cactus? and the JUnitPerf chapter has a nice recipe about "When to use JUnitPerf"? it would have been VERY helpful to have such sections for EACH technology discussed in the book, but alas the book is inconsistent.

Overall, I think this is a good book to jump-start you into an XP development environment using open source technologies.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
March 2003
352 pages
Reviewed by Simon Brown, July 2003
  (9 of 10)


I've been reading this book for the past couple weeks and have to say that it's another great book from O'Reilly, although upon seeing the title I was slightly skeptical for a couple of reasons. First of all, I already have the Java Tools for XP book and secondly, the title is slightly misleading.

As regards the title of the book, I have the same complaint as the other book, namely that "XP" is unnecessarily used in the title. Since XP is currently a buzzword, I imagine that this was probably to attract a wider audience. Okay, some of the book does talk about XP and practices such as continuous testing and integration, but the book could have easily been titled "Java Open Source Tools Cookbook" because that's essentially what it is.

Title aside, the content of this book really shines through. Where the Java Tools for XP book talks about tools like JUnit, Ant, Tomcat, etc, this book provides recipes for using those tools, with each recipe addressing a particular problem. For example, there are recipes for building with Ant, testing classes, structuring tests, testing paths through web applications and so on. Imagine a design patterns book but with open source tools. Each problem is explained and followed up by a possible solution. The tools that are covered include all of the major open source offerings (Ant, JUnit, Tomcat, HttpUnit, Cactus, etc) in addition to some other tools such as JUnitPerf that many people may not have come across.

While you can read this book cover to cover, I feel that its real strength is as a reference book to be kept on your desk during development. Also, I think that there is something in this book for everybody. For example, although I've used many of these tools before, I still picked up quite a lot from this book, particularly around some of the less common JUnit functionality and the Ant recipes around automatically starting Tomcat and checking that it's running. Regardless of whether you are doing XP, I would recommend this book to anybody starting out with open source tools or using them from day to day on a project.

Discuss book in the Saloon — More info at Amazon.com


Wireless Java: Developing with J2ME
by Jonathan Knudsen


Apress
second edition
February 2003
384 pages
Reviewed by Mark Spritzler, March 2003
  (9 of 10)


Now, what's this new fangle, big city, ruckus we keep hearing about wireless Java. First they invent electricity, now it's all done without wires.

So I decided to find out and read Jonathan Knudsen's "Wireless Java: Developing with J2ME"

Now, I know that cell phones and PDA's are limited in memory and that any API for developing on these systems had to be streamlined, but I also expected it to be more difficult to learn. However, using this book, I was able to begin writing my first MIDLet in just 2 days. And it was an actual, production, working, business MIDLet, that we can use on our ranch.

The section on game programming for J2ME is exceptional. Especially for someone, like me, that has never understood how to write a game. It makes me really want to write one.

The book is very easy to read, you won't find yourself re-reading a paragraph because you didn't understand. Jonathan has a very smooth elegant writing style that not only instructs you, but it keeps you reading on. I didn't want to put it down, well except for the strong urge to start programming.

It has been a really long time that I have read any programming book that makes me want to code. But my brain is daydreaming of MIDLets after MIDLets that I want to write.

Discuss book in the Saloon — More info at Amazon.com


More Java Pitfalls
by Michael C. Daconta, et al


Wiley
1 edition
February 2003
300 pages
Reviewed by Salman Halim, June 2003
  (8 of 10)


This book continues where the first one left off; the items covered herein are given a more in-depth treatment than those in the first volume and include new Java technologies: J2EE, J2ME, EJB etc.

The layout of the book has been changed from its predecessor to consist of three big sections, one each for the client, Web and enterprise tiers.

There is still plenty of useful information here: for example, I found the breakdown of web.xml in item 35 and unique EJB primary key generation in (item 42) very informative.

One critique is that some of the items leave questions unanswered. As examples, item 13 suggests sealing JAR files to ensure precedence in class loading but doesn't really explain HOW to seal a JAR. Similarly, item 16 points out how Component.setSize() can't always be used to reliably set the size of components; it explains how to do it correctly, of course, but never really explains what setSize() CAN be used for!

While the book isn't error-free, they aren't major and don't detract from the value of the information.

Recommendation: get the book collectively and keep it as a reference, sharing it among friends or colleagues. A quick once-over to see the topics covered is sufficient, I think; a cover-to-cover read isn't necessary.

Discuss book in the Saloon — More info at Amazon.com


Java Performance Tuning
by Jack Shirazi, Jack Shirazi


O'Reilly
second edition
January 2003
600 pages
Reviewed by Thomas Paul, March 2003
  (9 of 10)


Once the business rules have been settled and all that is left is to tune the code, then the fun starts. Like a race car mechanic trying to squeeze out a couple of extra MPH from a race car, the most fun in programming is to try squeeze out extra performance from some code. A book on performance tuning should understand that and make the topic fun. Reading this book it is clear that Jack Shirazi loves to tune code. He has done an incredible amount of detailed research on different JVMs to determine exactly how to make Java perform. But he is also practical. He explains how to find performance problems, which exact areas to concentrate on, and which areas to ignore. After reading this book you won't waste your time on areas of code that can't be easily optimized and instead you'll know how to concentrate on those places where you can get the most bang. The book has been updated from the earlier edition to bring all the information up to date with the latest JVMs. Best of all, an additional 250 pages has been added to the book covering J2EE including Servlets, JSPs, EJBs, and JDBC. "Java Performance Tuning" is a programmer's book. You are guaranteed to learn a lot of very neat and useful tricks. I doubt that there is another Java book on the market with as many "WOW!" moments in it. Buy it and watch your code zoom.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
1 edition
January 2000
436 pages
Reviewed by Thomas Paul, April 2001
  (8 of 10)


You have been working on that Java application for two weeks and it's finally ready for testing. Your window for having the web site down is ten minutes but you aren't concerned. Three hours later with the program still running, you are more than concerned. Before you panic, pick up a copy of "Java Performance Tuning". This book is geared for serious developers who need to dramatically improve performance in their applications and are willing to dig deep into the code. For example, writing your own customized Reader and byte-to-char converter can be ten times faster than using the BufferedReader class. Shirazi starts off by showing how to measure performance and identify bottlenecks, including a way to override the Object class to measure object creation. Subsequent chapters discuss key performance issues and possible solutions. Topics covered include replacing Strings with char arrays, eliminating casting and minimizing object creation, removing method calls from inside of loops, writing your own sort routines instead of using Arrays.sort(), identifying the correct Collection object, using threading to improve performance, and optimizing distributed systems to decrease network communication. As Shirazi explains, some of the methods covered may violate encapsulation or other OO techniques so they should only be used when performance has been identified as a critical problem. Besides being well written, the book is fun. I found myself trying to figure out along with the author how to improve the performance of the various examples demonstrated in the book.

Discuss book in the Saloon — More info at Amazon.com


Cocoon: Developer's Handbook
by Lajos Moczar and Jeremy Aston


Sams
1 edition
December 2002
816 pages
Reviewed by Thomas Paul, April 2003
  (8 of 10)


Cocoon is a Java-based open source XML content manager and publishing engine from the Apache project. This book was written as an introduction to Cocoon for the developer with a good background in XML and Java but with no background in Cocoon. Part I of the book is an introduction to Cocoon. I found this part of the book to be very difficult and confusing. There was a lot of writing on Generators, Transformers, and Serializers, but the overall discussion was hard to follow. Fortunately, this was only the first 65 pages of the book. Starting with Part II, the book takes on a whole new and much better flavor. After a chapter describing how to install Cocoon, the authors go right into some real examples of how to use Cocoon. Suddenly all the information from Part I which felt incomplete started making sense. The examples and sample code (which need to be downloaded) are excellent in explaining how to use Cocoon. This section goes through example after example, each demonstrating more of the functionality of Cocoon. All the examples worked exactly as advertised and were well designed to demonstrate the many capabilities of Cocoon. Part III of the book discusses advanced topics such as database connectivity, web services, and integrating Cocoon with EJBs. Part IV covers design factors, administration, etc. The last two parts of the book are reference tools. Overall, I though the authors did a good job of making Cocoon easy to understand.

Discuss book in the Saloon — More info at Amazon.com


Java How To Program
by Harvey M. Deitel, Paul J. Deitel


Prentice Hall
5th edition
December 2002
1536 pages
Reviewed by Thomas Paul, March 2003
  (8 of 10)


Once again, Deitel has published a very impressive book. This new edition has been updated for Java 1.4 with, among other topics, coverage of regular expression and NIO. In addition, chapters on JDBC, Servlets, and JSP have been added. The chapter on object oriented programming and polymorphism has been rewritten and expanded into two chapters. The book has been cleaned up with redundancy removed in order to keep it around 1500 pages. Overall, the book is as complete as you would want in an introduction to Java. The book covers virtually everything in J2SE, gives a good primer on object oriented programming, covers design patterns and UML, and even gives an introduction to server side development. There's enough information in this book for at least two semesters of Java. All this information can be overwhelming but the authors use extensive, well commented color coded program samples to explain each topic. It is almost impossible to turn a page and not find either code samples or a diagram. In addition, there is a natural flow from topic to topic. This book was written as a college textbook and it has a college textbook "feel". Each chapter has well thought out exercises but the solutions must be purchased separately. A lab manual for this book is also available (release date, July 1, 2003). If you are planning on teaching a Java course and you are looking for a textbook this book would make a good choice.

Discuss book in the Saloon — More info at Amazon.com


Sun Certified Programmer & Developer for Java 2 Study Guide (Exam 310-035 & 310-027)
by Kathy Sierra and Bert Bates


McGraw-Hill
1 edition
December 2002
752 pages
Reviewed by Jessica Sant, December 2002
  (10 of 10)


Imagine this: you're in college, studying for the final exam -- and the teacher gives you all of her notes that spell out EXACTLY what you need to know, what you DON'T need to worry about, and even points out all the little traps she'll try to catch you in when you take the exam. Kathy Sierra, the co-developer of the 310-035 Programmer's exam, with the help of Bert Bates has done just that. The 3rd edition of Osborne's Sun Certified Programmer and Developer for Java 2 is an awesome book. Get this -- it's actually entertaining to read, very easy to understand, and the mock exams more closely resemble the real thing than any other mock out there. The "Two-minute Drills" are an excellent resource to help you review before you take the exam. The Exam Watches interspersed throughout the chapter point out all the traps you might fall in during the exam, and the On The Job blurbs give you a practical application for the knowledge you just learned. The end chunk of the book discusses what you need to know to pass the Developer s exam. It won't teach you Swing or Threads - but what the exam assessor's are looking for - the things you need to pay attention to in order to pass that exam. I fully recommend this book.

Discuss book in the Saloon — More info at Amazon.com


Thinking In Java
by Bruce Eckel, Bruce Eckel


Prentice Hall PTR
third edition
December 2002
1119 pages
Reviewed by Junilu Lacar, March 2003
  (9 of 10)


This edition is updated for the Java JDK 1.4 and includes significant changes over the previous edition.

New and expanded discussions touch on assertions, I/O and new I/O, logging, JavaDoc comments, exception handling, JNLP and Webstart. The 2nd edition's chapter on distributed computing, which included EJBs, Servlets and JSPs, RMI, and JNDI, and the appendix on JNI are gone and moved to another book on Enterprise Java.

Staying abreast of current development practices, Eckel introduces brief discussions on using Ant for automated builds, and version control using CVS. He also puts more emphasis on unit testing, replacing comments and System.out.println statements from previous editions with code that uses his own unit testing framework in most of the book's sample code. The source code, which you can download from his website, also comes with Ant build files.

The CD that comes with the book contains a multimedia course called "Foundations for Java" which you should go through before reading the book. Unfortunately, the CD I got was damaged during shipping and I haven't received a replacement as of this writing.

One minor complaint is that the typeface in the code and tables are not very readable. In the tables, the number 0 looks like a lowercase o. Overall, I think Eckel did a good job in keeping the book up-to-date and relevant to the needs of beginning to intermediate Java programmers who would benefit from this book.

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
second edition
May 2000
1128 pages
Reviewed by Kathy Sierra, May 1999
  (8 of 10)


My favorite book for those coming from a C++ background. Bruce Eckel explains complicated things about Java with the casual clarity of a conversation between two smart colleagues. You'll spend a lot of time reading this book. I must get Bert his own copy; he keeps going after mine.

Discuss book in the Saloon — More info at Amazon.com


LDAP Programming, Management and Integration
by Clayton Donley


Manning Publications
1 edition
November 2002
352 pages
Reviewed by Michael Ernest, August 2003
  (7 of 10)


Donley's has much less to do with with Java than it does with covering several aspects of LDAP and directory services in a brief guide. Several examples illustrate use of the JNDI (Java Naming and Directory Interface) API, but the core premise is in understanding the technologies that JNDI makes available to the Java programmer.

I found the coverage lucid and useful, but only one point at a time. I couldn't get a feel for the flow of this book, and found myself flipping around quite a bit to see if I'd accidentally skipped a page and missed some key point.

Most LDAP books show the reader how to program to a C or Java interface for LDAP, or warm over the RFCs and specs with some contextual help. None of them seem particularly energizing. This book, while helpful and strong on a lot of individual points, lacks whatever it takes to tie the points together so the reader can say "Now I get it."

Discuss book in the Saloon — More info at Amazon.com


Java 2 Web Developer Certification Study Guide with CD-ROM
by Natalie Levi, Natalie Levi, Philip Heller


Sybex
second edition
November 2002
576 pages
Reviewed by Michael Morris, June 2003
  (6 of 10)


While Sybex had a chance to redeem their credibility after the abysmal release of the Java 2 Web Developer Certification Study Guide First Edition, the Second Edition fell short. While most of the errors were corrected, some still remain. One glaring error that could cause serious trouble to a certification candidate is the assertion that Session attributes are normally thread-safe while the Servlet Specification clearly states that they are not.

The book begins with an assessment test to see what you know before you begin and to identify any weak areas you may have. The thirteen certification objectives are analyzed sequentially. Each chapter is laid out with a list of objectives to be covered, the text, a summary, a list of exam essentials and key terms and a chapter test. Interspersed in the book are Real World Scenarios giving insight into how the subject at hand is being implemented. The code examples are very easy to follow. Probably the biggest advantage to this guide is the CD that comes with it. The full text in e-book form is provided along with a great test engine with three pre-built tests and an option to generate a random test. The test environment itself is a good mockup of the actual Prometric environment with timer and option to mark a question for later review.

I would recommend this book to someone who has experience with Java web components but would advise that they use it along with the Servlet Specification.

Discuss book in the Saloon — More info at Amazon.com


Sybex
1 edition
June 2002
448 pages
Reviewed by Matthew Phillips, August 2002
  (3 of 10)


This could have been a great book. The authors did an excellent job of explaining the details of Web Component development in an interesting way. Unfortunately, it appears that they did not know the topic well enough to be writing about it in the first place.

This book has not been out long and the errata page is already huge. I can overlook the many typographical errors, but the factual errors I cannot. It is even worse that the factual errors are explained with the same detail as the valid information. This leaves me with the impression that the book was not rushed, so I cannot think of any explanation for why it is so bad. A corrected second edition would be a welcome sight, but unless that comes don t use this as your only resource for the exam. You will end up retaking it.

Note: Use this link to get to the errata page. Courtesy of Sybex.

Discuss book in the Saloon — More info at Amazon.com


Java 2 Enterprise Edition Web Component Developer Exam
by Alain Trottier


Que
unknown edition
November 2002
544 pages
Reviewed by Paul Stevens, January 2003
  (8 of 10)


The author laid out each chapter by stating the objectives, going into the objectives with code and descriptions of each and ending with a review section. The review section consists of a summary, questions and further reading links.

The author takes the approach that the reader has little knowledge of the subject being addressed. So there are explanations about not only the objectives but about subjects relevant to web component development.

There is also a short chapter on developing a plan. The author stresses this importance and lays out a sample plan. This is actually an important step in getting certifications that is often overlooked.

Overall this was a well written book and easy reading. It does a good job of covering the subject and is laid out very well.

The one complaint I have about the layout is that many pages have way too much white space at the edges of the pages. They have a good three inches on the outer margin. This causes some of the code examples to appear crunched and hard to read by forcing multiple lines for what should be one line of code.

Discuss book in the Saloon — More info at Amazon.com


Data Structures and Algorithms in Java
by Robert Lafore


Sams
second edition
November 2002
800 pages
Reviewed by Thomas Paul, February 2003
  (9 of 10)


Just about every Computer Science program requires a course called "Data Structures and Algorithms". In order to become a better programmer you must understand the information provided in this course. This book was written as a textbook for a "Data Structures and Algorithms" course and all the expected topics are covered; arrays, queues, stacks, linked lists, trees, hash tables, heaps, sorting, recursion, and searching. Whether you are a teacher looking for a text, a student who wants a better text than the required one, or someone who wants to learn more about programming, this book is an excellent choice. By using Java, all the complications of C++ are eliminated and the author's crystal clear explanations come shining through. And the author's explanations and examples are excellent. For example, the chapter on link lists explains what a linked list is, what problems it is supposed to solve and what problems it fails to solve, and then shows how to implement your own link list. The author provides a set of applets to visually illustrate the topics covered in the book. There are questions at the end of each chapter and answers are provided. This book is not going to explain the Collection classes or help you learn the API. What this book will do is help you get a deeper understanding of what data structures are, how they work, and what performance sacrifices must be made in order to achieve better overall performance in your programs.

Discuss book in the Saloon — More info at Amazon.com


Programming Jakarta Struts
by Chuck Cavaness


O'Reilly
1 edition
November 2002
462 pages
Reviewed by Thomas Paul, February 2003
  (7 of 10)


The target for the book is any experienced Java developer who is interested in Struts but has little or no experience with Struts. The book starts with an explanation of why Struts is a "good thing" and shows how Struts fits into a web architecture. The author then gives an explanation of each of the pieces of the Struts architecture and demonstrates a simple application. Although the explanations were clear, I felt that the author was making the architecture overly complicated by explaining things out of order. A diagram showing the interrelationships of the different Struts classes and config files would have been helpful. The author covers all the expected topics such as internationalization, exception handling, logging, and the Struts tag libraries. The chapter on the Struts tag libraries could have used more examples to make the explanations clearer. The book concentrates on Struts 1.1 and the author does a nice job of explaining the changes from the 1.0 version and the features available in the new version. The chapter on the new Validator framework is clear and the examples are on target. The chapter on Tiles is short but the author does a great job of explaining how it fits into the Struts architecture. The chapter on performance seemed completely unnecessary since there was nothing in it specific to Struts. Overall this book is a good addition to the Struts library. The book has some shortcomings but it provides a good deal of value.

Discuss book in the Saloon — More info at Amazon.com


Java Number Cruncher: The Java Programmer's Guide to Numerical Computing
by Ronald Mak


Prentice Hall PTR
1 edition
November 2002
480 pages
Reviewed by Jason Menard, May 2003
  (9 of 10)


At one time or another, most of us will likely have to write code performing some amount of numerical computation beyond simple integer arithmetic. As many of us are neither mathematicians nor intimately familiar with the bit gymnastics our machines must perform in order to manipulate numbers, we can get ourselves into trouble if we're not careful. Luckily, "Java Number Cruncher" comes to the rescue.

This book is an introduction to numerical computing using Java providing "non-theoretical explanations of practical numerical algorithms." While this sounds like heady stuff, freshman level calculus should be sufficient to get the most out of this text.

The first three chapters are amazingly useful, and worth the price of admission alone. Mak does a fine job explaining in simple terms the pitfalls of even routine integer and floating-point calculations, and how to mitigate these problems. Along the way the reader learns the details of how Java represents numbers and why good math goes bad. The remainder of the book covers iterative computations, matrix operations, and several "fun" topics, including fractals and random number generation.

The author conveys his excitement for the subject in an easy-to-read, easy-to-understand manner. Examples in Java clearly demonstrate the topics covered. Some may not like that the complete source is in-line with the text, but this is subjective. Overall, I found this book educational, interesting, and quite enjoyable to read.

Discuss book in the Saloon — More info at Amazon.com


Ant Developer's Handbook
by Kirk Pepperdine, Alan Williamson, Joey Gibson, Andy Wu


Sams
1 edition
November 2002
456 pages
Reviewed by Thomas Paul, April 2003
  (7 of 10)


Ant has become a widely used tool and should be part of every developer's toolkit. This book is a nice introduction for the developer who is unfamiliar with Ant and is looking to get started using it. If you are a developer who is experienced with Ant then this book will not be of much interest to you. The book starts with a nice introduction to Ant showing how to create and use a typical build script. The first three chapters cover the basics of Ant and the authors do a nice job of making Ant simple to understand. The next two chapters cover all the built-in and optional tasks that are part of Ant. This section is of limited use to the new Ant user. Since the tasks are listed in alphabetical order and broken out into separate chapters for built-in and optional tasks, you have to know what you are looking for in order to find it. It would have been nice to have a list of all the tasks with a brief description all in one or two pages which would have made it much easier to find a task. There is one brief chapter explaining how to write your own Ant tasks. Troubleshooting Ant scripts is followed by two chapters showing real world examples of using Ant. The book ends with a discussion of tool support. Conclusion: the authors have done a very nice job of explaining Ant for the novice Ant user.

Discuss book in the Saloon — More info at Amazon.com


Struts In Action
by Ted Husted, Cedric Dumoulin, George Franciscus, and David Winterfeldt


Manning Publications
1 edition
November 2002
630 pages
Reviewed by Matthew Phillips, November 2002
  (8 of 10)


Although the title of this book is not descriptive, I cannot deny the author's approach to making the reader a Struts expert is effective.

Section 1 is an introduction to Struts. By the end of the section you have written your first Struts application. This is great for someone with no prior knowlege of Struts.

Section 2 delves into the details of Struts framework. It gets away from a hands on approach to explain the details. It covers Actions, ActionForms, etc. quite well. The sample code accompanying the explanations is not enough to run, but it did help me understand the topics better.

Section 3 continues the same approach to learning as section 2 but concentrates on the presentation layer tools. One of my complaints about this book relates to its coverage of the Struts tag libraries. The chapter is clearly intended to compliment the online documentation at the Struts website and it really doesn't provide much value over it. The coverage of Tiles, validation, and localization are excellent.

Section 4 gets back to the hands on approach to effectively tie everything together. The book's organization lends itself to being a great reference, but I would have liked it to take a more hands on approach and build a large application piece by piece. I still learned more about Struts than I knew existed. I would not hesitate recommending this book to anyone that wants to go from Struts beginner to Struts expert.

Discuss book in the Saloon — More info at Amazon.com


Professional SCWCD Certification
by Sam Dalton and Dan Jepp


Wrox
unknown edition
November 2002
480 pages
Reviewed by Dirk Schreckmann, May 2003
  (8 of 10)


As with many certification study books, this book is laid out to cover each exam requirement point-by-point. Readers with introductory experience developing Servlet-based web applications will find the explanations in this book easy to follow and comprehend. Each chapter is concluded with a topic summary and about 10 review questions. These are definitely good for the brain while studying. Two additional chapters on a Web Application Case Study, which helps to bring many of the exam topics together, and Servlet Filters, make this book valuable beyond exam studies. The included CD-ROM includes all of the source code in the book, Apache Tomcat and Ant installation files, and an edition of the WhizLabs exam simulator with 52 practice questions.

To pass the SCWCD exam, this very good book, and a bit of study and practice time should do the trick for any Java programmer with introductory knowledge of Servlets. To fully grasp the details and applications of some of the exam objectives, readers will have to pursue additional resources, as some of the explanations of basic concepts were not complete.

Discuss book in the Saloon — More info at Amazon.com


Objects First with Java
by David J. Barnes, Michael Koelling


Prentice Hall
unknown edition
October 2002
400 pages
Reviewed by Frank Carver, December 2003
  (9 of 10)


This book is intended to be a course text book for an introductory course in Java and Object Oriented Programming. The authors have made a conscious decision to cover the material in a different order to almost all other books on the subject. You won't find an initial chapter on classpaths, compilation and the main method, there's no pseudo-procedural "hello, world" example. The book leaps straight in to creating objects from classes, examining values and calling methods.

There is a trick to all this, of course. The book is based on a kind of Java development environment optimised for teaching called "BlueJ". BlueJ is a free download, and a copy is included on a CD with the book, along with all the source code examples. I've had a play with BlueJ, and it certainly makes important things like the distinction between a class and an object, and the inheritance structure of the code, much clearer than traditional IDEs.

If you are planning to teach a course on Java or OO, you should certainly take a look at this book. Even if you don't run the course exactly as presented, the approach is fascinating. If you are trying to pick up these tricky ideas on your own, this book might also be very useful. Even if none of those cases apply, the BlueJ software is still a really neat tool for prototyping.

Discuss book in the Saloon — More info at Amazon.com


NetBeans: The Definitive Guide
by Tim Boudreau, Jesse Glick, Simeon Greene, Jack Woehr, Vaughn Spurlin


O'Reilly
1 edition
October 2002
672 pages
Reviewed by Thomas Paul, February 2003
  (8 of 10)


NetBeans, a free IDE available at http://www.netbeans.org, is based on donated code developed by Sun. The NetBeans architecture is an open architecture that supports plug-ins for each function of the IDE. This book, which discusses the NetBeans IDE, is made up of two parts. The first part is a description of the IDE designed for the NetBeans user. The NetBeans architecture is described in detail. The book covers each of the different pieces such as editing, compiling, and debugging. The book also covers using the NetBeans GUI editor to design visual components. Integrating NetBeans with CVS and Ant is also covered. The book does a fairly good job in this section of providing a handy manual for NetBeans users. The second part of the book is aimed at those who wish to use the NetBeans open architecture to define their own modules to be added to NetBeans. This part of the book is very well written and will serve as a major resource for anyone interested in module writing. Several examples are demonstrated including building an IMAP email server and client to integrate into NetBeans. The first part of the book is for a general audience and will be useful but it isn't required reading to use NetBeans. The second part of the book has a more limited audience but will be extremely useful to anyone interested in writing NetBeans modules. Overall this is a well-written book with clear explanations and examples.

Discuss book in the Saloon — More info at Amazon.com


Java Power Source
by Luis A. Gonzalez, Charles R. Buhrmann


Best Power Source LLC
1 edition
October 2002
254 pages
Reviewed by Andrew Monkhouse, October 2003
  (8 of 10)


This book covers all the basics of how to program in Java, then provides an introduction into many specialized parts of Java.

This book is very light with only 250 pages. To cover such broad ground, the authors chose to leave out most code samples (available on the book's web site), opinions, experiences, or analogies. As a result, this book covers more topics than much larger books. And being much light, it is easy to carry with you.

The book is divided into four parts. The first part details how to write a Java program - from the low level keywords, through what makes up a class & how to use threads, up to common classes in java.lang and java.util.

The second part quickly covers GUI programming, describing the main classes of the AWT and Swing classes, and describing Applets and Graphics methods. The third part briefly describes the major classes of I/O, Networking, Databases, JSP and Servlets. Finally the book covers Mainframe issues and an introduction to Design.

Covering as much ground in sections 2, 3 and 4 means that they are not covered in depth. These sections will only give you a feel for what is possible, and give you clues where to find out more information.

All in all, a very good book - one that can be used to learn the basics of Java, and can be used as a refresher / reference guide to many of the capabilities of the Java language.

Discuss book in the Saloon — More info at Amazon.com


Professional Apache Tomcat
by Vivek Chopra, Ben Galbraith, Sing Li, Chanoch Wiggers, Amit Bakore, Debashish Bhattacharjee, Sandip Bhattacharya, Chad Fowler, Romin Irani


Wrox
unknown edition
October 2002
552 pages
Reviewed by Michael Ernest, February 2003
  (9 of 10)


This book is a solid, well-rounded guide to using Apache Tomcat and getting the most out of it. The authors cover a wide number of topics, including installation, modification, managing services, and even testing applications for server load. I was particularly pleased with the clean language and style of the book, something I had noted before in Sing Li's Wrox book on Jini. Li is a contributing author here as well.

The only objection I have really isn't a fault of the book at all, but it nonetheless hampers my ability to read it carefully. So much work is done these days to convert configuration and property files into XML formats, that books like this one are often forced to explain features by showing example XML files and encouraging the reader to parse it visually. Sweet mama, that's boring; fortunately, the authors keep this aspect to a minimum.

I recommend it to anyone who needs a desktop reference for learning all the aspects of Apache Tomcat as they need them.

Discuss book in the Saloon — More info at Amazon.com


The Struts Framework: Practical Guide for Programmers
by Sue Spielman


Morgan Kaufmann
1 edition
October 2002
150 pages
Reviewed by Jessica Sant, May 2003
  (7 of 10)


I found this book's introduction to Struts to be inadequate. I have a very strong understanding of JSP and Servlets and a cursory understanding of the MVC design pattern. After reading the first two chapters I was quite confused about the general workings of Struts. A small, trivial Struts application to introduce the reader to the pieces and how they are inter-related would have increased the understandability ten-fold. However, that might have cut into the author's allowed page count: realize this book is 137 pages soaking wet (including the appendix and index... I don't recommend actually soaking the book). After getting a better understanding of Struts from another source, I came back to learn the details.

The author does an good job of explaining how best to use each part of the Struts Framework (that's where the "practical guide" part comes into play). More importantly she notes the possible hang-ups that normally you'd only learn through a bad experience (Don't use instance variables in your Action classes. Don't worry if you forget this rule now -- after you've read the book, this and other gotchas are tattooed inside your head).

Overall I'd say this is a very good resource. You'll need to go elsewhere to introduce yourself to Struts (find a nicely explained step-by-step tutorial), but after that, this book will be able to take you most of the way to a well-designed Struts implementation.

Discuss book in the Saloon — More info at Amazon.com


StarOffice Suite Companion
by Solveig Haugland and Floyd Jones


Prentice Hall PTR
1 edition
September 2002
1056 pages
Reviewed by Marcus Green, February 2003
  (10 of 10)


This book doesn't just tell you how StarOffice is supposed to work, it also tells you about some of its quirks and peculiarities. It includes comments on the differences between StarOffice and OpenOffice and pointers to other useful resources, such as websites with information on creating macros and additional templates that are available from the web. The book uses the OpenOffice.org logo in the margin to indicate a tip specifically for that version of the program.

The tone of the book comes across as being created by people who like the program rather than a creation of a faceless corporation. Here is an example of the text style from the section on macros from the last chapter of the book. "Macros can do things like open a file when you do a particular task, process data, or buy your grandmothers' credit cards and buy $3000 worth of cat toys.

The StarOffice suite has a huge amount of functionality and this book covers most of the functionality you are likely to use. The book is in paperback and has a 40 page alphabetical index. It doesn't try to do it in a visual style with a screen shot for every mouse click but via text instructions. I learnt a huge amount of new features despite having worked extensively with StarOffice for over two years. I strongly recommend this book to anyone who intends to use StarOffice.

Discuss book in the Saloon — More info at Amazon.com


Mastering Jakarta Struts
by James Goodwill


Wiley
1 edition
September 2002
360 pages
Reviewed by Paul Stevens, September 2002
  (8 of 10)


This book takes a good step by step approach to giving the reader an understanding of struts. Good examples and explanations of each topic covered fairly well. Don't let the title (Mastering Jakarta Struts) deceive you. The book says it is meant as a tutorial on Stuts and that is what it is. So if you already have an understanding of Struts this book won't be right. But if you are looking to get familiar with Struts this book is a good starter.

I would like to give the author James Goodwill a big thumbs up. The source code for the book was not on the Wiley site and James emailed it to me right away.

Discuss book in the Saloon — More info at Amazon.com


Java NIO
by Ron Hitchens


O'Reilly
1 edition
August 2002
312 pages
Reviewed by Valentin Crettaz, November 2002
  (8 of 10)


The New Input/Output (NIO) packages of the Java 2 platform introduce several long awaited advanced I/O features for developing high-performance and large-scale Java applications. It is not unsafe to say that these new capabilities bridge the gap between Java and other natively compiled languages.

The author starts by giving some insights on some system-level I/O services before delving into how low-level features are abstracted by NIO in a portable way. He assumes the reader to be fairly comfortable with Java and common I/O concepts, that is, the book should not be seen as a tutorial on Java I/O.

The book dedicates one chapter to each new feature, namely low-level buffer management, scalable networking and file channels, multiplexed I/O using selectors, and character set encoding/decoding. As last, the author presented a Regular Expressions API that brings Perl-like capabilities into the Java language, as a feature that is often used when performing I/O operations, although it is not strictly related to I/O.

This is a first book on Java NIO, which is a well-written resource and contains a several concrete and ready-to-use examples illustrating various key concepts of the NIO packages.

Discuss book in the Saloon — More info at Amazon.com


Algorithms in Java, Parts 1-4 (Third Edition)
by Robert Sedgewick, Michael Schidlowsky


Addison-Wesley Professional
third edition
August 2002
768 pages
Reviewed by Matthew Phillips, September 2002
  (7 of 10)


This book is volume one of a three part series. It covers fundamentals, data structures, sorting, and searching. This book is very detailed with good examples and well-placed exercises to reinforce the knowledge. The author does a very good job of avoiding unnecessary mathematical explanations. I spent two weeks reading this book, but to get a firm grasp of the subject matter expect to spend a lot more time.
I did find a few things that I did not like about this book. My biggest complaint is that answers are not provided to the exercises. No benefit is derived from doing it wrong and thinking you are doing it right. I also think that the examples would be much improved if the property and method names better described their purpose. Variable names like M and l are common in the example code and leave the reader with a little bit of extra work to do in understanding the code.
Overall, the positives outweigh the negatives in my opinion and make this a worthwhile book for any new Java programmer looking to take that next step.

Discuss book in the Saloon — More info at Amazon.com


The Sun Certified Java Developer Exam with J2SE 1.4
by Mehran Habibi, Jeremy Patterson, Terry Camerlengo


Apress
1 edition
August 2002
364 pages
Reviewed by Mark Spritzler, March 2003
  (8 of 10)


I got to read SCJD Exam book after passing the SJCD with a 151/155. So I know what is on the assignment and essay exam.

Of all the SCJD books that I have read, this book comes closest to presenting an application that resembles the actual assignment and without giving away the goodies.

You will find that you will not only learn everything you need to pass the SJCD, but you will also learn all the new features of Java SDK version 1.4. You'll learn about the New IO, Regex, Assertions, and Logging.

It will go over all the considerations that you must make for the SCJD assignment including Design decisions, Coding Standards and RMI vs Sockets. All very important parts of the SCJD.

If I could only say one thing negative, It would be that I feel a couple, very small couple of issues where handled with more complexity than was needed. But, that is just my opinion. :)

Overall I would say that this is the best book to buy if you want a book for the SCJD Assignment.

Discuss book in the Saloon — More info at Amazon.com


Java Development with Ant
by Erik Hatcher, Steve Loughran


Manning Publications
1 edition
August 2002
672 pages
Reviewed by Michael Ernest, February 2003
  (9 of 10)


Maybe it's me getting tool old or too out of step with books on popular tools, but I found this guide informative, thorough, and quite tedious to read.

The information is fine, although it has that ring of authorship by people who are too close to the technology. That is, while they do stri