java hosting


Title
Author
Publisher
ISBN
Reviewed by
Review text
Category

Your search returned 123 matching documents



Learning Wireless Java
by Qusay H. Mahmoud


O'Reilly
1 edition
December 2001
300 pages
Reviewed by Matthew Phillips, February 2002
  (10 of 10)


Learning Wireless Java is a small book, but the author uses the pages well. The book doesn't waste time trying to teach basic java programming. It jumps right into the subject and doesn't look back.

The book is broken down into three sections. The first section introduces Java 2 Micro Edition. It gives you definitions of basic terms and by page 10 you are working on your first program. The rest of the section gives you the detail on CLDC and MIDP that you will need for the rest of the book.

Section two introduces you to programming with CLDC and MIDP. It starts with an introduction to the KToolbar and then each other chapter introduces you to another area of wireless programming with Java 2 Micro Edition.

Section 3 has a quick reference to the APIs included with CLDC and MIDP. Normally I am not a fan of including API in a book but I found myself referencing this one often.

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


Wireless Java Programming With J2ME
by Yu Feng , Dr. Jun Zhu


Sams
1 edition
May 2001
512 pages
Reviewed by Shailesh Sonavadekar, August 2001
  (10 of 10)


J2ME. The next frontier of Java technology. The first book was written by Eric Gigure. It was only a reference for J2ME with CLDC in mind as MIDP was under construction at that time. This book is written straight from the trenches. It is a great feast for the coders who want to sully their hands with code.
The book is nicely structured in three parts. Part I talks about Wireless applicatons: how Java is getting into the wireless area, what are the basics needed for J2ME programming, etc. In Chapter 4 , the authors have explained MIDP in detail. Part II is the core of this book. The authors have covered everything on components of UI for wireless devices. Use of high level and low Level API for application development is explained in detail with lots of code. The use of XML in the wireless application chapter gives an idea of what is possible in the future. The data synchronizatiuon techniques and network programming chapters show the real reach of J2ME. The biggest plus point of this book is the chapter on MOTOSHOP, the application for which Yu Feng won the Motorola contest. The entire chapter is dedicated to the application. In Part III, CLDC and MIDP class liabraries are given along with very, very good information about DOCOMO's I-mode which made J2ME so popular. This book is the icing on the cake after Eric's book. Developers who like to play with lots of code will love this piece. The book is for Intermediate to Advance Developers.

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


Professional Java Mobile Programming
by Taylor, et all.


Peer Information
1 edition
July 2001
1000 pages
Reviewed by Matt Midcap, July 2001
  (10 of 10)


"Java Mobile Programming" starts out strong with an in-depth view of J2ME technologies and protocols, explains how they are related, and shows what each technology has to offer for the embedded and mobile device developer.

Advantages of a proper J2ME architecture and a very useful case study implementing the architecture is provided before plunging into the core J2ME device configurations. Each of these sections provide a clear and concise explanation of each configuration supported by self-documenting code examples. However, since "small" and "limited resources" are the name of the game, the book gives reference and rightfully recommends the use of code obfuscators to help decrease the size of J2ME applications.

Equally impressive and pleasantly surprising were details of the current limitations of J2ME technologies. Suggestions on how to avoid designs that may prove to limit a J2ME application are also included in this detailed book. I also appreciated the chapter on how to convert applications to CDC and CLDC. This indicates that the authors wrote this book thinking about real world scenarios.

The bottom line: This book gives a detailed and in-depth look at J2ME technologies, design, and architecture. It has useful - real world case studies, sample code, and several working applications that teach the concepts. It explains how to use/interact J2ME with JMS, J2EE, Servlets, Security, Synchronization, etc., and explanations of the pros, cons, and gottchas of each.

If this sounds like what you need, this book is for you.

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


Testing Applications on the Web
by Hung Quoc Nguyen


Wiley
1 edition
October 2000
400 pages
Reviewed by Ersin Eser, May 2002
  (9 of 10)


I grabbed this book to improve my understanding of web applications testing, and to start exploring the field. Well, it was a great decision. The book thoroughly explains the terms, steps, and approaches involved in web applications testing while providing an excellent introduction to gray-box testing. As we all know, web apps run on a variety of platforms and anything can change in the system. So be prepared for the unexpected.

The Author's point is that testers should learn more about the technical details of the system and understand how things interact with the specific application while building the test plans.

I liked the book a lot; it gives a perceptive to very valuable information. If you are serious about web application testing, you must have this book. It is a great companion for a web application tester. At the end of each testing sample, the author provides tips that you will appreciate, and you also will be able to find testing-related links at the end of book.

The author supports his approach with his experience in the field, and I was not surprised to learn that he is president of a software testing company.

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


Web Content Mining with Java
by Tony Loton


Wiley
1 edition
January 2002
320 pages
Reviewed by Frank Carver, April 2002
  (9 of 10)


This book may not seem an obvious choice for many readers. It's not about a particular API, certification, or other buzzword topic, and the title can sound dry and academic. Don't be put off! This is a practical, hands-on book which can take your software straight past the hype of web services and into using the resources of the whole internet in your programs right now. With no big middleware downloads, protocol specs, or head-scratching config files.

The book walks you through how to read, control and extract information from existing web pages and web applications anywhere on the internet, how to read, send and process emails and newsgroup postings, how to recognise just the text or data you want, and much more. Source code is given for servlets and applets to examine and drive web forms, and usage examples include sending SMS messages and applying decision-making rules to internet share-price data. It's also full of ideas and suggestions to make you want to leap up and get started.

When I got this book, I couldn't put it down. A lot of computer books sit on the shelf or send me to sleep, but not this one. Not only is it both topical and useful, but it hits a just-about-ideal balance between code and food for thought. The author has a real knack for useful solutions to complex problems.

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


Apache Jakarta-Tomcat
by James Goodwill


Apress
1 edition
December 2001
200 pages
Reviewed by Carl Trusiak, December 2001
  (9 of 10)


Want to get the most out of your Tomcat 4.0 installation? You need this book!

Troubleshooting? Well, that is the only thing this book lacks. James covers topics and capabilities with Tomcat that I didn't realize it had, Embedding Tomcat in a Java Application for one. Other topics covered include the Management application that comes with Tomcat, Valves and Filters, Persistent Sessions, JDBC Realms and integration with: Apache's Web Server, Jakarta Struts, Log4j and Soap.

The coverage provided for Servlets and JSP is completely elementary and should not be substituted for a good book on these topics. It does however give someone good enough examples to ensure your Tomcat is properly installed and configured.

Thanks James, this is the book that Tomcat has needed for too long.

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


Sams Teach Yourself Wireless Java with J2ME in 21 days
by Michael Morrison


Sams
unknown edition
June 2001
576 pages
Reviewed by Johannes de Jong, October 2001
  (9 of 10)


I've never bothered to purchase a book that claims it will teach me something in x # days. Well this book surely has changed my mind.

It's a well-structured book that takes you by the hand and step for step teaches you the ins-and-outs of programming for the J2ME "platform".

Programming for mobile devices is all about compromises. Not enough memory, the limitations of the screen etc. Mr. Morrison clearly highlights these limitations and shows you how to program around them.

The examples in the book are fantastic and fun. If they don't get you started on your own little pet project nothing will. I did not manage to try them all but the one's I did try worked perfectly, without any problems.

Mr. Morrison also has an easy style that is fun to read and his enthusiasm for the subject shows. There is a reference to his site Michael Morrison but at the time of writing, it was still under construction.

Having said this all. It would be nice if Mr. Morrison extended his Appendixes to include the API's for J2ME and a list with the New Term's that he has scattered all over his book.

I think it's the perfect book to start your journey programming with J2ME and I mean any device that can use J2ME and not only mobile phones. I highly recommend it.

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


Wireless Java : Developing with Java 2, Micro Edition
by Jonathan Knudsen


Apress
1 edition
June 2001
226 pages
Reviewed by Thomas Paul, July 2001
  (9 of 10)


The latest revolution in Java (the micro revolution) has begun within the release of J2ME. However, the revolution has just started and most of the specification is still being defined within the Java Community Process. The one part of J2ME that is available to developers is the Mobile Information Device Profile (MIDP), the specification for devices such as pagers, mobile phones, and small PDAs. This is the focus of this excellent book by Jonathan Knudsen. After a brief history of J2ME, the author introduces us to MIDlets, which are the applets of Mobile Information Devices. Comparing J2ME with J2SE, the author shows us how to leverage our Java skills to make coding for MIDP devices a breeze. Each step of the way, the author uses working code examples to demonstrate the capabilities of MIDlets. Starting with developing forms, the author explains how to interact with the user and code event handlers. He then demonstrates how to interact with servlets over the Internet using HTTP. Maintaining persistent storage, handling cookies, and programming a game interface are all demonstrated. Performance tuning, which is a critical issue on MIDP devices, is discussed. As long as we are going to be on the cutting edge, a chapter on XML is included. Security and cryptography are critical issues on MIDP devices. Knudsen is the author of "Java Cryptography" and as expected he does an excellent job with these topics. All of this information is well covered in a concise 175 pages.

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


Java Internationalization
by Andy Deitsch, David Czarnecki


O'Reilly
1 edition
March 2001
445 pages
Reviewed by Thomas Paul, May 2001
  (9 of 10)


There are three ways to handle internationalization of your Java applications. First, ignore it and give up all your non-English speaking customers. Second, write customized versions of your programs for each language you wish to support and live with a maintenance nightmare. Or third, take advantage of the many internationalization features built into Java. Fortunately, the internationalization features of Java are fairly simple to use and this book clearly explains how to apply them to your applications. The authors start with a description of the many writing systems in use through the world and discuss the many problems that these writing systems can cause for developers. The book then covers a wide range of topics: * how to use resource bundles to isolate locale specific data * formatting dates, numbers, and currency * handling searching and sorting issues for non-Latin alphabets (Japanese, Chinese, Hindi, etc.) as well as special cases within the Latin alphabet (an "a" with an umlaut is sorted with "a" in German but after "z" in Swedish) * handling languages such as Arabic and Hebrew that write from right to left * designing graphical interfaces to handle any writing system * building internationalized web sites If you plan on using the internationalization features of Java then you will definitely want to start with this book. The book is written for the intermediate to advanced Java programmer who needs to develop internationalized applications. The authors assume that the reader is unfamiliar with the issues involved with developing internationalized applications.

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


Early Adopter J2SE 1.4
by James Hart


Wrox
1 edition
September 2001
203 pages
Reviewed by Thomas Paul, November 2001
  (8 of 10)


This book, as part of the Wrox 'Early Adopter' series, explains some of the new features of J2SE 1.4. This new version of Java has many improvements over prior versions and also contains quite a bit of added functionality.

The book is very well done and gives excellent examples of some of this new functionality. However some new features have been left out including print service and some AWT and Swing enhancements. The information included, however, covers some of the more complex features of this release.

The book starts with excellent coverage of the new I/O features and the Java Network Launch Protocol (JNLP). The chapter on XML, however, seems unnecessary. Although this version of Java is the first to include XML support, the JAXP, SAX, and DOM information is not new and is readily available from many published sources. The author's coverage of enhancements to the java.util package (especially regular expressions) is very good. The chapter on language enhancements is a bit confusing because the author starts the chapter with items that are not included in this release. This information would have been better placed in a separate appendix. The book ends with a section on possible enhancements for the next release of Java. The section on JAXB will be good news for many developers since it is available as an early access release. The book does not contain an index.

Anyone interested in the new features of Java will find this book very useful.

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


Java 2: The Complete Reference, 4th Edition
by Patrick Naughton, Herbert Schildt


Osborne Publishing
third edition
March 1999
1108 pages
Reviewed by Carol Murphy, November 2001
  (8 of 10)


This nice, fat volume is much more than a reference book. It's packed with example code, clear definitions of the fundamental language elements, and lots of side notes to fill in those "Why the heck do they do it like that?" moments. Half of the book is devoted to the Java Library, which I find really convenient. (I know this stuff is available online, but I love to have a book at my fingertips.)

Updated to cover the JDK 1.3, software development using JavaBeans and Swing is in there. There's also a chapter given to making the pilgrimage from C++ to Java. No exercises for the beginner, but there are 4 programs laid out with source code and development process at the end of the book showing how things can be done. One of these is a multiplayer, networked, client/server game. Well-indexed information right there whenever you need it! Worth checking out.

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


Taming Java Threads
by Allen Holub


Apress
unknown edition
June 2000
300 pages
Reviewed by Thomas Paul, September 2001
  (8 of 10)


This book is for the experienced Java developer who has a solid understanding of the basics of threads. If you have been working with threads and are looking for a book to help you avoid thread problems then this book may be exactly what you need. The author does an excellent job of explaining why threads are not easy to use correctly and then provides an extensive library of classes that can be used to overcome thread problems. These classes are the meat of the book. Each class is designed to solve a specific problem that using threads by themselves can create. In general the classes are explained well although there were several blocks of code that I thought deserved a deeper discussion.

The topics covered are extensive: exclusion semaphores, counting semaphores, locks with timeouts, and read/write locks. The semaphore classes provided can solve a host of problems and are worth the price of the book by themselves. For Swing the author discusses timers, alarms, thread safety, observers, and multicasters. The discussion of Swing and threads is critical for Swing developers to understand but is often skipped over in books on Swing. However, I have one complaint with this book. The main reason for buying this book is the code but the author insists on either a mention in your about box or you must pay a license fee to use the code. For some corporate IT departments this could be an issue.

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


Professional Java Data
by Danny Ayers, John Bell, Carl Calvert-Bettis, Thomas Bishop, Bjarki Holm, Glenn E. Mitchell, Kelly Lin Poon , Sean Rhody et. al.


Peer Information
1 edition
June 2001
1300 pages
Reviewed by Johannes de Jong, August 2001
  (8 of 10)


This book does a fantastic job covering the different options available to the Java programmer when it comes to data centric problems / solutions. Though not a JDBC specific book, JDBC is the "golden thread" that runs through the whole book. Both the JDBC 2.0 optional packages and SQLJ are covered in depth , nice and up to date.

Most readers will be inclined to skip section I , (Software, Object, and Data Design and Modeling ), I suggest you don't its a fantastic summary on the subject. Technology watchers will be happy to see the inclusion of the chapter on JDO.

Case studies are included in books to make the theory come to life. This book has as many as 4. I would have preferred one massive case that took a "problem" , highlighted the options available to the designers , discussed the pro's and cons of each and implemented it.

I also wish the team that wrote this book took the time to choose one standard set of tools ie. data base servers, for their coding examples. I personally find it extremely irritating that I have to download and install something else first before I can try the code in a new chapter.

I highly recommend this book. This is the book you will grab when you want do "Data in Java".

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


Digital Image Processing: A Practical Introduction Using Java
by Nick Efford


Addison-Wesley
unknown edition
May 2000
340 pages
Reviewed by Sean MacLean, June 2001
  (8 of 10)


Efford's "Digital Image Processing" stands out as an excellent introduction to the topic. On reading the first few pages one is immediately struck by the book's thoughtful layout. The table of contents is as detailed as many indices that I have seen and is supported by a list of figures, tables, algorithms and program listings in the formal style of academic publications. Likewise, as you make your way through the chapters (each complete with "further reading" sections and accompanying exercises), you can't help but be impressed by the care with which the book has been organized. To top things off, the accompanying CD contains lots of supporting source code and fully functioning applications. The topics addressed in the book's 12 chapters covered almost every basic image processing technique that I am deeply familiar with and I was, for the most part, very comfortable with Efford's treatment of the material. Any complaints are minor. I would have liked a quick example of the ImageFilter class and a bit more on color histograms. The discussion on Fourier Theory, though very clear, could have been bumped up to excellent had Efford given a bit more weight to the transform optimizations. All in all, Efford has written an excellent book on the fundamentals of DIP that could easily serve as an undergraduate text. Within the first few chapters, I was already mentally removing several signal processing books from my book self to make room for this new found gem.

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


Java Cryptography
by Jonathan Knudsen


O'Reilly
1 edition
May 1998
362 pages
Reviewed by Thomas Paul, April 2001
  (8 of 10)


Are you concerned about someone outside your company intercepting a password between your applet and your server? Are you worried about someone inside your company using a packet sniffer to capture the credit card numbers of your customers? No? Well, perhaps you should be! As a first step towards closing your security holes you should pick up a copy of "Java Cryptography". This book is written for the experienced Java developer with no cryptography background who needs to build cryptography into their application. The book starts off with a brief description of secure systems and demonstrates a "Hello zoT1WY1NJA0=!" program. It then gives a fairly detailed description of cryptographic concepts and the Java Cryptography Architecture (JCA). Subsequent chapters discuss how to use the Java Cryptography Extension (JCE). Chapter 5 covers generating and managing symmetric and asymmetric keys with an explanation of the difference. Chapter 6 discusses authenticating users and messages. Signatures and certificates are covered. Chapter 7 covers encryption techniques using different types of ciphers. Chapter 8 covers signing applets. The last chapters include sample encrypted chat and e-mail programs. The end result is a book that provides excellent coverage of cryptography in Java. The only defect in the book is that it is three years old (Java 2 was in beta). Fortunately, the book was written recently enough to include the new utilities used in Java 2. Even though a new edition is desirable, "Java Cryptography" still stands alone as the best book available on this topic.

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


Java Message Service
by Richard Monson-Haefel and David A. Chappell


O'Reilly
1 edition
December 2000
238 pages
Reviewed by Thomas Paul, February 2001
  (8 of 10)


In the past, programmers using Message-Oriented Middleware (MOM) were forced to learn the protocol specific to a middleware product. With the development of the Java Message Service (JMS), developers only need to learn one simple API set for any MOM system. This book is written for the experienced Java developer who wishes to quickly learn how to use the JMS API. It clearly explains and demonstrates using the JMS API with easy to follow examples. The authors start with a description of the basis of MOM systems and describe the two types of messaging systems (point-to-point and publish-and-subscribe) that are supported by JMS. They also explain why an asynchronous messaging system may have an advantage over remote procedure calls in some applications. In the next few chapters, the authors give details on how to use the JMS API to develop a simple B2B application using the two messaging systems. The authors then discuss some advanced JMS topics including guaranteed messaging, transactions, and message failures. They then cover deployment considerations (including performance, scalability, and security), and the new EJB type, the message-driven bean. The final chapter is a brief look at some of the JMS products available. Appendixes provide a quick reference to the API and detailed information about messages. At a time when publishers seem to prefer more pages to quality information, it is a pleasure to find a book that manages to provide you with all the information you need on a topic in only 220 pages.

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


Java Threads
by Scott Oaks, et al


O'Reilly
second edition
January 1999
336 pages
Reviewed by Paul Wheaton, January 2000
  (8 of 10)


I bought this book when I was studying for the SCJP2 exam. I was worried that if the exam had a lot on threads I might not know the nitty-gritty particulars. As it turns out, Java threads are pretty simple. But! This book points out the details that can trip you up if you're not careful! Reading this book not only made Java threads rock solid in my head, but makes a great reference for when you jump into tricky threading waters.

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


O'Reilly
second edition
January 1999
336 pages
Reviewed by Kathy Sierra, May 1999
  (8 of 10)


You need to learn more about Threads, so you need this book. It goes into great detail and will give you the mechanics of Threads in Java. If you're interested in patterns and the more subtle design issues of Threads, then you should also check out the Doug Lea "Concurrent Programming in Java" book, but start with the Oaks/Wong book first! [little warning: in some places "Java Threads" oversimplifies, and it doesn't offer the very lowest level of detail you could hope for, but it's still the best place to start]. This new Second Edition is updated for Java2, and includes new material and corrections to the earlier book.

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


Instant Messaging In Java - The Jabber Protocols
by


Manning Publications
1 edition
April 2002
300 pages
Reviewed by Sean MacLean, June 2002
  (7 of 10)


Having no previous experience using Jabber for instant messaging, my interest was piqued when I first picked up a copy of Iain Shigeoka's "Instant Messaging In Java - The Jabber Protocols". I have to admit that my interest waned somewhat as I read through to the final chapters. I expect this is due, in part, to the Jabber protocols but this is my general impression having read the book. That said, the authors writing style is effortless, making this, like many of the Manning titles, a lucid and well-paced discussion of the Jabber Protocols. The client/server example is well thought out and develops nicely over the course of the book. If you have any interest in developing a real time messaging system, I'd certainly recommend this title - the only caveat being that, obviously, you accept an implementation using the Jabber protocols.

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


Java IO
by Elliotte Rusty Harold, et al


O'Reilly
1 edition
March 1999
596 pages
Reviewed by Kathy Sierra, May 1999
  (6 of 10)


Fresh off the press (Spring 1999), this book covers some of the same ground in his Networking book, but its all updated for Java2 and full of Things You Don't Know. The java.io package has more than 60 classes, and lots of twisty little subtleties. Did you know that PrintStream.println() is not cross-platform safe when used to send information via a networking socket, for instance? Aha! Then you need this book.

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


Java 2 Micro Edition
by


Manning Publications
1 edition
April 2002
400 pages
Reviewed by Matthew Phillips, June 2002
  (5 of 10)


This book delivers on the expectations set on the back cover. The way it delivers on this provides both the positive and negative aspects of the book.

The book is laid out in four parts. Part 1 is an overview of J2ME. Although a lot of good information comes from this chapter, I felt that a lot of information went beyond the scope of the book into territory that an experienced Java programmer would already know. Chapter 3 lays out the overall design of the application used in Parts 2 and 3, an investment quote application.

Part 2 implements the investment quote application using the MID Profile. Part 3 implements it with the KJava Profile. Both sections do a good job of explaining the code. I really like that they chose a real world scenario for the tutorial.

Part 4 goes into a more in depth analysis of networking issues, analysis, and design. Chapter 11 is definite must read if you are new to programming in general and very new to limited resource devices.

I have two major problems with this book. Issue one is the editing. It appears that the editor did not read through to find the spelling errors. A few errors could have been found by a spell checker. My other issue is the fact that the book is dull. On more than one occasion I fell asleep while reading it. I usually don't have that problem with tech books, so it was particularly noticeable.

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


Programming and Deploying Java Mobile Agents with Aglets
by Danny B. Lange, Mitsuru Oshima


Addison-Wesley Professional
1 edition
August 1998
256 pages
Reviewed by Paul Wheaton, January 2000
  (5 of 10)


I won this book at the Java Software Summit in November of 1998. I think this is the core of JNI and may have a big future. I haven't developed anything along those lines. I keep hoping a manager will see the book on my shelf, ask about it, get an idea, and tell me to spend a few weeks making something using it. Until then, the book goes mostly unread.

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


Mobile Information Device Profile for Java 2 Micro Edition (J2ME)
by


Wiley
1 edition
January 2001
352 pages
Reviewed by Sean MacLean, April 2002
  (3 of 10)


I was genuinely looking forward to learning the finer points of Java wireless device programming and, with this in heart, I read through Ortiz's and Giguere's "Mobile Information Device Profile for Java2 Micro Edition" in a few short days (trying out many of the example programs along the way). Unfortunately, this "ultimate guide to creating applications for wireless devices" fell rather short of its goal. The first few chapters provide a nicely detailed introduction to the development environment and the basics of MIDlets. However, what remains in the proceeding chapters includes far too much coverage of basic Java programming techniques and practices along with innumerable source code listings of the Micro Edition classes. For example, the 23 page chapter on security includes a 11 page primer on network security, encryption, and the like, as well as the 11 pages source code of a third party MD5 digest and Https implementations. This leaves a single page for discussion of the topic as it relates to wireless device programming! Adding to this, the book concludes with a 72 page MIDP/CLDC API appendix. Though money isn't everything, at over 13 cents a page, this is too much.

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


Java Thread Programming: The Authoritative Solution
by Paul Hyde


Sams
1 edition
August 1999
528 pages
Reviewed by Matthew Phillips, January 2002
  (8 of 10)


The short review is this: if you want to know threads inside and out, buy this book.

For those who want more details, you may read on. This book assumes no Thread knowledge. By the end of the book, you will understand the finer points of thread programming. The book is broken down into three parts.

Part 1 shows you all of the ins and outs of threads. There is a lot of sample code and many details. This section will give you all you need to know to program with threads.

Part 2 shows several techniques for good thread design. I found the chapter on breaking out of a blocked I/O state particularly informative.

Part 3 has the Thread API and the ThreadGroup API. It is a nice reference, but not particularly necessary.

It is hard to find negatives about this book, but I did manage to find two. The primary negative is that the reading is a little dry. It wasn't so dry that the book was unreadable. The other negative is that there is no website to download sample code. This didn't affect me much since I prefer to type in the code anyway, but others might find that to be a major drawback.

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


Java Security
by Scott Oaks


O'Reilly
second edition
May 2001
618 pages
Reviewed by Annmarie Ziegler, August 2001
  (9 of 10)


The everything you need to know book about Java Security. The book provides a solid foundation of the classes that comprise the Java Security model. The book starts out with an overview of the Java 2 security model and quickly moves in to details of the 'Java Sandbox'. The author explains the fine points of permissions and policy files as related to the java.security file. That's it for the basics; this book is definitely for the advanced Java programmer.

The book goes in to detail describing class loaders and byte code verifiers, explaining how they are implemented within the JVM. A brief introduction to cryptography, this is a topic that warrants it's own book. There is extensive coverage of keys, certificates and key management, including examples of how to construct key pairs - both public/private and secret keys. Additionally there are examples of how to generate message digests and use them to create and verify digital signatures. The book also covers creating and verifying signed classes using the jarsigner tool.

Advanced topics cover the use Cipher engines for encryption using JCE. There is in-depth coverage on SSL/HHTPS, but this is the only place that I found the examples lacking. And to round out the security features, there is a chapter on JAAS that gets in to both the administrative and programmatic sides.

Overall, this is an excellent book on security and a welcome addition to the serious java developer's bookshelf.

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


Java Event Handling
by Grant Palmer


Prentice Hall PTR
unknown edition
August 2001
624 pages
Reviewed by Michael Ernest, December 2001
  (7 of 10)


Event handling is not a subject that needs a thick book. I'm looking at my O'Reilly Java books that cover a similar scope and notice they're all under 300 pages. They look and feel readable.

Java Event Handling is 590 pages. Most of it covers the "event API." There are, for my expectations, too few pages that explain events, their workings, and how they power Java. There are almost no pictures, which is a real shame. The index also tells a story: I had trouble finding entries that weren't class or method names.

There's so much one can say about events: JavaBeans, RMI, EJB, Jini, Jiro all rely heavily on them. The least interesting thing is knowing the names of classes and what their methods do; those things should be the by-product of discussion and illustration, not the centerpiece.

The book does seem like a complete reference on its subject. And there are code samples, more than a few, to illustrate key points. Someone who feels lost and wants a lot of examples for a guide may benefit from it. But the "deep questions" that follow learning by repetition don't get much support. Those who can take the precepts given on faith will find it serviceable; those who want proof the author knows what he's talking about will find it unsatisfying.

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


Program Generators with XML and Java
by J. Craig Cleaveland


Prentice Hall PTR
unknown edition
February 2001
448 pages
Reviewed by Margarita Isayeva, May 2002
  (6 of 10)


I had a very satisfying experience working with template-based program generators and have been intrigued by these techniques since then. A combination of Java and XML stated in the title sounded promising. So, maybe because of too high an expectation, this book was somewhat disappointing. It is written in a simple, "dummies friendly" style which is just too simple for the subject matter.

The book starts with a light introduction to domain analysis; then there is an outline of JSP and XSLT/XPath technologies - probably to allow a reader unfamiliar with them to understand examples. However if you are familiar with both, the examples don't provide too much insight besides common sense.

The chapter that could be central to the book shows how you can develop your own template language. Instead of formal approach, the development process is shown "by example", and a reader can witness how a syntactical clone of JSP is designed. In my opinion, absence of any formal design guidelines, limits the chapter's value.

In short, it can be a gentle introduction in a rather complex field, and give you some ideas how to implement a simple Program Generator in your project. Then, if you want more, Krzysztof Czarnecki and Ulrich W. Eisenecker's "Generative Programming" is the classic in this field; which is more of a challenge to read, though.

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


Constructing Intelligent Agents with Java
by Joseph P. Bigus, Jennifer Bigus


Wiley
unknown edition
December 1997
379 pages
Reviewed by Frank Carver, November 2000
  (6 of 10)


A potentially interesting book, but little use as a reference. This book consists largely of annotated Java source code for a simple expert system shell or knowledgebase, with a few simplistic examples of embedding business rules in classes based on an "intelligent Agent Framework". Unfortunately, the "agents" presented in this book are just classes which are dynamically loaded into a container, and offer not much new to anyone who has used servlets or EJBs. I read through this book, and was sufficiently dissapointed with the code that I wrote my own, considerably more flexible, knowledgebase using based on the same principles, so it was useful for that, but unless you are in a similar situation, you should probably avoid this book.

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


Java Connector Architecture
by Atul Apte


Sams
1 edition
May 2002
360 pages
Reviewed by Madhav Lakkapragada, June 2002
  (4 of 10)


This book is just another one of those things you could read when you have nothing else to do. While the back cover talks of "presenting JCA Specifications", you need to wait till the tenth chapter to get that taste.

The first few chapters overviews of J2EE, XML, Web Services, EJB and a few on Adapters. Personally, I don't understand why the author did not make these pre-requisites and concentrate on the actual subject matter - JCA. My interest in the book soon vanished as I had to wait till chapter 10 to see the first line of Java code.

Not my kind of book. I wanted to learn the Connector architecture throughly, but this book din't help me to the extent that I expected. There are very few examples. Just one huge application in the last chapter, although referece is made to parts of it in earlier chapters. This application is developed in the last five chapters. Seems to me that towards the end of the book, the author realized that we quickly need one example.

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


Aspect-Oriented Programming with AspectJ
by Ivan Kiselev


Sams
1 edition
July 2002
288 pages
Reviewed by Valentin Crettaz, September 2002
  (8 of 10)


This book presents Aspect-oriented Programming (AOP) as a new programming trend that complements the traditional object-oriented approach by introducing a new kind of module called "aspect". The book does not provide any exhaustive tutorial on AOP, but it merely presents one approach to AOP using AspectJ (http://aspectj.org). The book also requires the reader to have a solid understanding of Java as well as a basic knowledge of JDBC, JSP/Servlets and Custom Tags since the presented case study focuses on a web-based application.

The first part of the book gives a very brief introduction to AOP. For a first book on the subject, it would have been legitimate to expect a little more substance in this introductory part.

The second part is dedicated to AspectJ and creates a real-world web application from scratch. The author clearly explains how to modularize crosscutting concerns such as security, logging, tracing, profiling, buffering, pooling, caching, etc, si well-presented.

The third part presents the syntactic and semantics details of the AspectJ language constructs (aspects, pointcuts, etc) whose use is illustrated by simple examples. I would have expected the precision and completeness of the AspectJ Programming Guide coupled with those nice little examples.

The little details and a substantial amount of typos put aside, I was basically satisfied and would recommend it to any serious developer willing to get in touch with AOP. The AspectJ Programming Guide (available at aspectj.org) is also an excellent and necessary resource.

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


JUnit in Action
by Vincent Massol, Ted Husted, Petar Tahchiev, Felipe Leme, Vincent Massol, and Gary Gregory


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


Manning Publications
second edition
July 2010
504 pages
Reviewed by Jeanne Boyarsky, September 2010
  (7 of 10)


I truly enjoyed reading the first edition of "JUnit in Action" and was somewhat disappointed by the second edition. It wasn't even that the second edition was bad. It's that my expectations were too high from the first edition.

I think there were too many authors on the book. The different styles were apparent which is awkward in a book. The cover says the book covers JUnit 4.8 while the contents of the book are JUnit 4.6. (This one is probably marketing's fault, but it stands out extra on a book about quality.)

I also think the scope of the book was too large. Many things are covered, but not enough things are covered well. I expect a book titled "JUnit in Action" to cover the core of JUnit well. While most things were mentioned, there were only 3 pages on Hamcrest matchers. I felt other core concepts were breezed through and not enough space was spent on the fundamentals. The first edition had more pages on core JUnit and there was less to cover then!

I was also surprised not to see Mockito mentioned in the mock testing section or Emma in the coverage section. Not featured, mind you. Just mentioned. And finally, I found one factual error that I consider significant because it is a fallacy. I posted it in the Manning forum 8/3 and haven't received a reply. Nor have many people who posted since May or beyond. Why is there a forum if nobody reads it?

Many things were done well - examples, best practices, available tools. I just had the bar so high from the previous edition that I was let down.

If you already own the first edition or are familiar with what is out there, you don't need this book. If you've never done anything in JUnit, it is still useful. Just remember that the order unit tests are run is not guaranteed!


Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch.

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


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


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


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


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


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


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


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


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


Eclipse 3 Live
by Bill Dudney


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


OSGi and Equinox: Creating Highly Modular Java Systems
by Jeff McAffer, Paul Vanderlei & Simon Archer


Addison-Wesley Professional
1 edition
February 24, 2010
460 pages
Reviewed by Jeanne Boyarsky, April 2010
  (8 of 10)


"OSGi and Equinox" is the first "Eclipse Series" book I have read. It has three parts.

The first part is an introduction. The brief history shows how OSGI came to be and the benefits. It had excellent visuals to see the concepts being presented.

The second part is an extended tutorial to create the TOAST application from scratch. The tutorial assumes you've never used Eclipse before so it was a bit slow to get started. I would have liked seeing how to create a project/class as an appendix. There were a ton of IDE screenshots so I certainly felt like I was doing the tutorial with the author. That style got a little dry/repetitive; maybe because I wasn't following along on a computer. Many concepts were covered and there were good tips and warnings to the reader. I was a bit puzzled why the tests are using EasyMock with Java 5 and JUnit 4. I'll be sure to ask the author when he is at JavaRanch the week of April 20th.

The third part is "deep dives" into specific concepts. This section was less tutorial-y and I liked it better. It includes patterns, the lifecycle and crosscutting concerns. There is also an "other"/kitchen sink chapter that contains numerous tips and tracks.

Overall, I did learn a lot from the book. If you are looking to learn OSGi/Equinox, I think it is good to read.

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


Addison-Wesley Professional
1 edition
February 24, 2010
460 pages
Reviewed by Deepak Bala, December 2010
  (9 of 10)


This book has a detailed explanation of how to develop modular Java systems and applications using OSGi and Equinox. It is a very good book not only for OSGI beginners but also for people who want understand eclipse plugin development. Those that do not have experience with OSGi previously, will feel at home when they begin reading the book.

The book itself feels like a tutorial with plenty of screen grabs to go with it. As such it makes for an easy read as the author guides you through the OSGi concepts. The chapters towards the end focus more on the details, while the rest of the book is a practical guide to OSGi.

The examples can be tried with an Eclipse plug-in which is installed from the web. I would advise folks to read the book and practice the examples at the same time. They go hand in hand.

Overall a great book to learn OSGi and Equinox.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

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


Lucene in Action, Second Edition: Covers Apache Lucene 3.0
by Michael McCandless, Erik Hatcher, Otis Gospodnetic


Manning Publications
second edition
July 2010
475 pages
Reviewed by Ulf Dittmer, September 2010
  (9 of 10)


It's been 5 years since the first edition of this book, and Lucene has progressed from version 1.4 to 3.0 since then. This has meant significant new features, performance improvements, a much larger ecosystem around the core library, and more.

That's where the second edition comes in. It still describes the basics (indexing and searching) in as much detail as before, but also addresses new features such as payloads and new query types. The book also covers significant 3rd party extensions (the 'contrib' packages) that are not part of the Lucene core, but are considered of high enough quality to be shipped with it, as well related projects (like the Luke tool for analyzing indexes, and the Tika library that unifies indexing a wide variety of document types).

The book is full of ready to use code examples, is very readable, and is written in a way that one can read a section about a particular feature without having to digest everything that came before it first. So it doubles as a reference book. And, let's face it, there's way more to know about Lucene than one can pick up from articles and forums on the web. I consider the book indispensable to anyone who uses (or considers using) Lucene for more than simple toy projects; it will pay itself back quickly through time saved.

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


Unlocking Android: A Developer's Guide
by Frank Ableson, Charlie Collins, Robi Sen


Manning Publications
1 edition
April 2009
416 pages
Reviewed by Ulf Dittmer, September 2010
  (7 of 10)


Android being a complete application platform, it's impossible to cover all of it in a single book, but "Unlocking Android" makes a credible attempt at getting the reader up and running quickly. The major chapters cover the development environment, user interfaces, intents and services (the building blocks of Android apps), storing and retrieving data, networking and web services, telephony, notifications and alarms, graphics and animation, multimedia, and handling location. After the capabilities of the platform have been introduced along with many code examples that show them in use, a lengthy example app that ties it all together is developed from scratch.

None of the areas is covered in full depth -trying to do so would be futile, given the size of the class libraries- but once a familiarity with the basic concepts has been established, the reader can consult the javadocs for more information, and use targeted web searches to find the missing pieces. The same is true for more advanced concepts such as OpenGL and native code, which are covered just briefly or not at all.

It needs to be said that Android is a fast-moving target, and while this book covers the now obsolete Android 1.x, a 2nd edition is on its way and will update coverage to Android 2.x. I recommend the book -or rather, its upcoming new edition- to anyone who has had no exposure to Android, and needs to get up to speed quickly on a whole range of issues. Reading javadocs and searching the web will be necessary to fill in some of the blanks, though.

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


Spring Persistence with Hibernate (Beginning)
by Paul Tepper Fisher, Brian D. Murphy


Apress
1 edition
November 2010
264 pages
Reviewed by Jeanne Boyarsky, December 2010
  (7 of 10)



Apress' "Spring Persistence with Hibernate" covers Spring 3.0. (Take care that you don't confuse it with Packt's book with the same title which covers Spring 2.5)

The roadmap on the back cover implies you should have read "Beginning Spring" or "Beginning Hibernate." For an experienced developer, this isn't necessary. The key is that this book is fast moving so you should have some development background. It does cover beginner concepts - just faster.

The book goes beyond the title with bonus chapters on integration, Grails and Roo. It also covers the basic Spring MVC setup. I particularly liked the chapter with things to beware of including lazy loading and caching.

The only errors I caught were the case of @PostConstruct and @PreDestroy. They were consistenly wrong which makes me think it was edited after the authors last saw it. I also noticed a JUnit version mismatch while not wrong per se. Didn't affect readability though and the testing coverage was still good.

Overall, I was happy with the book.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

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


Apress
1 edition
November 2010
264 pages
Reviewed by Christophe Verre, January 2011
  (8 of 10)


If you are looking for a book to learn about Spring and Hibernate, pass your way. If you are looking for a reference, pass your way. So who is this book for ? I think it is aimed at people who want to try a simple application using Spring3 and Hibernate 3.x (JPA2). It is fast paced, straight to the point. If you know what you are doing, it's a fun book. You'll start by setting your development environment (authors use Maven), configure Spring and Hibernate, make some domain classes, make some DAOs... Very fun. But don't expect to find answers if you're stuck somewhere.

There are some interesting explanations about persistence optimization like caching and lazy-loading, as well as a chapter about integration of frameworks like Dozer and Lucene. It also mentions REST and Spring MVC, and concludes with Grails and Spring Roo. These last two might be out of topic, but they have their own merit. I think they are worth reading.

I didn't notice many typos. Source snippets are neither too short nor too big. They illustrate well the explanation they are attached to. I already know about Spring3 and JPA2, but I never used Hibernate as my persistence provider. This book provided me a chance to try it. I felt it was not like any other technical books. Very enjoyable.

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


Application Security for the Android Platform: Processes, Permissions, and Other Safeguards
by Jeff Six


O'Reilly Media
1st edition
December 2011
112 pages
Reviewed by Ulf Dittmer, December 2011
  (8 of 10)



While it's tempting to think that a mobile phone is a safer environment than, say, a web app, the reality is that it's becoming less so, if it ever was that in the first place. Malware of various kinds is just as much of a threat to a mobile app as to a web app, particularly in an ecosystem as open as Android.

This book ties together the different aspects that an Android app developer needs to consider when releasing an app into the wild (like through Google's Android Market). It covers the underlying OS architecture, where many app privileges are based on Linux file permissions, and then proceeds to the application permissions that govern capabilities granted to an app, like access to GPS location, use of internet connectivity, and access to SD card data. The latter will be familiar to anyone who's written an Android app (since they need to be listed explicitly in each app's manifest file). The next chapter covers the interprocess communication that allows apps to make use of other apps capabilities and permissions - Intents, BroadcastReceivers and ContentProviders. While the "how" of those is generally covered extensively, the security aspects tend to get overlooked; but not here. The last couple of chapters deal with securing sensitive data stored on the device, and with the internet connectivity that most mobile apps do in some form, and to which the same network security principles apply as for web apps (SSL encryption and mutual authentication). Those chapters delve deeply into Java's JCE API.

Overall I found the book easy to follow along, with plenty of code examples to study. The chapters can be read largely independently of one another, but at a length of not much more than 100 pages one might as well read the book in whole. While parts of the book will be familiar to a seasoned Java developer, and some parts have been covered widely online, this reviewer thinks it's still useful to have it all in one place, so as better to start thinking about app security as a whole, not as individual pieces to be used as is convenient - the threats are multiple, and an app is only as strong as its weakest point. Once it's out there on a device, it's subject to much more extensive probing than would be possible for a web app. Better to get its security story straight.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

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


Hudson Continuous Integration in Practice
by Ed Burns, Winston Prakash


McGraw-Hill Osborne Media
1 edition
September 2013
384 pages
Reviewed by Jeanne Boyarsky, September 2013
  (7 of 10)



"Hudson Continuous Integration in Practice" targets developers with system admins as a secondary audience. It assumes Java knowledge. It doesn't assume you know any tool in particular that Hudson works with (Ant/Maven, Junit, etc) but it is more helpful if you already know them for more understanding.

I think pieces of the book serve different audiences. You could learn about Hudson on a high level and how to integrate it with different tools. Or you could learn how to write a plugin - something I've found tricky from the documentation online. There are also good tips on maintaining your Hudson instance well. I particularly liked the description of setting up slaves and the description of "containing code."

There were a few places I felt the code could have been edited better. Like AbtractBuil vs AbstractBuild and HTML entities in the Java code. But they didn't get in the way of reading.

One thing I really liked about the book is that it contains something for everyone. For me, the plugin chapters would have made the book worth it all on its own.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

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


Test-Driven Infrastructure with Chef: Bring Behavior-Driven Development to Infrastructure as Code
by Stephen Nelson-Smith


O'Reilly Media
second edition edition
October 2013
308 pages
Reviewed by Jeanne Boyarsky, November 2013
  (6 of 10)



Regarding "Test-Driven Infrastructure with Chef":
Step 1 - Disregard reviews about version 1 of the book. It is completely different.
Step 2 - Make sure you are near a computer with internet
Step 3 - Start reading

Part of the book is higher level. The principles of good coding. Why infrastructure developers are developers and why best practices for developers still apply. Along with the benefits of test driven. This shouldn't be new to developers, but it was still a good take on the topic and worth reading. And of course, it could easily be new to the system administrator part of the audience. Chapter 2 is the Ruby you need to know to understand the rest of the book. It was a good and fast moving overview.

Then we get to the meat of the book. A series of exercises including directions, a walkthrough of the author's attempt (with lots of output and dead ends), and then a discussion on the topic.

I liked the comments about workarounds for various "annoyances." And the incremental TDD demo. I liked the quadrant approach to the different types of tests on page 166 (how's that for a teaser.)

There were two things I didn't like. One was the pages of output. That's not my learning style. The other was the insistence that you look up things in the manual before reading. I like to read on the train where there is no internet. I also found a couple of typos, but not significant.

I'm rating this as a 6 because I couldn't try the exercises or the manual with the book. If you plan to read this book at a computer, add another star.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

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


Developing Jini Applications Using J2ME
by


Pearson Education
1 edition
March 2002
368 pages
Reviewed by Paul Stevens, May 2002
  (3 of 10)


I was disappointed in this book. Over 200 of the 300+ pages were API. While the remaining pages did an ok job of explaining the technology, there were very few examples. This book would make a much better white paper or web page than a book. If you want an overview of the technology and the API, then this is your book. I think it was a very bad idea to have more pages on the API than actual content.

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


Mastering XMI: Java Programming with XMI, XML, and UML
by Timothy J. Grose, Gary C. Doney, Stephen A. Brodsky


Wiley
unknown edition
April 2002
480 pages
Reviewed by Valentin Crettaz, September 2002
  (8 of 10)


This book shows the benefits of using an XML-based standard called the XML Metadata Interchange (XMI). It presents XMI 2.0 as an elegant facility for integrating different heterogeneous systems. One chapter is dedicated to showing how the IBM WebSphere Studio application makes a real-world use of XMI (trial version on the CD-ROM). All Java examples of the book, as well as the XMI Framework, a high-level API for manipulating XMI files, can be found on the CD-ROM. The authors assume that no previous knowledge of XMI, XML, or UML is required. Thus, the first part of the book explains all the necessary XML and UML concepts and goes on with presenting XMI concepts in details. The second part presents different ways of using XMI. The authors show different algorithms for reverse engineering UML models from XML documents. They also explain how to manipulate simple and complex XMI documents with the standard DOM and SAX XML APIs, as well as with the XMI Framework and the Java Object Bridge (JOB). A special attention is given to XMI schemas that enable powerful validation of XMI documents. It is also shown what role XMI plays in the new Object Management Group's (OMG) software development approach, the Model Driven Architecture (MDA). This book is an accurate and well written resource that contains simple and clearly explained examples. I would recommend it to any Java software developer who is willing to start or is already using XMI.

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 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


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


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


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


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


Scala for the Impatient
by Cay S. Horstmann


Addison-Wesley Professional
1 edition
March 2012
384 pages
Reviewed by Mohamed Sanaulla, July 2012
  (8 of 10)



- The book covers almost all of the concepts in Scala in a very concise format.
- More emphasis on learning by doing.
- Lot of exercise problems at the end of each chapter. It is highly recommended to try them out.
- The concepts have been divided into varying difficultly levels and the chapters have been arranged so as to facilitate good understanding.
- The initial few chapters help Java programs to get onto programming in Scala by not scaring with Functional style of programming.

Some of the not so good things:
- You dont get to see lot of idomatic scala code. Unlike Core Java where the examples gave the reader an idea of how to organise code. It is acceptable considering the size of the book.
- The questions dont have solutions so its difficult to evaluate if your code follows best practices.

This would not be the last book you would read, I am sure once you finish this book you would be in a better position to read other Scala books and try to grasp the advanced scala concepts and also learn to write idomatic scala code.

The ideal approach to read this book is to practice the exercises and also keep the Scala API documentation handy.

Being a newbie with lot of failed efforts to learn Scala, I found this book to be easy to pick scala concepts and also familiarize with the code.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

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


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


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.

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


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 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


Pragmatic Unit Testing in Java with JUnit
by Andy Hunt, Dave Thomas


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


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


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


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


Manning Publications
second edition
July 2007
600 pages
Reviewed by Janeice DelVecchio, September 2010
  (8 of 10)


I have to admit, as someone with knowledge of core Java alone and no prior knowledge of build tools, I was overwhelmed by the table of contents of this book. Once I started reading, I realized there was no reason to worry.

Each step of the setup and use of Ant is described in the first couple chapters of the book. There is an appendix for people (like me) who need a little more help starting up. The build file creation process is broken down and built upon over time. I found the examples helpful and the layout of the book intuitive.

The later chapters of Ant in Action go into way more complex things like larger projects, Ant tasks, integrating Ant into Java projects, and enterprise applications. This is a book I expect to use now and grow into later. I am especially excited about the section on working with XML, and adding in optional tasks.

I would not recommend this book to anyone who has less than a solid understanding of core Java and some awareness of XML. There is an XML primer in an appendix which is pretty helpful if you don't know XML.


Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch.

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


JasperReports 3.6 Development Cookbook
by Bilal Siddiqui


Packt Publishing
1 edition
July 1, 2010
396 pages
Reviewed by Ankit Garg, September 2010
  (7 of 10)


The book can be used by beginners and experienced people in JasperReports. This book teaches you how to develop reports using iReports, the GUI report designer. The book is full of snapshots which makes learning very easy. There were some errors in some of the snapshots, like on page 200 the values of static text components is not consistent which might be confusing. But overall the snapshots are pretty good.

The first three chapters are very basic, and they are only useful for beginners. If you are familiar with JasperReports, you'll already know things covered in these chapters. From the fourth chapter the book moves to advanced recipes. Beginners might face some difficulties understanding some of these recipes. There is a lot to learn for people familiar with JasperReports in these chapters.

The last chapter covers generating reports from Java code. This chapter covers topics from compiling a report from java code to exporting it to Excel, Pdf or printing it. It also covers how to generate reports from a web application. This topic has some technical errors (not related to JasperReports) like the response content type is not set through a page directive, there should be no HTML tags in the generated content as its a PDF response and the report is generated through a JSP page using scriptlets instead of a Servlet. The JasperReport code is correct though so this is not a big issue. An additional chapter can be downloaded from the publishers site which is a little weird.


Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of JavaRanch.

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


A Developer's Guide to Amazon SimpleDB (Developer's Library)
by Mocky Habeeb


Addison-Wesley Professional
1 edition
August 2010
288 pages
Reviewed by Andrew Monkhouse, October 2010
  (9 of 10)


If you are interested in the no-SQL database systems or in utilizing cloud computing to set up a database, this book will teach you more than enough to get you started.

Mocky Habeeb (the author) demonstrates his mastery of this subject in providing valuable hints throughout the book. These include simple warnings about certain processes that are "high cost", tuning queries, avoiding throttling server side, altering queries depending on local versus remote queries, and so on.

Although the book is primarily a Java centric book, Mocky also provides sample code in C# and PHP. He also provides comparisons between other cloud providers offerings, and discusses some methods of choosing between schema-less databases and SQL databases.

Finally, Mocky builds an API that makes it easier for newcomers to Amazon SimpleDB to use within their Java programs.

This book is well written, and an easy to read and understand introduction to Amazon SimpleDB.

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


Addison-Wesley Professional
1 edition
August 2010
288 pages
Reviewed by David O'Meara, November 2010
  (2 of 10)


The knowledge and experience of the author is not in question, but it doesn't come out in the text of this book.

"Amazon SinpleDB" is not a large book at a bit over 250 pages and even though it is aimed at developers I was expecting some coverage of the practical uses or experience but that is not evident. More on the source code later, but the user tips were often useful but buried in the text and not that accessible.

Sample source code is provided for four languages, Java, PHP, C# and Python but personally the code was niether here nor there.
50 pages worth of the same code covered four times feels like padding, and while it is helpful that each language introduced a library to simplify interacting with the Amazon Web Services, I kept thinking that at some point the book would directly address the Web Services.

In my mind this wasn't the book that the author intended and it falls short in so many areas that it feels unfinished and leaves you wondering what wasn't covered. There are other positive areas about the book but overall for me it was difficult to recommend an audience for this book.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

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.

More info at Amazon.com
 
The Bunkhouse administrator is Ankit Garg.