97 Things Every Java Programmer Should Know Kevlin Henney Trisha Gee
, is a collection of brief essays from dozens of industry experts that provide practical, diverse advice for Java developers. It serves as a modern follow-up to the original general-programming version, specifically focusing on the
JVM, modern Java APIs, and professional development practices O'Reilly books Key Takeaways from the Experts
The "things" mentioned in the book range from deep technical JVM insights to broad professional advice: Performance & Internals : Experts like Monica Beckwith
highlight that benchmarking is difficult and that understanding how the JVM handles memory and garbage collection is vital for writing performant code. Modern Language Features : The book covers the evolution of Java, including
Lambda expressions, records (introduced in Java 14), and Optional types Clean Code & Architecture : Recurring themes include the "Boy Scout Rule"
(leave the code cleaner than you found it), the importance of readable naming, and preferring package-by-feature over package-by-layer to reduce coupling. Testing & Quality : Contributors emphasize Test-Driven Development (TDD) and unconventional methods like fuzz testing as effective ways to build resilient software. O'Reilly books Where to Find Content on GitHub
While the full O'Reilly book is a commercial product available through retailers like O'Reilly Media learning platform, related open-source projects exist: Original General Version : The broader 97-things-every-programmer-should-know
repository contains many of the foundational essays that also apply to Java. Summaries & Gists
: Many developers host personal summaries and key takeaway lists, such as this comprehensive Gist of 97 things Essential "Things" to Know Contributor Edson Yanaga "Behavior Is Easy, State Is Hard" Managing application state and immutability. Jeanne Boyarsky "Learn Java Idioms and Cache in Your Brain" Mastery of common patterns for faster coding. Holly Cummins "Garbage Collection Is Your Friend" Understanding memory management instead of fearing it. "Java's Unspeakable Types" 97 things every java programmer should know pdf github
Exploring complex type system nuances like non-denotable types. JVM performance tuning modern concurrency 97 Things Every Programmer Should Know - GitHub
97 Things Every Java Programmer Should Know is a collection of 97 short essays edited by Kevlin Henney and Trisha Gee that distills the collective wisdom of 73 experts across the global Java community. Originally inspired by the broader 97 Things Every Programmer Should Know series, this volume focuses specifically on the challenges and nuances of the Java ecosystem, ranging from JVM performance to the human side of development. Core Themes and Highlights
The book is structured alphabetically by title, allowing readers to consume the tips in any order. The advice covers several critical domains:
JVM Mechanics and Performance: Expert tips like Monica Beckwith’s advice on characterizing and validating benchmarks and Holly Cummins' reminder that Garbage Collection is your friend rather than a foe to be constantly tuned.
Modern Language Features: Contributions encourage developers to embrace changes since Java 8, such as Java's Unspeakable Types by Ben Evans and Optional as a good type by Nicolai Parlog.
Effective Design and Architecture: Essays like Edson Yanaga’s "Behavior Is Easy; State Is Hard" emphasize the difficulty of managing state compared to logic, while Daniel Bryant argues against Fat JARs in containerized environments.
Professionalism and Soft Skills: The book goes beyond code, with advice on building diverse teams by Ixchel Ruiz and developing technical interviewing as a skill by Trisha Gee.
The Ecosystem: Beyond Java itself, the book touches on Kotlin interop, Rediscovering the JVM through Clojure, and making Java "Groovier". Where to Find the Content
While the full book is a paid publication available on platforms like O'Reilly Online Learning and Amazon, much of its underlying philosophy is rooted in open-source principles. 97 Things Every Java Programmer Should Know Kevlin
97 Things Every Java Programmer Should Know a collaborative project edited by Kevlin Henney Trisha Gee
. It serves as a collection of distilled wisdom from 73 expert contributors, covering technical Java skills, JVM performance, and the "human" side of software development. Core Themes & Highlights
The book is structured into 97 short, independent essays that readers can explore in any order to spark new connections in their work. JVM & Performance Garbage Collection Is Your Friend
: Holly K. Cummins explains how to work with the GC rather than fighting it. Benchmarking Is Hard—JMH Helps
: Michael Hunger discusses the complexities of measuring Java performance and the utility of the Java Microbenchmark Harness (JMH). Java Programming from a JVM Performance Perspective
: Monica Beckwith provides tips on not obsessing over garbage while validating benchmarks. Architecture & Design Behavior Is Easy, State Is Hard
: Edson Yanaga explores why managing state is the primary challenge in complex applications. The Case Against Fat JARs
: Daniel Bryant discusses the architectural trade-offs of large deployment artifacts. Package-by-Feature
: Organizing code by business feature rather than technical layer (e.g., controller, service) to reduce coupling. Best Practices & Modern Java Learn Java Idioms and Cache in Your Brain : Jeanne Boyarsky emphasizes mastering common patterns. How to Avoid Null Open Contributions: Many of these "Things" were originally
: Carlos Obregón suggests avoiding null returns and parameters to prevent runtime errors. Optional Is a Lawbreaking Monad but a Good Type : Nicolai Parlog explores the nuances of using correctly. O'Reilly books Resources & GitHub Access
You can find various versions and summaries of these "97 Things" projects on GitHub and other platforms: 97 Things Every Programmer Should Know - GitHub
Optional for Return Values Only"Wrong: public void setMiddleName(Optional<String> name) – creates null confusion.
Right: public Optional<String> getMiddleName() – clearly signals absence.
When developers search for the PDF on GitHub, they are usually looking for the official repository associated with the project or community-driven resources.
While the full published book is a paid product (and supporting the authors by purchasing it is highly recommended), the "97 Things" concept thrives on open-source culture. The official GitHub repository for the project (often found under the 97-things organization or similar) serves as the backbone for the content's creation.
Why look for it on GitHub?
(Note: Always respect copyright. While the raw contributions are often open, the compiled, edited, and formatted PDF published by O'Reilly is the premium product that supports the creators.)
Java is a language that evolves rapidly. With a new release every six months, books on syntax become obsolete quickly. However, 97 Things Every Java Programmer Should Know remains timeless because it focuses on principles over syntax.
The advice on API design, concurrency models, and development mindset applies just as much to Java 21 as it did to Java 8. It captures the "tribal knowledge" that usually takes a decade to acquire.