Glossary

A file listing what Git should never track, such as build output.

An annotation that binds every key under a prefix to a record's components, converting the values.

A bean whose methods handle HTTP requests and whose return values become the response body.

A bean whose @ExceptionHandler methods turn exceptions from every controller into responses.

A full file address that starts at the top of the disk, such as /home/ada/notes.txt.

A class marked abstract that can't be instantiated but can have fields, constructors and methods.

A method declared with no body, ending in a semicolon, for subclasses to implement.

A concrete statement about the finished program that is either true or false, so a test can check it.

private, protected or public (or nothing) in front of a member, saying which code may use it.

A short-lived OAuth token, limited by scopes, sent as a bearer token.

A method that returns a field's value or something computed from the fields.

Code that looks the same but expresses two different rules, which should not be merged.

A variable that builds up a result as a loop runs.

Atomicity, consistency, isolation and durability, the four guarantees of a transaction.

A use of a class that makes the JVM initialize it, such as new or a static method call.

A class that makes an object you can't change fit an interface your code expects.

A SQL function such as COUNT, SUM or AVG that turns many values into one.

A second variable referring to the same object.

A fixed list of permitted values in code, used for SQL parts that can't be placeholders.

A call that two overloads fit equally well

Replacing the last commit, to fix its message or add a forgotten file.

Constant cost on average over many calls, even though an occasional call is expensive.

A marker such as @Test written before a declaration, read by tools.

A class with no name, declared and instantiated in one expression with new Interface() { ... }.

A file recording the classes an application loads and links (and, in Java 25, method profiles), so later runs start faster.

A class that wraps a web API so callers deal only in domain types.

A long random string identifying a calling program, issued by a provider.

A new edition of an API for changes that would break existing clients.

One destination for log lines, such as the console or a file.

Spring's container, which finds, creates, wires and holds the application's beans.

The folder jpackage makes before any installer, with a native launcher, the app and a Java runtime.

Spring Boot's settings file in src/main/resources.

A value written in a method call and copied into the matching parameter.

A Mockito stand-in for an argument value, such as any(), anyString() or eq("x").

An annotation such as @ValueSource, @CsvSource or @MethodSource that supplies a parameterized test's arguments.

The three-part shape of a test, which builds the fixture, calls the behaviour, then checks the result.

A fixed-length, numbered row of values of one type.

A list of values in braces that creates an array.

The exception thrown when an array is given an element of the wrong type at run time.

The file a build produces for others to use, usually a JAR.

A check inside a test, such as assertEquals(expected, actual), that fails the test if it doesn't hold.

A Library of fluent assertions that start from assertThat(actual), an alternative to JUnit's Assertions.

An operation that gives the same result however its inputs are grouped, as adding does and subtracting doesn't.

The order in which operators of equal precedence are grouped, such as left to right for - and +.

A request that returns at once, leaving its result to arrive later.

A rename that happens in one step, so nobody ever sees a half-finished file.

A one-value holder, such as AtomicInteger, whose updates happen in one indivisible step.

Connecting a debugger to a JVM that is already running.

Establishing who is calling.

Deciding what a known caller may do.

The OAuth 2 flow where a user logs in at the authorization server and approves an app.

The service that checks who you are and issues tokens.

Spring Boot setting up beans by itself based on what is on the classpath.

Java wrapping a primitive in its wrapper object automatically, as when list.add(42) stores an Integer.

The interface with one method, close(), that every try-with-resources resource implements.

JDBC's default mode, in which every statement is committed on its own as soon as it succeeds.

A plain JAR placed on the module path, given a module name and treated as a module.

A long-running program that listens on a port and answers requests from browsers, apps and other services.

The input a recursive method answers directly

A way of writing bytes as letters and digits, reversible by anyone.

Sending a user name and password as Authorization Basic plus Base64.

An object that the Spring application context creates and manages.

A bean's identifier; for a scanned class, its simple name with a lower-case first letter.

A token that lets in whoever holds it, sent as Authorization Bearer.

A way of describing how an operation's work grows as the data grows, ignoring constant factors.

A standard-library class that stores decimal numbers exactly, used for money.

A data format written as bytes meant for programs, not people, such as PNG or Protocol Buffers.

Finding a value in a sorted array by repeatedly halving the range.

Finding a fault by checking halfway and keeping the half that is wrong.

JMH's object for consuming a value so the JIT can't delete the work that produced it.

A pair of curly braces with statements inside, treated as one unit.

A thread-safe queue whose put waits while it is full and whose take waits while it is empty.

What turns a response body into a Java value, such as BodyHandlers.ofString().

What supplies a request's body, such as BodyPublishers.ofString(json).

A pom listing a library family's parts at versions that work together.

The type with exactly two values, true and false.

Building and testing small helper methods first

A method reference like hello::concat whose receiver object is fixed when the reference is made.

A type parameter restricted to subtypes of something, such as T extends Comparable.

A named line of work in Git; a movable name for a commit.

The share of decision outcomes (each side of every if, loop condition, && and ?:) that the tests took.

A marker that makes the debugger pause the program on a chosen line.

A server that doesn't check whether this user may perform this action on this resource.

One slot of a hash table, chosen by an element's hash code, holding the few elements that hash there.

A block of memory that holds data so it can move to or from the disk in large chunks.

Maven's fixed, ordered list of build phases.

A program that compiles, tests, and packages a project, and downloads the libraries it needs.

A helper object that collects an object's values through named methods, then creates it with build().

A java.io stream that moves raw bytes, one value from 0 to 255 at a time.

The compact instructions javac produces and the JVM runs.

The JVM's check, before a class runs, that its bytecode can't misuse the operand stack, types or memory.

HotSpot's quick JIT compiler, which compiles methods fast and records a profile for C2.

HotSpot's optimising JIT compiler, which recompiles hot methods using their profile.

The last-in, first-out pile of frames for the calls in progress; only the top one runs.

A task with a result that may throw any exception, V call() throws Exception.

A record's main constructor, taking every component in order.

Converting input to one standard form before checking it, then using that same form.

How many elements an ArrayList's internal array can hold before it must grow.

A local variable from the surrounding method that a lambda uses; the lambda keeps a copy of its value.

A platform thread that a virtual thread is mounted on while it runs.

Capital and small letters count as different.

A type name in brackets, such as (int), that converts a value and accepts any loss.

The part of a try statement that handles one type of exception: catch (Type e) { ... }.

Java's compile-time rule that a checked exception a method can throw must be caught there or declared with throws.

A server's digital ID card for its host name, vouched for by a trusted authority.

An organization whose signature on a certificate clients trust.

The type for a single character, stored as a 16-bit number code.

A java.io stream that moves characters, decoding or encoding bytes with a charset.

A test that records what code does today, so a refactoring that changes the result is caught.

The rule for turning characters into bytes and bytes back into characters.

Testing shared state and then acting on the answer, which another thread may make stale in between.

An exception the compiler makes you catch or declare, such as IOException.

A linter that checks Java source against a configurable rule set such as naming and NeedBraces.

Waiting that forms a cycle, A for B and B for A, the deadlock condition lock ordering removes.

The container Java organizes all code into; every method lives inside a class.

A file of compiled Java bytecode, ending in .class.

The one-time running of a class's static field initializers and static blocks, on the class's first active use.

A rule about an object's fields that holds whenever none of its methods is running.

The part of the JVM that finds a class's bytes and turns them into a Class object.

The JVM's process of finding a class file, checking it and setting the class up the first time it is needed.

The list of folders and JAR files where javac and java look for classes your code uses.

A non-code file that ships with the program and is read through the class path.

The version number stored in a compiled class, the Java release plus 44 (69 for Java 25).

The exception thrown when a downcast names a class the object doesn't belong to.

The OAuth 2 flow where a program gets a token as itself.

An object you ask for the current time, so tests can use a fixed one.

A family of types whose complete list of kinds is fixed and known to the compiler.

Suggestions the editor offers while you type, such as method names.

A measure of which lines and branches of code ran while the tests ran.

A tool that rewrites source code into one fixed layout without changing what it does.

A character's number in Unicode, such as U+1F600 for one emoji.

Teammates reading a change before it is merged.

How closely everything inside one class or method belongs to the same job.

An object a class uses to do its job, such as a catalog or a notifier.

An object that holds a group of other objects and grows or shrinks as they are added and removed.

A collection that looks through to another one, such as a map's keySet(), showing its current contents.

The java.util interfaces and classes for lists, sets, queues and maps, designed to work together.

A ready-made recipe, from the class Collectors, that tells collect what to build from a stream's elements.

One named, typed field that every row of a table has.

One instruction typed into a terminal, such as java -version.

A word typed after the program's name when it is started, received in args.

A note for people in the source code, which the compiler ignores.

One saved snapshot of a project, with a message saying what changed.

The text saved with a commit: a short subject, and a body saying why.

The JVM-wide ForkJoinPool that async CompletableFuture methods use by default.

A record constructor written with no parameter list, used to check and tidy the values before they are stored.

A Java 25 JVM option that shrinks every object's header from 12 to 8 bytes.

A Java file with just a main method and no class around it.

The interface whose compareTo method gives a type its natural order.

Store a new value only if the current value is still the expected one, and say whether it worked.

A final primitive or String variable with a constant initializer, whose value javac copies into every use.

A mistake the compiler finds before the program can run.

A tool that translates source code into a form that can run.

Java's future that steps can be attached to, and that join waits for.

The unchecked wrapper join throws when a future's work failed.

Spring searching the application's package and those below it for classes marked @Component or a stereotype.

Building a class from other objects held in its fields.

The one place, usually main, that creates the concrete objects and passes them to the objects that need them.

A shortcut such as total += 5, which updates a variable using its own value.

A class that isn't abstract, so it can be instantiated.

Several tasks in progress over the same period, whether or not any run at the same instant.

A thread-safe map with atomic per-key operations such as merge and computeIfAbsent.

The exception an iterator throws when its collection was changed by something other than the iterator.

A breakpoint that pauses only when a condition you wrote is true.

The range a measurement's true average very likely lies in; JMH's Error column gives half its width.

Values a program reads at start-up from outside its code.

The <<<<<<<, ======= and >>>>>>> lines Git writes around a conflict.

How long a client may take to set up a connection before giving up.

One open session with a database, through which every statement is sent.

A borrowed connection that is never closed, so it never goes back to the pool.

A set of open database connections that code borrows and gives back instead of opening new ones.

How long a borrower waits for a free pooled connection before giving up.

A variable declared final, whose value can't be changed after it is first set.

The compiler computing an expression on constants once, ahead of time, instead of every time it runs.

The table inside a class file holding the names, strings and method references its bytecode uses.

Work that stays the same however many elements there are.

Comparing secret values in a time that doesn't depend on where they differ.

A rule on a table's data, such as NOT NULL, that the database enforces on every write.

An annotation such as @NotBlank, @Size or @Positive that states a rule for one value.

Special code named after the class, with no return type, that sets up each new object.

One constructor handing its work to another with this(...).

A JPQL select new ...(...) that builds records or other objects directly from query values.

Receiving dependencies as constructor parameters stored in final fields; the style this course uses.

A method reference like ArrayList::new that calls a constructor and returns the new object.

The JDK functional interface that takes a value and returns nothing, void accept(T t).

An isolated environment, run by Docker, in which one program such as a database runs.

A server that builds and tests every pushed branch automatically.

What a method needs from its callers (precondition) and promises in return (postcondition).

A small named value a browser stores for a site and sends back with every request to it.

A thread-safe list that copies itself on every write, for lists read often and changed rarely.

An array of tally counters indexed by value.

How much a change in one part of a program forces changes in another.

The array rule that a String[] is also an Object[].

An override returning a subtype of the original's return type.

What a caller presents to prove who it is, such as a password or a token.

Code that only one thread at a time may be running, because it touches shared data.

Every row of one table paired with every row of another, usually a forgotten join condition.

Create, read, update and delete, the four basic operations on data.

A table saved as text, one row per line, commas between columns.

An exception class you write, extending Exception (checked) or RuntimeException (unchecked).

The public catalogue number of a known vulnerability, such as CVE-2021-44228.

A 0-to-10 severity score for a vulnerability.

A background thread the JVM doesn't wait for when deciding whether to exit.

Two threads accessing one variable, at least one writing, with nothing ordering them.

A plain record that carries data across an edge of the program, in the shape the outside format needs.

A program that stores data and answers other programs' requests for it.

A versioned SQL script that changes a database schema; production schemas change only through migrations.

The declared tables, columns, types and rules of a database.

The javax.sql interface for anything that hands out database connections.

The java.time object that turns dates into text and text into dates, using a pattern such as dd/MM/uuuu.

Moving the clocks forward in spring and back in autumn, which skips one hour and repeats another.

The compiler removing a computation whose result is never used.

Threads each waiting for a lock another of them holds, so none can ever proceed.

A tool that pauses a running program so you can look inside it.

The type written in a variable's declaration; it decides which calls compile.

Splitting a problem into smaller parts

A wrapper with the same interface as the object it holds, adding behavior around each call.

Using reflection with setAccessible(true) to reach private fields, methods or constructors.

The empty, no-argument constructor the compiler adds to a class that declares none.

An interface method with a body, marked default, inherited by every implementing class.

The starting value Java puts in each new array element.

A copy of a mutable object made on the way in or out of a class, so outside code can't change its internals.

A method passing its call straight on to an object the class holds.

Refusing any action that no rule explicitly allows.

A check that lists forbidden values and accepts everything else.

The JVM discarding compiled code whose assumption has failed, and continuing in the interpreter.

Someone else's code your project uses, downloaded by the build tool.

Gradle's name for a scope, such as implementation or testImplementation.

A rule that drops one transitive dependency from under one dependency.

Handing an object its collaborators from outside, usually through its constructor, instead of letting it create them.

Business rules depend on an interface they own, and the low-level details implement it.

How Maven picks one version when several are requested: nearest wins, then first declared.

Which class paths a dependency joins: compile, provided, runtime or test.

The tree of a project's dependencies and theirs, printed by mvn dependency:tree.

The pom section that sets versions without adding any dependency.

Marked as discouraged; still works, but the compiler warns, and it may be removed later.

A queue that can add, remove and inspect at both ends, usable as a queue or a stack.

A repository method whose name, such as findByAuthorIgnoreCase, Spring Data turns into a query.

Building objects back from stored or received bytes or text.

A named, reusable shape of solution to a problem that keeps recurring in object-oriented code.

The empty angle brackets after new, which let the compiler fill in the type arguments.

Two unrelated interfaces supplying a default for the same method; the class must override it.

Hibernate noticing changed fields at commit and writing the UPDATE itself.

The one servlet Spring MVC registers, which routes each request to a controller method.

The worldwide directory that turns host names into IP addresses.

A tool that runs programs in isolated, throwaway environments called containers, started from images.

A comment placed just before a class or method that tools turn into its documentation.

The types a program's own logic works with, strict about what values are allowed.

A case that can never run because an earlier case matches everything it would.

A cast like (Circle) s from a supertype to a subtype, checked when it runs.

The collector groupingBy or partitioningBy applies to each group, such as counting or summingInt.

Don't repeat yourself: give each piece of knowledge, such as a rate or a rule, one place in the code.

A test double passed only to fill a parameter and never used.

An exact amount of time in seconds and nanoseconds, such as PT1H30M.

Choosing which override runs from the object's class while the program runs.

A local variable that is never reassigned after its first value, so a lambda may use it.

One value stored in an array.

A database that runs inside the application's JVM, such as H2, with nothing to install.

A real String with zero characters, written "".

Keeping a class's fields private so other code can change them only through the class's own methods.

A test that drives the whole running application from outside, as a user would.

One URL pattern together with one method, such as GET /v1/books/{id}.

A loop that visits every item of a group in order, written for (String word : args).

A thing that keeps its identity while its data changes, like a customer account.

The Jakarta Persistence object that saves, loads and queries entities.

A type whose only values are a fixed list of named constants.

One named value of an enum, such as Speed.EXPRESS; Java creates exactly one object for it.

A named setting the operating system hands to every program it starts.

Midnight UTC at the start of 1 January 1970, the moment Instant counts from.

Equal objects must have equal hash codes, and equals must be reflexive, symmetric, transitive, consistent and false for null.

The branch of Throwable for failures of the JVM itself, such as running out of memory or stack.

Google's javac plugin that reports bug patterns as compile errors or warnings.

The JIT's check of whether an object can be seen outside the method that creates it.

A backslash code such as \n or " that writes a character you can't type directly in quotes.

A format's rule for writing a value that contains the format's own special characters.

A debugger command that runs a Java expression once, using the paused program's values.

Java's way of signalling that something went wrong while the program runs.

A debugger setting that pauses the program where an exception of a chosen type is thrown.

The exception that led to this one, kept inside it when one exception is wrapped in another.

Catching an exception and throwing a new one that holds the first as its cause.

Wrapping done at a boundary between layers, so each layer throws exceptions in its own terms.

The error thrown when a class's static initializer throws; its cause is the original exception.

A JFR snapshot of the method and stack a thread was running at one moment.

The checked exception Future.get throws when the task failed; the real exception is its cause.

An object you hand tasks to, which runs them on threads it manages and returns Futures.

A switch is exhaustive when its cases cover every possible value of the selector.

The correct result a test compares the actual result against.

Waiting longer before each retry, such as 1, 2, then 4 seconds.

A piece of code that produces a value, like 2 + 3.

The dot-and-letters ending of a file name, like .java.

Something passed into code, usually a Supplier, that creates new objects when that code needs them.

An iterator that throws as soon as it notices its collection changed underneath it.

Checking arguments as they arrive and refusing bad ones before changing anything.

Spring Boot's start-up report that turns a wiring exception into a description and a suggested action.

A working, simplified implementation used in tests, such as an in-memory catalog backed by a HashMap.

In the old colon form of switch, carrying on into the next case because no break stopped it.

A merge that only moves the branch's name forward; no new commit is made.

One JAR containing your classes and all their runtime dependencies.

A Java version that gets updates only until the next version, about six months.

A variable declared in a class's body; each object of the class has its own copy.

A starting value written next to a field's declaration, such as int lives = 3.

The legacy style of putting @Autowired on fields, which leaves them null outside Spring.

The rule that the element waiting longest leaves first, as in a queue.

A folder together with everything inside it, at every level.

A class that can't be extended, or with final on a method, one that can't be overridden.

A field that must be assigned exactly once, by the end of every constructor, and never again.

The deprecated mechanism that ran an object's finalize() method before collecting it.

The block of a try statement that runs on every way out: normal end, caught or uncaught exception, or return.

A test that passes or fails from run to run without any code changing.

A profiler chart of stacked bars where each bar is a method and its width is its share of samples.

The stream step that turns each element into a stream and joins those streams into one.

Java 25 lets a constructor run statements before this(...) or super(...), as long as they don't use the object.

A pattern variable is usable exactly where the compiler can prove the test succeeded.

To send whatever is waiting in a writer's buffer on to the file or stream it wraps.

A named container for files and other folders.

A column whose value must match the primary key of a row in another table.

A % code in a format string marking where and how a value goes.

The text pattern given to printf, with blanks marked by % that values fill in.

A superclass change breaking subclasses because they depended on its internal self-calls.

The part of a URL after

A class's package plus its simple name, such as com.example.greet.Greeting.

The JDK functional interface that turns one value into another, R apply(T t).

An interface with exactly one abstract method, which a lambda can implement.

An object standing for a result that will exist later.

The JVM's default garbage collector since Java 9, balancing short pauses with throughput.

Ordinary methods in classes already on the class path, run in an order crafted bytes choose.

The part of the JVM that reclaims the memory of objects nothing can reach any more.

A starting point for the garbage collector's tracing, such as a running method's local variable or a static field.

The primary key value the database chose for a newly inserted row.

The observation that most objects become unreachable soon after they are created.

A class or record that declares type parameters, so one declaration works safely for many types.

A method that declares its own type parameter, before its return type.

A class or interface that takes type arguments, such as List or Map<K, V>.

A tool that records snapshots of your project so you can go back and see what changed.

A Git command that binary-searches the history for the commit that introduced a bug.

A copy of the repository on a server that a team shares.

A project folder whose history Git keeps track of.

A fixed name for one commit, used to mark a release such as v1.0.0.

A file-name pattern such as *.txt, where * stands for any run of characters.

A mutable value reachable and changeable from anywhere, such as a public static non-final field.

A formatter with no options that applies the Google Java Style Guide (2-space indent, 100-column lines).

A Java build tool configured by a build.gradle.kts file.

One unit of Gradle work, such as compileJava, test or jar.

Scripts that download and run the exact Gradle version a project names.

An extra yes-or-no test added to a pattern case with when.

A check at the top of a method that returns early for an input the rest can't handle.

Code that deals with a thrown exception: the block of a matching catch clause.

The Java Memory Model's guarantee that one action's effects are visible to another.

The relationship composition expresses; a car has an engine.

An int summarizing an object, used by HashSet and HashMap to find it quickly.

Git's pointer to the branch you are on.

The first line of a data file, naming the columns.

The area of memory where objects live, independent of any method's frame.

A parameterized collection holding an element of the wrong type, slipped in through unchecked code.

A design where the domain sits in the middle, declares interfaces (ports) for what it needs, and everything outside plugs in through adapters.

The most widely used implementation of Jakarta Persistence.

A subclass static method (or field) with the same name as the superclass's; the declared type picks which.

The connection-pool library most Java applications, and Spring Boot by default, use.

A chart showing how often each value occurs.

A breakpoint setting that pauses only on the nth time a line is reached.

How many times the thread holding a reentrant lock has taken it and not yet released it.

A step in a template method with a default body that subclasses may override.

Any machine on a network, such as a laptop, a phone or a server.

A response header telling browsers to use only HTTPS for a host for a set time.

The request-response protocol web programs use to talk to each other.

One Name, colon, value line of facts about a request or response.

The verb of a request, such as GET, POST, PUT, PATCH or DELETE.

The three-digit verdict on a request; its first digit is its class.

HTTP over QUIC, an encrypted transport on UDP; in HttpClient from JDK 26.

The JDK's built-in HTTP client, java.net.http.HttpClient.

HTTP sent inside an encrypted TLS connection.

An editor with built-in tools to write, run, and debug code.

A unique value sent with a POST so the server can recognise a retry.

Having the same effect on the server whether sent once or twice.

The name of a variable, method or class.

Being the very same object; what == compares for references.

The starting value of a reduce that changes nothing when combined, such as 0 for adding; also the result for an empty stream.

The JDK's exception for an argument a method or constructor can't accept.

The JDK's exception for an operation the object can't do in its current state, such as paying with a blocked card.

Can't be changed after it is created.

The keyword by which a class promises to supply an interface's methods.

A line at the top of a file that lets the code use a class by its simple name.

Rearranging the original array instead of making a sorted copy.

The exception setAccessible(true) throws when the target package isn't opened to the caller's module.

A build that skips work whose inputs haven't changed since last time.

An unfinished JDK API shipped in a jdk.incubator module so people can try it.

The position number of a character or element, counting from 0.

A loop whose condition never becomes false, so it runs until the program is stopped.

A class getting the fields and methods of another class by extending it.

The JIT replacing a call with a copy of the called method's body.

A non-static class declared inside another; a class written under void main() in a compact file is one.

A join that keeps only rows that found a match in both tables.

Returning or changing an object found by an id from the request, without checking who owns it.

A sort that inserts each element into a sorted left part.

An object made from a particular class; a Point object is an instance of Point.

An ordinary, non-static field, with one copy in each object.

A method without static, called on an object, that works on that object's fields.

An operator testing whether an object is of a class or one of its subclasses; false for null.

One exact moment on the timeline, the same everywhere, counted from the epoch.

The shared Integer objects for -128 to 127 that boxing reuses instead of allocating.

Division of two whole numbers that keeps only the whole part, so 7 / 2 is 3.

When a whole-number result doesn't fit its type and silently wraps around to the other end.

A test that checks real parts working together, such as code against a real database or real files.

A type listing methods that implementing classes promise to supply, with no per-object state.

No client should be forced to depend on methods it doesn't use.

A stream step such as filter, map or sorted that returns a new stream and does no work until a terminal operation runs.

The part of the JVM that runs bytecode one instruction at a time, before any of it is compiled.

The checked exception a waiting thread gets when another thread interrupts it.

A combination of values a type allows but the business never would.

The rule that List is not a List, even though Integer is a Number.

A promise that stays true at each step of an algorithm.

The framework calls your code, instead of your code calling the framework.

A bytecode call whose target is set up at run time by a bootstrap method, used for string + and lambdas.

The checked exception family for failed input and output, such as a missing file.

The number other machines use to reach a host, such as 203.0.113.10.

The relationship inheritance expresses; an hourly worker is an employee.

The international date and time format, such as 2026-11-01T14:30, that java.time prints and parses.

How much concurrent transactions are shielded from each other's changes.

An object that walks through a collection one element at a time with hasNext and next.

The library most Java projects use to turn objects into JSON and back.

The usual Java code-coverage tool, run as a Maven plugin with prepare-agent and report goals.

A set of server-side Java specifications, such as Servlet, Persistence and Validation, formerly Java EE.

Java's standard ORM API, in the jakarta.persistence package.

The specification for rules written as annotations; Hibernate Validator implements it.

A zip file of compiled classes and resources, with a manifest, that Java can run or use as a library.

Failures caused by duplicate or conflicting classes on the class path, such as two versions of one library.

The file META-INF/MANIFEST.MF that describes a JAR, including its Main-Class.

The java command that starts the JVM and runs a program.

The rules that say when one thread's writes are visible to another.

A named set of packages with a module-info.java saying which modules it requires and which packages it exports.

The official specification of the Java language and its standard library.

An environment variable that tells tools which JDK folder to use.

An older class shape with a public no-argument constructor and a get/set pair for every private field.

The Java compiler command; it turns .java files into .class files.

The JDK tool that prints what is inside a class file, including each method's bytecode with -c.

The JDK tool that sends diagnostic commands to a running JVM.

The JDK's command-line debugger.

Java's standard API, in java.sql, for talking to relational databases.

The library that implements JDBC for one database, added as a dependency.

The JDBC object that sends a piece of SQL text to the database.

The text passed to getConnection that says which database to open, starting jdbc:.

Spring's thin layer over JDBC that binds parameters and maps rows while you write the SQL.

A JDK tool that lists uses of deprecated APIs in a JAR or class folder.

The JDK tool that reads class files and lists the modules and JARs they depend on.

The kit you install to write and run Java, with the compiler, the JVM, and tools.

A packaged build of a JDK from a particular vendor, such as Temurin or Corretto.

The profiler built into the JVM, which records events such as execution samples, GC pauses and JIT activity.

A free graphical tool, downloaded separately, for reading JFR recordings.

The protocol every Java debugger uses to control a JVM.

A numbered document describing one JDK feature and the release that delivered it.

The part of the JVM that turns frequently run bytecode into fast machine code while the program runs.

The JDK tool that builds a runtime image holding only chosen modules.

The OpenJDK tool for writing and running Java microbenchmarks correctly.

Combining rows of two tables that match on a condition, such as a key.

A JPQL clause that loads an association in the same query as its owner.

A table whose rows each pair one row of one table with one row of another.

The policy object that decides when a scope's join returns and what it returns.

A library that builds SQL from Java code generated from your schema, checked at compile time.

The JDK tool that packages an application with its own runtime as an app image or an installer.

Jakarta Persistence's query language, written with entity and field names instead of tables and columns.

An interactive tool where you type Java and see each result immediately.

A text format of objects, arrays, strings, numbers, true/false and null.

An expression such as .title or [0].id that picks a value out of a JSON body.

The Jackson object that converts between Java values and JSON text.

Java's standard testing library (Library); JUnit 6 uses the Jupiter API.

The part of JUnit that discovers test classes and launches a test engine to run them.

JUnit 6's API for writing tests (org.junit.jupiter.api), with @Test and Assertions.

The program that runs Java bytecode on your computer.

A signed token whose JSON claims anyone holding it can read.

Lower-case words joined by dashes, as in catalogue.max-loans.

A text field in a flat format that names which case of a sealed type a value is.

Keep it simple: choose the design with the fewest ideas for a reader to hold that meets today's needs.

A test whose expected value was worked out independently of the code.

The Kotlin-syntax language Gradle build files (build.gradle.kts) are written in.

Code like x -> x * 2 that implements a functional interface's one method in place.

A listener that was never unsubscribed, kept alive in memory by the subject's list.

Splitting an application into controller, service and repository layers, with calls going one way down.

Not doing any work until a result is asked for; stream steps run only when the terminal operation pulls elements.

Loading an associated entity only when code first uses it.

Checking a recursive method by assuming the smaller call is correct and checking only the current step.

Giving each account only the permissions its job needs.

A join that keeps every row of the first table, filling in NULL where nothing matched.

A method JUnit calls around tests, such as @BeforeEach, @AfterEach, @BeforeAll or @AfterAll.

One named step of Maven's build, such as compile, test or package.

The time while the program runs during which a variable exists.

The rule that the most recently added element leaves first, as in a stack.

The share of executable source lines that ran at least once during the tests.

Checking each element in turn until the target is found.

Work that grows in proportion to the number of elements.

A chain of nodes, each holding one element and links to its neighbours.

A static-analysis tool that enforces style and simple rules on source code.

An ordered sequence of elements that, unlike an array, can have any length.

An object a subject calls when an event happens.

A value written directly in source code, such as 42, 2.5, 'A' or "Hi".

Threads that keep reacting to each other, such as retrying in step, so none makes progress.

Maven's cache of downloaded artifacts on your machine, ~/.m2/repository.

A variable declared inside a method (parameters included)

The numbered slots in a frame that hold a method's parameters and local variables.

A language and region setting that decides how month and day names are written.

Taking locks in one agreed order everywhere, so no cycle of waiting can form.

How important a log message is, from TRACE up to ERROR.

The December 2021 flaw in log4j-core 2.0-beta9 to 2.14.1 that turned logged text into remote lookups.

Work that grows by about one step each time the data doubles.

The library that writes SLF4J's log lines, configured by logback.xml.

An object a program sends messages to, each with a level, for the log.

A small logging API that code calls, with the real logging library plugged in at run time.

A project's rules for what goes in its log, at which level, and what is never logged.

A mistake that lets the program run but gives the wrong result.

A breakpoint that prints a message instead of pausing.

A counter for many writers and rare readers, which spreads updates and adds them up in sum().

The counter a for loop is built around, such as i in for (int i = 0; i < 5; i++).

The address that always means this same machine, 127.0.0.1 or ::1.

One change overwritten by another because both read the old value before either wrote.

A release that gets updates for years; Java 25 is the current one.

Instructions a particular processor can run directly.

PrintCompilation's note that a compiled version will no longer be used for new calls.

The method where a Java program starts running.

The thread the JVM starts to run main; its name appears in "Exception in thread "main"".

An attacker relaying traffic between two parties, reading or changing it.

Many rows on each side can be linked to many on the other, like orders and products.

A collection of key-value pairs in which each key leads to one value.

One key together with its value inside a map.

Code that converts a DTO to domain types or back.

A Java build tool configured by a pom.xml file.

The public repository open-source Java libraries are published to.

The groupId, artifactId and version that identify a project or library.

The Maven plugin that runs *IT integration tests after package and fails the build in the verify phase.

An add-on that does Maven's actual work, such as compiling or running tests.

A named value in a pom.xml, used elsewhere as ${name}.

A server or folder that stores artifacts in folders named by their coordinates.

The most connections a pool will open at once.

A JMH run of a benchmark whose timing is recorded and reported.

A two-part name for a kind of content, such as application/json.

In Java: objects the program no longer needs that are still reachable, so they are never collected.

Bringing one branch's commits into another.

A commit with two parents that joins two lines of work.

Two branches changed the same lines differently, so Git asks you to choose.

The function that tells toMap how to combine two values for the same key, such as Integer::sum.

A named group of instructions, such as main or println, that runs when it is called.

The statements between a method's braces.

Running a method by writing its name and arguments; the caller pauses until it returns.

The compact type signature in bytecode, such as (II)I for "takes two ints, returns an int".

A method's first line: return type, name and parameter list.

Shorthand like String::toUpperCase for a lambda that only calls one method.

A timing of one small piece of code, often a single method.

The smallest input and program that still show a bug.

A test double that records how it was called, so the test can verify the interaction afterwards.

A small server, run by a test, that answers like the real API.

A Library that creates stubs and mocks at run time: mock, when(...).thenReturn(...), verify(...).

Spring's test tool that sends requests through Spring MVC without opening a network port.

A JAR with module-info.class at its root.

The module-info.java file at a module's root, compiled to module-info.class.

An import of every public type in every package a module exports, such as import module java.sql;.

The list of folders and modular JARs where java and javac look for modules, given with -p.

Garbled text, such as café for café, from decoding bytes with the wrong charset.

The lock built into every Java object, used by synchronized.

One catch clause for several unrelated exception types: catch (A | B e).

One Maven build made of several projects, listed as modules in a parent pom.

Can be changed after it is created.

Making small deliberate changes to code and rerunning the tests; a change no test notices marks weak testing.

A method whose job is to assign one field, such as setName.

A library that maps hand-written SQL statements, kept in XML or annotations, to objects.

One query for a list, then one more query per item to load an association.

A value placeholder in JPQL written as :name and filled with setParameter.

The floating-point value meaning "not a number", such as the result of 0.0 / 0.0.

A conversion to a smaller type, which may lose information and needs a cast.

A primary key taken from the data itself, such as an ISBN.

The default order compareTo defines.

A pattern inside another pattern, such as a record pattern for a component that is itself a record.

The error thrown when running code needs a class the JVM can't provide.

Something a project has decided not to do in this version, written down next to its goals.

The modifier that reopens one branch of a sealed hierarchy so any class may extend it.

Designing tables so that each fact is stored in exactly one place.

The value of a reference that points at no object.

The run-time error thrown when code calls a method on a null reference.

The run-time error thrown when text can't be parsed as a number.

The rule that converts both operands of an arithmetic operator to a common type first.

The common way to give programs short-lived, limited tokens instead of passwords.

A value with its own data and methods, kept in memory and reached through a reference.

The class at the top of every hierarchy, source of toString, equals and hashCode.

The JVM's own bookkeeping at the start of every object, 12 bytes on a typical 64-bit JVM.

A library that maps classes to tables and writes the SQL to load and save objects.

A subject keeps a list of listeners and tells each one when something happens.

A loop that runs one pass too many or one too few.

How far a local clock is ahead of or behind UTC at some moment, such as +02:00.

The part of the heap for objects that have survived several young collections; collected far less often.

An import of every public type in one package, such as import java.util.*;.

Switching a running loop from the interpreter to compiled code partway through.

One row in one table is linked to many rows in another, like a customer and their orders.

Each row on one side is linked to at most one row on the other.

A setting such as APPEND or CREATE_NEW that says how a write treats an existing file.

Adding a new kind should mean adding code, not editing code that already works.

The open-source project that produces the code for nearly every JDK.

An open-source tool that applies automated migration recipes to code as a reviewable diff.

A module-info line that allows deep reflection into a package at run time, without exporting it.

The per-call stack where bytecode instructions take their inputs and leave their results.

A box that holds one value or is empty, returned when a result may be missing.

A library's dependency marked optional, which its users don't get unless they declare it.

The error thrown when the JVM can't allocate an object because the heap is full of reachable objects.

Declaring several methods with one name and different parameter lists.

Writing a method with the same signature as an inherited one, so yours is used instead.

A named group of classes kept in one folder, declared with a package line at the top of each file.

The package line that must be the first statement of a file, naming the package its types belong to.

The access a member gets with no modifier, usable by any class in the same package.

A throughput-oriented garbage collector, for batch work where longer pauses don't matter.

Several tasks executing at the same instant, which needs several processor cores.

A variable declared in a method's header that receives an argument's value when the method is called.

A log message written with {} gaps, filled only if it is written.

One test method that JUnit runs once per set of arguments, each run reported separately.

The rule that a class loader asks its parent for a class before searching its own locations.

A pom other poms inherit settings from.

Reading text such as "42" to produce the number it describes.

Java's only way of passing arguments: each argument's value (a number, or a reference) is copied into the parameter.

The one-way, slow, salted value a server stores instead of a password.

The address of a file or folder, written as folder names separated by slashes.

The list of folders a terminal searches to find a command.

Untrusted text in a file path, such as ../, reaching files outside the intended folder.

A {name} part of a mapped URL path, bound to a method parameter with @PathVariable.

Choosing what to do by testing what kind of value you have, and naming it in the same step.

The name introduced by a type pattern, such as c in s instanceof Circle c.

A password hashing function built into the JDK.

The rule for choosing wildcards - producer extends, consumer super.

Writing a character a URL can't hold as % and two hex digits per UTF-8 byte.

An amount of calendar time in years, months and days, such as P1Y2M3D.

The list after a sealed type's name of every type allowed to extend or implement it.

The set of entities an EntityManager has loaded or saved, one object per row.

The named set of entity classes and connection settings in persistence.xml.

A virtual thread that can't leave its carrier while it waits, holding the carrier like a platform thread.

A ? in a prepared statement's SQL where a value will be supplied.

A Java thread backed one-to-one by an operating-system thread.

One task a plugin can perform, written prefix:goal, such as surefire:test.

An agreed end marker a producer puts into a queue to tell a consumer to stop.

Letting JSON say which subclass to build.

One call written once behaving differently for different kinds of object.

Maven's build file, pom.xml, describing one project.

A number from 0 to 65535 that picks one program on a host.

What a method guarantees afterwards

Which operator is applied first when several appear together, such as * before +.

The fixed order in which a program looks for a setting; the first source that has it wins.

What must be true when a method is called; meeting it is the caller's job.

The JDK functional interface for a yes-or-no test on one value, boolean test(T t).

A JDBC statement with ? placeholders whose values are sent separately from the SQL.

Writing JSON over several indented lines so people can read it.

A finished but not yet final Java feature, usable only with --enable-preview.

The column whose value is unique in every row and never NULL, used to name the row.

A functional interface or stream for plain int, long or double values, such as IntPredicate, that avoids boxing.

A stream of plain int, long or double values, such as IntStream, with sum, average, max and min.

One of Java's eight built-in value types, such as int or double, held directly in the variable.

A queue whose head is always its smallest element, whatever order elements arrived in.

RFC 9457's standard JSON shape for error bodies.

A running program, with memory of its own that other programs can't touch.

Threads that make work handing it through a queue to threads that do it.

A named set of settings, such as dev or prod, loaded from application-.properties when active.

A tool that watches a running program and reports where its time and memory go.

A set of instructions a computer can carry out.

A precise notation for writing instructions a computer can follow.

Declaring variables and parameters with interface types, naming a class only in new.

A folder of source files plus the settings that say how to build them.

An exception passing from a method that doesn't handle it to that method's caller.

A text file of name=value settings that Java reads into a Properties object.

One place Spring Boot reads settings from; for each key the highest-precedence source wins.

A set of rules two programs agree on for what the bytes they exchange mean.

The generated subclass Spring hands out in place of a bean, to add behaviour such as transactions around calls.

Program steps written in plain English

The public constructors and methods other code may rely on; everything private is implementation.

A request on GitHub or GitLab to merge a branch, with its diff, checks and review.

Work that grows with the square of the number of elements, typically a loop over everything inside another.

An export to named modules only, written exports p to m1, m2;.

A SELECT statement, which reads data and returns a result set without changing anything.

The name=value pairs after the ? in a URL.

A bug where a program's result depends on how the scheduler happens to interleave its threads.

A 2D array whose rows have different lengths.

A generic type used without type arguments, such as List instead of List.

Maven's build of all modules of a multi-module project, in dependency order.

Reading a shared value, computing from it, and writing the result back, such as count++.

The words after a status code, such as OK, meant only for people.

Replaying a branch's commits on top of another branch, giving a straight history.

A class declared by listing its components; Java writes the fields, constructor, accessors, equals, hashCode and toString.

One of the values a record holds, listed in brackets in its header.

A pattern such as Rect(var w, var h) that matches a record type and binds its components.

The path where a recursive method calls itself on a smaller input.

A method that calls itself on a smaller input.

Combining all the elements of a stream into one value, as reduce, sum and count do.

A lock's property that the thread holding it can take it again without blocking.

A lock as an object, used as lock(); try { ... } finally { unlock(); }, with tryLock and timeouts.

Changing code's structure without changing what it does.

What a String (or other object) variable holds, pointing at an object stored elsewhere.

Any type that isn't primitive, such as String; its variables hold a reference to an object.

A credential an app swaps for new access tokens without a new login.

A bug in behaviour that used to work, introduced by a later change.

A small pattern language for matching text, used by split.

A type whose full information exists at run time, such as String[] or List<?>.

A database that keeps data in tables that refer to each other by key values.

A short file address, such as notes.txt, that Java finishes off with the working directory.

Spring Boot matching one key in several spellings, such as CATALOGUE_MAXLOANS for catalogue.max-loans.

The % operator, which gives what is left over after integer division.

A tool that reads what you type, runs it, and prints the result, over and over.

The bean, usually behind an interface, that stores and finds the application's data.

A company server, such as Nexus or Artifactory, that mirrors Maven Central and hosts private libraries.

A description of a resource's current state, usually written in JSON.

The first line of an HTTP request, such as GET /greeting HTTP/1.1.

How long one request may wait for its response.

A requires that also passes the read on to every module that requires this one.

The helper, usually run by the OS or the local network, that answers DNS lookups.

An object that holds something outside the program, such as an open file, and must be closed after use.

A thing an API offers, such as a book, with its own URL.

Maven replacing ${...} placeholders in resource files as it copies them.

A return type holding a status, headers and a body, used to choose the response's status code.

The conventions most web APIs follow, with resources as nouns and methods as verbs.

A header HttpClient sets itself and refuses to let code set, such as Host.

The table of rows a query returns.

The JDBC cursor over a query's rows, read one row at a time with next().

To throw a caught exception again, unchanged, with throw e; inside a catch block.

Describes a failure that may go away if the same request is sent again later.

return expression; ends the method and hands back the value; return; ends a void method.

The type of value a method hands back

The value a method hands back to its caller; the call takes that value.

Discarding every change made in the current transaction.

The first exception in a chain: the last Caused by section of a stack trace.

One thing stored in a table, with one value for each column.

Visiting a grid row by row.

An IDE's saved recipe for how to start your program.

Run until the line the cursor is on, as a breakpoint used once.

A problem that stops a program while it is running.

The functional interface for a job with no input and no result: void run().

A JAR whose manifest names a Main-Class, so java -jar can start it.

A self-contained Java runtime folder, made by jlink, with only the modules a program needs.

The class an object was created from with new; it decides which override runs.

The branch of Exception for failures that usually mean the calling code made a mistake; all of it is unchecked.

A method that only reads and asks for no change on the server, like GET.

Random bytes mixed into a password before hashing, stored next to the hash.

A machine-readable list of every component and version in a build.

Keeping a non-escaping object's fields in registers instead of allocating the object.

Handling a saved format whose fields change between versions of a program.

The part of a program where a variable's name can be used.

A named permission a token carries, such as books:read.

A value bound for exactly one call and everything it calls, readable without a parameter.

A provider's ready-made client library for its API.

A class or interface that names every type allowed to extend or implement it.

A setting that grants access, such as a password or an API key.

A service that stores secrets encrypted, controls and logs access, and can rotate them.

Replacing a secret with a new value and retiring the old one.

The JDK's unpredictable random generator, for tokens, ids, salts and keys.

An old in-process sandbox for Java code, permanently disabled since Java 24.

The starting number that fixes a random sequence.

Version numbers MAJOR.MINOR.PATCH, where the part that changes says what kind of change it is.

A set of permits that limits how many threads use a resource at once.

A special input that means no more data, like typing 0 to finish a list.

Putting each kind of decision, such as input, rules and output, in its own part of the code.

A collection with a defined first and last element, offering getFirst, getLast and reversed.

A single-threaded garbage collector for small heaps, chosen automatically on very small machines.

Turning objects into bytes or text that can be saved or sent.

A check on each class in a Java serialization stream before it is created.

A version-number field that serializable classes, including every exception class, are expected to declare.

The beans that hold an application's rules and use cases, in plain Java with no HTTP types.

The server part, such as Tomcat, that accepts connections, reads HTTP requests and runs them on threads.

An attack where an id planted before login becomes the victim's logged-in session.

A random, unguessable key the server maps to a logged-in user, sent in a cookie.

A collection that never holds two equal elements.

A parameter or local with the same name as a field hides the field; this.name reaches the field.

A copy that shares the objects inside the original.

Having final fields that can't be reassigned, while the objects they refer to can still change.

The rule that && and || skip their right side when the left side already decides the answer.

A stream step such as limit, findFirst or anyMatch that can stop pulling elements once it has its answer.

Anything a method does besides computing its return value

A method's name plus its parameter types in order; return type and parameter names are not part of it.

A class should have one reason to change, meaning one source of change requests.

An import of one named type, such as import java.util.List;.

Spring's default of one instance of a bean per context, shared by every caller and thread.

The logging API most Java projects call.

A version ending in -SNAPSHOT, meaning work in progress that may change.

One end of a network connection, as a program sees it.

An IP address together with a port, naming one listening program.

Five design principles for classes and interfaces, one per letter.

The human-readable text of a program, written in a programming language.

Running a .java file directly with java File.java, with no separate compile step.

One package whose classes are spread over two or more JARs.

A tool that analyses compiled bytecode for known bug patterns such as RV_RETURN_VALUE_IGNORED.

A build plugin that runs a code formatter: spotless:check reports violations, spotless:apply fixes them.

Spring with defaults decided, starters, auto-configuration and an embedded Tomcat, so an app is one runnable JAR.

Spring's module that implements repository interfaces extending JpaRepository at start-up.

The website and service that generates a new Spring Boot project as a zip.

The Spring framework module that authenticates requests and enforces access rules.

The language programs use to query and change a relational database.

An attack where typed text is pasted into SQL and changes what the statement does.

SQL's marker for a missing or unknown value in a column.

A five-character standard error code an SQLException may carry, such as 23505.

The checked exception every JDBC method can throw when the database reports an error.

A relational database that is a library keeping the whole database in one file, with no server.

The memory for one call in progress: its parameters, locals and where to return to.

The report Java prints when an exception isn't handled, showing where it happened.

Thrown when the call stack has no room for another frame

The folders every Maven and Gradle project uses, such as src/main/java and src/test/java.

A program's second output stream, for error reports; the JVM prints uncaught stack traces there.

The stream of characters a program reads, normally from the keyboard.

The ready-made code that comes with every JDK, such as String and the collections.

A Spring Boot dependency with no code of its own that brings a tested set of libraries for one job.

A thread that never gets a resource because others keep winning it.

The current values of an object's fields.

Each request carries everything the server needs, credentials included.

One complete instruction, usually ending in a semicolon.

Examining code without running it, looking for rule violations and patterns that indicate bugs.

A static method that creates and returns an object, like a constructor with a name.

A field that belongs to the class, with one copy shared by every object.

An import of a static member, so code can write max(3, 8) instead of Math.max(3, 8).

Code in a class's static { ... } block, or a static field's initializer, run once when the class is initialized.

A method that belongs to the class, is called through the class name, and has no this.

The first line of an HTTP response, such as HTTP/1.1 200 OK.

Debugger commands that run the program one line or one method at a time.

Designing a program by turning plain-English steps into method calls

@Component or a specialisation of it (@Service, @Repository, @Controller, @RestController) that makes a class a bean and names its layer.

A moment when the garbage collector stops all of the program's threads to do part of its work.

Putting one interchangeable algorithm behind an interface so it can be swapped at run time.

A sequence of elements flowing through a chain of operations; it stores nothing and never changes its source.

A source, zero or more intermediate operations, and one terminal operation.

A formatter setting that rejects impossible dates such as 31 April instead of moving them.

The shared store that lets equal string literals be one object.

The module rule that public types in a package the module doesn't export can't be used from other modules.

Concurrency where subtasks start, fail and finish as one unit inside a scope.

Java 25's preview API for forking subtasks on virtual threads and joining them as one unit.

A method with its real header and a placeholder body that just compiles.

The class that extends another, as Hourly extends Employee.

Code written for a superclass must keep working, every promise kept, with any subclass object.

A piece of work forked inside a StructuredTaskScope, on its own virtual thread.

super(...) runs a superclass constructor; super.m() runs the superclass's version of m.

Maven's built-in default pom that every pom inherits from.

The class being extended; every class without extends has Object as its superclass.

The JDK functional interface that takes nothing and returns a value, T get().

An exception thrown while closing a resource after the try block had already thrown, kept inside the first exception.

The Maven plugin that runs unit tests in the test phase.

A primary key with no meaning outside the database, usually a number it generates.

Two chars that together store one character beyond 65,535, such as most emoji.

Catching an exception and carrying on as if nothing happened, with no report and no correct recovery.

A switch that produces a value, so it can be stored or printed.

Code that holds an object's monitor while it runs, so only one thread at a time can be inside.

A request whose caller waits on that line until the response has arrived.

A setting given to the JVM on the command line with -Dname=value.

A grid of rows and named columns holding one kind of thing in a relational database.

A short name for a table in a query, such as c for customers.

The functional interface type a lambda or method reference is assigned or passed to.

The protocol that gives two programs a reliable, ordered, two-way stream of bytes.

A chain of constructors, each adding one more optional parameter, whose calls nobody can read.

A final method that fixes an algorithm's steps and leaves some steps to subclasses.

A window where you type commands for the computer to run.

The last step of a stream pipeline, such as toList or count, which runs the pipeline and ends the stream.

One input together with its expected result.

Any object that stands in for a real collaborator during a test.

A test that ended with an unexpected exception, which Surefire counts separately from a failed assertion.

The known starting state a test builds before acting, often in a @BeforeEach method.

Each test sets up what it needs and leaves nothing behind, so it gives the same result alone or in any order.

JUnit's default of creating a new test-class object for every test method.

Guidance for a test suite's mix, with many unit tests, fewer integration tests and few end-to-end tests.

A Spring test that starts only one layer, such as @WebMvcTest for one controller.

A test double that wraps a real object, letting calls through while recording them.

A test double that answers calls with canned values and records nothing.

All of a project's automated tests, run together by one command.

Writing a failing test before the code (red), then just enough code to pass (green), then tidying (refactor).

A Library that starts throwaway Docker containers, such as a real PostgreSQL, for tests.

A multi-line string literal written between triple quotes.

Inside a constructor or instance method, a reference to the object being built or worked on.

One path of execution inside a process, with its own call stack, sharing the process's heap.

Keeping data reachable from one thread only, so it can't race.

A list of every thread in a running JVM with its state, stack and locks.

One thread's request that another stop, made with interrupt() and signalled by a flag.

A fixed set of reusable threads that take tasks from a queue.

The part of the operating system that decides which thread runs next, and for how long.

Where a thread is in its life, from NEW to TERMINATED, as getState() reports.

Behaving correctly when used by many threads at once, with no extra care from the callers.

A variable with a separate value for each thread, which lives until removed.

The statement throw expression; which throws an exception object, usually one made on the spot with new.

The superclass of everything Java can throw: every Error and every Exception.

The part of a method header that lists checked exceptions it may let escape: void load() throws IOException.

HotSpot's scheme of running each method interpreted first, then C1-compiled, then C2-compiled as it gets hotter.

A region's rules for which offset from UTC its clocks use, and when that changes.

The rules that encrypt a connection and prove the server's identity.

One piece of input with no whitespace in it, such as a word or a number.

The small difference within which two computed doubles are treated as equal.

A class declared directly in a file, not inside another class.

The outermost catch in a program, such as in main, which reports any failure once and decides whether to continue.

A group of database changes that is saved all together or not at all.

A library your project gets because one of its dependencies needs it.

Visiting every element of an array once.

The line where data from a source you don't control enters code that acts on it.

The set of root certificates a client trusts, the JDK's lib/security/cacerts by default.

The block after try that holds statements which might throw.

A try statement that declares resources in brackets and closes each one automatically, on every path.

An array of rows, each row an array.

The kind of value something holds, such as int, double or String, which decides what you can do with it.

The actual type written in angle brackets when a generic type is used, such as String in List.

The compiler removing type arguments after checking them, so generic types don't exist at run time.

The compiler working out type arguments from a call's arguments or the type it is assigned to.

A placeholder for a type, declared in angle brackets, such as the T in class Box.

A case such as case Integer i that matches any value of that type and names it.

A small Jackson helper that carries a full generic type, such as List, to readValue.

A box sketch of a class with its name, fields and methods, marked - for private and + for public.

A method reference like String::length whose receiver is the first parameter passed in.

Java taking the primitive value out of a wrapper object automatically, as in int x = list.get(0).

An exception the compiler doesn't make you catch or declare: a RuntimeException or an Error.

A compiler warning that it couldn't check a generic type, as with a raw type or a cast to List.

An unchecked exception that wraps an IOException, for places a checked one isn't allowed, such as inside a lambda.

A check C2 plants where it chose not to compile a path; taking that path deoptimizes the method.

The worldwide standard that gives every character a number.

Code that runs one method with chosen inputs and compares the result with the expected value.

A collection whose elements can be read but not added, removed or replaced.

A list whose elements can be read but never added, removed or replaced.

The module that everything on the class path belongs to.

The underscore _, which matches anything in a pattern and names nothing.

Of an object: no chain of references from a live variable reaches it, so the garbage collector may reclaim it.

Data that came from outside your control, such as requests, uploads, partner APIs or user-written rows.

Abandoning stack frames one by one as an exception propagates, running finally blocks on the way.

Treating a subclass object as its superclass type; always safe and needs no syntax.

The general name for an identifier like a URL; Java's networking APIs take a java.net.URI.

A web address saying where a resource is and how to reach it.

One requirement told from the user's side: who wants it, what they want, and why.

The world's reference clock; other zones are a number of hours ahead of it or behind it.

The charset that stores every Unicode character in one to four bytes; Java's default since Java 18.

A class of only static methods and constants, like Math, with a private constructor.

An object identified only by its data, so two with the same data are interchangeable.

A way to declare a local variable and let the compiler work out its fixed type from the first value.

A last parameter written Type... name that accepts any number of arguments as an array.

A named storage place that holds one value of a fixed type.

Two parts of the dependency graph asking for different versions of one library.

A cheap thread managed by the JVM that frees its carrier while it waits.

Whether one thread's write is guaranteed to be seen by another thread's read.

A free, separately downloaded tool that attaches to running JVMs to monitor and profile them.

A field modifier that makes every read see the latest write, without making ++ atomic.

The thinnest version of a program that runs end to end through every layer.

The period after a Java program starts when its code is still interpreted or partly compiled, so it runs slower.

A JMH run of a benchmark whose timing is thrown away, so the code is compiled before measurement starts.

An expression the debugger shows again at every pause.

A ready-made program that routes HTTP requests to your methods and converts their inputs and results.

Invisible characters such as spaces, tabs and line breaks.

An automatic conversion to a type that can hold the value's range, such as int to double.

A ? in a type argument, meaning some type within limits, such as List<? extends Number>.

A method that returns a copy of an immutable object with one value changed.

The adjustable cost (iterations, cost or memory) that makes each password guess slow.

The folder a terminal is "in" right now.

A class whose objects hold one primitive value, such as Integer for int or Double for double.

Don't build options or abstractions for needs nobody has asked for yet.

The part of the heap where new objects are allocated and collected often.

A garbage collector that keeps pauses under a millisecond by doing nearly all its work concurrently.

A date and wall-clock time together with a time zone, which pins down one moment.