Posted by Jeroen Borgers in the late evening: November 18th, 2009
Last time I blogged about performance tuning based on evidence, the tuning cycle and some best practices. This time I’ll blog about the last step of the seven steps: sharing the responsibility for the whole system chain.
When an incident happens in production, this usually means stress. A performance problem in production often leads to finger pointing. (more…)
Posted by Erik Rozendaal in the early morning: November 18th, 2009
Besides organizing a Scala workshop at the J-Fall meeting we also presented five technical posters to serve as discussion points for anyone interested (or just walking by). Unlike traditional meeting sessions we could interact directly, somewhat similar to open space sessions.
(more…)
Posted by Vincent Partington mid-afternoon: November 13th, 2009
At XebiaLabs we know a thing or two about the automated deployment of Java EE applications 
. One thing that strikes me as odd is the fact that the people you would expect to know most about application deployment, the application server vendors, don’t seem to understand the problem at all.
On one of our previous blogs, you can read up on what we see as the full scope of a Java EE application deployment. The short version is this:
- It’s more than just deploying an EAR file or a WAR file. For starters, it can involve more than one of these.
- Most applications also need other kinds of artifacts to be deployed, such as static content for the webserver or static configuration files to be read by the Java code on startup.
- You’ll also need to configure Java EE resources such as data sources, JMS providers, etc.
- In most cases you need to configure the middleware itself too. Think about creating and configuring application server clusters, or setting up Apache virtual host configurations.
- All this needs to happen in the right order to minimize (or prevent) downtime of the application during deployment and improve speed of the deployment.
So what do the application server vendors make of this?
(more…)
Posted by Wilfred Springer at around evening time: November 11th, 2009
It was actually quite a while ago since I looked at Spring ME, but then Davide Cerbo mentioned that he had presented Spring ME on Android at a Rome Spring meeting. Way cool! It triggered me thinking about the things that – according to the document I once wrote about it – were not implemented yet.
Posted by Marco Mulder mid-afternoon: November 11th, 2009
One of the biggest strengths of Scrum is that it is a framework instead of a detailed methodology such as RUP. In Scrum, concepts are described that make essential aspects of projects fall into place in a very powerful way. One does not need a Process Engineer to tailor Scrum before it can be applied successfully. However, because there are many things that Scrum does not describe in detail, there is plenty of room left to mess things up 
In this blog, I discuss on how to facilitate the estimation of Product Backlog items so that the Product Owner can do release planning.
(more…)
Posted by Andrew Phillips mid-morning: November 9th, 2009
In the careers of most Spring/Hibernate developers I know, there sooner or later comes a point of no escape…they have to write a Hibernate user type. The first one is usually of the copy’n'paste variety, and by and large works perfectly well.
But when things are no longer going quite as expected – Hibernate is ignoring changes to items managed by the user type, for instance – it often becomes apparent that one doesn’t sufficiently understand how these user type thingies are supposed to work. At least, that’s what happened to me.
In this post, we’ll be dissecting the Hibernate UserType interface, explaining the relationships between the various methods, and developing a set of base user types that capture common use cases. (more…)
Posted by Iwein Fuld mid-afternoon: November 3rd, 2009
Concurrent testing is hard, but not as hard as you think. If you use the right tricks it can be done. This blog shows you one particular trick that uses a latch and a mock to ensure a test scenario is completed before running the verifications.
While working on Spring Integration in Action, I experimented with a neat solution for concurrent tests. When I showed it to some colleagues I was pleasantly surprised by the reaction that I got. Judge for yourself if it’s worth the blog.
The main idea is to use a latch and let your mock count it down. It sounds trivial (and to be honest it is).
(more…)
Posted by Jeroen Borgers in the late evening: November 2nd, 2009
Last time I blogged about the relevance of monitoring and diagnostics in production to solve incidents quickly and prevent future problems. This time I’ll talk about tuning based on evidence.
If an application turns out to be too slow, tuning can provide a solution. Tuning can take place on multiple levels. Adding hardware can be a cheap solution. However, when you add hardware at a place where the bottleneck is not located, this has little use.
(more…)