At Data Geekery, we go to the edge of what’s possible in the Java language to deliver you an awesome jOOQ experience. While doing that, we’ve found a lot of subtleties in the language, which we’re sharing with you on this list.
Java Top Picks
- Top 10 Easy Performance Optimisations in Java
- 10 Things You Didn’t Know About Java
- 10 Subtle Mistakes When Using the Streams API
- 10 Subtle Best Practices when Coding Java
Java
- Java’s Checked Exceptions Are Just Weird Union Types
- Write C-Style Local Static Variables in Java 16
- Could we Have a Language That Hides Collections From Us?
- A Quick Trick to Make a Java Stream Construction Lazy
- How to Unit Test Your Annotation Processor using jOOR
- Imperative Loop or Functional Stream Pipeline? Beware of the Performance Impact!
- How to Patch Your IDE to Fix an Urgent Bug
- How to Compile a Class at Runtime with Java 8 and 9
- Correct Reflective Access to Interface Default Methods in Java 8, 9, 10
- How to Order Versioned File Names Semantically in Java
- How to Implement Your Own XJC Plugin to Generate toString(), equals(), and hashCode() Methods
- A Common Mistake Developers Make When Caching Nullable Values
- How to Ensure Your Code Works With Older JDKs
- Squeezing Another 10% Speed Increase out of jOOQ using JMC and JMH
- Benchmarking JDK String.replace() vs Apache Commons StringUtils.replace()
- A Curious Java Language Feature and How it Produced a Subtle Bug
- Are Java 8 Streams Truly Lazy? Not Completely!
- A Basic Programming Pattern: Filter First, Map Later
- A Nice API Design Gem: Strategy Pattern With Lambdas
- Should I Implement the Arcane Iterator.remove() Method? Yes You (Probably) Should
- The Java Ecosystem’s Obsession with NonNull Annotations
- Would We Still Criticise Checked Exceptions, If Java had a Better try-catch Syntax?
- The Parameterless Generic Method Antipattern
- Watch Out For Recursion in Java 8’s [Primitive]Stream.iterate()
- Improve Your JUnit Experience with this Annotation
- Java A’s new Local-Variable Type Inference
- An Ingenious Workaround to Emulate Union Types in Java
- How to Support Java 6, 8, 9 in a Single API
- The Mute Design Pattern
- (Ab)using Java 8 FunctionalInterfaces as Local Methods
- If Java Were Designed Today: The Synchronizable Interface
- Please, Java. Do Finally Support Multiline String Literals
- JEP 277 “Enhanced Deprecation” is Nice. But Here’s a Much Better Alternative
- 3 Reasons why You Shouldn’t Replace Your for-loops by Stream.forEach()
- A Subtle AutoCloseable Contract Change Between Java 7 and Java 8
- Beware of Functional Programming in Java!
- Comparing Imperative and Functional Algorithms in Java 8
- Common SQL Clauses and Their Equivalents in Java 8 Streams
- Java 8’s Method References Put Further Restrictions on Overloading
- We’re Taking Bets: This Annotation Will Soon Show up in the JDK
- How to Access a Method’s Result Value From the Finally Block
- 10 Java Articles Everyone Must Read
- Avoid Recursion in ConcurrentHashMap.computeIfAbsent()
- The Java Legacy is Constantly Growing
- Top 5 Use-Cases For Nested Types
- Leaky Abstractions, or How to Bind Oracle DATE Correctly with Hibernate
- Really Too Bad that Java 8 Doesn’t Have Iterable.stream()
- Don’t be “Clever”: The Double Curly Braces Anti Pattern
- How to Integrate Commercial Third-Party Artefacts into Your Maven Build
- Let’s Deprecate Those Legacy Libs
- Three-State Booleans in Java
- No More Need for ORMs
- Java Rocks More Than Ever
- The Dark Side of Java 8
- Spring API Bingo
- Optional Will Remain an Option in Java
- Lean Concurrency
- Easy-as-Pie Local Caching
- Local Transaction Scope
- When All Else Fails: Using “the Unsafe”
- Feature Request for the JLS: Auto-Rethrow
- Free Java Profiling with Oracle Java Mission Control
- Lambdas and Sorting
- Lambdas and SQL
- The New New I/O APIs
- Use JUnit’s expected exceptions sparingly
- Lambdas and XML
- A Lesser-Known Java 8 Feature: Generalized Target-Type Inference
- Does Java 8 Still Need LINQ? Or is it Better than LINQ?
- Java Auto-Unboxing Gotcha. Beware!
- How to Speed Up Apache Xalan’s XPath Processor by Factor 10x
- The Lame Side of Java’s Backwards-Compatibility
- Inadvertent Recursion Protection with Java ThreadLocals
- Java Streams Preview vs .Net LINQ
- Java Collections API Quirks
- Hibernate, and Querying 50k Records. Too Much?
- How to Execute Something Multiple Times in Java
- A dirt-ugly hack to modify private final fields in Java
- Throw checked exceptions like runtime exceptions in Java
- A nice way of using jOOQ with Spring
- The depths of Java: API leak exposed through covariance
- jOOX and XSLT. An XML love story, continued
- CSS selectors in Java
- Use Xalan’s extension functions natively in jOOX
- jOOX and JAXB
- A neater way to use reflection in Java
- Java’s missing unsigned integer types
JDBC
- How I Incorrectly Fetched JDBC ResultSets. Again.
- It is all about the JDBC Basics
- Are You Binding Your Oracle DATEs Correctly? I Bet You Aren’t
- The JDBC Boolean Compatibility List
- Map Enhancements
- JDBC 4.0’s Lesser-known Clob.free() and Blob.free() Methods
- What you Didn’t Know About JDBC Batch
- Detect JDBC API Misusage with JDBCLint
- RDBMS bind variable casting madness
Other languages
- Using Kotlin’s Apply Function for Dynamic SQL with jOOQ
- 10 Nice Examples of Writing SQL in Kotlin with jOOQ
- 10 Features I Wish Java Would Steal From the Kotlin Language
- Ceylon Might Just be the Only (JVM) Language that Got Nulls Right
- A Very Peculiar, but Possibly Cunning Kotlin Language Feature
- The 10 Most Annoying Things Coming Back to Java After Some Days of Scala
- Top 10 Ceylon Language Features I Wish We Had In Java