Developerworks is featuring the best article
I have ever read on the subject of Java performance. The authors dispose of the
canard that temporary object creation is expensive in Java, by explaining how
generational garbage collection works in the Sun JVM (this is a bit more detailed
explanation than the typical one, by the way). Well, I already knew this; Hibernate
rejected the notion of object pooling right from the start (unfortunately, the
EJB spec has not yet caught up).
Currently I have noticed that Naked Objects gets more and more blog-time.
And every time I wondered why (many?) people found it so intriguing -
and I often thought about making a blog about the good and bad about Naked Objects;
but I've never found the time.
I just released 2.1.2 . This is a maintenence release, meaning no especially exciting new features (the interesting work is all going on in the 2.2 branch). However there are some small changes that might make a big performance difference in certain specific cases, especially if you are using a second-level cache. I'm hoping that this release brings the 2.1 branch to the same level of maturity that we were able to achieve with 2.0.3.
I just finished a consulting job at a large retailer where we managed to increase the performance of a Hibernate application by perhaps two orders of magnitude with just some fairly simple changes. It really drove home to me how almost all performance problems I've ever seen can be solved by either or both of:
One of the reasons we use relational database technology is that existing RDBMS implementations provide extremely mature, scalable and robust concurrency control. This means much more than simple read/write locks. For example, databases that use locking are built to scale efficiently when a particular transaction obtains /many/ locks - this is called /lock escalation/. On the other hand, some databases (for example, Oracle and PostgreSQL) don't use locks at all - instead, they use the multiversion concurrency model. This sophisticated approach to concurrency is designed to achieve higher scalability than is possible using traditional locking models. Databases even let you specify the required level of transaction isolation, allowing you to trade isolation for scalability.
There were quite a few comments in response to my post about Criteria queries. I finally get around to responding. A number of people suggest a more tree-oriented approach, where we treat all logical operators as binary. For example, anonymous suggests the following: