Become a fan of Slashdot on Facebook


Forgot your password?
Slashdot Deals: Cyber Monday Sale Extended! Courses ranging from coding to project management - all eLearning deals 20% off with coupon code "CYBERMONDAY20". ×
Book Reviews

Submission + - Book Review for "Camel In Action" (

RickJWagner writes: "Book Review for "Camel In Action"

I'm pretty certain this is the definitive guide to Apache Camel, destined to be referred to as "The Camel Book" by Camel users for a long time. It covers Camel inside and out, upside and down, 550 pages worth of gritty detail that takes the reader from level zero to monitoring of your production applications. If you use Camel, or think you might want to, you need to pick up a copy of this book.

If you haven't used Camel, it's known as an "Integration Framework", a phrase that I like to equate to "ESB Lite". By that I mean if you want to route messages or transform them, this is a tool you might consider. Still not quite sure what I'm describing? Here's a couple of examples. If you want to read messages from a JMS queue, use the contents to invoke a web service and put the results of the web service call in a database, Camel's a good tool. If you want to read in a flat file, split it into individual lines, take a part from each line to call a web service, Camel's a good tool. Camel does all this and more, acting as a sort of universal router and message transformer. Camel aims to implement the famed "Enterprise Integration Patterns", which are easily understandable descriptions of processing snippets that provide functionality in likely scenarios when you're using messaging. If you're brand new to this type of programming, I'd encourage you to use Google to check out "Enterprise Integration Patterns"-- you'll quickly get a feel for the workspace Camel lives in.

The book is exhaustive in it's coverage of Camel. It shows the reader how to configure Camel using both Java code and Spring configuration snippets. It's meant to be progressive in nature, showing the reader simple uses to start with, then progressing to more advanced scenarios as the book gets into the latter chapters. (More about this later, it involves my only complaint about the book.) Along the way, the authors address real-world topics like transactions, production monitoring, and deployment to different hosting containers. All told, the book reflects the concerns of someone who has actually used Camel for real-world work, and as such will prove to be an invaluable resource for anyone moving Camel to production.

The source code that goes with the book is clean, easy to read, and above all it works right out of the box. It's all Maven-centric, so if you're not a Maven user yet you will be at least partially practiced in it by the time you're done with this book. The examples are straight out of the chapters, so you can look to the book for a detailed explanation of what you're running. (You can also run what's being described, and monkey with it to learn new things. Very handy.) I offer no improvement for the sample code, it works as advertised.

I was especially impressed by the care the authors took to explain the really nitty-gritty stuff that a real-world user is going to need. Concurrency and transactions fall into this category. All the sample examples in the world won't help you if the book doesn't help you scale you app and make it safe for production use, considerations you sometimes don't find in tech books. They're here, though, and covered in sufficient detail to meet your go-to-production needs.

This is a big book, and the text it contains is as simple as it should be but no simpler. The illustrations are simple and relevant. If you're brand new to Camel and want to read it front to back, be prepared to allocate a good number of hours for this task. This is because there's just a lot of material covered here, none of it fluff. If you're already an established Camel user, this book will serve well as a desktop reference for when you want to venture off into more of Camel's abundant functionality.

So what's not to like? The only criticism I have for this book is that the ordering of the chapters is not quite to my liking. It starts out with the simple canned examples, and they get progressively harder, 'till the reader is finally given the knowledge to write their own applications way out in chapter 11. If you're like me, you like to see an example or two, then you like to start hacking out your own "Hello World" apps to get a feel for how to build the artifacts you need to get things running. I thought chapter 11 was too late in the game for that knowledge. In fairness, if you're a reader who doesn't mind skipping around as you read, then just skip to chapter 11 right away and you needn't worry about this tiny nit.

So who's this book good for? Camel users of all types, from beginners to those who already own running Camel apps will benefit from this book. You won't be sorry-- you'll never wish you'd held out for a better book, because there just flat isn't going to be one, at least not for a long, long time. I give this book a solid 9 out of 10 stars.

The book can be found here:"

Submission + - Book Review for "Plone 3 Products Development Cook

RickJWagner writes: This book takes an interesting path to teaching Plone 3 development. Unlike most software instructional books, it starts way back in the often-unread Preface by listing 10 requirements a mythical customer is asking the reader to implement in Plone 3. The requirements are realistic and I think would probably be quite a stretch for an inexperienced Plone developer. The rest of the book is dedicated to implementing those 10 features, and coaching the reader on Plone 3 development along the way.

I wouldn't say this is a good book for a novice Plone user. There really isn't much introductory material, and there is little material to transition the reader from Plone installation to meaty development. A newbie could certainly use this book if it were augmented with additional material (say, the Internet and a fair amount of time allocate), but the reader had better be ready to self-educate on Plone/Zope/Python development if they are not already proficient in these areas. For developers who already know their way around Plone, however, this book is an excellent step-by-step guide to adding serious functionality to the platform.

The book follows a consistent theme throughout. The desired functionality is briefly (very briefly) described, then the reader is given the following sections: Getting Ready, How to Do It, How it Works, and (sometimes) There's More. Here's how these work:

Getting Ready — outlines installation prerequisites, the things you'll need to gather.
How to Do It — step by step instructions on how to implement your changes.
How It Works — after you've configured things in the previous step, this step explains why things work.
There's More — an optional section where further reading can be found, or maybe extras like test procedures.

The book includes more than just the 10 specified features from the Preface, though. The authors cover development best practices, documentation, a section on testing, and many other goodies that are not directly in the path of implementing those 10 requirements. I especially liked the parts about performance improvements, a consideration that's sometimes lacking in development books.

The book definately reads differently than most tech instructional books-- it's more like an expert's working notes than it is a typical dev book. It took me a few chapters to catch on, but after I figured out how to best use this format I can see how this would be very useful for random-access reference work. You don't need to do everything in sequence, just skip right to where you need to go.

If you're charged with doing Plone 3 development, I'd recommend this book. There's a lot of expert advice here, and it covers a wide range of development activities. I would imagine almost every developer will learn some things from this book, and many developers will learn a great deal. For producing Plone 3 products, it will provide a quick answer for many commonly encountered questions.

The book can be found here:

Submission + - Book Review for "CodeIgniter 1.7 Professional Deve (

RickJWagner writes: CodeIgniter is a multi-purpose, open source PHP web application framework that can dramatically reduce the amount of coding required in developing a full-featured web site. This book promises to introduce the reader to the most productive APIs and demonstrate their usage with minimal code snippets. In that regard, I think the book lives up to it's promise.

The first chapter covers CodeIgniter's MVC framework, which provides a way for a programmer to logically partition code so it's easier to maintain. For those of us who aren't accomplished PHP coders, this chapter also contains a PHP style guide, which I thought was a nice feature. By the way, the code snippets throughout the book are clean and easy to read-- the author must have followed his own advice on code style.

The second chapter is an introduction to some of the more productive libraries you'll find in CodeIgniter. Here you'll find some excellent advice on how to take timing metrics in your application, how to secure it, and how to accomplish routine activities like retreiving data from the user's request. Other 'web topics' are addressed here, like how to manipulate the session, how to manage emails and file uploads, and much more.

Chapter 3 handles form inputs and databases. As is common throughout the book, the reader is given minimal technical overview. What you'll find instead is a very brief explanation of what's about to be covered, then a few very readable source lines that demonstrate use of CodeIgniter in action. If this book were your only resource, I'm sure there would be times where you didn't find enough material to get everything done you wanted to do. But if you have a web browser (and Google) handy, a book of this type can be an effective index to help you find the parts of a framework you want to leverage.

The next few chapters cover user authentication and application security. I found these to be a little spotty-- heavy in some places, light in others. Still, the material was useful and not difficult to read or understand.

A nice chapter on tips for building a large-scale application was next. I found this one interesting-- many of the ideas were well-known, but a few had not occurred to me before. I liked reading it. Next up was a chapter on Web Services. I didn't take the time to test the provided code for this chapter, but I would like to sometime. If it works as I hope it will, I may have a new way to stand-up test web services!

The final 2 chapters are on extending CodeIgniter (it's great that the library authors institutionalized this!) and donating code back to the community.

So who is this book for? The book itself tells you it's for expert PHP coders, but I don't believe that's exactly right. Given the easy-to-read nature of the book and the light treatment given to some of the meatier topics, I'd say this book is about right for a novice-to-intermediate level PHP coder. I haven't done a lot in PHP, yet I found the code reading very easy.

If I had a wish for the book, I'd wish for a little more depth in the harder topics and maybe some quick overviews for a few topics. (Diagrams accompanying the overviews would be nice, too. This book has few illustrations except for screen-shots.)

All things considered, I'd recommend this book to coders that are getting started with PHP and CodeIgniter. It's easy to read and will get the reader pointed in the right direction for solving many web problems.

The book (and a sample chapter) can be found here:

"Everybody is talking about the weather but nobody does anything about it." -- Mark Twain