Authoritative sources
Every source used across all topics. Filter by type, topic, or text — anything with the green dot is canonical (Javadoc / JLS / JEP / OpenJDK).
Showing 525 of 525
Collections Framework Overview
The canonical narrative of why the framework exists and what it ships.
Collections Reference (annotated outline)
Annotated tree of every interface and implementation in java.util.
Collections Design FAQ
Authors explain the controversial design choices (why Map is separate, optional ops).
Tutorial: Introduction to Collections
Friendly narrative intro to the framework.
Collection (javadoc)
The root interface; class-level docs define the contract.
Iterable (javadoc)
The for-each interface above Collection.
List (javadoc)
Ordered Collection contract.
ArrayList (javadoc)
Read the class-level notes for the amortized-O(1) add guarantee.
LinkedList (javadoc)
Doubly-linked list; also implements Deque.
Tutorial: The List Interface
Narrative description of List semantics.
Tutorial: List Implementations
Compares ArrayList vs LinkedList trade-offs.
OpenJDK source: ArrayList.java
See grow(int) for the 1.5× growth factor.
OpenJDK source: LinkedList.java
Node<E> doubly-linked structure.
Set (javadoc)
Mathematical set contract.
HashSet (javadoc)
Backed by HashMap.
LinkedHashSet (javadoc)
Insertion-ordered HashSet.
TreeSet (javadoc)
Red-black tree NavigableSet.
SortedSet (javadoc)
Adds ordering to Set.
NavigableSet (javadoc)
Adds floor/ceiling/lower/higher.
Tutorial: The Set Interface
Narrative intro to Set semantics.
Tutorial: Set Implementations
Compares HashSet / LinkedHashSet / TreeSet trade-offs.
OpenJDK source: HashSet.java
A thin wrapper over HashMap.
Map (javadoc)
Map contract — note how it deliberately does not extend Collection.
HashMap (javadoc)
Read the implementation notes for treeification and load factor.
Tutorial: The Map Interface
Narrative intro to Map.
Tutorial: Map Implementations
Compares HashMap / LinkedHashMap / TreeMap.
OpenJDK source: HashMap.java
See hash(), putVal, resize, treeifyBin — the heart of the framework.
JEP 180: Handle frequent HashMap collisions with balanced trees
The rationale for the linked-list → red-black-tree promotion in Java 8.
LinkedHashMap (javadoc)
See removeEldestEntry for the LRU recipe.
OpenJDK source: LinkedHashMap.java
Doubly-linked Entry threaded through the table.
TreeMap (javadoc)
Red-black tree NavigableMap; log(n) for everything.
SortedMap (javadoc)
The basic sorted-map contract.
NavigableMap (javadoc)
Adds floorKey, ceilingKey, etc.
Tutorial: The SortedMap Interface
Narrative intro to sorted-map semantics.
OpenJDK source: TreeMap.java
Red-black tree implementation.
Object.equals(Object) (javadoc)
The contract: reflexive, symmetric, transitive, consistent, null-handling.
Object.hashCode() (javadoc)
Consistency + equal-implies-equal-hash invariants.
Tutorial: Object Ordering
Narrative coverage of equals/hashCode in collection context.
Effective Java — Item 10 & 11 (Bloch)
The canonical treatment of overriding equals/hashCode correctly.
Comparable (javadoc)
Natural ordering contract; consistency-with-equals discussion.
Comparator (javadoc)
External ordering + the comparing/thenComparing combinators.
Tutorial: Object Ordering
Narrative coverage of natural vs external ordering.
Effective Java — Item 14 (Bloch)
When (and how) to implement Comparable.
Queue (javadoc)
The throw/return method matrix lives here.
Deque (javadoc)
Double-ended queue; replaces Stack.
ArrayDeque (javadoc)
Circular-buffer Deque; preferred over Stack and LinkedList.
PriorityQueue (javadoc)
Binary-heap implementation; iterator order is undefined.
Tutorial: The Queue Interface
Narrative intro to Queue.
Tutorial: The Deque Interface
Narrative intro to Deque.
Iterator (javadoc)
The fundamental iteration protocol.
ListIterator (javadoc)
Bidirectional iterator + add/set/indices for List.
Iterable (javadoc)
The for-each contract that sits above Collection.
Spliterator (javadoc)
Splittable iterator that powers parallel streams.
ConcurrentModificationException (javadoc)
Read why detection is best-effort.
ConcurrentHashMap (javadoc)
Read the class-level docs for atomic operation semantics.
ConcurrentMap (javadoc)
Defines atomic putIfAbsent/compute/merge.
java.util.concurrent package overview
Memory-visibility guarantees that apply to every concurrent collection.
OpenJDK source: ConcurrentHashMap.java
The CAS-based implementation; see the overview comment.
Java Concurrency in Practice — Chapter 5 (Goetz)
Building blocks: concurrent collections.
BlockingQueue (javadoc)
The put/take/offer/poll method matrix.
ArrayBlockingQueue (javadoc)
Bounded, single-lock array-backed.
LinkedBlockingQueue (javadoc)
Two-lock node-based queue; optionally bounded.
SynchronousQueue (javadoc)
Zero-capacity rendezvous (used by cachedThreadPool).
DelayQueue (javadoc)
Elements become available when their delay expires.
PriorityBlockingQueue (javadoc)
Unbounded heap with blocking take semantics.
LinkedTransferQueue (javadoc)
Lock-free queue with transfer() for handoff.
ThreadPoolExecutor (javadoc)
See which queue each Executors factory uses.
CopyOnWriteArrayList (javadoc)
Snapshot iterator + array clone on every write.
CopyOnWriteArraySet (javadoc)
Set built on the same copy-on-write primitive.
ConcurrentSkipListMap (javadoc)
Lock-free concurrent NavigableMap.
ConcurrentLinkedQueue (javadoc)
Michael & Scott lock-free queue.
ConcurrentLinkedDeque (javadoc)
Lock-free double-ended sibling of ConcurrentLinkedQueue.
Collections (javadoc)
Static helpers: sort, binarySearch, unmodifiable*/synchronized* wrappers.
Arrays (javadoc)
Companion to Collections for array operations.
Tutorial: Algorithms
Narrative on the algorithms in Collections.
Tutorial: Wrapper Implementations
Explains unmodifiable, synchronized and checked wrappers.
SequencedCollection (javadoc)
Adds getFirst/getLast/addFirst/addLast/reversed to ordered collections.
SequencedSet (javadoc)
SequencedCollection with Set semantics.
SequencedMap (javadoc)
Sequenced equivalent for Map (firstEntry / lastEntry / reversed).
JEP 431: Sequenced Collections
Rationale for the new SequencedCollection hierarchy.
JEP 269: Convenience Factory Methods for Collections
Rationale and semantics of List.of / Set.of / Map.of.
Collectors (javadoc)
toList vs toUnmodifiableList vs the new Stream.toList.
Stream (javadoc)
Stream.toList() is unmodifiable since Java 16.
JEP 444: Virtual Threads
Why thread-local caching and synchronized boundaries matter for collection use.
Object-Oriented Programming Concepts (Tutorial)
Canonical "what is an object/class/inheritance/interface" trail.
Learning the Java Language trail
Parent trail covering all four pillars in narrative form.
Effective Java (3rd edition), Joshua Bloch
The OOP bible. Items 17–23 plus Methods Common to All Objects are interview gold.
Classes and Objects (Tutorial)
Constructors, methods, `this`, nested classes, enums, records.
Defining Methods (Tutorial)
Method declaration syntax, varargs, and overloading rules.
Passing Information to a Method (Tutorial)
Pass-by-value semantics — a perennial interview question.
JLS Chapter 8: Classes
Class declarations, constructors, instance initialization order — the formal spec.
Inheritance (Tutorial)
Subclassing, the `Object` superclass, and member access across hierarchies.
Overriding and Hiding Methods (Tutorial)
Overriding vs hiding (static methods) — a classic trick question.
Using the Keyword super (Tutorial)
How to call a superclass constructor or invoke a hidden parent method.
JLS §8.4.8: Inheritance, Overriding, and Hiding
Formal override rules — read this for senior interviews.
Interfaces (Tutorial)
Declaring interfaces, implementing them, and using them as types.
Abstract Methods and Classes (Tutorial)
When an abstract base class is the right call over an interface.
Default Methods (Tutorial)
Java 8+; diamond resolution is a favorite interview topic.
JLS Chapter 9: Interfaces
Interface declarations, default and private methods, functional interfaces.
Polymorphism (Tutorial)
Dynamic dispatch with a `Bicycle` hierarchy example.
Abstract Methods and Classes (Tutorial)
The mechanism behind polymorphic API design.
JLS §15.12: Method Invocation Expressions
Dispatch rules: static vs dynamic binding, with the formal resolution algorithm.
Controlling Access to Members of a Class (Tutorial)
public / protected / package-private / private — the canonical reference.
JLS §6.6: Access Control
Formal access-control rules including the cross-package protected nuance.
Object as a Superclass (Tutorial)
Overview of equals, hashCode, toString, clone, finalize on Object.
Object.equals (Javadoc)
The five-property equals contract — memorize this.
Object.hashCode (Javadoc)
The hashCode contract and its relationship with equals.
Object.toString (Javadoc)
The minimal contract and the case for overriding it.
Cloneable (Javadoc)
Read to understand why you should never use it.
Nested Classes (Tutorial)
Static nested, inner, local, anonymous — what each can capture.
JLS §8.1.3: Inner Classes and Enclosing Instances
Formal rules for enclosing instances, captured variables, and synthetic refs.
Effective Java Item 17: Minimize Mutability
The canonical recipe for immutable classes.
Records (Java 25 Language Guide)
The modern immutable-by-default data carrier.
Effective Java Item 18: Favor Composition Over Inheritance
The single most-cited argument in Java OOP design.
Inheritance (Tutorial)
The mechanics of subclassing — context for the "is-a" trade-offs.
SOLID (Wikipedia)
Accurate overview of each principle with code examples.
Clean Coder Blog (Robert C. Martin)
Canonical SRP/OCP/LSP/ISP/DIP articles by Uncle Bob himself.
Clean Architecture (Robert C. Martin)
Book-length treatment of SOLID and the architectural principles built on it.
Refactoring.Guru — Creational Patterns
Best free visual explanations of Singleton, Factory, Builder, Prototype.
Head First Design Patterns (Freeman & Robson)
The friendliest path into GoF — see chapters on Factory and Singleton.
Java Design Patterns (GitHub)
Runnable Java implementations of every major pattern.
Refactoring.Guru — Structural Patterns
Adapter, Decorator, Proxy, Facade, Composite with diagrams.
Head First Design Patterns (Freeman & Robson)
The Decorator chapter (Starbuzz coffee) is the gold-standard introduction.
Baeldung Design Patterns Series
Pragmatic Java examples for every structural pattern, free.
Refactoring.Guru — Behavioral Patterns
Strategy, Observer, Command, State, Chain of Responsibility, etc.
Head First Design Patterns (Freeman & Robson)
Strategy, Observer, Template Method, Command — explained with vivid examples.
Design Patterns: Elements of Reusable OO Software (GoF)
The original; dense but canonical reference.
Records (Java 25 Language Guide)
What the compiler generates for a record and how to extend it safely.
Sealed Classes (Java 25 Language Guide)
How `permits` enables exhaustive switch checking and controlled extension.
Pattern Matching for instanceof (Java 25 Language Guide)
The cast-eliminating instanceof pattern and its scope rules.
JEP 395: Records
The motivation and design choices behind records as nominal tuples.
JEP 409: Sealed Classes
Sealed classes and interfaces as a building block for algebraic data types.
JEP 394: Pattern Matching for instanceof
The first pattern-matching JEP — foundation for switch patterns later.
Low-Level Design Primer (GitHub)
Free open-source LLD problem set with worked solutions.
Grokking the Object-Oriented Design Interview
Widely used for FAANG OOD rounds (paid course).
LeetCode — Object-Oriented Design Problems
Design parking lot, Twitter, LRU cache — the classic LLD warm-up problems.
Tutorial: Defining and Starting a Thread
Runnable vs subclassing Thread, start vs run.
Thread (javadoc)
Lifecycle, daemon, interrupt, join — read the class-level notes.
Thread.State (javadoc)
The six thread states: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED.
Runnable (javadoc)
The functional task interface.
Tutorial: Pausing Execution with Sleep
sleep() semantics and interruption.
Tutorial: Interrupts
The cooperative interruption mechanism.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
Tutorial: Synchronization
Intrinsic locks, synchronized methods and statements.
Tutorial: Intrinsic Locks and Synchronization
Monitors, reentrancy, the lock behind every object.
Tutorial: Guarded Blocks (wait/notify)
The canonical wait()/notifyAll() producer-consumer pattern.
Object.wait / notify / notifyAll (javadoc)
Contract for the wait set and why wait() must be looped.
JLS §17.1 Synchronization
The language spec for monitor entry/exit.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
JLS Chapter 17: Threads and Locks
The Java Memory Model itself — happens-before, volatile, final-field semantics.
JLS §17.4 Memory Model
Formal definition of happens-before and the actions ordering.
JLS §17.5 final Field Semantics
Why correctly-constructed immutables are safe to publish via a data race.
Java Language Spec — volatile (JLS §8.3.1.4)
The volatile modifier definition.
JSR-133 (JMM) FAQ — Jeremy Manson & Brian Goetz
The classic plain-English explanation of the rewritten memory model and double-checked locking.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
java.util.concurrent.locks (package javadoc)
Overview of the Lock framework.
ReentrantLock (javadoc)
tryLock, fairness, lockInterruptibly — read the class notes.
ReentrantReadWriteLock (javadoc)
Read/write separation and downgrade rules.
StampedLock (javadoc)
Optimistic-read API and its caveats.
Condition (javadoc)
Multiple wait-sets per lock; await/signal.
AbstractQueuedSynchronizer (javadoc)
The CLH-queue framework behind locks and synchronizers.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
java.util.concurrent.atomic (package javadoc)
The package overview describes CAS and the atomic toolkit.
AtomicInteger (javadoc)
compareAndSet, getAndIncrement, accumulate/update methods.
LongAdder (javadoc)
Striped counters for high write contention.
AtomicStampedReference (javadoc)
The standard fix for the ABA problem.
VarHandle (javadoc)
The supported replacement for sun.misc.Unsafe memory ops.
JEP 193: Variable Handles
Rationale for VarHandle and the access-mode model.
Tutorial: Executors
Executor, ExecutorService, thread pools — the narrative intro.
ThreadPoolExecutor (javadoc)
Every parameter, queueing strategy, and rejection policy is documented here.
Executors (javadoc)
Factory methods and exactly which pools/queues they build.
ExecutorService (javadoc)
submit, shutdown, awaitTermination, invokeAll.
RejectedExecutionHandler (javadoc)
AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy.
Effective Java, 3rd Edition (Bloch) — Concurrency chapter
Items 78–84: synchronization, executors, lazy initialization, and the JMM.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
CompletableFuture (javadoc)
The full composition API — thenApply/thenCompose/thenCombine/handle.
Future (javadoc)
get, cancel, isDone — and the blocking limitation.
Callable (javadoc)
A task that returns a result and may throw.
CompletionStage (javadoc)
The interface defining the dependent-stage combinators.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
CountDownLatch (javadoc)
One-shot latch; await until count reaches zero.
CyclicBarrier (javadoc)
Reusable barrier with an optional barrier action.
Semaphore (javadoc)
Permit-based access control; bounded resource pools.
Phaser (javadoc)
Dynamic-party, multi-phase barrier.
Exchanger (javadoc)
A rendezvous point for two threads to swap objects.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
Tutorial: Liveness (Deadlock, Starvation, Livelock)
The official definitions and examples.
Tutorial: Deadlock
The classic two-lock deadlock example.
Tutorial: Starvation and Livelock
How greedy threads starve others and how livelock differs.
ThreadMXBean.findDeadlockedThreads (javadoc)
Programmatic deadlock detection at runtime.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
Tutorial: Immutable Objects
A strategy for defining immutable, inherently thread-safe objects.
ThreadLocal (javadoc)
Per-thread variables; read the notes on lifecycle and pooled threads.
JLS §17.5 final Field Semantics
The guarantee that backs safe publication of immutables.
Effective Java, 3rd Edition (Bloch) — Concurrency chapter
Items 78–84: synchronization, executors, lazy initialization, and the JMM.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
Tutorial: Fork/Join
Divide-and-conquer with RecursiveTask/RecursiveAction.
ForkJoinPool (javadoc)
Work-stealing pool, the common pool, and managed blocking.
ForkJoinTask (javadoc)
fork/join/compute semantics.
Stream — Parallelism (javadoc)
When and how streams go parallel, and the constraints.
Java Concurrency in Practice (Goetz et al.)
The definitive book on the Java Memory Model, safe publication, and concurrent design.
JEP 444: Virtual Threads
The definitive design: scheduling, mounting, pinning, and intended use.
Thread (javadoc) — Virtual Threads
Thread.ofVirtual, startVirtualThread, and the platform/virtual distinction.
JEP 453: Structured Concurrency
StructuredTaskScope and treating concurrent subtasks as a unit.
JEP 506: Scoped Values
Immutable per-thread sharing designed for virtual threads.
Oracle: Virtual Threads (Core Libraries Guide)
The user guide covering carriers, pinning diagnosis, and migration.
Tutorial: The SQL Language
Canonical narrative intro to relations, queries, and joins in PostgreSQL.
Queries
FROM/WHERE/GROUP BY/HAVING/SELECT semantics and logical processing order.
Constraints
Primary keys, unique constraints, foreign keys, and ON DELETE actions.
Comparison Functions and Operators
How NULL behaves in comparisons, IS DISTINCT FROM, and three-valued logic.
PostgreSQL: Up and Running (3rd ed.), Obe & Hsu
Practical PostgreSQL from the ground up; chapters on SQL basics.
Data Definition
Tables, columns, constraints, and inheritance — the schema-design reference.
UUID Type
UUID storage; pair with gen_random_uuid() and v7 ordering discussion.
The Art of PostgreSQL, Dimitri Fontaine
Schema design and modeling chapters written by a Postgres committer.
Database Internals, Alex Petrov
B-tree storage internals that explain why monotonic keys matter.
Data Types
The full catalog of built-in types and their storage characteristics.
Date/Time Types
TIMESTAMP vs TIMESTAMPTZ, DATE, TIME, INTERVAL, and time-zone handling.
JSON Types
JSON vs JSONB storage and when to choose each.
Arrays
Array declaration, indexing, and containment operators.
Indexes
The umbrella chapter: when indexes help, their cost, and maintenance.
Index Types
B-tree, Hash, GiST, SP-GiST, GIN, and BRIN and what each is for.
Multicolumn Indexes
Composite indexes and the left-prefix rule.
Index-Only Scans and Covering Indexes
INCLUDE columns and when an index-only scan is possible.
Partial Indexes
Indexing a subset of rows for big wins on skewed predicates.
Indexes on Expressions
Functional indexes such as LOWER(email).
PostgreSQL 14 Internals, Egor Rogov
Free, deeply authoritative coverage of access methods and index internals.
Using EXPLAIN
Reading plan nodes, costs, rows, actual time, loops, and BUFFERS.
Planner Statistics
How ANALYZE feeds selectivity estimates the planner relies on.
pg_stat_statements
The extension for finding slow and frequent queries in production.
Query Planning Configuration
random_page_cost and the GUCs that steer planner choices.
PostgreSQL 14 Internals, Egor Rogov
Chapters on the cost model and join algorithms.
Tutorial: Transactions
Narrative intro to BEGIN/COMMIT and atomicity.
Transaction Isolation
The four isolation levels, the anomalies, and SSI Serializable.
Concurrency Control (MVCC)
How MVCC removes read/write blocking; xmin/xmax row versions.
Explicit Locking
Row-level lock modes and FOR UPDATE / FOR SHARE semantics.
Routine Vacuuming
VACUUM, autovacuum, and transaction-ID wraparound prevention.
Designing Data-Intensive Applications, Kleppmann
Chapter 7 on transactions and isolation anomalies across systems.
Explicit Locking
Table-level and row-level lock modes and which statements take which.
pg_locks View
The system view for investigating live lock contention.
Monitoring Statistics
pg_stat_activity and the cumulative statistics for diagnosing blocking.
Tutorial: Window Functions
Gentle intro to PARTITION BY, frames, and ranking.
Window Functions
Reference for ROW_NUMBER, RANK, LAG/LEAD, and frame clauses.
WITH Queries (CTEs)
CTE materialization rules (the 12+ inlining change) and recursive CTEs.
LATERAL Subqueries
How LATERAL lets a subquery reference earlier FROM items.
JSON Types
JSON vs JSONB storage, equality, and JSONB containment.
JSON Functions and Operators
The -> / ->> / #> operators, jsonb_set, and JSONPath.
GIN Indexes
Indexing JSONB with GIN and jsonb_path_ops.
Full Text Search
The umbrella chapter for tsvector/tsquery search.
Full Text Search: Introduction
Concepts: documents, lexemes, dictionaries, and the @@ match operator.
Controlling Text Search
Parsing, ranking with ts_rank/ts_rank_cd, and highlighting.
Table Partitioning
Range/List/Hash partitioning, pruning, and live attach/detach.
Declarative Partitioning
The native partitioning syntax introduced in PostgreSQL 10.
High Availability, Load Balancing, and Replication
Physical vs logical, sync vs async, hot standby, and failover.
Write-Ahead Logging (WAL)
How the WAL underpins durability and replication.
Replication Configuration
Streaming replication GUCs, synchronous_standby_names, and slots.
Logical Replication
Publications and subscriptions for row-level replication.
PgBouncer Usage
Session/transaction/statement pooling modes and their trade-offs.
Designing Data-Intensive Applications, Kleppmann
Chapter 5 on replication and consistency models.
Backup and Restore
Logical (pg_dump) vs physical (file-system/base) backup strategies.
Continuous Archiving and PITR
archive_command, restore_command, and point-in-time recovery.
pg_dump
Reference for the logical-backup tool and its formats.
pg_basebackup
Reference for taking a physical base backup of a cluster.
Resource Consumption Configuration
shared_buffers, work_mem, maintenance_work_mem, effective_cache_size.
Automatic Vacuuming Configuration
Tuning autovacuum so it keeps up with write-heavy tables.
Monitoring Statistics
pg_stat_user_indexes and friends for finding unused/bloated objects.
pg_stat_statements
Aggregated query statistics for finding the worst offenders.
auto_explain
Automatically logging execution plans of slow statements.
CREATE FUNCTION
Function definition, languages, volatility, and security context.
CREATE PROCEDURE
Procedures and how they differ from functions (transaction control).
PL/pgSQL
The procedural language used for most stored logic and triggers.
Trigger Definition
BEFORE/AFTER/INSTEAD OF and statement vs row-level triggers.
Function Volatility Categories
IMMUTABLE vs STABLE vs VOLATILE and how the planner uses them.
The IoC Container
The foundational chapter: beans, the container, and dependency injection.
Dependencies
Constructor vs setter injection and dependency resolution.
Java-based Container Configuration
@Configuration, @Bean, and the CGLIB proxy / inter-bean reference behavior.
Classpath Scanning and Managed Components
@ComponentScan and the stereotype annotations.
Spring in Action (6th ed.), Craig Walls
Approachable, example-driven coverage of the core container.
Official Spring Guides
Short, runnable getting-started guides maintained by the Spring team.
Bean Scopes
singleton, prototype, request, session, application, websocket scopes.
Customizing the Nature of a Bean
Lifecycle callbacks: @PostConstruct, InitializingBean, init-method.
Container Extension Points
BeanPostProcessor and BeanFactoryPostProcessor mechanics.
Using @Autowired
How @Autowired resolves by type/name/qualifier, and ObjectProvider.
Autowiring Collaborators
@Primary, @Qualifier, collection injection, and ambiguity resolution.
Auto-configuration
How Boot discovers and applies auto-configuration classes.
Externalized Configuration
Property sources, precedence, @ConfigurationProperties vs @Value.
Profiles
@Profile and spring.profiles.active activation rules.
Developing Auto-configuration
Writing your own starter and @Conditional classes.
Spring in Action (6th ed.), Craig Walls
Practical walkthrough of Boot starters and auto-config.
Spring Web MVC
The servlet-stack web framework overview.
Annotated Controllers
@RequestMapping, argument resolvers, and return values.
DispatcherServlet
The request-processing pipeline and special beans.
Exception Handling (MVC)
@ExceptionHandler, @ControllerAdvice, and ResponseStatusException.
Spring Data JPA Reference
The umbrella reference for repositories and JPA integration.
JPA Repositories
Entities, persistence context, and the JPA programming model.
Query Methods
Derived queries, @Query, pagination, and projections.
Transaction Management
Where @Transactional propagation and isolation are defined.
Spring in Action (6th ed.), Craig Walls
Data-access chapters with repository examples.
Transaction Management
The full transaction abstraction overview.
Declarative Transaction Management
How the @Transactional AOP proxy is built and applied.
@Transactional Settings
Propagation, isolation, rollbackFor, and readOnly semantics.
Spring Security Reference
The entry point for the whole security framework.
Servlet Security Architecture
The SecurityFilterChain and how filters compose.
Authentication
UserDetailsService, AuthenticationManager, and password encoders.
Authorization
Method security and request-level authorization.
OAuth2
Client, resource server, and JWT support.
Spring Security in Action (2nd ed.), Laurentiu Spilca
The definitive practical book on Spring Security.
Aspect Oriented Programming with Spring
Pointcuts, advice, and the @AspectJ programming model.
Proxying Mechanisms
JDK dynamic proxies vs CGLIB and the self-invocation limitation.
Spring AOP APIs
The lower-level ProxyFactory and Advisor APIs.
Spring Framework source on GitHub
Read the actual proxy and advice implementations.
Pro Spring 6
In-depth treatment of Spring internals including the AOP machinery.
Standard and Custom Events
ApplicationEvent, @EventListener, and async publishing.
Transaction-bound Events
@TransactionalEventListener and its commit phases.
Spring Modulith Reference
How events drive decoupled module-to-module communication.
Cache Abstraction
@Cacheable/@CachePut/@CacheEvict, key generation, condition/unless.
Caching (Spring Boot)
Auto-configured cache providers: Caffeine, Redis, and others.
Task Execution and Scheduling
@Async, @Scheduled, TaskExecutor, and the executor abstraction.
Task Execution and Scheduling (Spring Boot)
Boot auto-config for executors and virtual-thread enablement.
Spring WebFlux
The reactive web stack built on Reactor.
Web on Reactive Stack
Overview of the reactive runtime and APIs.
Project Reactor Reference
Mono/Flux, operators, and backpressure.
Reactive Streams Specification
The Publisher/Subscriber/Subscription contract underlying Reactor.
Spring Boot Actuator
Production-ready endpoints, health, and metrics.
Actuator Endpoints
The full endpoint catalog and how to secure them.
Observability
Micrometer metrics and tracing integration.
Micrometer Documentation
Counters, gauges, timers, and the meter registry model.
Testing (Spring Boot)
@SpringBootTest, slice tests, and test utilities.
Testing Spring Boot Applications
@MockBean, MockMvc/WebTestClient, and context configuration.
Testing (Spring Framework)
The TestContext framework and context caching.
Testcontainers for Java
Real dependencies in disposable containers for integration tests.
Spring Boot Reference
The Boot 3.x reference root: baseline, features, and migration.
REST Clients
RestClient, @HttpExchange interface clients, and RestTemplate status.
Spring Boot 3.0 Migration Guide
javax→jakarta, removed APIs, and config migration.
Spring Modulith Reference
Structuring a modular monolith between monolith and microservices.
Spring Boot source on GitHub
Authoritative source for auto-config and Boot internals.
Spring Microservices in Action (2nd ed.), John Carnell
Patterns for the modern distributed Spring stack.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
MIT 6.006 Introduction to Algorithms (OCW)
Full lecture notes and videos on core algorithms.
Big-O Cheat Sheet
Quick-reference table of common data-structure/algorithm complexities.
java.util Javadoc (complexity notes)
Implementation notes document the cost of each operation.
Arrays (Javadoc)
Utility methods for primitive and object arrays.
StringBuilder (Javadoc)
Mutable string buffer; the answer to String immutability.
Two Pointers (LeetCode tag)
Curated practice problems for the two-pointers pattern.
Sliding Window (LeetCode tag)
Curated practice problems for the sliding-window pattern.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
LinkedList (Javadoc)
Doubly-linked list; rarely the right choice in modern Java.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Linked List (LeetCode tag)
Curated practice problems for the linked-list pattern.
ArrayDeque (Javadoc)
The modern default for both stack and queue use cases.
Deque (Javadoc)
Double-ended queue interface.
Stack (LeetCode tag)
Curated practice problems for the stack pattern.
Monotonic Stack (LeetCode tag)
Curated practice problems for the monotonic-stack pattern.
HashMap (Javadoc)
Bucketed hash table with treeified buckets since Java 8.
HashSet (Javadoc)
Hash-table-backed Set implementation.
LinkedHashMap (Javadoc)
Insertion/access order; the basis of a simple LRU cache.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Hash Table (LeetCode tag)
Curated practice problems for the hash-table pattern.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Tree (LeetCode tag)
Curated practice problems for the tree pattern.
Binary Tree (LeetCode tag)
Curated practice problems for the binary-tree pattern.
Algorithms (4th ed.) — Sedgewick & Wayne
Java-based algorithms text with runnable implementations.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
TreeMap (Javadoc)
Red-black tree implementation of NavigableMap.
NavigableMap (Javadoc)
floor/ceiling/subMap navigation API.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
PriorityQueue (Javadoc)
Binary-heap min-priority-queue; iterator order is NOT sorted.
Heap / Priority Queue (LeetCode tag)
Curated practice problems for the heap/priority-queue pattern.
Trie (LeetCode tag)
Curated practice problems for the trie pattern.
Algorithms (4th ed.) — Sedgewick & Wayne
Java-based algorithms text with runnable implementations.
CP-Algorithms
Community-maintained, high-quality algorithm reference.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Graph (LeetCode tag)
Curated practice problems for the graph pattern.
Breadth-First Search (LeetCode tag)
Curated practice problems for the breadth-first-search pattern.
Depth-First Search (LeetCode tag)
Curated practice problems for the depth-first-search pattern.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
CP-Algorithms
Community-maintained, high-quality algorithm reference.
Shortest Path (LeetCode tag)
Curated practice problems for the shortest-path pattern.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
CP-Algorithms
Community-maintained, high-quality algorithm reference.
Union Find (LeetCode tag)
Curated practice problems for the union-find pattern.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Arrays.sort (Javadoc)
Dual-Pivot Quicksort for primitives, Timsort for objects.
Timsort design notes (listsort.txt)
Tim Peters' original write-up of the adaptive merge sort.
Arrays.binarySearch (Javadoc)
Binary search over a sorted primitive array.
Binary Search (LeetCode tag)
Curated practice problems for the binary-search pattern.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Backtracking (LeetCode tag)
Curated practice problems for the backtracking pattern.
The Algorithm Design Manual (3rd ed.) — Steven Skiena
Practical war stories plus a catalog of algorithmic problems.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
MIT 6.006 Introduction to Algorithms (OCW)
Full lecture notes and videos on core algorithms.
Dynamic Programming (LeetCode tag)
Curated practice problems for the dynamic-programming pattern.
Competitive Programmer's Handbook — Antti Laaksonen
Free PDF covering the full competitive-programming toolkit.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
Greedy (LeetCode tag)
Curated practice problems for the greedy pattern.
Integer (Javadoc)
bitCount, numberOfTrailingZeros, highestOneBit, and friends.
BitSet (Javadoc)
Arbitrary-length bit arrays.
Bit Manipulation (LeetCode tag)
Curated practice problems for the bit-manipulation pattern.
Introduction to Algorithms (CLRS, 4th ed.) — Cormen, Leiserson, Rivest, Stein
The canonical algorithms reference; rigorous proofs and pseudocode.
CP-Algorithms
Community-maintained, high-quality algorithm reference.
Math (LeetCode tag)
Curated practice problems for the math pattern.
Tech Interview Handbook — Algorithms Study Cheatsheet
Pattern-to-technique mapping for interview problems.
LeetCode Study Guide (Discuss)
Community study guides organized by topic and pattern.
Cracking the Coding Interview (6th ed.) — Gayle Laakmann McDowell
The classic interview-prep problem book.
VisuAlgo — algorithm visualizations
Interactive visualizations of data structures and algorithms.
Princeton COS226 (Sedgewick)
Algorithms-and-data-structures course materials.
Stanford CS161
Design and analysis of algorithms.
awesome-low-level-design (ashishps1)
Curated LLD problem set with worked Java solutions.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
workat.tech — Machine Coding
Practice platform and rubric for machine-coding rounds.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Refactoring.Guru — Pattern Catalog
Index of all 23 GoF patterns grouped by intent.
Head First Design Patterns (2nd ed.) — Freeman & Robson
Approachable, example-driven pattern walkthroughs.
iluwatar/java-design-patterns
Runnable Java examples of every GoF pattern.
Design Patterns: Elements of Reusable OO Software — Gang of Four
The original 1994 pattern catalog.
java.util.concurrent (Javadoc)
Locks, atomics, concurrent collections, and executors.
Java Concurrency in Practice — Brian Goetz
The definitive reference for thread-safe Java design.
Parking Lot — awesome-low-level-design
Worked Java reference solution for the parking-lot problem.
low-level-design-primer (prasadgujar)
LLD problem write-ups and approach guides.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Elevator System — awesome-low-level-design
Worked Java reference solution for the elevator-system problem.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Library Management — awesome-low-level-design
Worked Java reference solution for the library-management problem.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
State Pattern — Refactoring.Guru
The State pattern, the backbone of the vending-machine design.
Vending Machine — awesome-low-level-design
Worked Java reference solution for the vending-machine problem.
low-level-design-primer (prasadgujar)
LLD problem write-ups and approach guides.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
awesome-low-level-design (ashishps1)
Curated LLD problem set with worked Java solutions.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
ATM — awesome-low-level-design
Worked Java reference solution for the ATM problem.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Movie Booking — awesome-low-level-design
Worked Java reference solution for the movie-ticket-booking-system problem.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Ride Sharing — awesome-low-level-design
Worked Java reference solution for the ride-sharing-service problem.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Effective Java — Joshua Bloch (instance control / Singleton)
Items on instance control and the enum-Singleton idiom.
Apache Log4j 2 Architecture
Log4j 2 architecture: loggers, appenders, layouts, filters.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Token bucket (rate-limiting algorithm)
The token-bucket algorithm that underpins most rate-limiter implementations.
System Design Interview Vol. 1 — Alex Xu
Chapters on rate limiting, URL shortener, and more.
LRU Cache (LeetCode)
The canonical O(1) cache-design problem.
LFU Cache (LeetCode)
The canonical O(1) cache-design problem.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Designing Data-Intensive Applications — Martin Kleppmann
Reference for messaging, delivery guarantees, and storage.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
System Design Interview Vol. 1 — Alex Xu
Chapters on rate limiting, URL shortener, and more.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Publish–subscribe pattern
The pub/sub model behind multi-channel notification fan-out.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
Design In-Memory File System (LeetCode)
In-memory file-system design problem.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
ScheduledExecutorService (Javadoc)
JDK scheduled task execution.
Refactoring.Guru — Design Patterns
The clearest catalog of GoF patterns with diagrams and Java examples.
awesome-low-level-design (ashishps1)
Curated LLD problem set with worked Java solutions.
workat.tech — Machine Coding
Practice platform and rubric for machine-coding rounds.
Grokking the OO Design Interview (Design Gurus)
Popular OO-design interview course.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
System Design (Karan Pratap Singh)
Concise open-source course covering system-design fundamentals and patterns.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
CAP Twelve Years Later (Eric Brewer)
Brewer revisits the CAP theorem and clarifies common misconceptions about its tradeoffs.
Jepsen — Consistency Models
Reference map of distributed-systems consistency models and their relationships.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
Amazon Dynamo paper (2007)
The foundational leaderless-replication / consistent-hashing paper.
Consistent Hashing (Wikipedia)
Overview of consistent hashing for distributing keys across a changing set of nodes.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
Redis — Patterns
Official Redis docs covering common usage patterns like rate limiting and distributed locks.
AWS — Caching Overview
AWS overview of caching concepts, strategies, and managed caching services.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
Apache Kafka Documentation
Official Kafka docs covering its distributed log architecture, producers, consumers, and streams.
RabbitMQ Documentation
Official RabbitMQ docs covering message brokering, exchanges, queues, and routing.
Confluent — Exactly-Once Semantics
Explains how Kafka achieves exactly-once delivery via idempotent producers and transactions.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
MongoDB — NoSQL Explained
Vendor explainer introducing NoSQL database types and when to use them over relational stores.
AWS — NoSQL
Vendor explainer of NoSQL database categories and their use cases.
REST API Tutorial
Tutorial site explaining REST principles, resources, and best practices for HTTP APIs.
gRPC Documentation
Official gRPC docs covering its RPC framework, protobuf, and streaming over HTTP/2.
GraphQL — Learn
Official GraphQL learning guide covering schemas, queries, mutations, and resolvers.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
Cloudflare — Counting Things
Cloudflare engineering post on counting at scale, underpinning distributed rate limiting.
NGINX — What Is Load Balancing?
Glossary entry explaining load balancing concepts and common distribution algorithms.
Envoy — Load Balancing
Official Envoy docs detailing its load-balancing policies and health-checking model.
microservices.io
Chris Richardson’s catalog of microservices patterns and their tradeoffs.
Martin Fowler — Microservices
Foundational article defining the microservices architectural style and its characteristics.
Building Microservices (2nd ed.) — Sam Newman
Practical guide to designing, building, and operating microservices.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
ScyllaDB — LSM-tree glossary
Glossary entry explaining log-structured merge-trees used by write-optimized storage engines.
Latency Numbers Every Programmer Should Know
Reference list of typical latencies for memory, disk, and network operations.
Cloudflare — What is a CDN?
Explains how content delivery networks cache and serve content from edge locations.
OpenTelemetry Documentation
Official docs for the OpenTelemetry standard for traces, metrics, and logs instrumentation.
Site Reliability Engineering (Google)
Free online; SLI/SLO/SLA and operational practice.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
System Design Interview Vol. 2 — Alex Xu & Sahn Lam
Second volume: Twitter, notifications, payments, and more.
X (Twitter) Engineering Blog
X engineering blog with posts on timeline, feed, and large-scale infrastructure.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
Uber Engineering Blog
Uber engineering blog with posts on dispatch, geospatial, and large-scale systems.
H3 — Uber Geospatial Index
Official docs for H3, Uber’s hexagonal hierarchical geospatial indexing system.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
Netflix Tech Blog
Netflix engineering blog covering streaming, encoding, and large-scale distributed systems.
System Design Interview Vol. 2 — Alex Xu & Sahn Lam
Second volume: Twitter, notifications, payments, and more.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
Amazon Dynamo paper (2007)
The foundational leaderless-replication / consistent-hashing paper.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
Airbnb — Airflow
Airbnb’s introduction to Airflow as a platform for authoring and scheduling workflows.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
Operational Transformation (Wikipedia)
Overview of operational transformation for real-time collaborative editing.
CRDT.tech
Curated resource hub on conflict-free replicated data types for collaborative and distributed apps.
Stripe — Designing robust and predictable APIs with idempotency
Stripe’s guide to using idempotency keys for safe retries of payment API requests.
Uber — Payments Platform
Uber engineering post on the architecture of its large-scale payments platform.
Designing Data-Intensive Applications — Martin Kleppmann
THE distributed-systems book; cited across nearly every HLD topic.
System Design Interview Vol. 1 — Alex Xu
Worked walkthroughs of the classic system-design problems.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
The System Design Primer (donnemartin)
Popular open-source primer organizing core system-design concepts and interview prep.
System Design (Karan Pratap Singh)
Concise open-source course covering system-design fundamentals and patterns.
Hello Interview
Interview-prep platform with structured system-design walkthroughs and practice.