The Java(tm) Specialists' Newsletter

Java's serialization mechanism is optimized for immutable
objects. Writing objects without resetting the stream
causes a memory leak. Writing a changed object twice
results in only the first sta...

In this newsletter we examine what happens when a
ReadWriteLock is swamped with too many reader or writer
threads. If we are not careful, we can cause starvation of
the minority in some versions...

Prior to Java 1.4, ThreadLocals caused thread contention,
rendering them useless for performant code. In the new
design, each thread contains its own ThreadLocalMap, thus
improving throughput. H...

Joshua Bloch has at long last published an updated version
of Effective Java. An essential guide for professional
Java programmers who are interested in producing high
quality code, this book is...

In this article, we look at exception handling in Java. We
start with the history of exceptions, looking back at the
precursor of Java, a language called Oak. We see reasons
why Thread.stop() sh...

The developers of the Java language tried their best to
stop us from constructing our own enum instances. However,
for testing purposes, it can be useful to temporarily add
new enum instances to...

Imagine a very stubborn father insisting that his equally
stubborn child eat its spinach before going to sleep. In
real life one of the "threads" eventually will give up, but
in Java, the thread...

We all expect faster hardware to make our code execute
faster and better. In this newsletter we examine why this
is not always true. Sometimes the code breaks on faster
servers or executes slowe...

In this newsletter, we reveal some of the polymorphism
mysteries in the JDK. The HotSpot Server Compiler can
distinguish between mono-morphism, bi-morphism and
poly-morphism. The bi-morphism is ...

Late binding is supposed to be a bottleneck in
applications - this was one of the criticisms of
early Java. The HotSpot Compiler is however rather good at
inlining methods that are being called ...