Customer Reviews

Jakarta Commons Cookbook

5 star:		(3)
4 star:		(5)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

If you have used any of the open-source technologies offered at apache.org, you've probably got a few of these libraries already. This is a great introduction to the <insert word that doesn't sound as obnoxious as "plethora" or "myriad" here> of tools and utilites that will make your routine java development easier.

While it is not a comprehensive book, each chapter takes a look at various areas of Java development and which of the Commons libraries provide classes and methods to handle common routines. Covered are things like Text Manipulation, JavaBeans utils, Collections (stuff that isn't in the offical JDK... yet) and Math functions. Personally, I didn't realize just how cool some of the Math functions are - so that was an interesting read. I like the fact that there was a lot of source examples in the book, too.

I think O'Brien does a nice job at balancing the Commons stuff with the topics that are better handled by a more focused book. For example, he just touches on XML and Log4J - so if you're looking for a book that has details on getting logging up, running and configured (for example), this isn't it.

If you want to know if you should incorporate any of the Jakarta Commons stuff in your development, this book will give you plenty of reasons why.

One of the beauties about Java, compared to earlier languages like C or Pascal, is the huge set of library classes that comes with the default distribution. An immense amount of code, all for free. Any experienced Java programmer knows this. But what if you could also get another set of free classes that extends the functionality even more? And has been well tested? O'Brien educates us about this - the Jakarta Commons. A nifty amount of heavy code. It can be highly worth your while to peruse this for useful classes.

Here is a brief excerpt of what is offered. Consider the default maths classes that come with Java. Important. But still very primitive compared to the decades of effort put into various mathematical libraries in other languages like Fortran. Of course, many of those tend to be proprietary. Now, in Commons, we have Maths classes. These can solve a linear system of equations. In other words, matrix arithmetic is implemented. Opens up entire regions of electrical circuit modelling and control systems theory, for example.

For statistics, simple regressions between two variables is now computed. And complex numbers can be explicitly handled with the ComplexMath class.

It can be appreciated that the new Commons maths classes fill longstanding gaps in the default maths ability of Java, which has been weak in numerical methods and high performance computing. It greatly strengthens the credibility of developing applications in those fields with Java.

How many times do you find a solution written for your last project to be equally applicable to your current problem but too closely coupled to reuse without adapting code in copy-and-paste style? Even worse, when bug is found you have to patch the same solution differently amongst relevant projects. While open source and Java mean free, community support, and options, Jakarta Commons bring the next level of productivity and ease of maintenance. Being one of the contributors, the author introduces the audience components refactored from more elaborated projects in an easily referenced form of tips and cautions.

How many times do you end up disappointed when a primitive function is expected from the language with its Javadoc being searched through? Even though you find it from the latest release, sometimes upgrading the runtime environment is not an option. Language supplements are described like Jakarta Commons being the lead of the direction the language should be steered towards. Text manipulation is so universal where handy utilities are illustrated. JavaBeans, a simple yet versatile convention, deserve a helper library that eases your life. Feature rich collections, command line interface, properties configuration, logging, and networking I/O are clearly mentioned. By practical to conceptual ideas, the math library is employed to estimate the amount of time left in long running processes. Arbitrary complexity of comparison and sorting is managed by means of functors.

The author intends to be neither comprehensive nor surveying options to a problem. Nonetheless, it is inconvenient to have no source available for download. With the book in its first edition, there exists missing cross reference and code inaccuracy sometimes is obvious. By including instructions for the use with Maven, those new to the framework may be confused. Coverage of advanced topics like XML, web development with templating, WebDAV, and indexing are not sufficient. After the book is glanced through, it is really desirable to see how the author can deploy the same way of presentation to areas where no thorough documentation of good quality ever exists.

The Jakarta Commons Cookbook provides an excellent resource into the many useful features and functions in the Apache Jakarta Commons libraries. In addition to the nice cookbook style, there are large numbers of examples in one single volume. This is an indispensable book for the Java developers who want to understand the Jakarta Commons libraries.

It's hard to write a review of a book like this.
The Commons are such a big group of components, you really cannot cover all of it. Tim does a good job of introducing you to them (+2). Unlike most books, this is very readable, using (for the most part) clear examples (watch out for the phantom 'Person' class) (+1).
The only draw-back I can really point to is that Commons is really designed to be straight forward and easy to understand, so an O'Reilly cookbook might be too indepth for this (-1). I like that I can read other posts by the author, related to Commons, in the ASF (+2).

This book does provide a good overview of some of the most popular libraries in the Commons project. Although I have read and enjoyed several other Cookbook style books on more general topics, I did not find this one as useful. This is because the Jakarata Commons recipies are very speicific, and cover a wide array of unrelated topics. If you have a specific need that is covered, you will likely find the book helpful. Otherwise, it may be like some of the real cookbooks in my kitchen that are interesting, but rarely used.

Although a bit out of date, this book is a great introduction to the Jakarta Commons libraries.
The Jakarta Commons libraries are an invaluable resource for the Java programmer. So many holes in the Java class libraries are covered by Commons, that it can become an inseparable part of any Java code. As a Java programmer, I recognized such utilities and code fragments, found in the commons libraries, that I used to implement over and over again on my past various projects.
No more! Commons is to the rescue, and much tested, working code can now be reused.
The book itself follows some of the major libraries: Strings, IO, Templates, Networking, Collections and more.
Some of the covered libraries are not any longer part of the Jakarta Commons (Velocity), and others are missing (commons-jdbc). It would be great to have a new edition for this book.
But even so, the book provides a structural, well defined review of the most interesting features in these libraries. Written in an easy to follow language, having simple yet clear examples and making a point on where and why Jakarta Commons is a good choice.
Many of the features are not well presented in the Commons User's Guide on the Jakarta web page. This book complements the online examples, and serves as a useful reference.

This book serves as a good introduction to commons project. It gave me a brief overview and applicability of the projects. Though the Cookbook doesn't serve as a exhaustive reference in itself, it starts the ground work .

It is a very good book, but there is some stuff that's missing and it's important, like Commons Validator