Java

How long a bean lives, and the two moments the container promises to call you at.

One shape for every error response, wherever it comes from.

Two different answers to what an object mapped to a row actually is.

The four states an entity moves through, and the operations that move it.

What `@Transactional` actually wraps, and the two ways it surprises people.

Skipping work you've already done, on purpose, and knowing when to throw the answer away.

What the container actually is, and the five things it does to every bean before it's ready to use.

What Boot changes about starting a Spring application, and how it decides what to create for you.

One dependency instead of a dozen, and a server that ships inside the jar.

Where a setting comes from, and what wins when two sources disagree.

Turning a URL and a verb into a method call, and a method's return value into a response.

Refusing a bad request before it reaches your business logic.

Asking for data without writing the SQL yourself.

Finding the real bottleneck before optimizing the wrong thing.

Getting your dependencies handed to you — by constructor, and by name when there's more than one candidate.

Why Spring hands you your dependencies instead of you building them yourself.

What the symbols do when the types are not the ones you assumed.

Deciding once and repeating without copying, and the boundaries that go wrong.

Text that never changes, and what that costs when you build it in a loop.

What a variable actually holds, and how to choose the type that holds it.

Packaging behaviour under a name, and what a method can and cannot change for its caller.

What javac produces, what java consumes, and why one file runs on every machine.

Where a value lives, what keeps it alive, and what the two memory errors mean.

Two threads, one field, and the two different ways it goes wrong.

One call, several bodies, and which one the JVM picks.

Type parameters, what the compiler checks, and what is gone by runtime.

Starting work that runs beside your code, and what each thread takes to exist.

What synchronized guarantees, on which object, and what it still does not protect.

Three interfaces, many implementations, and which name to declare a variable with.

Two lists with the same methods and opposite costs.

Collections that refuse duplicates, and collections that decide what comes out next.

What a hash map does with a key, and what it costs when two keys collide.

A fixed run of values under one name, and the index that throws.

The three methods every object inherits, and what breaks when two of them disagree.

Teaching Java an order, for one natural ordering and for many.

A pipeline over a source, what runs lazily, and what comes out of the end.

A pipeline over a source, what runs lazily, and what comes out of the end.

Passing behaviour as an argument, and the interface it is compiled against.

A return type that makes "there might be nothing" impossible to ignore.

Type parameters, what the compiler checks, and what is gone by runtime.

Where a value lives, what keeps it alive, and what the two memory errors mean.