Showing posts of category: Java

Garbage Collection can have a major impact on application performance. The more distributed an application becomes the trickier it is to identify the impact on the overall transaction response times. If you are dealing with heterogeneous systems it is even harder because the set of tools out there usually don’t cross runtime and technology boundaries.
Identifying [...]

Whenever the Garbage Collector kicks in to free up memory - the runtime puts all currently executing threads on hold in order to do the cleanup. The GC runs when the application tries to allocate new objects and not enough free memory is available in the 1st Generation Heap. Putting the current execution on hold means [...]

Synchronization is a necessary mechanism to control access to shared resources. Especially in multi user environments, e.g.: Web Applications where the same code can be executed by multiple threads at a time – it is essential to make sure that data access is protected. Whether it is for Java or .NET – the same performance [...]

In the last posts I already covered the session cache as well as the query cache. In this post I will focus on the second-level cache. The Hibernate Documentation provides a good entry point reading on the second-level cache.
The key characteristic of the second-level cache is that is is used across sessions, which also differentiates [...]

TechTarget is hosting this years Java Symposium in Las Vegas. dynaTrace is exhibiting and we are given the opportunity to talk about the challenges of Software Architecture and how the lack of visibility into the performance aspect of your architecture will result in huge efforts when those problems manifest itself in a production environment.
If you happen [...]

In the last post I wrote on caching in Hibernate in general as well as on the behavior of the session cache. In this post we will have a closer look at the QueryCache. I will not explain the query cache in details as there are very good articles like Hibernate: Truly Understanding the Second-Level [...]

Hibernate offers caching functionality which is designed to reduces the amount of necessary database access.  This is a very powerful feature if used correctly. However I have seen a lot of cases and also talked to many people on caching in Hibernate, where caching is either not understood correctly or even used the wrong way.
There [...]

Last year december I gave a talkat DeVoxx on Performance Antipatterns.  Some people asked me to make avaiable the contents of my talk. Instead of publishing the slides I decided to write a couple of blog entries on the contents of my talk.
In the first entry I will start with some general perceptions on people [...]

In the first post for this year, I will discuss an interesting question: “How to find invisible performance problems”.
What makes up an invisible performance problem? An invisible performance problem is an inherent problem in your code, which does not yet manifest in externally observable problems like slow response times, high CPU load or the like. [...]

Exceptions are a great way to communicate error state back to the caller. The exception class basically defines the type of error, e.g.: AccessDenied that happened. The detailed message then explains the exact reason for the problem, e.g.: “Your user has no rights to access file xyz”.
Documentation of frameworks usually lists all types of exceptions that [...]