Customer Reviews

Modular Java: Creating Flexible Applications with Osgi and Spring (Pragmatic Programmers)

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

 

 

A short book that just touches the very surface of OSGi. Everything of importance is magically hidden by tools the author uses like PAX. The author does a good job at getting the reader from zero knowledge to a superficial "up and running". This is less than I expected and I learned very little (after only reading the OSGi specifications, which are free). I would not recommend this book to anyone but a beginner that has never heard of OSGi.

Pros:
- OSGi 101

Cons:
- No popular IDE coverage
- Solely reliant on PAX (which isn't that good)
- No real depth into OSGi

The title of the book leads you to believe that this is a book about OSGi. It isn't. It is a book about OSGi as seen in a Maven-centric universe with some Spring thrown in for good measure.

If you are going to use this book as a guide to how you approach the OSGi universe and you are not already a Maven user or a Spring user, you need at least a couple of books more and a lot of time to get you sorted. (You need at least a Maven book and possibly a Spring book if you are not already familiar with these technologies). If you are not already an experienced Maven user I suggest you stay away from this book. You are going to burn a lot of time learning Maven and figuring out all the OSGi annoyances the book doesn't cover.

The useful parts of the book that give you an introduction to OSGi are readable and probably and a good intro. But nothing more. The worthwhile parts of this book is a one-afternoon read.

When learning OSGi I found the specification documents of OSGi itself to be surprisingly well-written.

For the blantant misrepresentation of the book in the title of the book I would be tempted to give it a 1 star rating. I, as a reader was interested in OSGi. Not the baggage of the author.

I decided to give it two stars since the parts of the book that are actually about OSGi are a quick read and do give you an intro to OSGi -- though it is a weak two stars.

It is immediately obvious none of the prior reviewers have attempted to actually USE the book. Instead they have furbished us with hollow feedback based on a quick skim of the book.

I've found an error in the published material approximately every 10 pages. In fact if you typed all the code in the book line for line NONE of it would work. There are good ideas and concepts in material, but the lessons will come at great expense to your personal time. The author inconsiderately uses you and your money as his personal Quality Assurance. Buy something else from a more thoughtful author who prides himself on the quality of his work.

P.S. - The book is maven and pax-construct heavy. Be prepared for baptismal by fire if you think your Ant background will suffice.

If you want a hands-on guide to write and build modular Java applications you won't be disappointed with this book. It's a detailed tutorial for using OSGI and Spring with the help of Maven and other tooks to create a modular, configurable application. This is not a guide to the concepts behind these frameworks. While the book gives a brief overview of of what Spring and OSGI offer, it's only at a basic level. If you enjoy learning by writing code, you'll enjoy and benefit from this book. If you are looking for a deeper understanding of Spring and OSGI, you might want to look elsewhere.

I hate to be giving this book a bad review - as I flip through it and look at the ground Mr Walls intended to cover in the guided tutorial through OSGi, I very badly would like to work through it. Unfortunately, the execution is so bad, I gave up about a 1/3 of the way through. I have the Java background I could PROBABLY get through it, but as a busy professional who really needs to maximize the amount of time I need to spend on career development tasks, I just can't justify it.

It appears as though there was literally nothing done in the way of applying a QA process to this book. Have you ever tried to carry on a conversation with a little kid and notice their tendency to jump around & omit background information that in their little kid brain they assume you already know? That is sort of what this book feels like - virtually every section of the book required some legwork to get it to work. I expect to have to do that in my real day to day job (that's part of programming), but when I'm sitting down to read a book that I paid good money for to learn a new skill, there should not be that expectation (at least, not to this level).

I'm sure Mr Walls is a very accomplished professional and I really can't say enough about the concept behind the book (easily 5 stars+), so if I had to make an educated guess I would say the sloppy execution isn't entirely his fault - my assumption would be the publisher probably rushed it out and didn't provide appropriate resources for QA/editing. Very sad (though, for the record, if they came out with a cleaned up "2nd Ed.", I would probably buy it because the concept was so good).

I wanted to read this book to find out more about 'modular Java'. I hoped to some well-written thoughts on why modularity is good and why one should use OSGi to achieve modularity. This hope was not fulfilled. Instead, I found a superficial intro into OSGi. A more accurate title would have been "A step-by-step tutorial on how to create a simple web application with OSGi and Spring".

As an example of how miserably the author fails at why and how modularity should be done, I'll take chapter 1.2. Actually, I have not much choice here as only the very first thin chapter reasons about modularity in general. In that chapter, the author argues that modularity is good because it improves changeability, testability, etc -- listing a number of advantages of modularity that are relevant at compile-time. Then he says that Java itself is bad at this because all classes of all jars end up being in the same class space at runtime. That makes no sense. Runtime-modularity is not the same as compile-time modularity, but it looks like the author consistently fails to understand this distinction.

If you are looking for a discussion on how to achieve modularity in Java and the pros and cons of different approaches, this is not the book you are looking for.

Overall I was pretty happy with this book. There are some really good topics including target configuration and in depth review of OSGi that is on par with the Eclipse OSGi book. The problem came during the Spring DM topics. The author relies heavily on PAX and Maven - both useful tools - but not required for Spring DM development. As my target needed to as lean as possible, I would have preferred a discussion on manual setup of the project. PAX and Maven are not properly discussed so they are more of a prerequisite for Spring DM in this case.

I've read and worked through the first fifty pages. I'm glad to see a book written on OSGI as I appreciate an edited, in-depth treatment of topics over a 4 page article on dzone. However, I'm running into some difficulty stemming from errors in the examples, and a reliance on tools that may simplify use for someone familiar with both them and osgi. I find use of the tools hides the details that I, as a student of osgi, need to see. I would fully expect to use them, once I've mastered osgi itself, but using them here is too much "magic" too early on. A similar point is made in the "Head First" books when they say not to use an IDE at first.

I find the style a bit wordy: "You're probably wondering how I knew what the group and artifact IDs should be. Well, it certainly would be nice if there were some sort of search engine that would find these things for us. But since nobody has developed one of those yet..." p. 59
I appreciate a friendly style, but this can be a lot to wade through.

The book could be improved with better introductions that layout the chapter in high-level terms. As it is, you have to walk the path with the author to get an idea of what the chapter is about. It really is more of a workbook that way.

OSGI has many popular implementations and this presents a problem for the author of an OSGI book: which implementation to use? Writing for all, or a substantial subset would be quite a task. In some cases Walls writes examples for three, in others just one. I don't know if some of the problems I see stem from using a different implementation, or from a generic error. The OSGI implementation used is another variable to consider when something doesn't work. A 5 star book would have tested the code across a number of implementations and flagged differences in each example.

Having said that, I'm glad the book was written and don't have suggestions for other, better books. Though obvious [...] makes for a good start.

MODULAR JAVA provides a fine guide to developing modular applications using OSGi, the framework for modularity in Java. Beginners will find excellent step-by-step coverage of the basics of creating loosely coupled modules and how they are applied to larger applications, and will learn how to build a complete web application made up of several such modules. Packed with programming tips, this is a 'must' for any serious Java collection.

Overall, I really enjoyed the book. However, with all the emphasis on Maven (of which I'm a huge fan), there seems to be way too much Maven output sprinkled throughout this book. One wonders how many pages this book would be without it. Thank you for introducing me to Pax Construct! It is a great help for anyone who wants to get up and running with OSGi quickly.