DEV Community: Michele Gallotti

JLS Deep Dive: Variables & Definite Assignment — When is a Value 'Safe'?

Michele Gallotti — Fri, 13 Mar 2026 10:41:56 +0000

Before you can write safe code, you must understand how the compiler proves it's safe. In Java, this proof is called Definite Assignment.

Defined in JLS Chapter 16, it's a static analysis that guarantees no local variable is ever read before a value has been assigned to it. This mechanism is the reason local variables don't have default values, and it's what allows the compiler to be so strict about initialization paths.

This sixth chapter in our Java SE 25 deep dive explores the world of variables from the compiler's perspective.

In this article, you'll learn:

The 8 kinds of variables recognized by the JLS, from instance variables to lambda parameters, and their different initialization strategies.
The formal distinction between a final variable and an effectively final one, and why this matters for lambdas and anonymous classes.
How the compiler's flow analysis navigates short-circuit operators (&& and ||) to determine if a variable is assigned in all possible code paths.
The concept of Definite Unassignment, the mirror image of definite assignment, which ensures a final variable is assigned exactly once.

This is a guide to the rules that make Java a memory-safe language, grounded in the official JLS documentation.

Read the full article: https://eldritch.codes/en/tome/tome-02-jvm-runtime/chapter-04

Part of the "Eldritch Codes" series — a comprehensive guide to Java SE 25, explored through the lens of the JLS and the original specs.

JVMS Deep Dive: How the JVM Represents Data — Integers, Floats, and the Mysterious returnAddress

Michele Gallotti — Tue, 10 Mar 2026 06:58:14 +0000

At the source code level, Java has a rich type system. But at the bytecode level, the Java Virtual Machine operates on a much simpler, more efficient set of computational types. For the JVM, most of your variables are just int.

This fifth chapter in our Java SE 25 deep dive explores JVMS Chapter 2, focusing on how data is represented and manipulated on the stack. We'll uncover the discrepancy between language types and computational types and shed light on the most enigmatic type in the specification: returnAddress.

In this article, you'll learn:

The difference between Category 1 (32-bit) and Category 2 (64-bit) types and why it matters for stack instructions like pop/pop2 and dup/dup2.
How the JVM promotes byte, short, char, and boolean to int for all computational purposes.
The story of the returnAddress type, a primitive with no Java equivalent, used for the now-forbidden jsr/ret subroutines.
The concept of Word Tearing and why volatile is the specified solution for long and double in multi-threaded code.

Read the full article: https://eldritch.codes/en/tome/tome/tome-01-lexical-foundations/chapter-04

Part of the "Eldritch Codes" series — a comprehensive guide to Java SE 25, explored through the lens of the JLS and the original specs.

JLS Deep Dive: The Java Type System — Primitives vs. References

Michele Gallotti — Fri, 06 Mar 2026 10:26:51 +0000

Most Java developers know the difference between int and Integer. But do you know why List<Integer> is not a subtype of List<Number>? Or that null has its own type — one you can never declare?

This fourth chapter in our Java SE 25 deep dive explores JLS Chapter 4 — the formal specification of Java's type system. We go beyond the surface to understand the rules that govern every variable, every cast, and every generic you write.

In this article, you'll explore:

The precise distinction between primitive types (stored on the stack, direct value) and reference types (heap-allocated, pointer semantics).
The full widening primitive conversion chain (byte → short → int → long → float → double) and when a narrowing cast is required.
The mechanics of autoboxing and unboxing — including the JVM's integer cache (-128 to 127) and the NullPointerException risk of unboxing.
Type erasure (JLS §4.6): why generic type information is removed at compile time and what reifiable types are.
The special null type: why it's the subtype of all reference types, yet has no name.

This isn't a beginner's guide to generics. It's a formal, specification-grounded analysis of the type system that underpins every line of Java you write.

Read the full article: https://eldritch.codes/en/tome/tome-02-jvm-runtime/chapter-03

Part of the "Eldritch Codes" series — a comprehensive guide to Java SE 25, explored through the lens of the JLS and the original specs.

JLS Deep Dive: The Rules of the Language — Identifiers, Keywords, and the Underscore

Michele Gallotti — Mon, 02 Mar 2026 13:20:41 +0000

Every language has its grammar, and Java's is defined by the Java Language Specification (JLS ). Before you can master the patterns, you must understand the vocabulary.

This third chapter in our deep dive into Java SE 25 explores the fundamental rules that govern how we name things in Java. We'll look at the strict hierarchy of identifiers, reserved keywords, and the more flexible contextual keywords.

In this article, you'll learn:

The formal rules for creating a valid identifier (and why my-var is illegal but my$var is not).
The difference between the 51 reserved keywords (class, if, else) and the 17 contextual keywords (var, record, sealed) that allow the language to evolve without breaking old code.
The new role of the underscore (_) as a reserved keyword for unnamed variables and patterns, a key feature for writing cleaner, more readable code.
How the compiler resolves name conflicts through Shadowing and Obscuring.

This is a guide to the foundational syntax of modern Java, grounded in the official JLS documentation.

Read the full article: https://eldritch.codes/en/tome/tome-02-jvm-runtime/chapter-02

Part of the "Eldritch Codes" series — a comprehensive guide to Java SE 25, explored through the lens of the JLS and the original specs.

The Forbidden Workshop: Three Interactive Tools to See Inside the Java Compiler

Michele Gallotti — Fri, 27 Feb 2026 14:07:48 +0000

Most developers write Java every day without ever seeing what happens before compilation begins.

Tokenization, parsing, semantic analysis — these three stages transform the text you write into something the JVM can actually execute. They're the foundation of every compiler, and yet most of us treat them as a black box.

I built three interactive tools — free and open source — that let you observe each phase live, on real Java code. These aren't simplified simulations: they follow the actual language specifications.

⚙️ The Arcane Tokenizer — Java Tokenizer

Enter any Java code and watch the scanner break it down into lexical tokens: keywords, identifiers, operators, literals. This is the first step of every compiler — the moment raw text becomes structured data.

🌲 The Arcane Parser — Java Parser

Visualize the Abstract Syntax Tree generated by a recursive descent parser. See how a flat sequence of tokens becomes a tree structure with hierarchical relationships — MethodDecl, Block, Expr, Literal.

👁️ The Semantic Eye — Java Semantic Analyzer

Type checking, variable scoping, initialization analysis, return path analysis. The errors the parser can't see, semantic analysis reveals. This is where the compiler starts to understand your code.

Each tool includes bilingual step-by-step explanations (IT/EN) and a coverage section showing exactly what's supported and what's not.

👉 Try the tools: https://eldritch.codes/en/tools

Part of the "Eldritch Codes" series — a comprehensive guide to Java SE 25, explored through the lens of the JVM and the original specs.

JVMS Deep Dive: From Source to Bits — How the JVM Interprets Tokens and Literals

Michele Gallotti — Thu, 26 Feb 2026 10:15:09 +0000

Most tutorials teach you what to write. This series explores how the JVM actually runs it.

This second chapter dives deep into the .class file, leaving the source code behind. We'll follow the journey of a simple literal — from a token to a structured entry in the constant_pool, and finally onto the operand stack via a specific bytecode instruction.

In this article, you'll explore:

The structure and purpose of the Run-Time Constant Pool.
How the JVM uses different instructions (ldc, bipush, iconst) to load constants efficiently.
The internal representation of primitive types (e.g., why boolean is treated as an int).
The mechanics of String Interning and the evolution of string concatenation with invokedynamic.

This isn't another high-level overview. It's a deep dive into the arcane machinery of Java SE 25, built directly on the Java Virtual Machine Specification.

Read the full article: https://eldritch.codes/en/tome/tome-02-jvm-runtime/chapter-01

Part of the "Eldritch Codes" series — a comprehensive guide to Java SE 25, explored through the lens of the JVM and the original specs.

The Building Blocks of Code: Lexical Structure and Grammars in Java SE 25

Michele Gallotti — Mon, 23 Feb 2026 06:53:51 +0000

Most Java tutorials teach you what to write. This series is different — it explores the language from the perspective of how the JVM actually processes your code, guided by the original documentation that most developers never open.

In this first chapter, you'll explore:

How the JLS formally defines Java through context-free grammars
The difference between lexical grammar and syntactic grammar
How raw text is transformed into tokens before compilation even begins
Why understanding lexical analysis changes the way you read (and debug) code

This isn't another tutorial sequence — it's a deep dive into the arcane foundations of Java SE 25, built directly on the Java Language Specification.

Read the full article: https://eldritch.codes/en/tome/tome-01-lexical-foundations/chapter-01

Part of the "Eldritch Codes" series — a comprehensive guide to Java SE 25, explored through the lens of the JVM and the original specs.