The Curious Engineer

All blogs / Java / JVM

Vanilla Java

blog.vanillajava.blog

Understanding how Core Java really works can help you write simpler, faster applications.

Java / JVMPerformance / optimizationAI / MLEngineering blogs

’10’15’20’25
Posts
385 from 2 May 2010 to 12 Sep 2026
Posting
now and then (4 in the last year)
Kind
personal blog
Feed
http://blog.vanillajava.blog/feeds/posts/default

2026 4

  1. Deciding how to progress your career and find work you find interesting/challenging.
  2. Which Doc Format is Best for AI Specifications?
  3. Why You Should Tune Code Before Your Garbage Collector
  4. Testing Java Memory Management with Chronicle-FIX using AI

2025 9

  1. Updated Biography
  2. Improving the prompt to the AI to get better code
  3. Asking multiple AI to optimise the same code
  4. Practical Considerations for Advancing AI Collaboration in Software Development
  5. A Functional intreface can extend other interfaces
  6. Hands-On Career: The Evolution of a Java Champion
  7. Does AI-Generated Documentation Have Value?
  8. Generative AI and the Reverse Baltimore Phenomenon
  9. Prompt Engineering for AIDE

2024 33

  1. Next-Level Development: Harnessing AI with AIDE
  2. Empowering Your Annotations with Fields
  3. Dates aren't what they used to be
  4. The AI Trough
  5. AI on a Hype Cycle
  6. What might an AI System Prompt look like?
  7. Demystifying Java Object Sizes: Compact Headers, Compressed Oops, and Beyond
  8. Novel Uses of Core Java for Low-Latency and High-Performance Systems
  9. Trivially Copyable Objects in Java
  10. Efficient Distributed Unique Timestamp Identifier Generation
  11. A Java Conversion Puzzler: Understanding Implicit Casting and Overflow
  12. Why Does Math.round(0.49999999999999994) Round to 1?
  13. TLDR: Designing Hyper-Deterministic, High-Frequency Trading Systems
  14. Performance Tip: Specify Collection Capacity When Size is Known
  15. Performance Tip: Rethinking Collection.toArray(new Type[0])
  16. Storing 1 TB in Virtual Memory on a 64 GB Machine with Chronicle Queue
  17. Unveiling Floating-Point Modulus Surprises in Java
  18. Thread Safety Issues with Vector and Hashtable
  19. Exceptional Exception, StackTrace extends Throwable
  20. StringBuffer is Dead, Long Live StringBuffer
  21. What can make Java code go faster, and then slower?
  22. Overly Long Class Names in Java or Geeky Poem?
  23. Unexpected Full GCs Triggered by RMI in Latency-Sensitive Applications
  24. How SLOW can you read/write files in Java?
  25. Advanced Applications of Dynamic Code in Java
  26. Two Overlooked Uses of Enums in Java
  27. How to avoid using a Triple Cast
  28. Calculating an Average Without Overflow: Rounding Methods
  29. Why double Still Outperforms BigDecimal: A Decade-Long Performance Comparison
  30. Incomparable Puzzles in Java
  31. Ten Java Myths and Misconceptions
  32. Java Arrays, Wat!
  33. Some Common Java Gotchas and How to Avoid Them

2022 11

  1. Java is Very Fast, If You Don’t Create Many Objects
  2. Comparing Approaches to Durability in Low Latency Messaging Queues
  3. Event-Driven Order Processing Program
  4. Efficient Memory Mapping for Terabyte Sparse Files in Java
  5. Event Driven Hello World Program
  6. How Behaviour Driven Development Works Well with Event Driven Architectures
  7. The More You Say, the Less People Remember The Fewer the Words, the Greater the Profit
  8. Nine Core Java Questions
  9. Eight Core Java Questions
  10. Benchmarking Kafka vs Chronicle for Microservices: which is 750 times faster?
  11. Distributed Unique Time Stamp Identifiers

2021 3

  1. System wide unique nanosecond timestamps
  2. Unusual Java: StackTrace Extends Throwable
  3. Low Latency Microservices, A Retrospective

2017 13

  1. Reviewing Exception Handling
  2. Distributing common java apis
  3. Modelling microservice patterns in code
  4. Simple asynchronous microservices using
  5. Microservices are about applying group
  6. Bad string we have program here that
  7. A jdbc gateway microservice deep dive
  8. Microservices in chronicle world part 5
  9. Microservices in chronicle world part 4
  10. Microservices in chronicle world part 3
  11. Microservices in chronicle world part 2
  12. Microservices in chronicle world part 1
  13. Micro services for performance

2016 17

  1. Hubpress now has RSS support.
  2. Goldilocks Microservices
  3. Talks on performant microservices, exception handling and documentation driven development.
  4. Distributing Common Java APIs
  5. Modelling Microservice Patterns in Code
  6. Simple Asynchronous Microservices using Lambda Architecture
  7. Microservices are about applying a group of Best Practices
  8. Bad String abuse
  9. An Interveiw on my talk for Low Latency Microservices at QCon New York
  10. Turning JDBC into a Micro Service
  11. Low latency Microservices
  12. Micro-services for performance
  13. Moving to Github and Asciidoc
  14. Printing arrays by hacking the JVM.
  15. Simple Event Driven design
  16. How do low latency applications differ for regular applications?
  17. StackOverflow Q&A you should read if you program in Java

2015 27

  1. Some reviews of my JavaOne 2015 talks
  2. My Bio
  3. Common misconception: How many objects does this create?
  4. Low latency FIX engine in Java
  5. Custom operators for collections in Java
  6. An introduction to optimising a hashing strategy
  7. Chronicle Journal - Customizable Data Store
  8. Half priced Gold support.
  9. What does Chronicle Software do?
  10. Managing your application as a file system
  11. What do AIs have to talk about?
  12. Comparing Hashing strategies
  13. Upcoming presentations
  14. Using JSON in a low latency environment
  15. Wiring YAML to a file or network with Chronicle Wire.
  16. Using YAML over the network.
  17. Accessing Chronicle Engine via NFS
  18. Is using Unsafe really about speed or functionality?
  19. Using JMH to find the fastest way to encode/decode UTF8
  20. How and Why to Serialialize Lambdas
  21. Puzzler: nested computeIfAbsent
  22. What are the bad features of Java.
  23. Inconsistent operation widen rules in Java
  24. Java 8 Optional is not just for replacing a null value
  25. micro-timing
  26. Mixing memory unit messages
  27. Java Lambdas and Low Latency

2014 27

  1. On heap vs off heap memory usage
  2. Chronicle Map and Yahoo Cloud Service Benchmark
  3. Essentialism and Technology
  4. A Java conversion puzzler, not suitable for work (or interviews)
  5. Kafka Benchmark on Chronicle Queue
  6. Men in Tech
  7. lambdas and side effects.
  8. An Inconvenient Latency
  9. Try optimising the memory consumption first
  10. Team training in Expert Core Java
  11. Compounding double error
  12. If BigDecimal is the answer, it must have been a strange question.
  13. Adding @atomic operations to Java
  14. Making operations on volatile fields atomic.
  15. Classes in the JLS 8
  16. MineCraft and off heap memory
  17. Making Unsafe safer
  18. SharedHashMap vs Redis
  19. Uncomparable puzzles in Java
  20. Chronicle and low latency in Java
  21. Common Java Myths
  22. Java arrays, Wat!?
  23. Common gotchas in Java
  24. Hardware Transactional Memory in Java, or why synchronized will be cool again.
  25. sun.misc.Unsafe and off heap memory
  26. Hiring a Java Analyst Developer
  27. Interview: Starting out as an IT Consultant.

2013 36

  1. Why we shouldn't use more threads than we need to
  2. Computing units don't have to be confusing
  3. Unique hashCodes is not enough to avoid collisions.
  4. Interning in High Frequency Trading systems
  5. Writing and Testing High Frequency Trading Engines talk at JavaOne
  6. Update on Writing and Monitoring HFT systems
  7. Tutorial on writing and monitoring low latency, high throughput systems in Java.
  8. C++ like Java for low latency
  9. How do I calculate the remainder for extremely large exponential numbers using Java?
  10. OpenHFT Java Lang project
  11. ext4 slower than tmpfs
  12. Micro jitter, busy waiting and binding CPUs
  13. Easy to add but hard to remove
  14. High resolution timings without the custom hardware
  15. Plans for Chronicle 2.0
  16. The Java version of patenting the Wheel
  17. Exercise to understand double.
  18. Presentation on; Using BigDecimal and double
  19. First talk posted online
  20. Is it better to use immutable or mutable values in multi-threaded systems
  21. A very interesting expert panel
  22. Performance Java User's Group (redo)
  23. First Performance Java User's Group meeting
  24. Why a synchronized StringBuffer was never a good idea
  25. Low GC Coding: Efficient listeners (exercise)
  26. Lies, statistics and vendors
  27. Simplifying low latency services
  28. Low latency services
  29. Chronicle and the Micro-Cloud
  30. Performance Java Training Details
  31. Performance Java Training
  32. Java is dead (again)
  33. A down side of durable messaging
  34. High Performance Durable Messaging
  35. Java Memory Model and optimisation.
  36. Should Java be more high level or low level?

2012 57

  1. Can synchronization be optimised away?
  2. Local variables inside a loop and performance
  3. Object resurrection
  4. Over one million page views
  5. A use for overflow
  6. Performance of inlined virtual method invocations in Java
  7. When using direct memory can be faster
  8. Wasting time by saving memory
  9. Why is it not allowed in Java to overload Foo(Object…) with Foo(Object[])?
  10. Practical uses for WeakReferences
  11. Why Double.NaN==Double.NaN is false
  12. Java Intrinsics and Performance
  13. Java += and implicit casting
  14. Moving the decimal place in a double
  15. Can try/finally prevent a StackOverflowError?
  16. Hidden code
  17. String intern puzzle
  18. Map interface and equals()
  19. Java memes which refuse to die
  20. Uses for special characters in Java code
  21. Odd practices in Java
  22. My first article in Oracle Magazine
  23. What is latency, throughput and degree of concurrency?
  24. yield(), sleep(0), wait(0,1) and parkNanos(1)
  25. Why Math.round(0.499999999999999917) rounds to 1 on Java 6
  26. EOL Date for Java 6
  27. Complexity of Time
  28. Art of Programming
  29. Quotes relating to System Design
  30. Adding code to an annotation
  31. Presentation on Using Shared Memory in Java
  32. Different results summing a double[]
  33. Benchmarking a slow machine
  34. Attending the LJC QCon London Meeting.
  35. Magazine layout appears to increase page views
  36. File local access
  37. How much difference can thread affinity make
  38. High performance libraries in Java
  39. Using Java 7 to target much older JVMs
  40. Ultra low latency Event Store
  41. "Java Sucks" revisited
  42. Demonstrating when volatile is required
  43. Another Shifty Challenge
  44. Shifting Challenge
  45. Unsigned Challenge
  46. Java Thread Affinity support for ExecutorService
  47. Java Thread Affinity support for hyper threading.
  48. Surprising results of autoboxing
  49. Java Thread Affinity supports groups of threads.
  50. Generating every combination without duplicates
  51. Project Euler
  52. Generic class names to avoid
  53. Top Java Article of 2011
  54. String.valueOf(int) vs "" + int
  55. An odd case of initialization
  56. Java Puzzler, double chars
  57. Regex vs IndexOf in Java.

2011 136

  1. Happy New Year all
  2. Using a memory mapped file for a huge matrix
  3. Thread Affinity library for Java supports JNA
  4. What skills should a Core Java Developer have?
  5. Solution: What is this broken code doing
  6. What is this broken code doing
  7. Solutions: Testing an Anagram of a Palindrome
  8. synchronized is slower but not worth worrying about
  9. DZone adds page view summary.
  10. Java Interview Question; Anagram of a Palindrome
  11. Thread Affinity library for Java.
  12. Java Puzzle operator confusion
  13. Java puzzle System.exit and locks.
  14. Test a complete failure of the JVM
  15. Java puzzle, low latency queue
  16. Low Latency Slides
  17. Ever decreasing cost of main memory
  18. Stupid performance trick in Java
  19. Java puzzle (Single threaded client server)
  20. Java puzzle (Sum of even Fibonacci numbers)
  21. How arbitary is the start of System.nanoTime()?
  22. Why Concurrency examples are confusing
  23. Recycling objects to improve performance
  24. Serialization using ByteBuffer and recycled objects
  25. Serialization benchmarks and charts
  26. Strine translator
  27. Randomly not so random
  28. Java plus
  29. HugeCollections moved to github
  30. New Contributors to HugeCollections
  31. Forum for ideas
  32. The Exchanger and GC-less Java
  33. Is making Boost more like Java a good idea?
  34. Memory alignment in C, C++ and Java
  35. Why thread priority rarely matters
  36. Order of elements in a hash collection
  37. The importance of innovation
  38. Java can be significantly faster than C
  39. MethodHandle performance in Java 7
  40. Added Memory Mapped support to HugeCollections
  41. Writing to stdin
  42. Avoiding Java Serialization to increase performance
  43. Generating ASCII Banners
  44. Double your money again
  45. Why testing code for thread safety is flawed
  46. Collections Library for millions of elements
  47. Tuning buffer sizes
  48. Comparing Collections speeds
  49. Reading/writing GC-less memory
  50. 50,000 pages views last month
  51. A collection with billions of entries
  52. Should server applications limit themselves to 4 GB?
  53. Strange Hello World in Java
  54. Comparing Java 7 Async NIO with NIO.
  55. Using tmpfs to speed up "disk" access
  56. Synchronized vs Lock performance
  57. C++ or Java, which is faster for high frequency trading?
  58. How fast are Java Datagrams?
  59. Why are the keys of a Map in a jumbled order
  60. Size of an entry in a Map
  61. Send XML over a Socket fast
  62. How fast are Java sockets
  63. Java: How much memory do different arrays consume
  64. Java and Memory Leaks
  65. Java: What is the limit to the number of threads you can create?
  66. Java: Getting the size of an Object
  67. 30,000 hits last month.
  68. Incorrect Core Java Interview Answers
  69. Java Secret: Generated methods
  70. Java low level: Converting between integers and text (part 2)
  71. Java low level: Converting between integers and text (part 1)
  72. Java: All about 64-bit programming
  73. Human Readable vs Machine Readable Formats
  74. 20000 hits last month.
  75. Low GC in Java: Using primitives
  76. World's first commercial quantum computer
  77. New toy for home
  78. Low GC in Java: Use primitives instead of wrappers
  79. Java Secret: Loading and unloading static fields.
  80. 15,000 hits last month.
  81. Java Secret: Are static blocks interpreted?
  82. Being as fast as possible is a bad idea
  83. Java Secret: What is called before main.
  84. Java Secret: More uses for varargs
  85. Queues with Threads to be avoided.
  86. 4000 hits today.
  87. Java Secret: Using an enum to build a State machine.
  88. Java Insanity: Two methods with the same super.method()
  89. Java Secrets: Using ExecutorService to run many background tasks.
  90. How to avoid Garbage Collection
  91. Java Secret: Labels as an Anti-Pattern
  92. Java Secret: Double Brace Initialization
  93. Java Secret: InheritableThreadLocal
  94. Java Secret: LRU cache in Java.
  95. Are String, Date, Method immutable?
  96. Bugs: Don't use new StringBuilder(char)
  97. Best Practice: Don't use equals(null)
  98. Best Practice: Don't create instances of Utility classes.
  99. Bugs: Don't use co-variant equals and compareTo
  100. Best Practices: Don't make the finalize() method public.
  101. Performance Tip: Avoid creating an Object to convert between a primitive and String.
  102. Performance Tip: Avoid using String + inside a StringBuilder.append()
  103. Performance Tip: Avoid using a String when char will do.
  104. Performance Tip: Avoid String operations which don't do anything.
  105. Performance Tip: Use StringBuilder instead of String for a non constant field.
  106. Performance Tip: System.arrayCopy is usually faster than a manual array copy.
  107. Performance tip: If you want to iterate over the keys and values use entrySet()
  108. Performance Tip: Use static fields and classes.
  109. PeformanceTip: Pre-compile your patterns
  110. Performance Tip: Don't use StringBuilder for compile time constants.
  111. Performance Tip: Avoid "" + x to convert to a String.
  112. Performance Tip: Set the capacity of a collection is you know its size.
  113. Performance Tip: Use String.intern() correctly.
  114. Performance Tip: avoid Collection.toArray(new Type[0])
  115. A review of some old best practices
  116. Common tricks to optimising Java with examples from the JDK
  117. Writing human readable data faster than binary.
  118. How long does throwing an Exception take?
  119. Linkedin Group for Core Java Performance Professionals
  120. Does Thread.stop() really stop a Thread?
  121. When the JIT gets it wrong
  122. Forgotten feature of LinkedHashMap.
  123. How to get C like performance in Java
  124. Special non-exceptions.
  125. StringBuffer is dead, long live StringBuffer
  126. What can make Java code go faster and slower.
  127. Improving Java support for 64-bit.
  128. Tasks to test your Java concurrency skills.
  129. Creating Dangling Pointers in Java
  130. A history of "Java is Dead"
  131. With generics, the return type is part of the method signature.
  132. float has a use after all.
  133. Don't type 2.2250738585072012e-308 in java.
  134. Memory was cheap but now its cheaper.
  135. Using unsigned values in Java
  136. How *slow* can you read/write files in Java?

2010 12

  1. More uses for dynamic code in Java.
  2. Two uses for enum most people forget.
  3. Gotcha: Save on objects and get more Full GCs.
  4. Java NIO is faster than Java IO for Sockets
  5. Stupidly long class name or a geeky poem?
  6. Memory is cheaper than you think.
  7. Fastest way to lock/synchronize objects.
  8. OMG: Using a triple cast.
  9. Calculating an average.
  10. Monotonically increasing time
  11. Accuracy of double representation for decimals.
  12. Locking a ConcurrenthashMap for exclusive access.