After the issues we run into with immutable structures, I decided that I still wanted to maintain the same guarantees that immutable data structures gave us, but that still maintain the speed of mutable structures.
Web session clustering provides freedom of load balancing user sessions to any app server without losing intermediate user session data. Why? Because underneath it takes advantage of in-memory distributed caching technology which ensures that user sessions are available in memory regardless of which server is hit.
Every week here and in our newsletter, we feature a new developer/blogger from the DZone community to catch up and find out what he or she is working on now and what's coming next. This week we're talking to Nikita Salnikov-Tarnovski, founder and Master Developer of Plumbr, a memory leak detection tool.
These simple Linux tuning tips will increase MySQL performance and make it more stable (and avoid swapping).
If you are facing a Java system performance issue in production, and JProfiler is not the right tool for it, probably JMX monitoring using the VisualVM will do the work for you.
The first blog in this mini-series looked at creating a very leaky sample application, so that we can investigate techniques for solving heap based problems on server applications.
The shared storage concept is great for helping to keep storage infrastructure and management costs relatively low but creates cross silo finger pointing when there are performance issues. In this blog post we will explore a real world example of how to avoid finger pointing and get right down to figuring out how to fix the problem.
The first blog in this mini-series looked at creating a very leaky sample application, so that we can investigate techniques for solving heap based problems on server applications. It demonstrates the big problem with the Producer-Consumer pattern.
Why is the performance of an immutable list over 16 times slower than a standard list? I took a peek at what it was actually doing, and it made a lot of sense.
So I wanted to know how long it would take to fully clone a 10-million items dictionary. The answer: 0.6 seconds. Doing the same with immutable dictionary? 16 seconds.
In this article we will cover the subject of fronting a Tomcat application server with Apache.
What does one do when Hibernate is “finished” and feature complete and one needs new challenges? Right. One creates a new JVM language called Ceylon. Here’s my personal Top 10 List of Ceylon Language Features I Wish We Had In Java:
Recently I’ve been doing some benchmarking and came upon a very surprising behavior from a number of different Intel i7 CPUs (it manifests on Sandy Bridge and Haswell desktop-class CPUs as well as Sandy Bridge-EP Xeon CPUs).
In many occasions the stacktrace does contain all the information required to fix the problem. In other situations it only surfaces the symptoms without a clue to what could be causing the underlying the problem. Let me illustrate this with three examples triggering the following infamous error messages:
This post is following up the experiment we ran exactly a year ago comparing the performance of different GC algorithms in real-life settings. We took the same experiment, expanded the tests to contain the G1 garbage collector and ran the tests on different platform.
When we call fsync, we have to do that with a file handle. But as it turned out, that isn’t quite as useful as you might have thought it would be.
I found this little problem the other day: there’s this server that runs for a while and then falls over.
While I fully agree that making decisions based on micro benchmarks is a silly way to go about doing so, the reality is that many people do just that. So one of the things that I’m focusing on is exactly those things. It helps that we currently see a lot of places to improve in those micro benchmarks.
If our Grails application renders XML or JSON output we can set configuration properties to enable pretty printing
If you look at the history of computers, the modern smartphone has all the same characteristics that computers have had since at least the 50s and 60s. If you think about the big revolutions in computing, things become very obvious.
Got a chance to play with Goliath for a bit. You don’t need to do much work to mount Grape behind it. Grape figures out content-negotiation and formatting for you, so just stream the response through Goliath.
Recently, I had a chance to review the book "Instant Effective Caching with Ehcache" by Daniel Wind. If you have ever worked with EhCache, many recipes would look very familiar to you. But for a newbie or even intermediate developer, it might be very interesting to see
Recently, I helped a client that was having issues with deployments causing locking in their production databases. As I wasn’t very familiar with Liquibase, I took this opportunity to learn more about it and it seems like a very valuable tool. Essentially, it does the following:
Groovy is of course great for writing DSLs. We can write our own Script class to implement a DSL that can be used when we evaluate a script. We can set the custom Script class via CompilerConfiguration.
The term “leaky abstractions” has been around for a while. Coining it is most often attributed to Joel Spolsky, who wrote this often-cited article about it. I’ve now stumbled upon another interpretation of a leaky abstraction, measured by the depth of a stack trace: