Customer Reviews

Agile Java Development with Spring, Hibernate and Eclipse

5 star:		(9)
4 star:		(15)
3 star:		(6)
2 star:		(9)
1 star:		(6)

 

 

I bought Agile Java Development with Spring, Hibernate and Eclipse just because I buy a lot of books. The idea behind it looked very nice. Spring, Hibernate and Eclipse form a very good development platform. I already knew this much. I had even used all of them, but I can always learn more.

The book is, according to the author, based on the development of an example project which is also a very good idea.

The problems begin when transforming those ideas into the reality of a book.

For starters, the book is poorly written/edited. The author gets ahead of himself a lot. "We'll see more on this later" - he says, and later can be a good eight to ten pages. Section and subsection titles seem to have random importance and chapters are strangely structured, as if you were listening to a presentation where the speaker hadn't bothered to order things.

"Now, I will explain this", "Now, I'll do that"... "Oh, and by the way, I hadn't said anything about this other thing. I'll mention it now even if it doesn't fit here".

The next *big* problem is the code. The book relies a lot on the code, but instead of inserting the code within context, it just comments a couple of selected lines and you're expected to follow along with the downloaded code on your computer.
This is a big turn off for me. I don't usually read books by the computer.

Then there's that thing about the author. Don't get me wrong. This is the first I've read from Mr. Hemrajani but I'm sure he's a great developer. But a good book, more so a book like this, should be about Agile Development, about Java, about Spring, Hibernate and Eclipse.
Sure, I do like an author who can express and convey his own views and opinions, his experience and know-how. But reading this, there's a feeling that this is all only about how _he_ does this or that. There're too many mentions on "this particular piece I wrote years ago about...", too many self-references and details which ultimately do not seem to be all that relevant.


To sum it up: The idea is very good, and you may still get good bits from the book. But it *needs* a very thorough re-write and editing work.

Like a lot of other reviewers on Amazon - I was disappointed by this book. Granted -- its going to be difficult to cover multiple major topics like Spring, Hibernate, and Eclipse all in a single book...but this one tries.

I enjoyed Anil's stories about his real-world experience with Java technologies. But the level of detail in the book ranges wildly from 50,000 feet to 10 feet. At times, he is flying over concepts so quickly - its hard to realize they are important (ex: JUnit), and at other times, he gives step-by-step mouse clicks through an eclipse wizard as if the reader is a Freshman in High School.
I'm a software developer - and have been using eclipse for 4 years - and I never needed a manual to figure out how to use eclipse. I did however, need to read online docs and books in order to use the Spring Framework, Hibernate, and other topics such as Ant and JUnit effectively.

This book balances concepts differently than I expected. For example, the book spends 53 pages on Eclipse (chapter 8), but only 16 pages to Spring core (chapter 6), 34 pages to Spring MVC (chapter 7), and 32 pages to Hibernate.

He also categorizes Logging (log4j and JDK logging), and eclipse debugging (yes, even more pages about eclipse!) as "Advanced Features"

Personally - I find his distribution of coverage completely inverse to what a reader would expect. There's just too much time spent on no-brainer topics, and not enough time spent on real-world topics (hibernate, spring, junit). Counting pages isn't exactly a scientific way to review a book -- but it gives you a good idea of what the author was choosing to emphasize.

Agile Java Development would seem to be the natural successor to 2004's "J2EE Development without EJB". That volume's author, Rod Johnson, the creator of Spring, even contributes a one page forward to Anil Hemrajani's 2006 effort. "Agile Java Development" however is at best a "lite" version of it's predecessor. 300 pages just cannot do the topics justice; Mr Johnson' book was 500 pages and the current volume could have benefited from some more meat. There are very few source code examples in the book and while this is arguably better than page after page of code, it however crippled the book's usefulness when read while travelling and away from an internet connection.

Of the three technologies covered, Spring, Hibernate & Eclipse, I have the least experience with Hibernate, and even after finishing this volume, I feel like I know almost nothing about it. With regard to Eclipse, this book's coverage is significantly deficient when compared to just the 60-page first chapter of the second edition of "Eclipse: Building Commercial-Quality Plug-ins." Lest that comparison seem unfair, in a volume as slim as "Agile Java Development", the author more than once commits the cardinal sin of repetition. Sure I learned about a couple of useful keystroke shortcut combinations for Eclipse, but I certainly didn't need to read about them twice in a 300-page volume.

This volume at best provides the barest of overviews of the covered technologies and processes, and is best suited for junior developers and managers.

If you are unfamiliar with any of the technologies listed, then this is a good book to help you get up to speed. Nowadays, it's hard to stay current on Java and the magnitude of open source frameworks available. Any of the technologies are too big to cover in one book. Anil gives you a short concise introduction on each that allows you to start your journey using these technologies. It's enough so that you know where to dig to find more information. Along the way, he gives lessons about agile development and how these technologies help support that. I've been loaning this book out to fellow team members and it's been great to get everyone up to speed.

The writing style is straightforward and honest. Anil gives his candid opinions along the way on development. I found this refreshing. You might not like everything he says and that's OK. They're more like recommendations and advice. I appreciated that they were included.

If you approach this book as a way to get up to speed on Eclipse, Spring, and Hibernate, then you will not be disappointed. It's much too short to give you all the details, but like is stated in the introduction: it's a roadmap.

I can not believe how anybody who has read this book would honestly give it a 5 star. I read the whole book, waiting for that moment that I could say: Oh, that's what the author meant by repeatedly saying: "more to come later" or "we'll see this in later chapter" etc. That moment never arrived. This book looks like a hurried and lousy compilation of 5 day presentations on each subject that this books claims to cover, without proper editing and attention to detail.
I read the book riding the metro in Washington DC and I can honestly say that I would rather see DC tourists block the left side of the escalators in the metro stations on a busy rush hour day than read or refer to this book again

I've read a lot of books, of which many are conceptual, academic or technical or just hands-on cookbooks. The problem with "Agile Java Development with..." is that it fits none of the above categories. It feels like an attempt to a hands-on experience kind of book (there's a lot of "Let's get to the action!" phrases and then fails to deliver and just discusses another subject), but Raj delivers mostly academic unstructured comments on every aspect of the subject matter. Don't get me wrong, the book has all the information you need to get started and learn tons more from references Raj gives you, but the problem is: there's no structure to his story telling. For example, In every chapter when he's discussing a subject, he tends to reference/compare to other subjects that haven't been covered yet; he even adds a "(as covered in Chapter X)". Seriously, you actually have to have read the book in order to understand many of the comparisons and references he makes.

Also, he expects you to know a lot already, like packages that can be integrated with Spring, like Struts or Websphere. He expects you to a). know each every reference to such third-party software, or b). that you will look it up instantly or c). that you just don't care for the moment (and he makes a lot of these references). He also expects you to know what for example an Application Server is and that JBoss is one. Or what an EJB is and why you would need an Application Server for that. In my opinion, these are pretty fundamental subjects that you need to know in order to understand why Spring works and is popular. He could've covered those things shortly in a single paragraph or page, or even a sidebar.

Instead, he uses sidebars to express his personal opinion on something, often saying he disagrees with something and why. He even mentions those sidebars are subjective and you can ignore them if you want, but it's still annoying if you run into one.

Something Raj does what I find very annoying is that literally every 5 sentences on the average he adds a "(as we'll discuss in the next Chapter)", or Chapter X. I don't mean the reference itself, but the sheer number of times that he ads his sub comments like that. Even if you can understand some of his text, it's incredibly annoying to be interrupted all the time by his '(..)' all the time.

Aside from the annoyance and lack of proper structure, I agree with the other persons view that Raj depends on the external provided code too much. He often references code from the zip file you have to get yourself (which isn't necessarily a problem), but in his examples he picks out a code fragment utterly out of context and forces you to look and understand the entire code file/context in order to grasp the tiny fragment Raj picked for his example.

another thing that bugged me about his code is how he expects to magically understand his explanation, which in my opinion isn't nearly enough many of the times. Sometimes he'll show you some XML for ANT for example and says, "As you can see", or "Obviously, the bean depends on this or that", but he doesn't explain (or has explained) why something like that would be obvious (you just need to know it apparently). what I mean is, implicitly Raj expects you to read the Ant reference in between his chapters, just as he implicitly expects you to follow all the references of all other subjects before you read on in his own book. Very frustrating and makes you feel you're getting nowhere.

One last thing I'd like to mention about his dependency on external code. He often refers to the code which is ok, but he only provided the code to the final product, which you can only understand and run/compile after you read ALL chapters in principle. There's just no way you can go ahead and fiddle with some Hibernate code or XML file to see how it changes the program, because you don't have the faintest idea yet how to run/install/use Spring, Ant or JUnit. I wished he had made the code available for each step, compileable and runnable so we can experiment as he provides the context in his chapter about the subject (ie. Hibernate). I would even have been grateful if he provided an appendix with all installation steps so I can setup the entire program just to figure out how it worked. I'm at chapter 6 now and I still haven't run a single piece of code, because I just don't know how without reading tons of external references.

Granted, in his introduction he mentioned he wrote this book in such a way you could read a single chapter, or a subject that covered several chapters at once, or just as entire book. Unfortunately he wrote it single-chapterly way too much, hence the army of "(covered in Chapter X)" and external references.

He doesn't mention in his introduction what's in the source files. He does mention structure and packages/classes as he goes through the chapters, but not why there are two versions of his demonstration program. Apparently, somewhere in Chapter 8-10 he makes a second version with improvements. Nagging? Maybe, but I feel left in the dark when reading this book.

Conclusion:
This books has everything you need information wise, but getting it is a slightly different story. I feel like I need to read the book twice to understand everything he says, because of all the references to uncovered material. Reading this book feels like playing an FPS with serious lag and as the other reviewer said, Raj seriously needs an editor to refactor his book.

This book was a huge disappointment and is more of a reference to online documentation sources than any sort of content. Time after time the auther just lists links to online documentation, FAQ's, etc instead of addressing it in the text. I bought the book b/c I found the online docs to be insufficient, I really don't need a book to point me where to go. If you are not able to use Google to find online info on Hibernate, Spring and eclipse, maybe this book would be of value. Otherwise, skip it.

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.

The book fails to impress despite the rather impressive title. If you haven't bought this book yet, do yourself a favor and go to the home pages of Spring, Hibernate and Eclipse respectively, and just read the introductions. This book provides no more useful information than the individual websites' introductory pages. Moreover, the websites show better examples instead of asking you to refer to a zip file after every 10 lines or so.

This book's title doesn't match the actual content within. I read this book in about a week and I wasn't very impressed. You are better off going through the tutorials that are available online and learning from your mistakes. I promptly sold this book after reading it. I never had that "this book will be useful for a while" feeling.