Customer Reviews

Hibernate Quickly

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

 

 

I've read both this book and Hibernate in Action, the de facto Hibernate bible. Obviously, the main selling point of Hibernate Quickly is that it's supposed to help you get started with Hibernate faster and less painfully than with other resources or texts.

Unfortunately, I think it falls short. Even just looking at the number of pages in the book, Hibernate Quickly is not much briefer than Hibernate in Action. Some of you may argue that the latter might be more dense, and thus harder to digest. But going beyond book length, I actually think Hibernate in Action is an easier read, for a number of reasons.

First, it does a better job of explaining the reasons or motivations for a feature. Some of you might think this just slows things down, but for me (and I'm sure many others), it accelerates reading and learning.

Related to that issue, Hibernate in Action just flows better. They start simply with a basic example, bring up complications or difficulties surrounding that example, then incrementally introduce the next feature or example, which addresses those problems. The segues are intuitive, concise, and very helpful.

One other issue -- with Hibernate Quickly, I often found myself wondering about some detail surrounding an ORM or Hibernate concept, which I'm sure was excluded in the interest of brevity. I found this made it slower for me to get through the book. I know I have a tendency to get distracted with theoretical details. But I think any intellectually curious developer would also be frustrated by this. You know the feeling: wondering if you shouldn't continue reading forward because your understanding is lacking, or having to consciously suppress these questions as temporarily unimportant details.

With Hibernate in Action, this rarely was the case. If there was a related detail that was excluded, the authors were usually explicit about whether this was deferred to later in the text, or if they addressed it in a previous chapter.

It's clear that the same thoughtfulness used in the design of Hibernate itself was applied to the construction of Hibernate in Action.

On the other hand (and I hate to make this criticism), I don't get that impression with this book. Covering a topic briefly or "quickly" actually takes a lot more work on the part of the author than writing a long text -- assuming it's done well. Condensing and distilling the subject matter takes a lot of time, but the result should be time savings for the reader -- that's how the author usually creates value for most non-theoretical technical books.

But netting it all out, I think I would have "Hibernated quicker" if I just went straight to Hibernate in Action.

Chapter 2 in the book is EXCELLENT. Step by step on how to install and setting up and project.

After setting up everything from chapter 2, when you start learning Hibernate, this is what you're going to get:
1. Examples in the book do not match the code
2. The codes aren't complete
3. Authors walk you all over the place. You'll get even more confused after reading this book
4. Sample codes in the book aren't clear

My opinion:
I think the authors wrote this book while doing something else. The ideas are not focus.

Hibernate has become the most popular ORM framework for Java. This book is a great way to learn what you need to know to get started. The basic prerequisites for getting the most from the book are knowledge of Java and familiarity with relational databases.

In a progressive manner, Hibernate concepts are introduced. The organization of the material in the book is quite good. At the beginning of each chapter, a bullet list of the topics is followed by an overview of the chapter. The chapter goals are listed next. The assumptions made by the authors are also listed. This allows the reader to review a topic if it is required to understand the new material. Good examples (code and xml) accompany the text as well as some graphics to illustrate certain points. The code examples are available on the book web site. Each chapter concludes with a summary section.

The book starts with question "Why Hibernate?" and does a good job explaining the problems that Hibernate is designed to solve. Since Ant and MySQL are used in the examples, a chapter is devoted to introducing them and doing the install. The next four chapters cover the basics of Hibernate, how to work with associations, how to manage collections, and how to query objects persisted with Hibernate. One nice touch is that usually a problem is demonstrated with an example so that it is easier to appreciate the solution.

Since Hibernate is used in conjunction with other tools and frameworks, the next chapters show how to use Spring to organize the DAO, how to use it with three different presentation frameworks, how to use XDoclet to avoid all that xml, and how to unit test with JUnit and DBUnit. Although throughout the text, the differences between Hibernate 2 and Hibernate 3 are highlighted, the final chapter focuses on what is new in Hibernate 3.

While the main focus of the book is on getting developers started with Hibernate, the book could also be useful for developers that may have used some features, but want to enhance their knowledge. I found that the chapters on using Hibernate with Tapestry and Spring very helpful. This book is great way to get started.

The book does not do, what the title say's I brought the book to get knowleged of Hibernate quickly, after reading the first few chapters several times, I was not able to follow. In the first few chapters alone, there are several typos, which mis leads.

Now I am going through Hibernate Made Easy by Cameron McKenzie, which is very easy to follow and makes reading interesting.

...for the book before you buy it. This book does exactly what it was intended to do. It "give(s) readers the 20% of information they need 80% of the time". If you're already a somewhat experienced user of Hibernate and learning the first 20% of it is not your goal, then this book is not for you. Sounds like many people are holding this book accountable for the egregious void of in-depth and recent Hibernate3 books and lack of good documentation on it's own site. Don't burn a good book because hibernate.org doesn't even offer a metadata reference. Although I am referring to the book less over time, I a lot of value from it. If you don't know Hibernate, and want to, buy this book.

This book has an intended purpose, and it delivers. This is by no means a comprehensive book on the subject, and it doesn't try to be. It definitely won't teach you everything you need to know about Hibernate. This book is meant to get you up to speed on Hibernate quickly, focusing on the most commonly used features. Because of its quick nature, simple concepts are often glossed over. This is also not a book necessarily intended to be read cover to cover either; towards the middle of the book specific applications of Hibernate are addressed, such as Spring integration, which may not be applicable to everyone.

This book was very valuable to me. If you're joining a project where you need to learn Hiberate quickly -- like I was, or if you just want to get your hands dirty as soon as possible, this is the book for you. Other books from the In Action series which are more comprehensive may be appropriate otherwise, and are good books to buy after reading this one.

Hibernate Quickly is a good introductory level book for developers new to Hibernate. It gives you the basic knowledge on how to get started with Hibernate by taking you through a single step-by-step example scenario that is easy to follow. This same example is used in the entire book and expanded to explore advanced features of Hibernate. The book builds on covered grounds with every introduction of a new feature so that the reader is never lost or overwhelmed.

Examples and diagrams are used throughout the book to explain Hibernate's features in more than one way. One of the difficult aspects of Hibernate to new users is mapping. This book covers every type of mapping - many-to-one, one-to-many, and many-to-many, in great detail using UML diagrams and ER diagrams. It also shows table structures that would be used to support the object model. Thus, it clarifies the bridge between the object world and the entity world in multiple ways. By starting with a base that the reader already is familiar with (the relational world), the reader is able to absorb the new concepts of Hibernate easily.

Advanced topics such as cascading, lazy-loading, caching, and transaction management are also covered in the same way - gently progressing in complexity so as to not loose the reader. However, the book lacks a good explanation on why someone would use, for example, second level caching or one transaction strategy over the other, thus leaving advanced Hibernate users wanting more practical advice and best practices.

Hibernate is most often used with other technologies. In this book, the author covers integration with Spring, WebWork, Struts, Tapestry, XDoclet, JUnit and DBUnit at a very high level. However, it does not cover integration with JBoss, which is merging quite extensively with Hibernate 3.1. A whole chapter is dedicated to new features of Hibernate 3.0, while throughout the book, the differences between version 2 and 3 are pointed out.

As the name implies, this book is for developers who want to learn Hibernate quickly. It's easy to read and follow because it gives step-by-step instructions on getting started with the basics of Hibernate with plenty of examples and diagrams. I recommend this book for first time Hibernate users.

I didn't think that Manning books could get lower than Wrox, but I was very wrong. Unless you are doing very, very simple Hibernate 2 or want to how to use XDoclet and Ant, this book is a waste of money. If I were the authors, I would return the money to the publisher. You can forget in depth examples. This book has the most trivial of examples, but it does have pages and pages of exposition on why Hibernate is so cool. The real meat could be put into a 12 page booklet.

With a publish date of 2006, this book needs to be more up to date. To make matters worse, some diagrams are incorrect, many pages are smudged and smeared and the book reads as an insult.

I remember the days when computer books were actually helpful and useful, this book brings modern tomes to yet another new low. I thought the on-line docs for Hibernate were bad, but this book is worse. Wow. Worse than Wrox AND worse than the on-line docs. Makes me want to read an old VAX manual just for the fun of it.

This is the first and VERY last Manning book I will ever buy. The few I have read before I was able to get the gist by spending 20 minutes in the bookstore reading. Peak and Heudecker should stick to creative writing as that is what thy do best in this book.

Hibernate Quickly is a brightly introduced gate to the core knowledge needed to be a Hibernate productive guru; it starts gradually with the basic features then deeply to the core concepts and architecture. The book goes on two tracks; the first is introducing the core of Hibernate, the second is showing how the integration with the outer world tools and frameworks is done.

Hibernate Quickly comes with many sample codes lightning up the usage and integration with other third party tools and libraries, it is also addressing both slices of developers the new comers and the experts which makes it a useful quick reference to Hibernate.

The easy language introduced in the book is highly attractive to get to know Hibernate and as well as being able to work with it effectively.

I'm semi-new to Hibernate. I've read through most of Hibernate in Action. The Hibernate Developer's Notebook as well. And I just wanted to get MORE familiar with Hibernate. Part of what I like out of a good computer programming book (and I've read many in my career) is when the authors walk you through the examples presented. In this book this happens in the first couple chapters. So far, so good. You think you're getting a thorough code walkthrough and so far you are. Then the authors begin refactoring code like crazy. Often in very subtle yet meaningful ways, but they never bother to explain themselves. So if you like to learn by typing the examples yourself, this book isn't for you. You'll quickly have to just plug their code in and read through their code, not allowed to code it yourself, because they just give up on presenting complete code examples and walk-throughs. I'm not sure if this is because they were trying to save paper or just didn't care, but they completely lost me at chapter 6. After I began having to go through the source downloaded from the website, I didn't care to read on. I just skimmed at that point. Because if I can't actually learn to write the code myself it goes from being a teaching tool to a reference manual. As reference manuals go it's okay, but that's not what I was buying when I purchased this book. I was buying something to teach me "Hibernate Quickly". Good idea. Poor execution.