Finding useful information about open source software projects can be tedious – especially when trying to find facts that your customers understand.
ohloh.net provides excellent, comparable meta information for open source projects and should be on every decision-makers favorites list.

Why this software and not another?

I often find the need to justify the use of a specific open source software. Why is is better than another, competing open source software? How much better is the community support? How many supporters does it have? How active is the project and how much effort was spend on it’s development? How about metrics for the code, and how do you compare software in general?
Those are about the most important questions i have to answer.

Obtaining information about open source projects

Most of the above questions are not so easy to answer. When it comes to usage statistics and community support, one might be lucky to find the number of committers and the number of downloads, the number of mailings on the project mailing list or a more or less qualified article in a software mag. All of this information can usually be googled up or located on the projects site.
Unfortunately, many of the above facts are only loosely related to a project’s code quality.
To compare code, i am usually downloading the software and run QA tools on it, such as findbugs and JAVANCSS. But code metrics are something that developers understand, but customers usually do not. They want to know how many happy users a software has and whether or not community support might last long enough to justify investments.

Best practice: ohloh.net

ohloh.net: Money spend on developing hibernate, calculation based on the COCOMO model.

Looking for such Information, i found ohloh.net’s project information site for hibernate.
To my surprise, it had most of the things i was looking for. Code metrics. Information on who is involved in the projects development. Usage statistics. Ratings. Reviews. Journal links. An executive summary and statements on the code quality and project state, based on facts.

To sum it up i wish that more projects would publish information to the same extend ohloh does. ohloh.net’s project meta-information should be an example and a blue print for other big open source sites. Sourceforge, for example, is already publishing some useful project information (see for example findbugs sf project page) but does not deliver the same amount and quality of information that ohloh has to offer.


...
Caused by: javax.persistence.RollbackException: Error while commiting the transaction
at org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:71)
at org.springframework.orm.jpa.JpaTransactionManager.doCommit(
JpaTransactionManager.java:438)
... 55 more
Caused by: java.lang.ClassCastException: java.util.HashSet
cannot be cast to org.hibernate.collection.PersistentCollection
at org.hibernate.event.def.FlushVisitor.processCollection(FlushVisitor.java:34)
...


Das tritt dann auf, wenn man wohlmeinend die Exposition der internen Repräsentation vermeiden wollte und beispielsweise so etwas hier auf einer persistenten Collection macht:

 @Entity
 public  class foo {
       private Set<AnotherEntity> _relatedEntites = new HashSet<AnotherEntity>();

     @OneToMany(cascade = {CascadeType.ALL }, fetch = FetchType.LAZY)
     @Column(name = "RELATED_ENTITIES")
      public Set<AnotherEntity> getRelatedEntities() {
            return new HashSet<AnotherEntity>(_relatedEntites)
     }
 }

Das: new HashSet(…) ist ein Fehler, da es aus der vorher erzeugten persistenten Collection wieder eine HashMap macht, die nicht persistiertbar ist.

Um die Manipulierbarkeit der Klasse zu vermeiden kann man stattdessen die @Immutable-Annotation verwenden:

 @Entity
 public  class foo {
       private Set<AnotherEntity> _relatedEntites = new HashSet<AnotherEntity>();

     @OneToMany(cascade = {CascadeType.ALL }, fetch = FetchType.LAZY)
     @Column(name = "RELATED_ENTITIES")
     @Immutable
      public Set<AnotherEntity> getRelatedEntities() {
            return _relatedEntites;
     }
 }

Dann klappt’s auch mit Hibernate.