Javaspecialists

Running on Java 24-ea+28-3562 (Preview)

Home of The JavaSpecialists' Newsletter

The JavaSpecialists' Newsletter

Celebrating 24 years of publication, enjoyed in over 155 countries by 70,000 of the world's top Java programmers and spanning over 300 specialist Java articles.

Categories:

Newsletter Archive (All)

320 Please Don't Yield A Lot 2024-11-30

Java's Thread.yield() traditionally would cause a voluntary context switch. However, with virtual threads, it causes the thread to be unmounted from its carrier thread. This can greatly increase the user and system time for ALL the carrier threads. And there is no way to turn it off. Keep an eye ... Full Article
319 ArrayBlockingQueue: Weakly Consistent Iteration... 2024-10-25

Like many other concurrent collections, the ArrayBlockingQueue sports a weakly-consistent iterator. However, the ArrayBlockingQueue always has a maximum capacity, the length of the underlying array. In this newsletter we explore what happens to pending iterators when we wrap around the circular a... Full Article
318 Getting Rid of Unused Warnings with _ 2024-05-31

We sometimes are forced by the Java language to declare variables that we never use, attracting the ire of the javac compiler. Since Java 22 we have a way to declare these as "unnamed" by using an underscore. Full Article
317 Explicit vs Diagnostic GC 2024-04-30

How many times have we seen programmers call System.gc() to "help the garbage collector"? Unfortunately far too often, with potentially terrible performance implications. In this newsletter we explore the explicit and the diagnostic GC and how we can force a GC, even if explicit GCs are disabled. Full Article
316 Code Before super() - JEP 447 2024-03-30

Java 22 preview allows us to write code before the call to super(). There are restrictions. We are not allowed to refer to "this" in any way. We thus cannot set fields before calling the superclass constructor. But what if the superclass constructor calls our methods? In this newsletter we explor... Full Article
315 Random Newsletter 2024-02-29

Classes java.util.Random and java.util.SplittableRandom didn't used to have a common ancestor, making it difficult to write methods that take either. This was finally fixed in Java 17. Let's have a look at some random Java topics together. Full Article
314 Harnessing the Power of ChatGPT 4.0 From Java 2024-01-31

A few years ago, the second oldest man in our village Chorafakia wrote a book about the history of our area. Only catch - it was in Cretan Greek. I tried to read it, but couldn't. Google Translate shrugged at the strange Cretan dialect. Then ChatGPT 4.0 came along, and we can interact with it dir... Full Article
313 Selling Our Java Skills 2023-11-27

What causes opportunities to disappear? Is it #1 the market has lost interest in what we are selling (Java is dead). Or is it #2 we have personally become irrelevant (AI writes better code)? Or could it be something else? Join me as we read about my recent dumb mistakes :-) Full Article
312 Alternate String Formatting with # 2023-10-24

The printf() method in Java borrows heavily from C, including the alternate flag #. But %s works a bit differently in Java. In this newsletter we explore this a bit more deeply. Full Article
311 Virtual Threads and Parallel Streams 2023-08-31

Virtual threads should not be used for CPU intensive tasks. The recommended approach is to continue using parallel streams for processing large data sets. However, we should be careful when invoking a parallel stream from a virtual thread. In this newsletter we propose a "safety valve" that can p... Full Article
310 Garbage Collection and P99 Latency 2023-06-29

In this guest article by Kirk Pepperdine, we learn about how P99 latency is affected by garbage collection stop-the-world events. Full Article
309 TreeSet with Custom Comparator 2023-05-31

We can construct our TreeSet with our own Comparator, however, we need to be careful that it conforms to the specification. The Comparator needs to be consistent with equals() and hashCode() of the elements, otherwise we might end up with a TreeSet with non-symmetric equals() behaviour. Full Article
308 Formatting Inlined @value in Javadocs 2023-04-30

Javadoc specifies the details of our methods using special tags such as @param and @return. After Java 5, we did not see new standard Javadoc tags for 13 years. The hope was that annotations would replace the chaos of doclets. But tags have not disappeared. In this newsletter, we examine several ... Full Article
307 AccessFlag Set for Modifiers 2023-03-30

Reflection returns the modifiers of class elements as an unqualified int bitset. Unfortunately some of the bits have a different meaning depending on their context. For example, a method can have their transient bit set, even though that does not make sense for a method. In Java 20, we now have a... Full Article
306 Measuring compact strings memory savings 2023-01-30

JEP 254 replaced the char[] in our Strings with byte[]. How much memory does this save in our Strings? In this newsletter we show how we can determine this from a heap dump file. Full Article
305 Contributing BigInteger.parallelMultiply() to O... 2022-11-30

BigInteger has clever algorithms for multiplying large numbers. Unfortunately multiply() is single-threaded. Until now. In this newsletter I describe how the new parallelMultiply() method works and also how we can all contribute to the OpenJDK. Full Article
304 ObjectInputFilter 2022-10-31

JEP 290 introduced the ObjectInputFilter, which we can use to filter objects returned from an ObjectInputStream. We examine three ways of making filters, through subclassing, with factory methods and with text patterns, and then show some interesting edge cases. Full Article
303 Null Keys and Values in Maps 2022-08-30

Some Map implementations allow null keys and values. This leads to funky behaviour when calling putIfAbsent() and the compute functions. In this newsletter we look a bit more closely at the issues at hand when allowing nulls in maps. Full Article
302 Virtual Thread Deadlocks 2022-06-30

Virtual threads can deadlock, just like platform threads. Depending on what state they are in, this might be quite challenging to analyze. In this newsletter we explore some tricks on how to find and solve them. Full Article
301 Gazillion Virtual Threads 2022-05-24

As from this month, Project Loom is part of the mainstream OpenJDK as a preview feature. Expect fantastical results, as bloggers around the world kick the tyres of this fantastic technology. In this newsletter we show how we can have over 36 billion parked virtual threads in just 4 gigabytes of m... Full Article
300 Break in Switch With Pattern Matching 2022-04-26

The enhanced switch is cool. Pattern Matching for switch is super cool (they even timed the JEP number to be exactly 420 - or was that fate?). But what happens when we use "break" inside the case statement? Let's find out. Full Article
299 Synchronizing on Value-Based Classes 2022-03-31

Locking on Integer objects has always been a bad idea. And we now have a way to find such bad code with a runtime switch DiagnoseSyncOnValueBasedClasses. Full Article
298 Finding Permitted Subclasses 2022-02-28

Sealed classes show us which subclasses they permitted. Unfortunately there is no way to do this recursively. In this newsletter we show how to navigate the sealed class hierarchy and write a ClassSpliterator that can then create a Stream of classes. Full Article
297 Measuring ForkJoinPool Parallelism 2022-01-31

Java has support for parallelism baked into the JDK. We have parallel streams, parallel sort and CompletableFutures, all using the same common ForkJoinPool. In this newsletter we explore how to measure the effectiveness of our parallelism. Full Article
296 Concurrent LinkedHashSet 2021-12-31

LinkedHashSet is a set that can also maintain order. To make this thread-safe, we can wrap it with Collections.synchronizedSet(). However, this is not a good option, because iteration would still be fast-fail. And what's the point of a thread-safe LinkedHashSet that we cannot iterate over? In thi... Full Article
295 Faster Empty Streams 2021-11-26

Streams can make our code more readable, and therefore more maintainable. However, there is some overhead in setting up the stream, a cost that might become pronounced when the stream is empty. In this newsletter we will consider an idea of the EmptyStream to reduce that cost. Full Article
294 String.format() 3x faster in Java 17 2021-10-29

One of the most convenient ways of constructing complex Strings is with String.format(). It used to be excessively slow, but in Java 17 is about 3x faster. In this newsletter we discover what the difference is and where it will help you. Also when you should use format() instead of the plain Stri... Full Article
293 Canonical Orders 2021-09-30

Should we write "public abstract static class" or "public static abstract class"? And should fields be "final static private" or "private static final"? In this newsletter we explore the canonical order of modifiers in Java. Full Article
292 StartingGun Synchronizer 2021-08-31

CountDownLatch is easy to understand, but can be hard to use, especially the await() method that throws InterruptedException. In this newsletter we show how we can create our own synchronizer based on the AbstractQueuedSynchronizer. Full Article
291 Snakes and Ladders 2021-07-20

"Would you like to play with me?" - Summer holidays are a good time to relax and whip out a board game or two. In this newsletter we explore a children's favourite - snakes and ladders, with a simulation written in Java. Full Article
290 CopyOnWriteArrayList and Collection.toArray() 2021-06-10

When is it safe for a CopyOnWriteArrayList to accept the result from a toArray() method? In the past, the only thing that mattered was that the type was Object[]. But this was changed in 2020 to only accept the array if the source was a java.util.ArrayList. Full Article
289 MergingSortedSpliterator 2021-04-03

If we have a List>, each stream with sorted elements, how can we generate a sorted Stream, taking one at a time from each stream? In this newsletter we show how to do that with the Stream API and by writing our own MergingSortedSpliterator. Full Article
288 Weakly Consistent Iteration 2021-04-01

How consistent is weakly-consistent iteration? And which collections return weakly-consistent iterators? How do we know? Join us as we explore what weakly-consistent means with concrete examples. Full Article
287 @PolymorphicSignature 2021-01-31

MethodHandles annotate the invoke() methods with @PolymorphicSignature. In this newsletter we see how this can help to avoid unnecessary object creation. Full Article
286 Discernment on the Shoulders of Giants 2020-11-30

Today is the 20th anniversary of The Java Specialists' Newsletter. Time to sit back, relax, grab a coffee and wax lyrically about what makes Java so great (you) and how we can find great mentors in life. Full Article
285 I/O Stream Memory Overhead 2020-10-30

Each PrintStream uses about 25kb of memory. This might seem reasonable if we only have System.out and System.err. But what happens if we try create millions? And why do they use so much memory? Full Article
284 java.util.PrimitiveIterator.OfInt 2020-09-30

Java 8 Streams were the first time that Java deliberately split utility classes into multiple versions to be used for Object, int, long and double. This design was also applied to Iterator, which now has specialized types for these primites in the form of the PrimitiveIterator. In this newsletter... Full Article
283 Four Billion Changes 2020-08-28

A nice puzzle to brighten your day - how can we make the Iterator think that the List has not been changed? Full Article
282 Biased locking a goner, but better things Loom ... 2020-07-21

Biased locking has made unnecessary mutexes cheap for over a decade. However, it is disabled by default in Java 15, slated for removal. From Java 15 onwards we should be more diligent to avoid synchronized in places where we do not need it. Full Article
281 Puzzle 2: Is it garbage? 2020-06-24

In our next puzzle, we up the ante a bit. We prevent GC during the test() method by storing a strong reference to all our Vectors. Cock and bull story, or are we struggling to identity our biases? Full Article
280 Puzzle: What's up with Vector? 2020-06-23

For today's puzzle, we are getting elements from Vector, sequentially and in parallel. But why is the performance so much worse in Java 15-ea+28? Full Article
279 Upgrading ReadWriteLock 2020-05-28

The Java ReentrantReadWriteLock can never ever upgrade a read lock to a write lock. Kotlin's extension function ReentrantReadWriteLock.write() cheats a bit by letting go of the read lock before upgrading, thus opening the door for race conditions. A better solution is StampedLock, which has a met... Full Article
278 Free Memory 2020-04-30

How much memory was wasted when an additional boolean field was added to java.lang.String in Java 13? None at all. This article explains why. Full Article
277 Strings with Zero HashCode 2020-03-30

In Java 2, the computational time complexity of String#hashCode() became linear, as it used every character to calculate the hash. Java 3 cached the hash code, so that it would not need to be recalculated every time we called hashCode(), except in the case that the hash code was zero. Java 13 fi... Full Article
276 Serializing Records 2020-02-29

Java 14 Records (JEP359) reduce the boiler plate for simple POJOs. In this newsletter we look at what special magic is used to serialize and deserialize these new records. Full Article
275 EnhancedStream with Dynamic Proxy 2019-11-23

In our previous newsletter we enhanced Java 8 Streams by decorating them with an EnhancedStream class. The code had a lot of repetition, which often leads to bugs if written by hand. In this newsletter we use a dynamic proxy to create an EnhancedStream. The resulting code is shorter and more c... Full Article
274 EnhancedStream 2019-11-22

Java 8 Streams have a rather narrow-minded view of what makes objects distinct. In this newsletter, we enhance Streams to allow a more flexible approach for deciding uniqueness. Full Article
273 Truly Public Methods 2019-10-01

Class.getMethods() returns all the public methods in this class and the classes in its ancestry. However, we cannot necessarily call these methods, for example if they are declared in a private inner class or a lambda. In this newsletter we attempt to find all truly public methods. Full Article
272 Hacking Enums Revisited 2019-09-07

In a previous newsletter, we looked at how we could dynamically add new enums and also rewire affected switch statements. Due to improvements in Java security, our old approach needs to be updated for Java 12. Full Article
271 HttpClient Executors 2019-08-21

Java 11 added the HttpClient to give us a better way to send HTTP requests. It supports asynchronous and synchronous mode. HTTP2 comes out of the box. The threading is a bit funky though and Professor Cay Horstmann explores how things work underneath the covers. Full Article
270 Excursions into Deduplication 2019-05-31

When are Strings deduplicated? How can we find out whether they are of any benefit in our application? How much does it cost in terms of CPU? We try to show you how we can get this from the deduplication statistics provided by the JVM. Full Article
269 Heterogeneous Comparisons 2019-04-29

The compareTo() function has three rules. Break any one of them and you might get an exception when you sort. In this newsletter we explore what these rules are and how they can affect sorting. Full Article
268 Puzzle: Is a Programmer a Person? 2019-03-06

In today's puzzle, we want to sort a list of persons. It works in some versions of Java, but not in others. You need to figure out why. Full Article
267 Performance Impact of Design Patterns 2019-02-18

The Java Development Kit is filled with great examples of how design patterns can be used to make the Java code easier to maintain. But what is the performance impact of all this indirection and additional object creation? In this newsletter we explore how the compiler makes well-factored Java ... Full Article
266 Threading Questions in Job Interviews Part 2 2019-02-12

In our previous newsletter, we showed 14 typical questions that interviewers ask to find out if we know threading. Here are our model answers. Use them with caution. The interviewer is probably reading my newsletter. Full Article
265 Threading Questions in Job Interviews Part 1 2019-01-02

Asking detailed threading questions during an interview is like asking a football player to prove that he can sing well. Not necessarily relevant to their job description. And yet we see this commonly for Java jobs. In this newsletter we consider more than a dozen real questions that technical... Full Article
264 2018 Retrospective - Living Entrepreneurially 2018-12-19

Our lives are so busy, we sometimes forget to stop and smell the roses. Let's take a moment to look back at how far we have come in the last 12 months. Full Article
263 Anonymous Tuples 2018-11-28

Anonymous inner classes can be used effectively in Java 8 Streams to create tuples. See how this can improve our refactoring of old procedural code into the functional paradigm. Full Article
262 How Java Maps Protect Themselves from DOS Attacks 2018-10-09

A well known exploit with maps is to create a lot of Strings as keys that all have the same hash code. In this newsletter we see how easily that can be done and what Java 8+ HashMap does to protect itself. Full Article
261 Concurrent Queue Sizes and Hot Fields 2018-09-20

ConcurrentLinkedQueue's size() method is not very useful in a multi-threaded environment, because it counts the number of elements in the queue, rather than relying on a "hot field" to store the size. The result might be completely incorrect, or in strange situations, never return. Full Article
260 Java Is Still Free 2018-09-17

Is the Java Ecosystem still safe and robust or should we move to a different language? Maybe Go or Python? In this newsletter we look at whether Java is still a solid choice. Full Article
259 Try-With-Resource in Plain Java 2018-07-01

How would the plain Java code look for our try-with-resource constructs? Watch how 4 lines of code are expanded into 39 LOC and 170 bytecodes. We also look at how Java 9 has reduced this slightly. Full Article
258 ShuffleCollector 2018-04-09

Sorting a stream is easy. But what if we want the opposite: shuffling? We can shuffle a List with Collections.shuffle(List). But how can we apply that to a Stream? In this newsletter we show how with Collectors.collectingAndThen(). Full Article
257 CountDownLatch vs CyclicBarrier vs Phaser 2018-04-02

Java 7 gave us a brilliant new class called Phaser, which we can use to coordinate actions between threads. It replaces both CountDownLatch and CyclicBarrier, which are easier to understand, but harder to use. Full Article
256 Java 10: Parallel Full GC in G1GC 2018-03-31

Apparently Full GC is done in parallel in the Java 10 G1 collector. Or is it? In this newsletter we set out to discover the truth by dumping the GC CPU usage with the new Unified JVM Logging. Full Article
255 Java 10: Inferred Local Variables 2018-02-28

Local variable type inference is finally here, but dangers lurk. We might encourage overly long methods and lose the benefits of interface abstraction. Full Article
254 Big O Cost of Class.getMethod() 2018-02-27

We now look at why the best-case scenario for a getMethod() call is O(n), not O(1) as we would expect. We also discover that the throughput of getMethod() has doubled in Java 9. Full Article
253 Builder Pattern GoF vs Effective Java 2018-02-26

What is the best-case computational time complexity for finding a method inside a class via reflection? In this newsletter we do not answer that question. Instead, we look at the GoF Builder and wonder whether anyone has ever used it in Java. Full Article
252 New Year Day Spliterator 2018-01-01

We build a simple custom Spliterator to allow us to stream over dates to find how many times the 1st of January was on a Monday. Full Article
251 Collections.checkedCollection() 2017-11-30

Since Java 5, we have been able to create collections that would check at runtime that the objects added were of the correct type. But very few Java programmers know about it. The benefit we get in debugging ease is huge, as exceptions are thrown earlier. Full Article
250 Learning Java with jshell 2017-10-26

Java 9 has changed the way that new programmers can be introduced to Java. No more "public static void main(String[] args)", but instead a beautiful jshell REPL that lets us experiment with Java features without understanding the subtleties of "static". Full Article
249 @Contended @since 9 2017-08-23

Java 9 is more strict about what system internal classes we can use. So how can we use @Contended in Java 9? This article shows you how. Full Article
248 Immutable Collections in Java 9 2017-05-31

Java 9 now offers immutable lists, sets and maps. We look at how to create them and also how to do simple set operations like union and intersection. Full Article
247 Memory Puzzle with Lambdas 2017-03-31

Just like inner classes, lambdas might also suffer from memory issues, but to a lesser extent. In this puzzle you need to figure out which lambdas are affected. Full Article
246 LRU Cache From LinkedHashMap 2017-02-28

The LinkedHashMap has an interesting feature, where we can order elements in "access order", rather than the default "insertion order". This allows us to build a light-weight LRU cache. Full Article
245 Surprising += Cast 2017-01-30

Surprisingly, the compound arithmetic expression contains a cast that can produce some interesting side effects. In this newsletter we explore this and other edge cases in the Java Language Specification. Full Article
244 Your Brilliant Java Career 2016-12-31

My mother is a trained physiotherapist. Ergonomics and physical health has always interested me, even though like most of us, I struggle with laziness. As Java programmers, we need to keep in shape if we want to work for a long time, both mentally and physically. In this newsletter, I share 4 ... Full Article
243 Hacking Together a CircularArrayList (Video Tut... 2016-11-30

For our 16th anniversary edition, we have produced three short video tutorials on how to build your own CircularArrayList in Java, based on the AbstractList. Full Article
242 Concurrency Puzzle Explained, Solved With Stamp... 2016-10-31

Most programmers had a blind spot with the statement "arr[size++] = e;" We somehow think that size will be updated after the assignment. In this newsletter we look at this basic concurrency bug and also present a solution in the form of the Java 8 StampedLock. Full Article
241b Concurrency Puzzle Helpful Hints 2016-10-04

In the previous newsletter, we sent out a threading puzzle for you to solve. Here are some hints to help you figure out what is going on. Full Article
241 Concurrency Puzzle - System.arraycopy() 2016-09-29

"Friends don't let friends write low-level concurrency by themselves." -@karianna. Here is your chance to participate in a global code review puzzle to figure out what's going on in some synchronized code. Full Article
240 Interfacing with Messy Humans 2016-09-10

We humans are rather good at figuring out what is meant from context. Computers are terrible. They do exactly what we tell them to. Fun ensues when we feed them wrong number formatting information. Full Article
239 Sorting Lists 2016-07-19

List has a new method sort(Comparator). This is handy, as it allows implementations to specialize how to sort their internal data structures. Vector only synchronizes once per list, not once per element. ArrayList avoids copying the array unnecessarily. CopyOnWriteArrayList works. Full Article
238 java.util.Optional - Short Tutorial by Example 2016-05-09

Java 8 introduced the java.util.Optional class, based on the famous Guava class by the same name. It was said that we should hardly ever call get(). In this newsletter we offer a short tutorial that demonstrates coding examples of alternatives to get(). Full Article
237 String Compaction 2016-04-16

Java 6 introduced a mechanism to store ASCII characters inside byte[] instead of a char[]. This feature was removed again in Java 7. However, it is coming back in Java 9, except this time round, compaction is enabled by default and byte[] is always used. Full Article
236 Computational Time Complexity of BigInteger.mul... 2016-03-31

BigInteger has new algorithms for multiplying and dividing large numbers that have a better computational complexity than previous versions of Java. A further improvement would be to parallelize multiply() with Fork/Join. Full Article
235 Checking HashMaps with MapClashInspector 2016-02-29

Java 8 HashMap has been optimized to avoid denial of service attacks with many distinct keys containing identical hash codes. Unfortunately performance might degrade if you use your own keys. In this newsletter we show a tool that you can use to inspect your HashMap and view the key distributio... Full Article
234 Random Code Failures - Race Conditions Between ... 2015-11-20

Most of the time our code fails because of bugs in our code. Rarely, however, bugs in the JVM ecosystem cause our systems to fail. These are insanely difficult to diagnose in production systems. In this newsletter we look at two different such race conditions between our code and the JVM. Full Article
233 Intersection Types to Give Lambdas Multiple Per... 2015-10-18

Lambdas are often described as anonymous inner classes without the boilerplate code. However, lambdas are more powerful. Firstly, a lambda does not always result in a new object. Secondly, "this" refers to the outer object. Thirdly, a lambda object can implement multiple interfaces. In this ... Full Article
232 ByteWatcher from JCrete 2015-09-29

Even though standard Java is not real-time, we often use it in time-sensitive applications. Since GC events are often the reason for latency outliers, such code seeks to avoid allocation. In this newsletter we look at some tools to add to your unit tests to check your allocation limits. Full Article
231 Why Crete? 2015-07-31

In this newsletter, Heinz answers the question that he gets asked most: "Why Crete?" "Because I can" could be one answer, but the reality is a bit deeper than that. Full Article
230 String Substring 2015-06-30

Java 7 quietly changed the structure of String. Instead of an offset and a count, the String now only contained a char[]. This had some harmful effects for those expecting substring() would always share the underlying char[]. Full Article
229 Cleaning ThreadLocals 2015-05-23

ThreadLocals should in most cases be avoided. They can solve some tough problems, but can introduce some nasty memory leaks, especially if the ThreadLocal class or value refer to our own classes, not a system class. In this newsletter we show some mechanisms that help under OpenJDK. Full Article
228 Extracting Real Task from FutureTask 2015-04-30

ExecutorService allows us to submit either Callable or Runnable. Internally, this is converted to a FutureTask, without the possibility of extracting the original task. In this newsletter we look at how we can dig out the information using reflection. Full Article
227 How Can I Become a Champion Programmer? 2015-03-30

In this newsletter, Heinz talks about some characteristics that are useful if you want to become a successful champion Java programmer. Full Article
226 Discovering Where Threads Are Being Constructed 2015-02-24

How can you discover all the places in your program where threads are being constructed? In this newsletter we create our own little SecurityManager to keep an eye on thread creation. Full Article
225 Hiding Interface Methods 2015-01-21

Whenever a class implements an interface, all the implemented methods have to be public. In this newsletter we look at a trick that we can use to make them private. Full Article
224 Book Review: Mastering Lambdas: Java Programmin... 2014-12-27

In his latest book, Maurice Naftalin takes us on a journey of discovery as we learn with him how Lambdas and Streams work in Java 8. Full Article
223 ManagedBlocker 2014-11-27

Blocking methods should not be called from within parallel streams in Java 8, otherwise the shared threads in the common ForkJoinPool will become inactive. In this newsletter we look at a technique to maintain a certain liveliness in the pool, even when some threads are blocked. Full Article
222 Identity Crisis 2014-09-09

The JavaDocs for method Object.hashCode() seems to suggest that the value is somehow related to memory location. However, in this newsletter we discover that there are several different algorithms and that Java 8 has new defaults to give better threading result if we call hashCode a lot. Full Article
221 Throwing Checked Exceptions From Lambdas 2014-06-06

Lambdas in Java took a long time in coming, due to the considerable engineering effort put into incorporating them into the Java Language. Unfortunately checked exceptions are not managed as seamlessly as they should. Full Article
220b Runtime.getRuntime().availableProcessors() (Fol... 2014-05-30

Whenever we have thread pools in our system, we need to make their size configurable. In this follow-up, we continue looking at some issues with the common fork/join pool that is used in Java 8. Full Article
220 Runtime.getRuntime().availableProcessors() 2014-05-28

Java 8 magically makes all our code run in parallel. If you believe that, I've got a tower in Paris that I'm trying to sell. Really good price. In this newsletter we look at how the parallism is determined and how we can influence it. Full Article
219 Recent File List 2014-04-30

The LinkedHashMap has a little known feature that can return elements in least recently accessed order, rather than insertion order. In this newsletter we use this to construct a "Recently Used File" list. Full Article
218 Thread Confinement 2014-02-18

One of the techniques we use to ensure that a non-threadsafe class can still be used by multiple threads is to give each thread its own instance. We call this "thread confinement". In this newsletter we look at some of the issues that can happen when this instance leaks. Full Article
217b Parallel Parking (Follow-Up) 2014-02-11

Heavily contended concurrent constructs may benefit from a small pause after a CAS failure, but this may lead to worse performance if we do more work in between each update attempt. In this follow-up newsletter, we show how adding CPU consumption can change our performance characteristics. Full Article
217 Parallel Parking 2014-02-07

What is faster? Synchronized or Atomic compare-and-set? In this newsletter we look at some surprising results when we run Java on the new i7 chip. Full Article
216 Book Review: Good Math 2013-12-30

Software engineers need to have a good understanding of mathematics. In this newsletter, we review a book written by a geek and aimed at the geek who wants to discover interesting facts about maths. Full Article
215 StampedLock Idioms 2013-12-02

Java 8 includes a new synchronization mechanism called StampedLock. It differentiates between exclusive and non-exclusive locks, similar to the ReentrantReadWriteLock. However, it also allows for optimistic reads, which is not supported by the ReentrantReadWriteLock. In this newsletter, we loo... Full Article
214 CountingCompletionService 2013-10-10

CompletionService queues finished tasks, making it easier to retrieve Futures in order of completion. But it lacks some basic functionality, such as a count of how many tasks have been submitted. Full Article
213 Livelocks from wait() and notify() 2013-09-20

When a thread is interrupted, we need to be careful to not create a livelock in our code by re-interrupting without returning from the method. Full Article
212 Creating Sets from Maps 2013-07-19

Maps and Sets in Java have some similarities. In this newsletter we show a nice little trick for converting a map class into a set. Full Article
211 Unicode Redux (2 of 2) 2013-05-30

We continue our discussion on Unicode by looking at how we can compare text that uses diacritical marks or special characters such as the German Umlaut. Full Article
210 Calling Methods from a Constructor 2013-05-22

In this newsletter we investigate what can go wrong when we call methods from constructors, showing examples from the JDK, Glassfish, Spring Framework and some other well known frameworks.. Full Article
209 Unicode Redux (1 of 2) 2013-04-11

Unicode is the most important computing industry standard for representation and handling of text, no matter which of the world's writing systems is used. This newsletter discusses some selected features of Unicode, and how they might be dealt with in Java. Full Article
208 Throwing Exceptions from Fields 2013-03-31

How can you set a field at point of declaration if its constructor throws a checked exception? Full Article
207 Final Parameters and Local Variables 2012-12-27

The trend of marking parameters and local variables as "final" does not really enhance your code, nor does it make it more secure. Full Article
206 Striped Executor Service 2012-11-13

We present a new type of ExecutorService that allows users to "stripe" their execution in such a way that all tasks belonging to one stripe are executed in-order. Full Article
205 How to Make Your Own Rules 2012-08-27

Rule Based Programming, a declarative programming paradigm, is based on logical patterns to select data and associate it with processing instructions. This is a more indirect method than the sequential execution steps of an imperative programming language. Full Article
204 Book Review: The Well-Grounded Java Developer 2012-08-06

Ben Evans and Martijn Verburg explain to us in their new book what it takes to be a well-grounded Java developer. The book contains a section on the new Java 7 features and also vital techniques that we use for producing robust and performant systems. Full Article
203 GOTO in Java 2012-06-13

It is possible to use the break statement to jump out to the end of a labelled scope, resulting in some strange looking code, almost like the GOTO statement in C. Full Article
202 Distributed Performance Tuning 2012-05-28

In this newsletter, it is up to you to figure out how we improved the performance of our previous Fibonacci newsletter by 25%. Full Article
201 Fork Join with Fibonacci and Karatsuba 2012-05-24

The new Java 7 Fork/Join Framework allows us to define our algorithms using recursion and then to easily parallelize them. In this newsletter we describe how that works using a fast Fibonacci algorithm that uses the sum of the squares rather than brute force. We also present a faster algorithm ... Full Article
200 On Learning Concurrency 2012-03-26

Every Java programmer I have met knows that they should know more about concurrency. But it is a topic that is quite hard to learn. In this newsletter I give some tips on how you can become proficient in concurrency. Full Article
199 Hacking Java Surreptitiously 2012-02-23

Surreptitious: stealthy, furtive, well hidden, covert. In this newsletter we will show two Java puzzles written by Wouter Coekaerts that require a surreptitious solution. You cannot do anything to upset the security manager. Full Article
198 Pushing the Limits in Java's Random 2012-02-13

What is the largest double that could in theory be produced by Math.random()? In this newsletter, we look at ways to calculate this based on the 48-bit random generator available in standard Java. We also prove why in a single-threaded program, (int)(Random.nextDouble() + 1) can never be rounde... Full Article
197 What is the Meaning of Life? 2011-12-06

In this newsletter we try to calculate the meaning of life, with surprising results. Full Article
196 Uncaught AWT Exceptions in Java 7 2011-11-29

Java 7 removes the Swing Event Dispatch Thread (EDT) hack that allowed us to specify an uncaught exception handler for the EDT using a system property sun.awt.exception.handler. Full Article
195 Performance Puzzler with a Stack Trace 2011-09-15

In this newsletter, we present a little performance puzzler, written by Kirk Pepperdine. What is happening with this system? There is only one explanation and it can be discovered by just looking at the stack trace. Full Article
194 trySynchronize 2011-08-27

Did you know that it possible to "try" to synchronize a monitor? In this newsletter we demonstrate how this can be used to avoid deadlocks and to keep the wine coming. Full Article
193 Memory Usage of Maps 2011-06-30

In this newsletter we measure the memory requirements of various types of hash maps available in Java. Maps usually need to be threadsafe, but non-blocking is not always the most important requirement. Full Article
192b How Does "this" Escape? 2011-06-01

A quick follow-up to the previous newsletter, to show how the ThisEscape class is compiled, causing the "this" pointer to leak. Full Article
192 Implicit Escape of "this" 2011-05-31

We should never allow references to our objects to escape before all the final fields have been set, otherwise we can cause race conditions. In this newsletter we explore how this is possible to do. Full Article
191 Delaying Garbage Collection Costs 2011-04-27

The garbage collector can cause our program to slow down at inappropriate times. In this newsletter we look at how we can delay the GC to never run and thus produce reliable results. Then, instead of actually collecting the dead objects, we simply shut down and start again. Full Article
190b Automatically Unlocking with Java 7 (Follow-Up) 2011-04-15

In this newsletter we discuss why we unfortunately will not be able to use the try-with-resource mechanism to automatically unlock in Java 7. Full Article
190 Automatically Unlocking with Java 7 2011-02-27

In this newsletter we explore my favourite new Java 7 feature "try-with-resource" and see how we can use this mechanism to automatically unlock Java 5 locks. Full Article
189 Fun and Games with Java Lego NXT 2.0 2010-12-12

It is almost Christmas time, which gives us an excuse to invest in all sorts of toys. I found that the most ridiculously priced ones are those that promise to have an added benefit besides fun. "Educational", "Good for hand-eye coordination", etc. In this Java newsletter we look at one of thes... Full Article
188 Interlocker - Interleaving Threads 2010-10-31

In this newsletter, we explore a question of how to call a method interleaved from two threads. We show the merits of lock-free busy wait, versus explicit locking. We also discuss an "unbreakable hard spin" that can cause the JVM to hang up. Full Article
187 Cost of Causing Exceptions 2010-08-31

Many years ago, when hordes of C++ programmers ventured to the greener pastures of Java, some strange myths were introduced into the language. It was said that a "try" was cheaper than an "if" - when nothing went wrong. Full Article
186 Iterator Quiz 2010-07-30

Most of the northern hemisphere is on holiday, so here is a quick quiz for those poor souls left behind manning the email desk. How can we prevent a ConcurrentModificationException in the iterator? Full Article
185 Book Review: Java: The Good Parts 2010-07-11

In his latest book, Jim Waldo describes several Java features that he believes make Java "good". A nice easy read, and I even learned a few new things from it. Full Article
184 Deadlocks Through Cyclic Dependencies 2010-06-04

A common approach to ensuring serialization consistency in thread safe classes such as Vector, Hashtable or Throwable is to include a synchronized writeObject() method. This can result in a deadlock when the object graph contain a cyclic dependency and we serialize from two threads. Whilst unli... Full Article
183 Serialization Size of Lists 2010-05-31

What has a larger serializable size, ArrayList or LinkedList? In this newsletter we examine what the difference is and also why Vector is a poor candidate for a list in a serializable class. Full Article
182 Remote Screenshots 2010-05-12

In this newsletter, we describe how we can generate remote screen shots as compressed, scaled JPGs to build a more efficient remote control mechanism. Full Article
181 Generating Static Proxy Classes - Part 2 2010-03-01

In this newsletter, we show how the Generator described in our previous issue can be used to create virtual proxy classes statically, that is, by generating code instead of using dynamic proxies. Full Article
180 Generating Static Proxy Classes - Part 1 2010-02-19

In this newsletter, we have a look at how we can create new classes in memory and then inject them into any class loader. This will form the basis of a system to generate virtual proxies statically. Full Article
179 Escape Analysis 2009-12-30

Escape analysis can make your code run 110 times faster - if you are a really really bad programmer to begin with :-) In this newsletter we look at some of the places where escape analysis can potentially help us. Full Article
178b WalkingCollection Generics (Follow-Up) 2009-11-17

Generics can be used to further improve the WalkingCollection, shown in our previous newsletter. Full Article
178 WalkingCollection 2009-11-14

We look at how we could internalize the iteration into a collection by introducing a Processor interface that is applied to each element. This allows us to manage concurrency from within the collection. Full Article
177 Logging Part 3 of 3 2009-10-13

After almost nine years of silence, we come back to bring the logging series to an end, looking at best practices and what performance measurements to log. Full Article
176 The Law of the Xerox Copier 2009-09-22

Concurrency is easier when we work with immutable objects. In this newsletter, we define another concurrency law, The Law of the Xerox Copier, which explains how we can work with immutable objects by returning copies from methods that would ordinarily modify the state. Full Article
175 Creating Objects Without Calling Constructors 2009-09-08

De-Serialization creates objects without calling constructors. We can use the same mechanism to create objects at will, without ever calling their constructors. Full Article
174 Java Memory Puzzle Explained 2009-06-26

In this newsletter, we reveal the answer to the puzzle from last month and explain the reasons why the first class sometimes fails and why the second always succeeds. Remember this for your next job interview ... Full Article
173 Java Memory Puzzle 2009-05-28

In this newsletter we show you a puzzle, where a simple request causes memory to be released, that otherwise could not. Solution will be shown in the next newsletter. Full Article
172 Wonky Dating 2009-04-23

The DateFormat produces some seemingly unpredictable results parsing the date 2009-01-28-09:11:12 as "Sun Nov 30 22:07:51 CET 2008". In this newsletter we examine why and also show how DateFormat reacts to concurrent access. Full Article
171 Throwing ConcurrentModificationException Early 2009-03-09

One of the hardest exceptions to get rid of in a system is th ConcurrentModificationException, which typically occurs when a thread modifies a collection whilst another is busy iterating. In this newsletter we show how we can fail on the modifying, rather than the iterating thread. Full Article
170 Discovering Objects with Non-Trivial Finalizers 2009-02-27

It is well known that implementing a non-trivial finalize() method can cause GC and performance issues, plus some subtle concurrency bugs. In this newsletter, we show how we can find all objects with a non-trivial finalize() method, even if they are not currently eligible for finalization. Full Article
169 Monitoring Sockets 2009-01-22

In this newsletter, we show two approaches for listening to bytes on sockets. The first uses the Delegator from our previous newsletter, whereas the second uses AspectJ to intercept the call to Socket.getInput/OutputStream. We also write an MBean to publish this information in JConsole. Full Article
168 The Delegator 2009-01-15

In this newsletter we show the reflection plumbing needed for writing a socket monitor that sniffs all the bytes being sent or received over all the Java sockets. The Delegator is used to invoke corresponding methods through some elegant guesswork. Full Article
167 Annotation Processing Tool 2008-12-05

In this newsletter we answer the question: "How do we force all subclasses to contain a public no-args constructor?" The Annotation Processing Tool allows us to check conditions like this at compile time, rather than only at runtime. Full Article
166 Serialization Cache 2008-11-30

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 state being written. However, resetting the stream also loses the optimization stored in the stream. Full Article
165 Starvation with ReadWriteLocks 2008-10-14

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 of Java. Full Article
164 Why 0x61c88647? 2008-09-29

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. However, we still face the possibility of memory leaks due to values not being cleared out of the Thre... Full Article
163 Book Review: Effective Java 2nd Edition 2008-08-13

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 also very readable. In this newsletter we describe some of the nuggets found in the book. Full Article
162 Exceptions in Java 2008-06-10

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() should not be used and discover the mystery of the RuntimeException name. We then look at some best pract... Full Article
161 Of Hacking Enums and Modifying "final static" F... 2008-05-23

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 the system. In this newsletter we show how we can do this using the classes in sun.reflect. In addi... Full Article
160 The Law of the Uneaten Lutefisk 2008-05-12

Imagine a very stubborn viking father insisting that his equally stubborn child eat its lutefisk before going to sleep. In real life one of the "threads" eventually will give up, but in Java, the threads become deadlocked, with neither giving an inch. In this newsletter we discover how we can s... Full Article
159 The Law of Sudden Riches 2008-05-05

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 slower than on worse hardware. Full Article
158 Polymorphism Performance Mysteries Explained 2008-04-01

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 a special case which executes faster than poly-morphism. Mono-morphism can be inlined by the compile... Full Article
157 Polymorphism Performance Mysteries 2008-03-06

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 through polymorphism, provided that we do not have very many implementation subclasses. Full Article
156 The Law of Cretan Driving 2008-02-26

The Law of Cretan Driving looks at what happens when we keep on breaking the rules. Eventually, we might experience a lot of pain when we migrate to a new architecture or Java Virtual Machine. Even if we decide not to obey them, we need to know what they are. In this newsletter, we point you t... Full Article
155 The Law of the Micromanager 2008-01-16

In good Dilbert style, we want to avoid having Pointy-Haired-Bosses (PHBs) in our code. Commonly called micromanagers, they can make a system work extremely inefficiently. My prediction is that in the next few years, as the number of cores increases per CPU, lock contention is going to be the bi... Full Article
154 ResubmittingScheduledPoolExecutor 2007-12-04

Timers in Java have suffered from the typical Command Pattern characteristics. Exceptions could stop the timer altogether and even with the new ScheduledPoolExecutor, a task that fails is cancelled. In this newsletter we explore how we could reschedule periodic tasks automatically. Full Article
153 Timeout on Console Input 2007-11-25

In this newsletter, we look at how we can read from the console input stream, timing out if we do not get a response by some timeout. Full Article
152 The Law of the Corrupt Politician 2007-11-12

Corruption has a habit of creeping into system that do not have adequate controls over their threads. In this law, we look at how we can detect data races and some ideas to avoid and fix them. Full Article
151 The Law of the Leaked Memo 2007-10-04

In this fifth law of concurrency, we look at a deadly law where a field value is written early. Full Article
150 The Law of the Blind Spot 2007-09-05

In this fourth law of concurrency, we look at the problem with visibility of shared variable updates. Quite often, "clever" code that tries to avoid locking in order to remove contention, makes assumptions that may result in serious errors. Full Article
149 The Law of the Overstocked Haberdashery 2007-08-20

Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the third part of a series of laws that help explain how we should be writing concurrent code in Java. In this section, we look at why we should avoid creating unnecessary threads, even if they are n... Full Article
148 Snappy JSliders in Swing 2007-07-31

Recent versions of Swing do a good job of mimicking the underlying platform, with a few caveats. For example, the JSlider only snaps onto the correct tick once you let go of the mouse. Here I present a fix for this problem with a non-intrusive one-liner that we can add to the application code. Full Article
147 The Law of the Distracted Spearfisherman 2007-07-20

Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the second part of a series of laws that help explain how we should be writing concurrent code in Java. We look at how to debug a concurrent program by knowing what every thread in the system is doing. Full Article
146 The Secrets of Concurrency (Part 1) 2007-06-26

Learn how to write correct concurrent code by understanding the Secrets of Concurrency. This is the first part of a series of laws that help explain how we should be writing concurrent code in Java. Full Article
145 TristateCheckBox Revisited 2007-05-25

The Tristate Checkbox is widely used to represent an undetermined state of a check box. In this newsletter, we present a new version of this popular control, retrofitted to Java 5 and 6. Full Article
144 Book Review: Java Puzzlers 2007-05-16

Experienced Java programmers will love the Java Puzzlers book by Josh Bloch and Neal Gafter, both well known Java personalities. In this newsletter, we look at two of the puzzles as a teazer for the book. Full Article
143 Maths Tutor in GWT 2007-04-08

Google Web Toolkit (GWT) allows ordinary Java Programmers to produce highly responsive web user interfaces, without needing to become experts in JavaScript. Here we demonstrate a little maths game for practicing your arithmetic. Included is an Easter egg. Full Article
142 Instrumentation Memory Counter 2007-03-26

Memory usage of Java objects has been a mystery for many years. In this newsletter, we use the new instrumentation API to predict more accurately how much memory an object uses. Based on earlier newsletters, but revised for Java 5 and 6. Full Article
141 Hacking Enums 2007-03-13

Enums are implemented as constant flyweights. You cannot construct them. You cannot clone them. You cannot make copies with serialization. But here is a way we can make new ones in Java 5. Full Article
140 Book Review: Java Generics and Collections 2007-03-08

Java Generics and Collections is the "companion book" to The Java Specialists' Newsletter. A well written book that explains generics really nicely, including some difficult concepts. In addition, they cover all the new collection classes up to Java 6 Mustang. Full Article
139 Mustang ServiceLoader 2007-02-10

Mustang introduced a ServiceLoader than can be used to load JDBC drivers (amongst others) simply by including a jar file in your classpath. In this newsletter, we look at how we can use this mechanism to define and load our own services. Full Article
138 Better SQLExceptions in Java 6 2007-01-31

Java 6 has support for JDBC 4, which, amongst other things, gives you better feedback of what went wrong with your database query. In this newsletter we demonstrate how this can be used. Full Article
137 Creating Loggers DRY-ly 2006-12-28

A common idiom for logging is to create a logger in each class that is based on the class name. The name of the class is then duplicated in the class, both in the class definition and in the logger field definition, since the class is for some reason not available from a static context. Read ho... Full Article
136 Sneaking in JDBC Drivers 2006-12-11

In this newsletter, we look at a technique of how we can replace an existing database driver with our own one. This could be used to migrate an application to a new database where you only have the compiled classes. Or it could be used to insert a monitoring JDBC connection that measures the le... Full Article
135 Are You Really Multi-Core? 2006-11-06

With Java 5, we can measure CPU cycles per thread. Here is a small program that runs several CPU intensive tasks in separate threads and then compares the elapsed time to the total CPU time of the threads. The factor should give you some indication of the CPU based acceleration that the multi c... Full Article
134 DRY Performance 2006-10-08

As developers we often hear that performance often comes at the price of good design. However when we have our performance tuning hats on, we often find that good design is essential to help achieve good performance. In this article we will explore one example of where a good design choice has be... Full Article
133 Safely and Quickly Converting EJB3 Collections 2006-09-29

When we query the database using EJB3, the Query object returns an untyped collection. In this newsletter we look at several approaches for safely converting this to a typed collection. Full Article
132 Thread Dump JSP in Java 5 2006-09-11

Sometimes it is useful to have a look at what the threads are doing in a light weight fashion in order to discover tricky bugs and bottlenecks. Ideally this should not disturb the performance of the running system. In addition, it should be universally usable and cost nothing. Have a look at h... Full Article
131 Sending Emails from Java 2006-08-28

In this newsletter, we show how simple it is to send emails from Java. This should obviously not be used for sending unsolicited emails, but will nevertheless illustrate why we are flooded with SPAM. Full Article
130 Deadlock Detection with New Locks 2006-07-29

Java level monitor deadlocks used to be hard to find. Then along came JDK 1.4 and showed them in CTRL+Break. In JDK 5, we saw the addition of the ThreadMXBean, which made it possible to continually monitor an application for deadlocks. However, the limitation was that the ThreadMXBean only wor... Full Article
129 Fast Exceptions in RIFE 2006-06-27

One of the tricks that Java allows us to employ is to change the control flow of the application using exceptions. This is generally strongly discouraged, since it makes the code hard to decipher. In addition, exceptions are notoriously bad at performance. Here is a trick used in RIFE to make ... Full Article
128 SuDoKu Madness 2006-06-21

In this Java Specialists' Newsletter, we look at a simple Java program that solves SuDoKu puzzles. Full Article
127 Casting like a Tiger 2006-06-07

Java 5 adds a new way of casting that does not show compiler warnings or errors. Yet another way to shoot yourself in the foot? Full Article
126 Proxy equals() 2006-05-14

When we make proxies that wrap objects, we have to remember to write an appropriate equals() method. Instead of comparing on object level, we need to either compare on interface level or use a workaround to achieve the comparisons on the object level, described in this newsletter. Full Article
125 Book Review: Java Concurrency in Practice 2006-04-17

We review Java Concurrency in Practice by Brian Goetz. Brian's book is the most readable on the topic of concurrency in Java, and deals with this difficult subject with a wonderful hands-on approach. It is interesting, useful, and relevant to the problems facing Java developers today. Full Article
124 Copying Arrays Fast 2006-03-28

In this newsletter we look at the difference in performance between cloning and copying an array of bytes. Beware of the Microbenchmark! We also show how misleading such a test can be, but explain why the cloning is so much slower for small arrays. Full Article
123 Strategy Pattern with Generics 2006-03-14

The Strategy Pattern is elegant in its simplicity. With this pattern, we should try to convert intrinsic state to extrinsic, to allow sharing of strategy objects. It gets tricky when each strategy object needs a different set of information in order to do its work. In this newsletter, we look ... Full Article
122 Copying Files from the Internet 2006-03-08

Sometimes you need to download files using HTTP from a machine that you cannot run a browser on. In this simple Java program we show you how this is done. We include information of your progress for those who are impatient, and look at how the volatile keyword can be used. Full Article
121 How Deep is Your Hierarchy? 2006-02-14

Someone asked me yesterday what the maximum inheritance depth is in Java. I guessed a value of 65535, but for practical purposes, not more than 5. When I asked performance guru Kirk Pepperdine to estimate, he shot back with 63. In this newsletter, we look at the limitations in the JVM and exam... Full Article
120 Exceptions From Constructors 2006-02-08

What do you do when an object cannot be properly constructed? In this newsletter, we look at a few options that are used and discuss what would be best. Based on the experiences of writing the Sun Certified Programmer for Java 5 exam. Full Article
119 Book Review: "Wicked Cool" Java 2006-01-13

The book "Wicked Cool Java" contains a myriad of interesting libraries, both from the JDK and various open source projects. In this review, we look at two of these, the java.util.Scanner and javax.sql.WebRowSet classes. Full Article
118 A Simple Database Viewer 2005-12-19

A simple database viewer written in Java Swing that reads the metadata and shows you all the tables and contents of the tables, written in under 100 lines of Java code, including comments. Full Article
117 Reflectively Calling Inner Class Methods 2005-12-02

Sometimes frameworks use reflection to call methods. Depending how they find the correct method to call, we may end up with IllegalAccessExceptions. The naive approach of clazz.getMethod(name) is not correct when we send instances of non-public classes. Full Article
116 Closing Database Statements 2005-11-28

Don't Repeat Yourself. The mantra of the good Java programmer. But database code often leads to this antipattern. Here is a neat simple solution from the Jakarta Commons DbUtils project. Full Article
115 Young vs. Old Generation GC 2005-10-13

A few weeks ago, I tried to demonstrate the effects of old vs. new generation GC. The results surprised me and reemphasized how important GC is to your overall program performance. Full Article
114 Compile-Time String Constant Quiz 2005-09-16

When we change libraries, we need to do a full recompile of our code, in case any constants were inlined by the compiler. Find out which constants are inlined in this latest newsletter. Full Article
113 Enum Inversion Problem 2005-08-29

A problem that I encountered when I first started using enums was how to serialize them to some persistent store. My initial approach was to write the ordinal to the database. In this newsletter, I explore some ideas of a more robust approach. It will also show you some applications of Java ge... Full Article
112 Book Review: Head First Design Patterns 2005-08-22

This book is a fantastic introduction to Design Patterns, probably the best available. In this newsletter, I look at some of the winning formulae used in the book, and explain why they work. I also give some tips of where I disagree with the book and some additional information that will be use... Full Article
111 What Is Faster - LinkedList or ArrayList? 2005-07-12

ArrayList is faster than LinkedList, except when you remove an element from the middle of the list. Or is it? Full Article
110 Break to Labeled Statement 2005-06-30

Java does not use the "goto" statement, although it is a reserved word. We do have something similar though: labeled breaks. Full Article
109 Strategy Pattern of HashCode Equality 2005-05-18

Instead of auto-generating our hashCode() and equals() methods, why not use the strategy pattern to do this for us? In this newsletter, we examine different approaches and their benefits. Full Article
108 Object Adapter Based on Dynamic Proxy 2005-05-10

The object adapter pattern is similar in structure to the proxy pattern. This means that we can use the dynamic proxy mechanism in Java to also implement a dynamic object adaptor. Full Article
107 Making Enumerations Iterable 2005-04-19

Enumeration was the interface in Java 1.0 that has now been superceded by Iterator. It is still in widespread use. In this newsletter we look at how we can use Enumeration with the new for-in statement. Full Article
106 Multi-Line Cells in JTable in JDK 1.4+ 2005-04-14

Our earlier solution to multi-line cells in JTable did not work in Java 1.4. We show a new version that does. Full Article
105 Performance Surprises in Tiger 2005-03-28

Java 5 has some interesting performance optimizations than can make our code faster without our intervention. We look at some of the new features. Full Article
104 EDT Lockup Detection 2005-02-13

Swing is famous for its "refresh bug", where the application stops refreshing the screen. This happens when the Event Dispatch Thread (EDT) is blocked, either temporarily by a long operation or permanently because of a deadlock. In the newsletter we look at a technique for sounding the alarm. Full Article
103 New for in Loop Gymnastics 2005-02-07

Java 5 introduced the Iterable interface, used by the enhanced "for" statement to iterate. Collection extends Iterable, but we can also write our own classes that implement it. This way we can use the enhanced "for" statement to iterate over them. Examples would be ResultSet and InputStream. Full Article
102 Mangling Integers 2005-01-31

To optimize autoboxing, Java caches boxed integers in the range -128 to 127. We examine what happens if this cache were to get corrupted. Full Article
101b Causing Deadlocks in Swing Code (Follow-Up) 2005-01-19

A follow-up to explain that the previous code was not the "refresh bug", but rather an issue with the static initializer starting a thread and that thread calling a static method. Full Article
101 Causing Deadlocks in Swing Code 2005-01-18

Swing uses several locks. When several threads work with the GUI at the same time, it is not always easy to determine the order of the locks. This can result in deadlocks, the famous "refresh bug". Full Article
100 Java Programmers Aren't Born 2004-11-30

How can you become an excellent Java programmer? Is it an inherent trait or something you can learn? Can you learn Java if you are already over 30? Over 40? Over 60? In this newsletter I give some tips on how to become a Java programming expert. Hint: It's not as easy as it looks. But it's... Full Article
099 Orientating Components Right to Left 2004-11-23

In Swing, we can make GUIs be oriented either from left to right, as most countries do, or from right to left, as you would find in Arabic and Hebrew. Full Article
098 References 2004-11-08

Soft and weak references allow us to control how long objects stay live if they do not have strong references to them. Weak references can help us avoid memory leaks by breaking circular dependencies. Soft references can help us cache objects, recreating them when running low on memory. Full Article
097 Mapping Objects to XML Files Using Java 5 Annot... 2004-10-17

In this newsletter, we have Amotz Anner show us how we can map objects to XML files using the new Java 5 annotations. Full Article
096 Java 5 - "final" Is Not Final Anymore 2004-10-07

Final fields could not be set with reflection in Java 1.1. In Java 1.2 they changed it so that we could set final fields. We again couldn't in Java 1.3 and 1.4. Since Java 5, we can again set final fields. Full Article
095b Self-Reloading XML Property Files (Follow-Up) 2004-10-01

Do generics make the code easier or harder to read? Anything new can be challenging on the eyes, but time will tell whether generics will be as popular as we expect. Full Article
095 Self-Reloading XML Property Files 2004-09-30

The java.util.Properties class can load and store the properties in an XML file. We furthermore periodically check whether the file has changed and if so, reload the properties. Full Article
094 Java Field Initialisation 2004-09-20

Fields can either be initialized where they are declared or in the constructor. Some programmers set them twice. We have a look at how final fields avoid this. Full Article
093 Automatically Detecting Thread Deadlocks 2004-07-28

Deadlocks between synchronized monitors are impossible to resolve in Java. In this newsletter we look at a new MXBean that can detect deadlocks between threads and use it to warn us. Full Article
092 OutOfMemoryError Warning System 2004-07-20

Since Java 5, we have a JVM system thread constantly monitoring our memory usage. If we exceed our specified threshold, it will send us a notification. We can use this to get an early warning of possible trouble. Full Article
091 Controlling Machines Remotely with Java 2004-07-08

We use the java.awt.Robot to control machines remotely with Java, typing keys, moving the mouse and sending back screenshots. This can help instructors assist remote students. Full Article
090 Autoboxing Ourselves in Java 5 2004-06-22

We look at the new Java 5 features: Generics, autoboxing and the for-in statement. It should make our code more maintainable without sacrificing performance. Full Article
089 Catching Uncaught Exceptions in Java 5 2004-05-26

Java 5 introduced the UncaughtExceptionHandler. We can set it globally or per thread. This helps us to manage uncaught exceptions better. Full Article
088 Resetting ObjectOutputStream 2004-05-19

Object streams maintain caches on the input and output. This helps with avoiding StackOverflowError when we have circular references. It also saves bandwidth if we transmit the same objects several times. However, this can also cause a memory leak. Full Article
087 sun.reflect.Reflection 2004-04-09

A handy class shipped in the JDK is sun.reflect.Reflection. It allows us to find out which class called our method. Note that this class might become unavailable in future versions of Java. Full Article
086b Initialising Fields Before Superconstructor Cal... 2004-03-20

Follow-up to show another approach that works even better for initializing fields prior to the call to super(). Full Article
086 Initialising Fields Before Superconstructor Call 2004-03-19

We cannot execute any code before calling the superclass constructor. Or can we? Read more to find out. Full Article
085 Book Review: Pragmatic Programmer 2004-03-05

One of my favourite software development books, this one takes a good hard look at how to be a programmer in the real world. Surprisingly thin for a book with this much substance, I refer to the ideas in here all the time. The pragmatic bunch have built an entire industry around their software ... Full Article
084 Ego Tripping with Webservices 2004-02-05

We have a look at how to build a simple webservice with Java. Full Article
083 End of Year Puzzle 2003-12-26

Two easy Java puzzles to test your understanding of try-finally. Full Article
083b End of Year Puzzle (Follow-Up) 2003-12-26

Another small puzzle to test your knowledge of Java. Full Article
082 TristateCheckBox Based on the Swing JCheckBox 2003-12-02

The ordinary Swing JCheckBox has only two states. We present a new component that is based on the old JCheckBox, but which has three states. Full Article
081 Catching Exceptions in GUI Code 2003-11-25

When an exception occurs in Swing code, it is typically printed to the console, assuming we have one. On some systems the Swing thread is then stopped. In this newsletter we present a way that we can intercept the exception and display a warning dialog. Full Article
080 Many Public Classes in One File 2003-10-13

We have heard that we can only have one public class per .java file. But that is not entirely true. We could, in theory, have many public static inner classes inside one public class. Full Article
079 Generic toString() 2003-10-08

Instead of coding the toString() method repeatedly by hand, we present several approaches to generate the String automatically. Full Article
078 MemoryCounter for Java 1.4 2003-09-29

Our old MemoryCounter needed to be updated for Java 1.4. In previous versions of Java, each primitive field used at least 4 bytes, even a boolean. This changed in Java 1.4, where boolean and byte use a 1 byte, short and char use 2 bytes, int and float use 4 and long and double use 8. Full Article
077 "Wonderfully Disgusting Hack" 2003-09-02

In the early days of Java, the Sun Microsystems engineers still had the freedom to write hilarious comments into their code. Full Article
076 Asserting Locks 2003-08-05

A common pattern is the Java Monitor Pattern. All public methods are synchronized. Private methods would assume that the lock is already held. How can we verify this? In this newsletter we show how we can assert that we hold the lock inside the private methods. Full Article
075 An Automatic Wait Cursor: WaitCursorEventQueue 2003-07-29

Instead of programmatically setting the wait cursor, we can also let the java.awt.EventQueue do the heavy lifting for us. Nathan Arthur explains how. Full Article
074 GoF Factory Method in Writing GUIs 2003-07-14

Instead of using Rapid Application Development (RAD) tools for building GUIs, we can use GoF factory methods to create our user interfaces with code. Full Article
073 LinkedHashMap is Actually Quite Useful 2003-06-22

LinkedHashMap gives us a map that retains the order in which elements were inserted. This can help us maintain a dictionary of key-value pairs in the same order as they were read in. Full Article
072 Java and Dilbert 2003-06-15

We learn how we can download images from within Java and then display them in a JFrame. Full Article
071 Overloading Considered Harmful 2003-06-01

Overloading of methods refers to multiple methods with the same name, but different parameter types. As convenient as this feature is, we should use it sparingly. This newsletter explains why. Full Article
070b Multi-Dimensional Arrays - Creation Performance 2003-05-18

We have a look at the creation cost of multi-dimensional arrays in Java. Full Article
070 Too Many Dimensions Are Bad for You 2003-05-17

Multi-dimensional arrays in Java are simply arrays of arrays. This can have consequences in CPU and memory performance. Full Article
069b Results of Last Survey 2003-05-02

Quick update on the results of the last survey. Only 15.53% knew the correct answer! Full Article
069 Treating Types Equally - or - Life's Not Fair! 2003-04-29

We look at the difference in bytecode between using ints and bytes. We also compare a += b and the longer a = a + b. They are not equivalent. Full Article
068 Appending Strings 2003-04-21

Java compilers convert Strings appended with + to StringBuffer. The generated bytecode is compiler specific, with javac and the Eclipse compiler producing slightly different results. Full Article
067 BASIC Java 2003-03-31

A typical first computer language used to be BASIC. It had a bad reputation for producing spaghetti code, due to the GOTO statement. We show how switch-case and exceptions in Java can look like BASIC. Full Article
066 Book Review: Java Performance Tuning 2nd Ed. by... 2003-03-21

In this book, Jack outlines the process used to make Java systems run faster. He gives lots of tips on how to find your bottlenecks and then also gives specific tricks to make your code just that bit faster. A must-have for Java programmers who care about the speed of their programs. Full Article
065 Wait, Cursor, Wait! 2003-03-06

Coding Swing can be tricky. There are a lot of strange edge cases. One of the harder things to get right are the wait cursors, specifically in conjunction with modal dialogs. We will learn how to set the wait cursor on the parent window/frame of a modal dialog. Full Article
064 Disassembling Java Classes 2003-02-14

Before running a microbenchmark, it can be instructive to examine the code using a tool javap. This shows us the bytecode of the compiled class. Full Article
063 Revisiting Stack Trace Decoding 2003-01-28

Stack traces give us a clue of which method called us, giving us a form of caller ID. Full Article
062b Follow-Up and Happy New Year! 2002-12-31

Java 1.4 changed inner classes slighty to set the link to the outer object prior to calling super(). This avoids some hard to explain NullPointerExceptions. Full Article
062 The Link to the Outer Class 2002-12-27

Inner classes have magic handles to the outer object and provide synthetic methods to acces private data. This can result in some hard-to-understand bugs. Full Article
061 Double-Checked Locking 2002-12-07

The Singleton pattern allows for a single instance to be shared throughout the program. The question we will answer is how to initialize this. Full Article
060 Nulling Variables and Garbage Collection 2002-11-29

For years, programmers have spread the misinformation that it was necessary to set local variables to null to avoid memory leaks. Fortunately Java is smart enough to do that without our help. Full Article
059b When Arguments Get out of Hand... (Follow-Up) 2002-11-13

In this follow-up to our earlier newsletter on "When arguments get out of hand...", we look at the constant pool in Java classes and how this can be affected by how we compile our class. Full Article
059 When Arguments Get out of Hand... 2002-11-11

We turn the dial to full blast and find out how many parameters a method may contain. Wholly impractical, but fun. Full Article
058 Counting Bytes on Sockets 2002-10-09

By specifying our own RMISocketFactory, we can monitor the number of bytes that are transmitted over RMI. Full Article
057 A Tribute to My Dad, Hans Rudolf Kabutz 2002-09-22

A personal note of thanks to my father, who inspired me to "keep on writing". Full Article
056 Shutting down Threads Cleanly 2002-09-16

Starting threads is easy. Shutting them down again in an orderly fashion is not. In this newsletter we explore how to use interrupts to indicate to a thread that it should cooperatively shut down. Full Article
055 Once Upon an Oak ... 2002-08-26

A long time ago, James Gosling wrote Oak, which was later renamed to Java. Some of the quirky Java restrictions, for example only one public class per file, can be traced back to Oak. This newsletter looks at the Oak 0.2 specification. Full Article
054b Follow-Up to JDK 1.4 HashMap hashCode() Mystery 2002-08-15

The "remainder function" is a form of division. "Division" is the most expensive CPU operation. HotSpot can transform "remainder" to a cheaper "multiply" operation. When benchmarking, we need to make sure that the divisor is not constant. Full Article
054 HashMap Requires a Better hashCode() - JDK 1.4 ... 2002-08-14

One of the most significant changes in JDK 1.4 is regarding how the HashMap works internally. Instead of the remainder function, it now uses bit masking to assign keys to buckets. This change has implications on how we write our hashCode() method. Full Article
053 Charting Unknown Waters in JDK 1.4 Part I 2002-07-23

In Java 1.4, they added some cool new features. First off, toString() in collections was improved to avoid a StackOverflowError, secondly the RandomAccess interface was introduced and lastly, the JavaDocs were improved to also contain specifications of what unchecked exceptions to expect. Full Article
052 J2EE Singleton 2002-07-02

Singleton is one of the most recognizable design pattern from the Gang of Four book. We read how David Jones applies it to J2EE. Full Article
051 Java Import Statement Cleanup 2002-06-18

Import statements can get out of date quickly as we refactor our code. In this newsletter, our guest author Dr. Cay S. Horstmann shows us how we can clean up our import statements. Full Article
050 Commenting out Your Code? 2002-06-10

Source control systems give us insight into how a method has changed over time. It is usually a bad idea to comment out code, especially without adequate comments why. It confuses the person maintaining the code. Full Article
049 Doclet for Finding Missing Comments 2002-06-05

Another use of JavaDoc is to use the engine to find where comments are missing from our code. Full Article
048 Book Review: The Secrets of Consulting by Geral... 2002-05-29

How much do your customers love you? How should you give and receive advice? In this excellent book, we learn why it is so important to understand your customer. I use the principles daily in my work with code reviews, performance tuning and dealing with customers or clients. Full Article
047 Lack of Streaming Leads to Screaming 2002-05-24

Instead of writing and reading blobs as large byte[], we should rather stream the data using ResultSet.getBytes(). Full Article
046 "The Compiler Team Is Writing Useless Code Agai... 2002-05-05

We found a gem in Java 1.3, where a simple typo resulted in a strange static initializer method. Full Article
045 Multi-Line Cells in the JTable 2002-04-11

In this newsletter we have a look at how we can render a JTextArea in a JTable cell. Full Article
044 Book Review: Object-Oriented Implementation of ... 2002-04-01

In our first book review, we look at an interesting book that talks about implementing numerical methods in Java. Although not primarily a Java book, it gives us some insight as to the performance of Java versus other languages like C or Smalltalk. Full Article
043 Arrgh, Someone Wants to Kill Me! 2002-03-11

In Java we can use OS signals directly for detecting when a program is being closed. This can be used to write our own shutdown hook or put in whatever feature we need. Full Article
042 Speed-Kings of Inverting Booleans 2002-02-23

Java has some interesting ways in which we can invert a boolean value. We compare the speed of various approaches. Full Article
041 Placing Components on Each Other 2002-02-15

Swing uses the Composite design pattern for components. This means that we can place components on each other, creating new types of widgets. An example would be a JButton that also contains a JCheckBox. Full Article
040 Visiting Your Collection's Elements 2002-01-31

When iterating over a heterogeneous collection, one way to differentiate between object types is with instanceof. Another way is to create a special visitor object that can be applied to the objects in the collection. Full Article
039 Why I Don't Read Your Code Comments ... 2002-01-17

In this, our most misunderstood newsletter, I wax lyrically about the poor quality of comments in code. Often the comments are not in sync with what the code does. Trust them at your own risk. Full Article
038a Counting Objects Clandestinely 2001-12-28

In this newsletter, we modify the class Object to secretly count how many of each class are constructed. Full Article
038b Counting Objects Clandestinely (Follow-Up) 2001-12-28

A few questions came up in our previous newsletter, so here is a follow-up with answers. Full Article
037 Checking That Your Classpath Is Valid 2001-12-13

One of the challenges Java programmers had in the early days was to get the classpath right. In this newsletter, Sydney Redelinghuys presents some ideas on how to make sure that all the entries point to actual files. Full Article
036 Unicode Variable Names 2001-11-23

Java supports unicode in variable and method names, although we generally recommend using ASCII characters. Here we have a look at how to do it. Full Article
035 Doclets to Find Bad Code 2001-11-17

The JavaDoc tool can do more than just generate HTML documentation for our Java classes. We can also write our own "Doclets" to scan the source code in our project. In this newsletter we look at how we can (ab)use JavaDoc to look for classes with non-private fields. Full Article
034 Generic Types with Dynamic Decorators 2001-10-24

Prior to Java 5, we had to jump through all sorts of hoops to get something like generics. In this newsletter we use "dynamic decorators" to produce type-safe iterators dynamically. Full Article
033 Making Exceptions Unchecked 2001-10-18

Checked exceptions are a strange design that can make Java frustrating to use. In this article we wrap it with an unchecked exception, but delegate the printing methods to the wrapped exception. Full Article
032 Exceptional Constructors - Resurrecting the Dead 2001-10-11

One way to protect ourselves from badly constructed objects is to throw an exception from the constructor. However, the object can be resurrected if the class is non-final by using the finalize() method. Full Article
031 Hash, Hash, Away It Goes! 2001-09-26

When I first started using Java in 1997, I needed very large hash tables for matching records as quickly as possible. We ran into trouble when some of the keys were mutable and ended up disappearing from the table, and then reappearing again later. Full Article
030 What Do You Prefer? 2001-09-17

We learn how to build a simple, yet usable, cross-platform registry editor using standard Java. Full Article
029 Determining Memory Usage in Java 2001-08-28

Full Article
028 Multicasting in Java 2001-08-14

In this newsletter, we learn how to do network multicasting in Java using the Datagram class. Full Article
027 Circular Array List 2001-08-02

ArrayList can become slow when used as a FIFO queue. Whenever an element is removed from the head, the other elements need to be moved one space to the left. This is an O(n) operation and slows down the remove(0) operation the longer the list becomes. In this newsletter we describe a CircularA... Full Article
026 Package Versioning 2001-07-25

Packages should have versions numbers embedded in the Jar file's manifest. Our guest author Herman Lintvelt shows us how. Full Article
025 Final Newsletter 2001-07-12

No, this is not our "final" newsletter, but rather a newsletter about the "final" keyword. Full Article
024 Self-Tuning FIFO Queues 2001-07-06

If we were to use a List as a Queue, which would be better: ArrayList or LinkedList? Turns out that it depends on the length of the list. In this newsletter we try write a self-tuning queue, which swaps over to a suitable implementation based on the number of current elements. Full Article
023 Socket Wheel to Handle Many Clients 2001-06-21

Prior to Java NIO, we needed one thread per socket. In this newsletter we show how we can use timeouts on the sockets to simulate something like non-blocking IO. Full Article
022 Classloaders Revisited: "Hotdeploy" 2001-06-07

In this newsletter, Dr Christoph Jung amazes us by showing how we can build a minimalist application server by playing around with class loaders. Full Article
021 Non-Virtual Methods in Java 2001-05-31

In Java all methods are virtual, meaning that the most derived method is always called. In earlier versions of Java, it was possible to trick the JVM by replacing the superclass with another wheere the method is defined as "private". Full Article
020 Serializing Objects into Database 2001-05-24

In this newsletter, we serialize Java objects into a byte[] and then write that into a PreparedStatement with setBytes(). Full Article
019 Finding Lost Frames 2001-05-10

We keep a list of created Frame instances handy, so that we can find them again when we create Dialogs. This prevents ownerless modal Dialogs from causing issues. Full Article
018 Class Names Don't Identify a Class 2001-05-03

Classes loaded by different ClassLoaders are considered distinct, even when they have the exact same name and bytecode. Full Article
017b Switching on Object Handles (Follow-Up) 2001-04-28

A quick follow-up to our newsletter on abusing exceptions to simulate the switch construct, looking at the performance in comparison to other approaches. Full Article
017a Simulating Switch Statements on Object Handles ... 2001-04-26

The try-catch construct can be used for program flow control. In this newsletter we abuse it to simulate the switch statement. Full Article
016 Blocking Queues for Inter-Thread Communication 2001-04-11

In the days before BlockingQueue was added to Java, we had to write our own. This newsletter describes an approach using synchronized and wait()/notify(). Full Article
015 Implementing a SoftReference Based HashMap 2001-03-28

We all know WeakHashMap, which has WeakReferences to the keys and strong references to the values. In this class we instead have SoftReferences to the keys. This means that entries will typically be removed once we get low on memory, rather when there are no more references to the keys. Full Article
014 Insane Strings 2001-03-21

Some crazy antics as we modify the contents of the char[] embedded within Strings. Of little practical value, except to gain some understanding of how things work under the covers. Full Article
013b Serializing GUI Components Across Network (Foll... 2001-03-15

The previous newsletter had a dependency that stopped us serializing the components. The code worked when compiled with JBuilder 2, but not when compiled with the JDK 1.3. Full Article
013a Serializing GUI Components Across Network 2001-03-14

Thousands of classes implement the Serializable interface, meaning we can write them over an ObjectOutputStream. Amongst these is java.awt.Component, the superclass of all GUI classes in AWT and Swing. We can thus serialize JTable, JLabel, even JFrame. Full Article
012 Setting Focus to Second Component of Modal Dialog 2001-03-07

In Swing, we sometimes need to set the focus to the second component. This newsletter describes how to do it. Full Article
011 Hooking into the Shutdown Call 2001-02-28

System.exit() does not immediately shut down the Java Virtual Machine. Instead, it first runs our shutdown hooks, albeit in an undefined order. Once they are done, the JVM stops for real. Full Article
010 Writing Own GUI Layout Manager 2001-02-22

Layout managers in AWT/Swing can be frustrating to use. After trying various combinations, my colleague gave up and asked me for help. Instead of battling with GridBagLayout, we wrote our own LayoutManager. It was surprisingly simple and very effective. Full Article
009 Depth-First Polymorphism 2001-02-15

Usually in Java, polymorphism is done depth-first. This is the reason why in Java 5, classes implementing Comparable cannot be further specialized to another Comparable type (compareTo takes an Object). In this newsletter we look at how we can change this to breadth-first polymorphism. Full Article
008 Comparing Boolean Variables 2001-02-08

Java was based on ideas taken from C/C++, but the designers of the language tightened up the language significantly. In C/C++, a zero (0) means false and non-zero (e.g. 1) means true. In this newsletter, we examine how we should be comparing booleans. Full Article
007 java.awt.EventQueue 2001-02-01

In this newsletter, we learn how we can create our own EventQueue and then use that to intercept all the events that arrive in AWT/Swing. Full Article
006 Implementation Code Inside Interfaces 2001-01-25

Did you know that it is possible to define inner classes inside interfaces? This little trick allows us to create method objects inside an interface. Full Article
005 Dynamic Proxies - Short Tutorial 2001-01-18

Dynamic proxies can help us reduce the amount of code we have to write. In this newsletter, our guest author, Dr Christoph Jung, gives us a short tutorial on how the dynamic proxies work. Full Article
004 Logging Part 2 2001-01-11

We look at some tricks on how we can track where things are happening in our code, which can then be used for producing more detailed logging. Full Article
003 Logging Part 1 2000-12-14

In this newsletter we look at how we can write a TeeOutputStream that works similarly to the unix "tee" utility and pipes the output to two different OutputStreams. We can then reassign System.out to be written to a file and to the old System.out. Full Article
002 Anonymous Inner Classes 2000-12-07

Anonymous inner classes allow us to call super class methods inside its initializer block. We can use this to add values to a collection at point of creation, for example: new Vector(3) {{ add("Heinz"); add("John"); add("Anton"); }}); Full Article
001 Deadlocks in Java 2000-11-30

Java deadlocks can be tricky to discover. In this very first Java Specialists' Newsletter, we look at how to diagnose such an error and some techniques for solving it. Full Article

Subscribe Now

Get: every new article, exclusive invites to live webinars, our top-10 articles ever, access to expert tutorials & more!

Agree to JavaSpecialists Privacy Policy *

Read our Privacy Policy

About the Author

Java Champion, author of the Javaspecialists Newsletter, conference speaking regular... About Heinz

Superpack '23

Our entire Java Specialists Training in one huge bundle more...

Free Java Book

Java Training

We deliver relevant courses, by top Java developers to produce more resourceful and efficient programmers within their organisations.

Java Consulting

We can help make your Java application run faster and trouble-shoot concurrency and performance bugs...

JavaSpecialists

We deliver relevant courses, by top Java developers to produce more resourceful and efficient programmers within their organisations. Find Out More

Javaspecialists

The JavaSpecialists' Newsletter

Celebrating 24 years of publication, enjoyed in over 155 countries by 70,000 of the world's top Java programmers and spanning over 300 specialist Java articles.

Newsletter Archive (All)

About the Author

Superpack '23

Free Java Book

Java Training

Java Consulting

JavaSpecialists

Quick Links

Connect With Us

Javaspecialists

The JavaSpecialists' Newsletter

Celebrating 24 years of publication, enjoyed in over 155 countries by 70,000 of the world's top Java programmers and spanning over 300 specialist Java articles.

Newsletter Archive (All)

320 Please Don't Yield A Lot 2024-11-30

319 ArrayBlockingQueue: Weakly Consistent Iteration... 2024-10-25

318 Getting Rid of Unused Warnings with _ 2024-05-31

317 Explicit vs Diagnostic GC 2024-04-30

316 Code Before super() - JEP 447 2024-03-30

315 Random Newsletter 2024-02-29

314 Harnessing the Power of ChatGPT 4.0 From Java 2024-01-31

313 Selling Our Java Skills 2023-11-27

312 Alternate String Formatting with # 2023-10-24

311 Virtual Threads and Parallel Streams 2023-08-31

310 Garbage Collection and P99 Latency 2023-06-29

309 TreeSet with Custom Comparator 2023-05-31

308 Formatting Inlined @value in Javadocs 2023-04-30

307 AccessFlag Set for Modifiers 2023-03-30

306 Measuring compact strings memory savings 2023-01-30

305 Contributing BigInteger.parallelMultiply() to O... 2022-11-30

304 ObjectInputFilter 2022-10-31

303 Null Keys and Values in Maps 2022-08-30

302 Virtual Thread Deadlocks 2022-06-30

301 Gazillion Virtual Threads 2022-05-24

300 Break in Switch With Pattern Matching 2022-04-26

299 Synchronizing on Value-Based Classes 2022-03-31

298 Finding Permitted Subclasses 2022-02-28

297 Measuring ForkJoinPool Parallelism 2022-01-31

296 Concurrent LinkedHashSet 2021-12-31

295 Faster Empty Streams 2021-11-26

294 String.format() 3x faster in Java 17 2021-10-29

293 Canonical Orders 2021-09-30

292 StartingGun Synchronizer 2021-08-31

291 Snakes and Ladders 2021-07-20

290 CopyOnWriteArrayList and Collection.toArray() 2021-06-10

289 MergingSortedSpliterator 2021-04-03

288 Weakly Consistent Iteration 2021-04-01

287 @PolymorphicSignature 2021-01-31

286 Discernment on the Shoulders of Giants 2020-11-30

285 I/O Stream Memory Overhead 2020-10-30

284 java.util.PrimitiveIterator.OfInt 2020-09-30

283 Four Billion Changes 2020-08-28

282 Biased locking a goner, but better things Loom ... 2020-07-21

281 Puzzle 2: Is it garbage? 2020-06-24

280 Puzzle: What's up with Vector? 2020-06-23

279 Upgrading ReadWriteLock 2020-05-28

278 Free Memory 2020-04-30

277 Strings with Zero HashCode 2020-03-30

276 Serializing Records 2020-02-29

275 EnhancedStream with Dynamic Proxy 2019-11-23

274 EnhancedStream 2019-11-22

273 Truly Public Methods 2019-10-01

272 Hacking Enums Revisited 2019-09-07

271 HttpClient Executors 2019-08-21

270 Excursions into Deduplication 2019-05-31

269 Heterogeneous Comparisons 2019-04-29

268 Puzzle: Is a Programmer a Person? 2019-03-06

267 Performance Impact of Design Patterns 2019-02-18

266 Threading Questions in Job Interviews Part 2 2019-02-12

265 Threading Questions in Job Interviews Part 1 2019-01-02

264 2018 Retrospective - Living Entrepreneurially 2018-12-19

263 Anonymous Tuples 2018-11-28

262 How Java Maps Protect Themselves from DOS Attacks 2018-10-09

261 Concurrent Queue Sizes and Hot Fields 2018-09-20

260 Java Is Still Free 2018-09-17

259 Try-With-Resource in Plain Java 2018-07-01

258 ShuffleCollector 2018-04-09

257 CountDownLatch vs CyclicBarrier vs Phaser 2018-04-02

256 Java 10: Parallel Full GC in G1GC 2018-03-31

255 Java 10: Inferred Local Variables 2018-02-28

254 Big O Cost of Class.getMethod() 2018-02-27

253 Builder Pattern GoF vs Effective Java 2018-02-26

252 New Year Day Spliterator 2018-01-01

251 Collections.checkedCollection() 2017-11-30

250 Learning Java with jshell 2017-10-26

249 @Contended @since 9 2017-08-23

248 Immutable Collections in Java 9 2017-05-31