Authoritative sources
Every source used across all topics, grouped by type. Anything with the green dot is canonical — Javadoc, the JLS, a JEP, or OpenJDK source.
Javadoc
94 of 108
Javadoc
94 of 108Collection (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.
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.
Map (javadoc)
Map contract — note how it deliberately does not extend Collection.
HashMap (javadoc)
Read the implementation notes for treeification and load factor.
LinkedHashMap (javadoc)
See removeEldestEntry for the LRU recipe.
TreeMap (javadoc)
Red-black tree NavigableMap; log(n) for everything.
SortedMap (javadoc)
The basic sorted-map contract.
NavigableMap (javadoc)
Adds floorKey, ceilingKey, etc.
Object.equals(Object) (javadoc)
The contract: reflexive, symmetric, transitive, consistent, null-handling.
Object.hashCode() (javadoc)
Consistency + equal-implies-equal-hash invariants.
Comparable (javadoc)
Natural ordering contract; consistency-with-equals discussion.
Comparator (javadoc)
External ordering + the comparing/thenComparing combinators.
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.
Iterator (javadoc)
The fundamental iteration protocol.
ListIterator (javadoc)
Bidirectional iterator + add/set/indices for List.
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.
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.
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).
Collectors (javadoc)
toList vs toUnmodifiableList vs the new Stream.toList.
Stream (javadoc)
Stream.toList() is unmodifiable since Java 16.
Object.toString (Javadoc)
The minimal contract and the case for overriding it.
Cloneable (Javadoc)
Read to understand why you should never use it.
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.
Object.wait / notify / notifyAll (javadoc)
Contract for the wait set and why wait() must be looped.
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.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.
Executors (javadoc)
Factory methods and exactly which pools/queues they build.
ExecutorService (javadoc)
submit, shutdown, awaitTermination, invokeAll.
RejectedExecutionHandler (javadoc)
AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy.
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.
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.
ThreadMXBean.findDeadlockedThreads (javadoc)
Programmatic deadlock detection at runtime.
ThreadLocal (javadoc)
Per-thread variables; read the notes on lifecycle and pooled threads.
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.
Thread (javadoc) — Virtual Threads
Thread.ofVirtual, startVirtualThread, and the platform/virtual distinction.
java.util Javadoc (complexity notes)
Implementation notes document the cost of each operation.
StringBuilder (Javadoc)
Mutable string buffer; the answer to String immutability.
Arrays.sort (Javadoc)
Dual-Pivot Quicksort for primitives, Timsort for objects.
Arrays.binarySearch (Javadoc)
Binary search over a sorted primitive array.
Integer (Javadoc)
bitCount, numberOfTrailingZeros, highestOneBit, and friends.
BitSet (Javadoc)
Arbitrary-length bit arrays.
java.util.concurrent (Javadoc)
Locks, atomics, concurrent collections, and executors.
ScheduledExecutorService (Javadoc)
JDK scheduled task execution.
Spec
19 of 20
Spec
19 of 20OpenJDK source: ArrayList.java
See grow(int) for the 1.5× growth factor.
OpenJDK source: LinkedList.java
Node<E> doubly-linked structure.
OpenJDK source: HashSet.java
A thin wrapper over HashMap.
OpenJDK source: HashMap.java
See hash(), putVal, resize, treeifyBin — the heart of the framework.
OpenJDK source: LinkedHashMap.java
Doubly-linked Entry threaded through the table.
OpenJDK source: TreeMap.java
Red-black tree implementation.
OpenJDK source: ConcurrentHashMap.java
The CAS-based implementation; see the overview comment.
JLS Chapter 8: Classes
Class declarations, constructors, instance initialization order — the formal spec.
JLS §8.4.8: Inheritance, Overriding, and Hiding
Formal override rules — read this for senior interviews.
JLS Chapter 9: Interfaces
Interface declarations, default and private methods, functional interfaces.
JLS §15.12: Method Invocation Expressions
Dispatch rules: static vs dynamic binding, with the formal resolution algorithm.
JLS §6.6: Access Control
Formal access-control rules including the cross-package protected nuance.
JLS §8.1.3: Inner Classes and Enclosing Instances
Formal rules for enclosing instances, captured variables, and synthetic refs.
JLS §17.1 Synchronization
The language spec for monitor entry/exit.
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.
Reactive Streams Specification
The Publisher/Subscriber/Subscription contract underlying Reactor.
JEP
10 of 11
JEP
10 of 11JEP 180: Handle frequent HashMap collisions with balanced trees
The rationale for the linked-list → red-black-tree promotion in Java 8.
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.
JEP 444: Virtual Threads
Why thread-local caching and synchronized boundaries matter for collection use.
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.
JEP 193: Variable Handles
Rationale for VarHandle and the access-mode model.
JEP 453: Structured Concurrency
StructuredTaskScope and treating concurrent subtasks as a unit.
JEP 506: Scoped Values
Immutable per-thread sharing designed for virtual threads.
Official Docs
128 of 135
Official Docs
128 of 135Collections 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).
java.util.concurrent package overview
Memory-visibility guarantees that apply to every concurrent collection.
Records (Java 25 Language Guide)
The modern immutable-by-default data carrier.
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.
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.
Data Definition
Tables, columns, constraints, and inheritance — the schema-design reference.
UUID Type
UUID storage; pair with gen_random_uuid() and v7 ordering discussion.
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).
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.
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.
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 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.
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.
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.
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 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.
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.
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.
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.
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 Boot source on GitHub
Authoritative source for auto-config and Boot internals.
Apache Log4j 2 Architecture
Log4j 2 architecture: loggers, appenders, layouts, filters.
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.
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.
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.
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.
OpenTelemetry Documentation
Official docs for the OpenTelemetry standard for traces, metrics, and logs instrumentation.
H3 — Uber Geospatial Index
Official docs for H3, Uber’s hexagonal hierarchical geospatial indexing system.
Tutorial
44 of 48
Tutorial
44 of 48Tutorial: Introduction to Collections
Friendly narrative intro to the framework.
Tutorial: The List Interface
Narrative description of List semantics.
Tutorial: List Implementations
Compares ArrayList vs LinkedList trade-offs.
Tutorial: The Set Interface
Narrative intro to Set semantics.
Tutorial: Set Implementations
Compares HashSet / LinkedHashSet / TreeSet trade-offs.
Tutorial: The Map Interface
Narrative intro to Map.
Tutorial: Map Implementations
Compares HashMap / LinkedHashMap / TreeMap.
Tutorial: The SortedMap Interface
Narrative intro to sorted-map semantics.
Tutorial: Object Ordering
Narrative coverage of equals/hashCode in collection context.
Tutorial: The Queue Interface
Narrative intro to Queue.
Tutorial: The Deque Interface
Narrative intro to Deque.
Tutorial: Algorithms
Narrative on the algorithms in Collections.
Tutorial: Wrapper Implementations
Explains unmodifiable, synchronized and checked wrappers.
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.
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.
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.
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.
Polymorphism (Tutorial)
Dynamic dispatch with a `Bicycle` hierarchy example.
Controlling Access to Members of a Class (Tutorial)
public / protected / package-private / private — the canonical reference.
Object as a Superclass (Tutorial)
Overview of equals, hashCode, toString, clone, finalize on Object.
Nested Classes (Tutorial)
Static nested, inner, local, anonymous — what each can capture.
Tutorial: Defining and Starting a Thread
Runnable vs subclassing Thread, start vs run.
Tutorial: Pausing Execution with Sleep
sleep() semantics and interruption.
Tutorial: Interrupts
The cooperative interruption mechanism.
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.
Tutorial: Executors
Executor, ExecutorService, thread pools — the narrative intro.
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.
Tutorial: Immutable Objects
A strategy for defining immutable, inherently thread-safe objects.
Tutorial: Fork/Join
Divide-and-conquer with RecursiveTask/RecursiveAction.
Official Spring Guides
Short, runnable getting-started guides maintained by the Spring team.
MIT 6.006 Introduction to Algorithms (OCW)
Full lecture notes and videos on core algorithms.
Princeton COS226 (Sedgewick)
Algorithms-and-data-structures course materials.
Stanford CS161
Design and analysis of algorithms.
Article
80 of 115
Article
80 of 115SOLID (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.
Refactoring.Guru — Creational Patterns
Best free visual explanations of Singleton, Factory, Builder, Prototype.
Java Design Patterns (GitHub)
Runnable Java implementations of every major pattern.
Refactoring.Guru — Structural Patterns
Adapter, Decorator, Proxy, Facade, Composite with diagrams.
Baeldung Design Patterns Series
Pragmatic Java examples for every structural pattern, free.
Refactoring.Guru — Behavioral Patterns
Strategy, Observer, Command, State, Chain of Responsibility, etc.
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.
JSR-133 (JMM) FAQ — Jeremy Manson & Brian Goetz
The classic plain-English explanation of the rewritten memory model and double-checked locking.
Big-O Cheat Sheet
Quick-reference table of common data-structure/algorithm complexities.
Two Pointers (LeetCode tag)
Curated practice problems for the two-pointers pattern.
Sliding Window (LeetCode tag)
Curated practice problems for the sliding-window pattern.
Linked List (LeetCode tag)
Curated practice problems for the linked-list pattern.
Stack (LeetCode tag)
Curated practice problems for the stack pattern.
Monotonic Stack (LeetCode tag)
Curated practice problems for the monotonic-stack pattern.
Hash Table (LeetCode tag)
Curated practice problems for the hash-table pattern.
Tree (LeetCode tag)
Curated practice problems for the tree pattern.
Binary Tree (LeetCode tag)
Curated practice problems for the binary-tree pattern.
Heap / Priority Queue (LeetCode tag)
Curated practice problems for the heap/priority-queue pattern.
Trie (LeetCode tag)
Curated practice problems for the trie pattern.
CP-Algorithms
Community-maintained, high-quality algorithm reference.
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.
Shortest Path (LeetCode tag)
Curated practice problems for the shortest-path pattern.
Union Find (LeetCode tag)
Curated practice problems for the union-find pattern.
Timsort design notes (listsort.txt)
Tim Peters' original write-up of the adaptive merge sort.
Binary Search (LeetCode tag)
Curated practice problems for the binary-search pattern.
Backtracking (LeetCode tag)
Curated practice problems for the backtracking pattern.
Dynamic Programming (LeetCode tag)
Curated practice problems for the dynamic-programming pattern.
Greedy (LeetCode tag)
Curated practice problems for the greedy pattern.
Bit Manipulation (LeetCode tag)
Curated practice problems for the bit-manipulation pattern.
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.
VisuAlgo — algorithm visualizations
Interactive visualizations of data structures and 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 — Pattern Catalog
Index of all 23 GoF patterns grouped by intent.
Parking Lot — awesome-low-level-design
Worked Java reference solution for the parking-lot problem.
Elevator System — awesome-low-level-design
Worked Java reference solution for the elevator-system problem.
Library Management — awesome-low-level-design
Worked Java reference solution for the library-management problem.
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.
ATM — awesome-low-level-design
Worked Java reference solution for the ATM problem.
Movie Booking — awesome-low-level-design
Worked Java reference solution for the movie-ticket-booking-system problem.
Ride Sharing — awesome-low-level-design
Worked Java reference solution for the ride-sharing-service problem.
Token bucket (rate-limiting algorithm)
The token-bucket algorithm that underpins most rate-limiter implementations.
LRU Cache (LeetCode)
The canonical O(1) cache-design problem.
LFU Cache (LeetCode)
The canonical O(1) cache-design problem.
Publish–subscribe pattern
The pub/sub model behind multi-channel notification fan-out.
Design In-Memory File System (LeetCode)
In-memory file-system design problem.
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.
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.
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.
Confluent — Exactly-Once Semantics
Explains how Kafka achieves exactly-once delivery via idempotent producers and transactions.
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.
Cloudflare — Counting Things
Cloudflare engineering post on counting at scale, underpinning distributed rate limiting.
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.
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.
X (Twitter) Engineering Blog
X engineering blog with posts on timeline, feed, and large-scale infrastructure.
Uber Engineering Blog
Uber engineering blog with posts on dispatch, geospatial, and large-scale systems.
Netflix Tech Blog
Netflix engineering blog covering streaming, encoding, and large-scale distributed systems.
Airbnb — Airflow
Airbnb’s introduction to Airflow as a platform for authoring and scheduling workflows.
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.
Hello Interview
Interview-prep platform with structured system-design walkthroughs and practice.
Book
24 of 88
Book
24 of 88Effective Java — Item 10 & 11 (Bloch)
The canonical treatment of overriding equals/hashCode correctly.
Java Concurrency in Practice — Chapter 5 (Goetz)
Building blocks: concurrent collections.
Clean Architecture (Robert C. Martin)
Book-length treatment of SOLID and the architectural principles built on it.
Head First Design Patterns (Freeman & Robson)
The friendliest path into GoF — see chapters on Factory and Singleton.
Design Patterns: Elements of Reusable OO Software (GoF)
The original; dense but canonical reference.
Effective Java, 3rd Edition (Bloch) — Concurrency chapter
Items 78–84: synchronization, executors, lazy initialization, and the JMM.
PostgreSQL: Up and Running (3rd ed.), Obe & Hsu
Practical PostgreSQL from the ground up; chapters on SQL basics.
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.
PostgreSQL 14 Internals, Egor Rogov
Free, deeply authoritative coverage of access methods and index internals.
Designing Data-Intensive Applications, Kleppmann
Chapter 7 on transactions and isolation anomalies across systems.
Spring in Action (6th ed.), Craig Walls
Approachable, example-driven coverage of the core container.
Spring Security in Action (2nd ed.), Laurentiu Spilca
The definitive practical book on Spring Security.
Pro Spring 6
In-depth treatment of Spring internals including the AOP machinery.
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.
Algorithms (4th ed.) — Sedgewick & Wayne
Java-based algorithms text with runnable implementations.
The Algorithm Design Manual (3rd ed.) — Steven Skiena
Practical war stories plus a catalog of algorithmic problems.
Competitive Programmer's Handbook — Antti Laaksonen
Free PDF covering the full competitive-programming toolkit.
Cracking the Coding Interview (6th ed.) — Gayle Laakmann McDowell
The classic interview-prep problem book.
System Design Interview Vol. 1 — Alex Xu
Chapters on rate limiting, URL shortener, and more.
Building Microservices (2nd ed.) — Sam Newman
Practical guide to designing, building, and operating microservices.
Site Reliability Engineering (Google)
Free online; SLI/SLO/SLA and operational practice.
System Design Interview Vol. 2 — Alex Xu & Sahn Lam
Second volume: Twitter, notifications, payments, and more.