Hi.
I am very interested in having a concrete list of technical reasons
developers prefer Cayene. I have worked with Cayene only so I have no
real insight into the issues that caused the developers to revolt. A
table perhaps that all could share. Perhaps one that developers where
you work might care to add an entry or two (not too time consuming to
contribute) You see my resume says Cayene but I apply to places that
use Hibernate. So to say to them "here are the Hibernate issues, not
from me but practioners" would go far I think. They still might
respond "we selected hibernate so adapt" or they just might slowly
transition over.
Thank you,
Theresa Stewart
On Sep 6, 2010, at 9:21 AM, Michael Gentry <[email protected]>
wrote:
Hi Joe,
I don't have a Cayenne vs Hibernate comparison, but I can tell you a
little about how things have shifted a bit where I work.
Hibernate was the official ORM for non-WebObjects projects, which use
EOF, of course. (We have a lot of legacy WO projects to maintain.)
The WO people were much more interested in Cayenne since it mirrored
EOF quite a bit. The non-WO people were much more interested in
Hibernate because it was the "hip" ORM. Management chose Hibernate
because it was the de-facto standard ORM in the Java community
(everyone was using it) and they based part of that decision on the
job search issue (who has Hibernate on their resume vs Cayenne).
About 4-5 months ago, though, there was a small revolt by the
developers, led in large part by the non-WO developers -- that is, the
ones who wanted to use Hibernate because it was the standard ORM in
the Java community (and had the buzz/mindshare behind it). Many of
them were tired with problems they kept encountering with Hibernate
(especially the lazy initialization exception). After many
meetings/debates/etc, Cayenne got approved for general use and now
several projects (including a large one that has a huge
Hibernate-based backend already) are using Cayenne. The project I'm
working on now consists of three Tapestry 5-based web applications
with a common shared Cayenne-based core and that mirrors many of our
other projects (we tend to separate out admin-restricted interfaces
from user-exposed interfaces).
From a personal perspective, the previous project I worked on is based
on Tapestry 5 and Hibernate. (The developers voted at the beginning
of the project between Hibernate and Cayenne and Cayenne lost by one
vote.) There were numerous places in the application that we had to
do things "backwards" due to Hibernate and the lazy initialization
exception. For example, much of the application follows a
wizard-based entry system and the user chooses their state on one page
and then their county on another page. We couldn't call
state.getCounties() on the county page because the state's Hibernate
session was closed and would throw an exception. Things like that are
natural in Cayenne and Just Work. What we had to do was construct a
new query for the counties based upon the state. I joked around that
with Hibernate, we might as well not have relationships because we
don't use them because we can't follow them.
mrg
On Sun, Sep 5, 2010 at 2:21 PM, Joe Baldwin
<[email protected]> wrote:
Hi,
I am again responsible for making a cogent Cayenne vs Hibernate
Comparison. Before I "reinvent the wheel" so-to speak with a new
evaluation, I would like to find out if anyone has done a recent
and fair comparison/evaluation (and has published it).
When I initially performed my evaluation of the two, it seemed like
a very easy decision. While Hibernate had been widely adopted (and
was on a number of job listings), it seemed like the core decision
was made mostly because "everyone else was using it" (which I
thought was a bit thin).
I base my decision on the fact that Cayenne (at the time) supported
enough of the core ORM features that I needed, in addition to being
very similar conceptually to NeXT EOF (which was the first stable
Enterprise-ready ORM implementations). Cayenne seems to support a
more "agile" development model, while being as (or more) mature
than EOF. (In my opinion. :) )
It seem like there is an explosion of standards, which appear to be
driven by "camps" of opinions on the best practices for
accomplishing abstraction of persistence supporting both native
apps and highly distributed SOA's.
My vote is obviously for Cayenne, but I would definitely like to
update my understanding of the comparison.
Thanks,
Joe
