Reading list

Hand-picked books, articles and videos on networking, operating systems, databases, distributed systems and system design.

• The C# type system (Microsoft Learn): Value types, reference types and how the C# type system fits together.
• Structs (C# language specification) (Microsoft Learn): The formal rules for struct semantics, copying and default values.
• Records (C# reference) (Microsoft Learn): Record classes and record structs: value equality, with-expressions, immutability. Link not verified by the study guide; if it doesn't open, search for its title.
• Boxing and unboxing (Microsoft Learn): What boxing allocates and how to avoid it.
• Type conversions, casting and boxing (Microsoft Learn): Implicit and explicit conversions, casts and boxing.
• Nullable reference types (Microsoft Learn): How nullable annotations and warnings work, and their limits. Link not verified by the study guide; if it doesn't open, search for its title.
• Nullable value types (Microsoft Learn): Nullable<T>, lifted operators and HasValue.
• Introduction to LINQ queries (Microsoft Learn): Query anatomy and deferred execution.
• LINQ overview (Microsoft Learn): Language-Integrated Query across objects, databases and XML.
• IQueryable interface (Microsoft Learn): API reference: expression trees and query providers. Link not verified by the study guide; if it doesn't open, search for its title.
• Delegates overview (Microsoft Learn): Delegates, Func and Action, multicast invocation. Link not verified by the study guide; if it doesn't open, search for its title.
• Events overview (Microsoft Learn): Declaring, raising and subscribing to events. Link not verified by the study guide; if it doesn't open, search for its title.
• Covariance and contravariance (C#) (Microsoft Learn): in/out variance on interfaces and delegates, and array covariance.
• Covariance and contravariance in generics (Microsoft Learn): Variant generic interfaces and delegates in .NET.
• String operations: matching, performance and span-based search (Microsoft Learn): Immutability, comparisons and allocation-free string handling.
• How to define value equality for a type (Microsoft Learn): Implementing Equals, GetHashCode, == and IEquatable<T> correctly.
• Equality comparisons (Microsoft Learn): Reference equality versus value equality in C#.
• Pattern matching overview (Microsoft Learn): is, switch expressions and property patterns — a frequent follow-up question.
• Async/Await FAQ (.NET Blog): What the compiler and runtime actually do for async methods.
• Consuming the task-based asynchronous pattern (Microsoft Learn): Awaiting tasks, continuations, combinators and exceptions.
• ConfigureAwait FAQ (.NET Blog): Stephen Toub on synchronization contexts and when ConfigureAwait(false) matters.
• Understanding the whys, whats and whens of ValueTask (.NET Blog): When ValueTask saves allocations and the rules for consuming it.
• Async ValueTask pooling in .NET 5 (.NET Blog): How the runtime pools async state machines behind ValueTask.
• Don't block on async code (Stephen Cleary): The classic explanation of the .Result / .Wait() deadlock.
• ThreadPool class (Microsoft Learn): API reference for the managed thread pool.
• Runtime configuration options for threading (Microsoft Learn): Thread-pool settings such as minimum threads.
• Cancellation in managed threads (Microsoft Learn): The cooperative cancellation model with CancellationToken.
• Cancellation, part 1: overview (Stephen Cleary): A practical series on cooperative cancellation.
• Using threads and threading (Microsoft Learn): Creating threads and synchronizing access to shared data.
• Managed threading basics (Microsoft Learn): Threads, synchronization primitives and their trade-offs.
• Channels (Microsoft Learn): Bounded and unbounded async producer-consumer queues.
• An introduction to System.Threading.Channels (.NET Blog): Design and usage of channels, with backpressure.
• Parallel.ForEachAsync method (Microsoft Learn): Bounded-concurrency async loops with MaxDegreeOfParallelism.
• BackgroundService gotcha: silent failures (Stephen Cleary): Why exceptions in ExecuteAsync used to vanish, and how to handle them.
• Fundamentals of garbage collection (Microsoft Learn): Generations, the large object heap, compaction and background GC.
• .NET garbage collection (Microsoft Learn): Overview of automatic memory management in .NET.
• Memory management and patterns in ASP.NET Core (Microsoft Learn): Allocation patterns, the LOH, pooling and HttpClient in web apps.
• Workstation vs. server garbage collection (Microsoft Learn): How the two GC flavours trade footprint for throughput.
• Runtime configuration options for garbage collection (Microsoft Learn): GC settings, including behaviour under container limits.
• Implement a Dispose method (Microsoft Learn): The dispose pattern, finalizers and SafeHandle.
• Memory<T> and Span<T> usage guidelines (Microsoft Learn): Ownership and lifetime rules for spans and memory.
• Span<T> struct (Microsoft Learn): API reference for Span<T>.
• A complete .NET developer's guide to Span with Stephen Toub (Stephen Toub): Deep-dive video on Span<T> internals and usage.
• Native AOT diagnostics (Microsoft Learn): What changes when there is no JIT at runtime.
• What's new in the .NET 9 runtime (Microsoft Learn): JIT, tiering and code-generation improvements in .NET 9.
• BenchmarkDotNet overview (BenchmarkDotNet): The standard .NET micro-benchmarking library. Link not verified by the study guide; if it doesn't open, search for its title.
• .NET diagnostics tools (Microsoft Learn): Overview of counters, tracing and dump tools. Link not verified by the study guide; if it doesn't open, search for its title.
• dotnet-counters (Microsoft Learn): Live GC, thread-pool and request counters. Link not verified by the study guide; if it doesn't open, search for its title.
• Best practices for exceptions (Microsoft Learn): When to throw, what to catch and how to rethrow. Link not verified by the study guide; if it doesn't open, search for its title.
• ASP.NET Core middleware (Microsoft Learn): The request pipeline and middleware ordering.
• Write custom ASP.NET Core middleware (Microsoft Learn): Building your own middleware components.
• Dependency injection in ASP.NET Core (Microsoft Learn): Service lifetimes, scope validation and captive dependencies.
• Minimal APIs overview (Microsoft Learn): Endpoint-based APIs with minimal ceremony.
• ASP.NET Core fundamentals (Microsoft Learn): Hosting, configuration, routing and the overall app model.
• Options pattern in ASP.NET Core (Microsoft Learn): IOptions, IOptionsSnapshot, IOptionsMonitor and validation. Link not verified by the study guide; if it doesn't open, search for its title.
• Handle errors in ASP.NET Core (Microsoft Learn): Exception handling middleware and IExceptionHandler.
• Handle errors in ASP.NET Core APIs (Microsoft Learn): ProblemDetails responses for web APIs.
• Overview of ASP.NET Core authentication (Microsoft Learn): Schemes, handlers and JWT bearer authentication.
• Authentication and authorization in minimal APIs (Microsoft Learn): Securing endpoints with policies, roles and claims.
• IHttpClientFactory with .NET (Microsoft Learn): Typed and named clients, and avoiding socket exhaustion. Link not verified by the study guide; if it doesn't open, search for its title.
• Build resilient HTTP apps (Microsoft Learn): The standard resilience handler: retries, breaker, timeouts.
• Rate limiting middleware in ASP.NET Core (Microsoft Learn): Fixed window, sliding window, token bucket and concurrency limiters.
• Rate limiting samples (Microsoft Learn): Worked examples, including partitioned limiters.
• Change tracking in EF Core (Microsoft Learn): How the context tracks and diffs entities. Link not verified by the study guide; if it doesn't open, search for its title.
• Loading related data (Microsoft Learn): Eager, explicit and lazy loading, and split queries. Link not verified by the study guide; if it doesn't open, search for its title.
• Advanced performance topics (EF Core) (Microsoft Learn): Compiled queries, pooling and other EF Core performance techniques.
• Handling concurrency conflicts (Microsoft Learn): Optimistic concurrency with tokens and row versions.
• Saving data (EF Core) (Microsoft Learn): SaveChanges, transactions and execution strategies.
• Entity Framework Core overview (Microsoft Learn): Getting started with EF Core.
• Common web application architectures (Microsoft Learn): Layered and clean architecture for ASP.NET Core apps.
• NetArchTest (Ben Morris): A library for enforcing architecture rules in unit tests. Link not verified by the study guide; if it doesn't open, search for its title.
• .NET microservices: architecture for containerized .NET applications (Microsoft Learn): Microsoft's guide to designing and running microservices.
• Distributed data (Microsoft Learn): Data consistency challenges across services.
• Apply simplified CQRS and DDD patterns in a microservice (Microsoft Learn): Separating read and write models without full event sourcing.
• Pattern: Transactional outbox (microservices.io): Publishing events reliably without dual writes.
• Pattern: Transaction log tailing (microservices.io): Relaying outbox messages with change data capture.
• Pattern: Saga (microservices.io): Maintaining consistency across services with compensations.
• Temporal .NET developer guide (Temporal): Durable workflows, activities and determinism rules in .NET. Link not verified by the study guide; if it doesn't open, search for its title.
• Retry storm antipattern (Microsoft Learn): How naive retries amplify outages, and how to avoid it.
• Recommendations for handling transient faults (Microsoft Learn): Backoff, jitter, idempotency and retry budgets.
• Application resiliency patterns (Microsoft Learn): Retry, circuit breaker and other cloud-native resilience patterns.
• Introduction to resilient app development (Microsoft Learn): Microsoft.Extensions.Resilience and composing pipelines.
• Testing ASP.NET Core services and web apps (Microsoft Learn): Unit, integration and functional tests for services.
• Integration tests in ASP.NET Core (Microsoft Learn): WebApplicationFactory and in-memory test servers.
• Testcontainers for .NET (Testcontainers): Throwaway Docker dependencies for integration tests.
• OpenTelemetry .NET (OpenTelemetry): Logs, metrics and traces with one instrumentation API. Link not verified by the study guide; if it doesn't open, search for its title.
• Confluent .NET client documentation (Confluent): Producing and consuming Kafka messages from .NET. Link not verified by the study guide; if it doesn't open, search for its title.
• Stephen Cleary's blog (Stephen Cleary): Async and concurrency done right.
• Andrew Lock's blog (Andrew Lock): ASP.NET Core internals, explained in depth.
• .NET Blog (.NET Blog): Performance write-ups for every .NET release.
• The System Design Primer (Donne Martin): A free, community-maintained guide to designing large-scale systems.
• Load balancing (computing) (Wikipedia): How load balancers spread requests across servers and route around failed ones.
• Cache-Aside pattern (Microsoft Learn): Load data into a cache on demand to speed up repeated reads.
• Queue-Based Load Leveling pattern (Microsoft Learn): A queue between producers and workers absorbs spikes in load.
• Competing Consumers pattern (Microsoft Learn): Several workers read from one queue to share the work and survive failures.
• Static Content Hosting pattern (Microsoft Learn): Serve files from storage and a CDN instead of from the application servers.
• Valet Key pattern (Microsoft Learn): Let clients upload straight to storage with a short-lived, limited token.
• Rate Limiting pattern (Microsoft Learn): Throttle requests so one caller can't overload a service.
• Content delivery network (Wikipedia): Servers close to users that cache and deliver static content.
• Replication (computing) (Wikipedia): Keeping copies of data on several machines for reads and failover.
• WebSocket (Wikipedia): A long-lived, two-way connection between browser and server.
• Geohash (Wikipedia): Encoding locations so nearby points share a prefix, for fast proximity search.
• Search engine indexing (Wikipedia): How inverted indexes make full-text search fast.
• Idempotence (Wikipedia): Operations that can be repeated without changing the result beyond the first time.
• Big-O Cheat Sheet (Eric Rowell): Time and space complexity of common data structures and sorting algorithms.
• javascript.info: Recursion and stack (javascript.info): How recursive calls use the call stack, with memory costs.
• Array.prototype.sort() (MDN Web Docs): How sort compares elements; engines use O(n log n) algorithms such as TimSort.
• Set (MDN Web Docs): Set lookups are sublinear on average, unlike Array.prototype.includes.
• Map (MDN Web Docs): Keyed collection with fast average-case get and set.
• Running time of binary search (Khan Academy): Why halving the range gives logarithmic time.
• Analysis of merge sort (Khan Academy): Where the n log n comes from, level by level.
• Value types (C# reference) (Microsoft Learn): How structs and other value types are copied and stored.
• Built-in reference types (C# reference) (Microsoft Learn): The object, string, delegate and dynamic types, including string immutability.
• Pattern matching overview (Microsoft Learn): Type, null, property and list patterns plus switch expressions.
• Asynchronous programming with async and await (Microsoft Learn): The task-based asynchronous programming model in C#.
• Efficient querying (EF Core) (Microsoft Learn): Tracking vs no-tracking, loading related data, N+1 and split queries.
• Collections and data structures (Microsoft Learn): Choosing collection types, capacity growth and thread-safe collections.
• Memory- and span-related types (Microsoft Learn): Span<T>, Memory<T> and slicing memory without copying.
• Native AOT deployment overview (Microsoft Learn): Publishing apps compiled ahead of time to native code and its limitations.
• Unit testing C# with xUnit (Microsoft Learn): Writing Fact and Theory tests with xUnit and the dotnet CLI.
• C# language reference (Microsoft Learn): Types, keywords, operators, patterns and statements of the C# language.
• Configuration in ASP.NET Core (Microsoft Learn): Configuration providers, their precedence and key naming rules.
• Filters in ASP.NET Core (Microsoft): The MVC filter types and the order in which they run around an action.
• ASP.NET Core Razor component lifecycle (Microsoft): The lifecycle methods of Razor components and when each is called.
• .NET Generic Host (Microsoft): How the generic host starts and stops hosted services and raises lifetime events.
• Dependency injection in .NET (Microsoft): Service lifetimes, scopes and how the container creates and disposes services.
• Options pattern in .NET (Microsoft): Binding, configuring, post-configuring and validating options classes.
• Exception-handling statements (C# reference) (Microsoft): throw, try-catch, try-finally and exception filters in C#.
• Managed execution process (Microsoft): How C# source becomes IL and then native code through the JIT compiler.
• C# operators and expressions (Microsoft): The C# operators with their precedence and associativity table.
• C# language specification: Classes (Microsoft): Normative rules for constructors, field initialization, static constructors, accessibility and iterators.
• Make HTTP requests using IHttpClientFactory in ASP.NET Core (Microsoft): Typed clients and outgoing request middleware built from DelegatingHandler.
• Pattern matching - the is and switch expressions (Microsoft Learn): Type, relational, property, list, logical and positional patterns in C#.
• Arithmetic operators (C# reference) (Microsoft Learn): Integer division, remainder, floating-point behaviour and arithmetic overflow in checked and unchecked contexts.
• Math.Round method (Microsoft Learn): API reference for Math.Round, including the default to-even midpoint rounding and MidpointRounding options.
• yield statement (C# reference) (Microsoft Learn): How iterator methods produce values lazily with yield return and yield break.
• Lambda expressions and anonymous functions (C# reference) (Microsoft Learn): Lambda syntax and how lambdas capture outer variables.
• Knowing when to use override and new keywords (Microsoft Learn): Virtual dispatch with override compared with member hiding with new.
• Method parameters (C# reference) (Microsoft Learn): Passing by value and by reference with ref, out, in and params.
• Static constructors (C# programming guide) (Microsoft Learn): When static constructors run and how static members are initialized.
• The Go Programming Language Specification (The Go Authors): The authoritative definition of Go's syntax and semantics.
• Effective Go (The Go Authors): Official guide to writing clear, idiomatic Go code.
• Go Slices: usage and internals (The Go Authors): Explains how slices relate to arrays, length, capacity and append.
• Working with Errors in Go 1.13 (The Go Authors): Introduces error wrapping with %w, errors.Is and errors.As.
• Package errors (The Go Authors): Reference documentation for the standard errors package.
• Defer, Panic, and Recover (The Go Authors): Describes how defer, panic and recover behave.
• Fixing For Loops in Go 1.22 (The Go Authors): Explains the per-iteration loop variable change in Go 1.22.
• Data Race Detector (The Go Authors): How to use the Go race detector and what it can find.
• A Guide to the Go Garbage Collector (The Go Authors): Explains how the Go GC works and how escape analysis affects allocation.
• Package sync (The Go Authors): Reference documentation for Mutex, RWMutex, WaitGroup, Once and more.
• Package context (The Go Authors): Reference documentation for cancellation, deadlines and request-scoped values.
• Package net/http (The Go Authors): Reference documentation for Go's HTTP client and server.
• Package encoding/json (The Go Authors): Reference documentation for JSON encoding and decoding.
• Package testing (The Go Authors): Reference documentation for tests, benchmarks and subtests.
• Go Modules Reference (The Go Authors): Detailed reference for Go modules, versions and module paths.
• Command gofmt (The Go Authors): Reference for the standard Go source formatter.
• Package sync/atomic (The Go Authors): Reference for atomic operations and typed atomic values.
• Package time (The Go Authors): Reference for durations, timers, tickers and time parsing.
• Package io (The Go Authors): Reference for the Reader and Writer interfaces and helpers.
• Command go (The Go Authors): Reference for go build, go test flags, go vet and go mod.
• Package runtime (The Go Authors): Reference for runtime functions such as Goexit, GC and GOMAXPROCS.
• Go runtime source (src/runtime) (The Go Authors): Source of the Go runtime, including the scheduler, allocator and garbage collector.
• Introduction to the Go compiler (The Go Authors): Overview of the gc compiler's phases from parsing to machine code.
• Release History (The Go Authors): List of Go releases with dates and links to their release notes.
• Go 1.22 Release Notes (The Go Authors): Release notes describing per-iteration loop variables and range over integers.
• Strings, bytes, runes and characters in Go (The Go Authors): Explains how Go strings hold bytes and how range decodes UTF-8 runes.
• Tutorial: Getting started with generics (The Go Authors): Official tutorial on type parameters, constraints and type inference.
• Go FAQ (The Go Authors): Official answers to common questions, including why a nil error can be non-nil.
• Package slices (The Go Authors): Reference documentation for the generic slices package.
• Package fmt (The Go Authors): Reference documentation for formatted I/O and the printing verbs.
• Go maps in action (The Go Authors): Covers map creation, zero values, deletion and iteration order.
• Transaction Isolation (PostgreSQL Global Development Group): How PostgreSQL implements Read Committed, Repeatable Read and Serializable, and which anomalies each prevents.
• Concurrency Control: Introduction (PostgreSQL Global Development Group): Overview of multiversion concurrency control and why readers and writers do not block each other.
• Explicit Locking (PostgreSQL Global Development Group): Table-level and row-level lock modes, conflicts between them, and deadlock handling.
• Index Types (PostgreSQL Global Development Group): B-tree, hash, GiST, SP-GiST, GIN and BRIN indexes and the operators each supports.
• Use The Index, Luke! (Markus Winand): A free guide to how database indexes work and how to design them for real queries.
• How Connections Are Established (PostgreSQL Global Development Group): PostgreSQL's process-per-connection client/server model.
• Database normalization (Wikipedia): The normal forms from 1NF to BCNF and beyond, with worked examples.
• Write-Ahead Logging (WAL) (PostgreSQL Global Development Group): Why logging changes before writing data pages gives durability and crash recovery.
• High Availability, Load Balancing, and Replication (PostgreSQL Global Development Group): Streaming replication, synchronous vs asynchronous standbys and hot standby read queries.
• Continuous Archiving and Point-in-Time Recovery (PITR) (PostgreSQL Global Development Group): Base backups plus archived WAL for restoring a database to any moment in time.
• Routine Vacuuming (PostgreSQL Global Development Group): Why VACUUM and ANALYZE are needed: reclaiming dead rows, planner statistics, the visibility map and wraparound.
• Table Partitioning (PostgreSQL Global Development Group): Declarative partitioning, partition pruning and the limitations of partitioned tables.
• Consistency Models (Jepsen): A map of consistency models, from linearizability and serializability to session guarantees.
• CAP theorem (Wikipedia): The trade-off between consistency and availability during a network partition, and its PACELC extension.
• NoSQL (Wikipedia): Key-value, document, wide-column and graph databases and the trade-offs they make.
• Using EXPLAIN (PostgreSQL Global Development Group): Reading query plans, EXPLAIN ANALYZE output and the caveats of measuring execution.
• Statistics Used by the Planner (PostgreSQL Global Development Group): Per-column statistics gathered by ANALYZE and extended statistics created with CREATE STATISTICS.
• Reliability and the Write-Ahead Log (PostgreSQL Global Development Group): WAL, asynchronous commit, checkpoints and the settings that trade durability for speed.
• Backup and Restore (PostgreSQL Global Development Group): SQL dumps with pg_dump, file system backups, and continuous archiving with point-in-time recovery.
• Designing Data-Intensive Applications (Martin Kleppmann): Replication, partitioning, transactions, consistency and the trade-offs behind relational and NoSQL systems.
• PgBouncer Features (PgBouncer project): Session, transaction and statement pooling modes and which PostgreSQL features each mode supports.
• PostgreSQL: WAL Configuration (PostgreSQL Global Development Group): Checkpoints, the REDO point, full-page writes and how crash recovery replays WAL.
• PostgreSQL Documentation (current) (PostgreSQL Global Development Group): The full official manual: internals overview, triggers, constraints, pg_dump, logical replication, progress reporting and release notes.
• PostgreSQL: Database Physical Storage (PostgreSQL Global Development Group): Data directory layout, segment files, TOAST and the layout of pages and tuples.
• PostgreSQL: Frontend/Backend Protocol Message Flow (PostgreSQL Global Development Group): Message sequences for startup, simple queries and the extended query protocol.
• PostgreSQL: Server Configuration (PostgreSQL Global Development Group): Every server setting with its default: memory, WAL, planner costs, replication and vacuum.
• Use The Index, Luke: Anatomy of an SQL Index (Markus Winand): How a B-tree index is structured and the three steps of an index lookup.
• In Search of an Understandable Consensus Algorithm (Raft) (Diego Ongaro and John Ousterhout): The Raft paper: leader election, log replication and safety.
• SAVEPOINT (PostgreSQL Global Development Group): Defining savepoints inside a transaction and rolling back to them.
• System Columns (PostgreSQL Global Development Group): The hidden columns xmin, xmax, ctid and tableoid on every row.
• Constraints (PostgreSQL Global Development Group): CHECK, NOT NULL, UNIQUE, primary key, foreign key and exclusion constraints.
• Sequence Manipulation Functions (PostgreSQL Global Development Group): nextval, currval, setval and why sequence values are never rolled back.
• INSERT (PostgreSQL Global Development Group): INSERT syntax including RETURNING and ON CONFLICT (upsert).
• Overview of Trigger Behavior (PostgreSQL Global Development Group): Row versus statement triggers, BEFORE and AFTER, and what return values mean.
• CREATE VIEW (PostgreSQL Global Development Group): View definitions, automatically updatable views and WITH CHECK OPTION.
• Materialized Views (PostgreSQL Global Development Group): Views that store their result until refreshed.
• PL/pgSQL Control Structures (PostgreSQL Global Development Group): Includes trapping errors with EXCEPTION blocks and GET DIAGNOSTICS.
• Data Types (PostgreSQL Global Development Group): Numeric, character, date/time, JSON, array and range types.
• CREATE TABLE (PostgreSQL Global Development Group): Table options such as temporary tables, ON COMMIT and generated columns.
• SELECT (PostgreSQL Global Development Group): Reference for SELECT: joins, GROUP BY, HAVING, DISTINCT ON, UNION/INTERSECT/EXCEPT, ORDER BY and LIMIT.
• Comparison functions and operators (PostgreSQL Global Development Group): How =, IS NULL and IS DISTINCT FROM behave when NULLs are involved.
• Logical operators (PostgreSQL Global Development Group): Truth tables for AND, OR and NOT under three-valued logic.
• Aggregate functions (PostgreSQL Global Development Group): Built-in aggregates such as count, sum and avg, and how they treat NULLs and empty input.
• Window functions (PostgreSQL Global Development Group): ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD, LAST_VALUE and their frame behaviour.
• Window function calls (PostgreSQL Global Development Group): Syntax of OVER, PARTITION BY and frame clauses, including the default frame.
• WITH queries (common table expressions) (PostgreSQL Global Development Group): Non-recursive and recursive CTEs, data-modifying statements in WITH, and CTE materialization.
• Subquery expressions (PostgreSQL Global Development Group): EXISTS, IN, NOT IN, ANY and ALL, including their NULL behaviour.
• Conditional expressions (PostgreSQL Global Development Group): CASE, COALESCE, NULLIF, GREATEST and LEAST.
• Mathematical functions and operators (PostgreSQL Global Development Group): Arithmetic operators, including integer division that truncates toward zero.
• Pattern matching (PostgreSQL Global Development Group): LIKE, ILIKE, SIMILAR TO and regular expressions.
• TRUNCATE (PostgreSQL Global Development Group): How TRUNCATE empties tables, its transaction safety and its interaction with triggers.
• SQL Injection Prevention Cheat Sheet (OWASP Foundation): Parameterized queries as the primary defence against SQL injection, and how to handle identifiers safely.
• String functions and operators (PostgreSQL Global Development Group): Concatenation, length, substring, format and quote_ident.
• Date/time functions and operators (PostgreSQL Global Development Group): Date arithmetic, date_trunc, extract and the current-time functions.
• Sorting rows (ORDER BY) (PostgreSQL Global Development Group): How ORDER BY sorts rows, including DESC, NULLS FIRST/LAST and sorting by output columns.
• Combining queries (UNION, INTERSECT, EXCEPT) (PostgreSQL Global Development Group): Set operations, their precedence and how to parenthesize them.
• Table expressions (PostgreSQL Global Development Group): FROM, WHERE, GROUP BY, HAVING, GROUPING SETS/ROLLUP and window function processing.
• Window functions tutorial (PostgreSQL Global Development Group): Tutorial on OVER, PARTITION BY, ORDER BY inside OVER and the default window frame.
• Lexical structure: operator precedence (PostgreSQL Global Development Group): Precedence and associativity of SQL operators in PostgreSQL.
• CREATE INDEX (PostgreSQL Global Development Group): Reference for CREATE INDEX, including CONCURRENTLY, INCLUDE and partial indexes.
• Numeric types (PostgreSQL Global Development Group): Integer, numeric and floating-point types, including how NaN and Infinity sort.
• CREATE POLICY (PostgreSQL Global Development Group): Reference for row-level security policies.
• Value expressions (PostgreSQL documentation): Aggregate and window call syntax, including FILTER, ORDER BY in aggregates and window frames.
• Set returning functions (PostgreSQL documentation): generate_series and generate_subscripts.
• Returning data from modified rows (PostgreSQL documentation): RETURNING on INSERT, UPDATE and DELETE.
• JSON functions and operators (PostgreSQL documentation): ->, ->>, @> and jsonb aggregation.
• JavaScript data types and data structures (MDN Web Docs): Overview of JavaScript primitives, objects, strings as UTF-16 sequences, Number and BigInt.
• Equality comparisons and sameness (MDN Web Docs): Explains ==, ===, Object.is and SameValueZero, including NaN and signed zero.
• Hoisting (MDN Web Docs): Glossary entry on how function, var, let, const and class declarations are hoisted.
• Closures (MDN Web Docs): How functions capture their lexical environment, including the classic closures-in-loops mistake.
• this (MDN Web Docs): Reference for how the value of this is determined in functions, methods, arrow functions and classes.
• Classes (MDN Web Docs): Reference for class syntax, static members, private elements and class strict mode.
• Object references and copying (javascript.info): Covers reference semantics, const objects, shallow copies and deep cloning with structuredClone.
• Array (MDN Web Docs): Reference for Array methods, sparse arrays and copying versus mutating methods.
• Event loop: microtasks and macrotasks (javascript.info): Explains the event loop, the macrotask queue and why microtasks run before the next task.
• Promise (MDN Web Docs): Reference for promises and the concurrency methods all, allSettled, any and race.
• JavaScript modules (MDN Web Docs): Guide to ES module import/export semantics, including top-level await.
• Memory management (MDN Web Docs): Explains reachability, mark-and-sweep garbage collection, and WeakMap/WeakSet.
• JSON.stringify() (MDN Web Docs): Reference for how values such as undefined, functions, Map and BigInt are serialized.
• Iterators and generators (MDN Web Docs): Guide to the iteration protocols, iterables and generator functions.
• process: 'unhandledRejection' event (Node.js): Node.js documentation for unhandled promise rejections and the default throw behaviour.
• Control flow and error handling (MDN Web Docs): Guide covering falsy values in conditions, throw, try...catch...finally and error objects.
• Expressions and operators (MDN Web Docs): Guide to operators including logical assignment, nullish coalescing, optional chaining and destructuring.
• Variable scope, closure (javascript.info): Lexical environments, block scope, closures and the temporal dead zone.
• Strict mode (MDN Web Docs): What "use strict" changes, including errors that sloppy mode silently ignores.
• Microtasks (Ilya Kantor): Explains the microtask queue, promise handlers and why they run before the next macrotask.
• The Node.js Event Loop (Node.js): Official guide to the event loop phases, setImmediate, setTimeout and process.nextTick.
• Node.js Events API (Node.js): Reference for EventEmitter, EventTarget and how listeners are registered and invoked.
• Node.js Process API (Node.js): Reference for the process object, including the beforeExit and exit events and nextTick.
• Node.js Modules: CommonJS modules (Node.js): Reference for require(), module resolution, caching and the module wrapper.
• Public class fields (MDN Web Docs): How instance and static fields are initialized, including their timing relative to super().
• Proxy (MDN Web Docs): Reference for Proxy objects and the handler traps that intercept object operations.
• Operator precedence (MDN Web Docs): Precedence table for JavaScript operators and the distinction from evaluation order.
• Array methods (Ilya Kantor): Covers map, filter, sort and comparator functions, including default string-based sorting.
• Generators (Ilya Kantor): How generator functions pause at yield, receive values via next() and delegate with yield*.
• How browsers work (MDN Web Docs): Walks through parsing, style, layout, paint and compositing in the browser rendering pipeline.
• Bubbling and capturing (Ilya Kantor): Explains the capturing, target and bubbling phases of DOM event propagation.
• TC39 Finished Proposals (Ecma TC39): List of finished proposals with the ECMAScript edition each one was published in.
• for...in (MDN Web Docs): Reference for for...in, including property traversal order and inherited properties.
• String (MDN Web Docs): Reference for string methods such as slice, substring, split and replaceAll.
• Number (MDN Web Docs): Floating point numbers, safe integers, parsing and formatting.
• Destructuring assignment (MDN Web Docs): Unpacking arrays and objects, with defaults and rest elements.
• Iteration protocols (MDN Web Docs): The iterable and iterator protocols used by for...of, spread and generators.
• Object (MDN Web Docs): Reference for Object.assign, Object.keys, freeze and property ordering.
• Template literals (MDN Web Docs): Template literal interpolation and tagged templates.
• Cache stampede (Wikipedia): Why many simultaneous cache misses on a hot key can overload a backend, and the locking and early-expiration techniques that prevent it.
• Consistency model (Wikipedia): An overview of consistency models such as linearizability, eventual consistency and client-centric guarantees like read-your-writes.
• PACELC theorem (Wikipedia): An extension of CAP that adds the latency-versus-consistency trade-off replicated systems face when there is no partition.
• Consistent hashing (Wikipedia): A hashing scheme that remaps only a small fraction of keys when nodes join or leave a cluster.
• Apache Kafka documentation (Apache Software Foundation): Official Kafka documentation covering topics, partitions, consumer groups and delivery semantics.
• Using dead-letter queues in Amazon SQS (Amazon Web Services): How a queue moves messages that repeatedly fail processing to a separate dead-letter queue.
• Token bucket (Wikipedia): The token bucket algorithm for rate limiting and traffic shaping, and how it compares with the leaky bucket.
• Timeouts, retries, and backoff with jitter (Marc Brooker (Amazon Builders' Library)): How Amazon uses timeouts, bounded retries, exponential backoff and jitter to keep failures from cascading.
• Release It! Design and Deploy Production-Ready Software (2nd ed.) (Michael T. Nygard): The book that popularized stability patterns such as timeouts, circuit breakers and bulkheads.
• Service Level Objectives (Google SRE Book): Defines SLIs, SLOs and SLAs and explains why percentiles describe latency better than averages.
• RFC 9110: HTTP Semantics (IETF): The HTTP specification that defines request methods and which of them are safe or idempotent.
• RFC 9562: Universally Unique IDentifiers (UUIDs) (IETF): The UUID specification, including random UUIDv4, time-ordered UUIDv7 and the time-based ID schemes like Snowflake that motivated it.
• Monitoring Distributed Systems (Google SRE Book): Introduces the four golden signals, black-box versus white-box monitoring and paging on symptoms.
• RFC 9111: HTTP Caching (IETF): The HTTP caching specification, including the Cache-Control directives used by browsers and CDNs.
• How to do distributed locking (Martin Kleppmann): Why lease-based distributed locks can let two clients act at once and how fencing tokens prevent it.
• CircuitBreaker (Martin Fowler): Explains the circuit breaker pattern, its closed, open and half-open states and why it protects callers.
• Microservices (James Lewis and Martin Fowler): The classic description of microservice characteristics, including independent deployment and decentralized data.
• RFC 9293: Transmission Control Protocol (TCP) (IETF): The current TCP specification, including the connection state machine, handshake and close.
• RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3 (IETF): The TLS 1.3 specification: handshake messages, key schedule and version history.
• RFC 6749: The OAuth 2.0 Authorization Framework (IETF): Defines OAuth 2.0 roles, the authorization code grant and refresh tokens.
• RFC 7636: Proof Key for Code Exchange (PKCE) (IETF): Extends the authorization code grant with a code verifier and code challenge.
• Embracing Risk (Site Reliability Engineering, ch. 3) (Google SRE): Availability targets, downtime budgets and error budgets.
• HTTP | MDN (MDN Web Docs): Reference for HTTP messages, caching, CORS, protocol upgrades and HTTP versions.
• BlueGreenDeployment (Martin Fowler): Two production environments and a router switch for releases and rollback.
• The Raft Consensus Algorithm (Diego Ongaro and John Ousterhout): Raft paper, visualization and explanation of leader election and log replication.
• Two-phase commit protocol (Wikipedia): The prepare (voting) and commit phases of atomic commit, and its blocking failure mode.
• Leaky bucket (Wikipedia): The leaky bucket algorithm as a meter and as a queue that smooths output to a constant rate.
• Cache replacement policies (Wikipedia): Overview of eviction policies such as LRU, LFU and FIFO.
• Bloom filter (Wikipedia): Probabilistic set membership with false positives, no false negatives, and no deletion.
• Vector clock (Wikipedia): Detecting causality and concurrency between events in a distributed system.
• Lamport timestamp (Wikipedia): Logical clocks that order events consistently with message passing.
• Quorum (distributed computing) (Wikipedia): Read and write quorums and why overlapping quorums give consistency.
• Snowflake ID (Wikipedia): The 64-bit layout of timestamp, machine id and sequence used for sortable unique IDs.
• Making retries safe with idempotent APIs (Malcolm Featonby (Amazon Builders' Library)): Using client request tokens so that retried mutations take effect only once.
• Availability Table (Google SRE Book): How much downtime each availability level allows per year, quarter, month and day.
• Design patterns catalog (Refactoring.Guru): Illustrated catalog of the 22 classic GoF patterns with intent, structure and comparisons to related patterns.
• The Single Responsibility Principle (Robert C. Martin): Uncle Bob explains that SRP is about reasons to change and the people who request those changes.
• SOLID (Wikipedia): Overview of the five SOLID object-oriented design principles and their origins.
• The Clean Architecture (Robert C. Martin): Introduces the concentric-circle architecture and its Dependency Rule, building on Hexagonal and Onion architectures.
• Inversion of Control Containers and the Dependency Injection pattern (Martin Fowler): The article that named Dependency Injection and compares it with Service Locator.
• Anemic Domain Model (Martin Fowler): Why domain objects without behaviour are an anti-pattern.
• CQRS (Martin Fowler): Command Query Responsibility Segregation: separate models for updates and reads, and when to use them.
• Event Sourcing (Martin Fowler): Capturing every change to application state as a sequence of events.
• DDD Aggregate (Martin Fowler): Aggregates as clusters of domain objects treated as a unit, accessed through a root.
• Domain Driven Design (Martin Fowler): Short overview of Eric Evans' Domain-Driven Design, its strategic and tactical patterns.
• Saga distributed transactions pattern (Microsoft Learn): Coordinating local transactions with compensating actions, via choreography or orchestration.
• Repository (Martin Fowler): Catalog entry from Patterns of Enterprise Application Architecture for the Repository pattern.
• Yagni (Martin Fowler): Why you should not build capabilities for presumed future needs.
• The Pragmatic Programmer, 20th Anniversary Edition (David Thomas and Andrew Hunt): The book that coined DRY and discusses decoupling, the Law of Demeter and the costs of inheritance.
• Code Smells (Alexander Shvets): Catalog of code smells grouped into Bloaters, OO Abusers, Change Preventers, Dispensables and Couplers.
• Catalog of Patterns of Enterprise Application Architecture (Martin Fowler): Summaries of the PoEAA patterns such as Repository, Unit of Work, Active Record, Data Mapper and Identity Map.
• Effective Aggregate Design (Vaughn Vernon): Three-part essay giving rules of thumb for designing DDD aggregates.
• Cloud Design Patterns (Microsoft): Catalog of cloud and architecture patterns including Saga, Strangler Fig, Anti-Corruption Layer and CQRS.
• Design the infrastructure persistence layer (Microsoft): Explains the Repository and Unit of Work patterns in .NET and how EF Core's DbContext relates to them.
• Hexagonal Architecture (Alistair Cockburn): The original Ports and Adapters article: driving and driven sides around an application core.
• The Onion Architecture: part 1 (Jeffrey Palermo): Introduces the Onion Architecture and its layers from the domain model outward.
• Unit of Work (Martin Fowler): Catalog entry from Patterns of Enterprise Application Architecture on tracking and committing changes as one unit.
• CQRS pattern (Microsoft): Azure Architecture Center description of separate command and query models.
• Event Sourcing pattern (Microsoft): Storing state as an append-only sequence of events, with replay, snapshots and projections.
• Claim-Check pattern (Microsoft): Sending a reference to a large payload through the message bus instead of the payload itself.
• Strangler Fig Application (Martin Fowler): Gradually replacing a legacy system by routing pieces of it to a new one.
• Branch By Abstraction (Martin Fowler): Replacing a component in place behind an abstraction layer while trunk stays releasable.
• Test Driven Development (Martin Fowler): Short description of the red, green, refactor cycle.
• Singleton (Alexander Shvets (Refactoring.Guru)): Explains the Singleton pattern, its implementations and why it is often considered an anti-pattern.
• Decorator (Alexander Shvets (Refactoring.Guru)): Shows how decorators wrap objects to stack behaviour and why wrapping order matters.
• Observer (Alexander Shvets (Refactoring.Guru)): Describes subscribing, unsubscribing and notifying observers of a subject.
• Command (Alexander Shvets (Refactoring.Guru)): Turns requests into objects, enabling undo/redo histories and queued operations.
• Lazy<T> Class (Microsoft): Reference for Lazy<T>, including thread-safety modes and exception caching.
• Pattern: Command Query Responsibility Segregation (CQRS) (Chris Richardson): Describes maintaining query-side views updated from domain events in a microservice architecture.
• The Open Closed Principle (Robert C. Martin): Uncle Bob explains how modules can be open for extension yet closed for modification.
• Structure types (C# reference) (Microsoft Learn): Covers struct declarations, readonly structs, constructors and default values.
• Enumeration types (C# reference) (Microsoft Learn): Describes enum underlying types, conversions and flags enums.
• Tuple types (C# reference) (Microsoft Learn): Covers ValueTuple syntax, element names, equality and deconstruction.
• interface keyword (C# reference) (Microsoft Learn): Covers interface members, default implementations and static abstract members.
• Constraints on type parameters (Microsoft Learn): Lists every generic constraint, their order, and the allows ref struct anti-constraint.
• Generic math (Microsoft Learn): Explains INumber<T> and related interfaces, static abstract members and the CreateChecked/Saturating/Truncating conversions.
• Type-testing operators and cast expressions (Microsoft Learn): Covers the is, as, typeof and cast operators and which conversions each one considers.
• Operator overloading (C# reference) (Microsoft Learn): Lists overloadable operators and the operators that must be overloaded in pairs.
• User-defined explicit and implicit conversion operators (Microsoft Learn): Explains how to declare implicit and explicit conversion operators.
• Built-in numeric conversions (C# reference) (Microsoft Learn): Tables of implicit and explicit numeric conversions, including precision loss.
• String interpolation using $ (C# reference) (Microsoft Learn): Covers interpolation holes, alignment, format strings, constant interpolated strings and handlers.
• Member access operators and expressions (Microsoft Learn): Covers ., [], the null-conditional ?. and ?[] operators, the ^ index-from-end operator and the .. range operator.
• Standard query operators overview (Microsoft Learn): Overview of LINQ operators, their execution modes (immediate, deferred streaming, deferred non-streaming) and set operations.
• Query expression basics (Microsoft Learn): Explains query syntax clauses such as from, where, let, join, group and select, and how they map to method calls.
• Events (C# programming guide) (Microsoft Learn): Explains how events wrap delegates and what code outside the declaring class may do with them.
• Local functions (Microsoft Learn): Explains local functions and compares them with lambda expressions.
• Extension methods (Microsoft Learn): Explains how extension methods are declared, bound and called.
• Miscellaneous attributes interpreted by the C# compiler (Microsoft Learn): Explains Conditional, Obsolete, AttributeUsage, SetsRequiredMembers and other compiler-interpreted attributes.
• Properties (C# programming guide) (Microsoft Learn): Covers auto-properties, init accessors, required properties and expression-bodied properties.
• What's new in C# 11 (Microsoft Learn): Summarizes C# 11: raw string literals, UTF-8 literals, list patterns, required members, file-local types, generic attributes and more.
• What's new in C# 12 (Microsoft Learn): Summarizes C# 12: primary constructors, collection expressions, ref readonly parameters, default lambda parameters and alias any type.
• The history of C# (Microsoft Learn): Lists the features added in each C# version.
• The large object heap on Windows systems (Microsoft Learn): When objects go to the LOH, how it is collected and how to compact it on demand.
• Background garbage collection (Microsoft Learn): How background GC collects generation 2 while ephemeral collections continue.
• Garbage collection latency modes (Microsoft Learn): GCLatencyMode values, no-GC regions and when to use them.
• Weak references (Microsoft Learn): How weak references let the GC collect an object while code can still reach it.
• ConditionalWeakTable<TKey,TValue> class (Microsoft Learn): A table that attaches values to objects without keeping the keys alive.
• SafeHandle class (Microsoft Learn): The base class for wrappers around operating-system handles.
• GC class (Microsoft Learn): Collect, KeepAlive, AddMemoryPressure, AllocateArray and the other GC APIs.
• stackalloc expression (Microsoft Learn): Allocating a block of memory on the stack and the risks of large or looped allocations.
• ArrayPool<T> class (Microsoft Learn): A shared, thread-safe pool of reusable arrays.
• Unsafe code, pointer types and function pointers (Microsoft Learn): Pointers, the fixed statement and pinning in C#.
• Runtime configuration options for compilation (Microsoft Learn): Tiered compilation, quick JIT for loops, ReadyToRun and profile-guided optimization settings.
• ReadyToRun compilation (Microsoft Learn): Precompiling assemblies to native code to improve startup, and its trade-offs.
• Introduction to trim warnings (Microsoft Learn): Why the trimmer warns about reflection and how the trimming attributes fix it.
• About System.Runtime.Loader.AssemblyLoadContext (Microsoft Learn): How load contexts isolate assemblies and how type identity depends on them.
• How to use and debug assembly unloadability in .NET (Microsoft Learn): Loading plugins into a collectible AssemblyLoadContext and unloading them.
• Overview of synchronization primitives (Microsoft Learn): Monitor, Mutex, Semaphore, SemaphoreSlim, ReaderWriterLockSlim and other primitives.
• The lock statement (Microsoft Learn): How lock works with Monitor and System.Threading.Lock, and guidelines for choosing a lock object.
• .NET memory model (dotnet/runtime): The ordering, atomicity and volatile guarantees the .NET runtime gives.
• Interlocked class (Microsoft Learn): Atomic operations on variables shared by multiple threads.
• UnsafeAccessorAttribute class (Microsoft Learn): Accessing inaccessible members without reflection, compatible with Native AOT.
• .NET regular expression source generators (Microsoft Learn): How [GeneratedRegex] emits matching code at compile time.
• String.Intern method (Microsoft Learn): How the intern pool works and its memory implications.
• BenchmarkDotNet diagnosers (BenchmarkDotNet): What the MemoryDiagnoser columns such as Gen0 and Allocated report.
• Asynchronous programming scenarios (Microsoft Learn): When to use async/await for I/O-bound and CPU-bound work, and the common pitfalls such as async void and blocking.
• await operator (C# reference) (Microsoft Learn): How await suspends an async method, the awaitable pattern, and where await may appear.
• async (C# reference) (Microsoft Learn): What the async modifier does, valid return types, and why async void is meant for event handlers.
• Task-based asynchronous pattern (TAP) (Microsoft Learn): How TAP methods start, report exceptions through the returned task, and support cancellation.
• Task cancellation (Microsoft Learn): How a token passed to a task affects whether it runs and how it ends in the Canceled state.
• Exception handling (Task Parallel Library) (Microsoft Learn): How tasks store exceptions in AggregateException and how waiting and awaiting surface them.
• Background tasks with hosted services in ASP.NET Core (Microsoft Learn): IHostedService and BackgroundService: ExecuteAsync, the stopping token, scoped services and queued work.
• Worker services in .NET (Microsoft Learn): How BackgroundService-based workers start, run and stop inside the generic host.
• Use scoped services within a BackgroundService (Microsoft Learn): Creating a DI scope inside a singleton hosted service to consume scoped dependencies.
• Introduction to PLINQ (Microsoft Learn): How AsParallel works, degree of parallelism, ForAll and how PLINQ decides to run sequentially.
• Order preservation in PLINQ (Microsoft Learn): Why PLINQ results are unordered by default and how AsOrdered changes that.
• Potential pitfalls with PLINQ (Microsoft Learn): Common PLINQ mistakes, including shared state and preferring ForAll to foreach.
• How to write a Parallel.For loop with thread-local variables (Microsoft Learn): Using localInit and localFinally to accumulate per-task subtotals without contention.
• Parallel.ForEachAsync method (Microsoft Learn): API reference for running async loop bodies with a bounded degree of parallelism.
• Generate and consume async streams (Microsoft Learn): Writing async iterators with IAsyncEnumerable<T>, await foreach and cancellation.
• Implement a DisposeAsync method (Microsoft Learn): IAsyncDisposable, await using, ConfigureAwait on disposal, and combining it with IDisposable.
• TaskCompletionSource<TResult> class (Microsoft Learn): API reference for creating a task whose completion you control with SetResult, TrySetResult and related methods.
• TaskCreationOptions enum (Microsoft Learn): Options such as LongRunning and RunContinuationsAsynchronously that change how tasks are scheduled.
• SemaphoreSlim class (Microsoft Learn): API reference for the lightweight semaphore with WaitAsync for async mutual exclusion and throttling.
• PeriodicTimer class (Microsoft Learn): API reference for the async-friendly timer awaited with WaitForNextTickAsync.
• Timers in .NET (Microsoft Learn): Overview of System.Threading.Timer and the other timer types and how their callbacks run.
• Debug thread pool starvation (Microsoft Learn): How blocking calls starve the thread pool, what the symptoms look like, and how to fix the cause.
• Task.WaitAsync method (Microsoft Learn): API reference for waiting on a task with a timeout or cancellation token without affecting the task.
• ConfigureAwaitOptions enum (Microsoft Learn): The .NET 8 options for ConfigureAwait, including SuppressThrowing and ForceYielding.
• AsyncLocal<T> class (Microsoft Learn): API reference for ambient data that flows with the ExecutionContext across awaits.
• Lazy initialization (Microsoft Learn): Lazy<T> and its thread-safety modes for creating a value once on first use.
• Routing in ASP.NET Core (Microsoft Learn): Endpoint routing, route templates, constraints, precedence and link generation.
• Parameter binding in Minimal API apps (Microsoft Learn): Binding sources, inference rules, special types, AsParameters, TryParse/BindAsync and forms.
• Create responses in Minimal API applications (Microsoft Learn): Return values, IResult, Results versus TypedResults and the Results<T1,T2> union types.
• Overview of OpenAPI support in ASP.NET Core API apps (Microsoft Learn): Generating OpenAPI documents with Microsoft.AspNetCore.OpenApi in .NET 9 and later.
• Create web APIs with ASP.NET Core (Microsoft Learn): ControllerBase and the behaviours enabled by the [ApiController] attribute.
• Controller action return types in ASP.NET Core web API (Microsoft Learn): Specific types, IActionResult, ActionResult<T> and its implicit conversions.
• Model Binding in ASP.NET Core (Microsoft Learn): Binding sources, their order, [BindRequired] and binding attributes for controllers.
• Model validation in ASP.NET Core MVC (Microsoft Learn): Validation attributes, ModelState, non-nullable reference types and [Required] versus [BindRequired].
• Format response data in ASP.NET Core Web API (Microsoft Learn): Content negotiation, output formatters, Accept headers and 406 responses.
• Logging in .NET Core and ASP.NET Core (Microsoft Learn): ILogger, categories, log levels, filter rules, providers, scopes and message templates.
• Use multiple environments in ASP.NET Core (Microsoft Learn): How the environment is chosen and how it changes configuration and behaviour.
• Configure endpoints for the ASP.NET Core Kestrel web server (Microsoft Learn): Default addresses, ASPNETCORE_URLS, ASPNETCORE_HTTP_PORTS and Kestrel endpoint configuration.
• Policy-based authorization in ASP.NET Core (Microsoft Learn): Policies, requirements, handlers, Succeed/Fail semantics and default and fallback policies.
• Enable Cross-Origin Requests (CORS) in ASP.NET Core (Microsoft Learn): CORS policies, origins, credentials, preflight requests and middleware placement.
• Output caching middleware in ASP.NET Core (Microsoft Learn): Default output caching rules, cache keys, expiration, tags and eviction.
• Health checks in ASP.NET Core (Microsoft Learn): Health check registration, status codes, tags and filtering with predicates.
• How to instantiate JsonSerializerOptions instances with System.Text.Json (Microsoft Learn): JsonSerializerDefaults.Web and the options ASP.NET Core uses by default.
• ClaimsIdentity Class (Microsoft Learn): API reference for ClaimsIdentity: IsAuthenticated, NameClaimType, RoleClaimType and claim lookup.
• HttpClient Class (Microsoft Learn): API reference for HttpClient: BaseAddress, Timeout, headers and request methods.
• DbContext lifetime, configuration, and initialization (Microsoft Learn): How long a DbContext should live, how it is configured and why one instance must not be used by parallel operations.
• Explicitly tracking entities (Microsoft Learn): How Add, Attach, Update and Remove set entity states, including for detached graphs.
• Change detection and notifications (Microsoft Learn): Snapshot change tracking, when DetectChanges runs automatically and how to turn it off.
• Tracking vs. no-tracking queries (Microsoft Learn): Identity resolution, AsNoTracking, AsNoTrackingWithIdentityResolution and which projections are tracked.
• Using transactions (Microsoft Learn): Default SaveChanges transactions, explicit transactions, savepoints and ambient System.Transactions.
• ExecuteUpdate and ExecuteDelete (Microsoft Learn): Set-based updates and deletes that run immediately and bypass the change tracker.
• Cascade delete (Microsoft Learn): Delete behaviors for required and optional relationships, orphan deletion and database-side cascades.
• Owned entity types (Microsoft Learn): OwnsOne and OwnsMany, table splitting, column naming and the limits of owned types.
• Value conversions (Microsoft Learn): Mapping a property to a different provider type, such as enums stored as strings.
• Shadow and indexer properties (Microsoft Learn): Properties that exist in the EF model but not on the CLR class, and how to read them.
• Inheritance (Microsoft Learn): TPH, TPT and TPC mapping strategies, discriminators and key generation for TPC.
• What's new in EF Core 8 (Microsoft Learn): Complex types, raw SQL queries for unmapped types and other EF Core 8 features.
• Eager loading of related data (Microsoft Learn): Include, ThenInclude and filtered includes, including their interaction with tracking.
• Lazy loading of related data (Microsoft Learn): Lazy-loading proxies and ILazyLoader, and their requirements.
• Connection resiliency (Microsoft Learn): Execution strategies that retry failed commands, and how they interact with user transactions.
• Client vs. server evaluation (Microsoft Learn): Which parts of a LINQ query EF Core may evaluate on the client and when it throws instead.
• SQL queries (Microsoft Learn): FromSql, FromSqlRaw, SqlQuery, parameters, SQL injection and composing LINQ over raw SQL.
• Global query filters (Microsoft Learn): HasQueryFilter for soft delete and multi-tenancy, and IgnoreQueryFilters.
• Applying migrations (Microsoft Learn): SQL scripts, idempotent scripts, migration bundles, command-line tools and runtime Migrate().
• Data seeding (Microsoft Learn): UseSeeding, model-managed data with HasData, and custom migration operations.
• Interceptors (Microsoft Learn): Command, connection, transaction and SaveChanges interceptors and how to register them.
• Simple logging (Microsoft Learn): LogTo, sensitive data logging, detailed errors and filtering log messages.
• Efficient updating (Microsoft Learn): Statement batching in SaveChanges and bulk updates.
• Retrieve data using a DataReader (Microsoft Learn): Reading rows with ExecuteReader, checking for nulls and moving through multiple result sets.
• SQL Server connection pooling (ADO.NET) (Microsoft Learn): How ADO.NET pools physical connections per connection string and returns them on Close or Dispose.
• Implementing an implicit transaction using transaction scope (Microsoft Learn): TransactionScope, Complete, nesting and the Required, RequiresNew and Suppress options.
• Dapper (Dapper contributors): The Dapper micro-ORM: extension methods on DbConnection that map query results to objects.
• Shared context between tests (xUnit.net) (xUnit.net): Constructor and Dispose per test, class fixtures and collection fixtures in xUnit.
• FixtureLifeCycle attribute (NUnit) (NUnit): How NUnit reuses one fixture instance by default and how to opt into an instance per test case.
• MSTest attributes (Microsoft Learn): MSTest test, initialization and cleanup attributes such as ClassInitialize and TestInitialize.
• Unit testing best practices for .NET (Microsoft Learn): Naming, arranging tests and the difference between fakes, stubs and mocks.
• Moq on GitHub (devlooped): The Moq mocking library: setups, verification, mock behaviours and its proxy-based limits.
• Auto and recursive mocks (NSubstitute) (NSubstitute): Which values an NSubstitute substitute returns for calls that were not configured.
• Choosing a testing strategy (EF Core) (Microsoft Learn): Trade-offs between a real database, SQLite in-memory, the InMemory provider and test doubles.
• What is TimeProvider? (Microsoft Learn): The TimeProvider abstraction in .NET 8 and FakeTimeProvider for deterministic tests.
• Use code coverage for unit testing (Microsoft Learn): Collecting coverage with coverlet and the XPlat Code Coverage collector, and generating reports.
• dotnet test command (Microsoft Learn): Options of dotnet test, including --filter, --no-build, --collect and loggers.
• dotnet publish command (Microsoft Learn): Configurations, runtime identifiers and self-contained options of dotnet publish.
• .NET application publishing overview (Microsoft Learn): Framework-dependent versus self-contained deployments and single-file publishing.
• .NET tools (Microsoft Learn): Global and local .NET tools, tool manifests and dotnet tool restore.
• Customize your build by folder (Microsoft Learn): How MSBuild finds and imports Directory.Build.props and Directory.Build.targets.
• Central Package Management (NuGet) (Microsoft Learn): Directory.Packages.props, ManagePackageVersionsCentrally and PackageVersion items.
• Package versioning (NuGet) (Microsoft Learn): Version ranges, pre-release ordering and how NuGet picks a version.
• Overview of .NET source code analysis (Microsoft Learn): Code quality (CA) and code style (IDE) analyzers, severities and EnforceCodeStyleInBuild.
• C# compiler options for errors and warnings (Microsoft Learn): TreatWarningsAsErrors, WarningsAsErrors, NoWarn and related MSBuild properties.
• dotnet-trace (Microsoft Learn): Collecting EventPipe traces (.nettrace) of a running process without a native profiler.
• dotnet-dump (Microsoft Learn): Collecting process dumps and analyzing them with SOS commands.
• dotnet-gcdump (Microsoft Learn): Capturing a GC heap snapshot through EventPipe, and what it costs the target process.
• BenchmarkDotNet good practices (BenchmarkDotNet): Release builds, avoiding dead code elimination and other benchmarking pitfalls.
• Setup and cleanup (BenchmarkDotNet) (BenchmarkDotNet): GlobalSetup, IterationSetup and when each runs.
• Add distributed tracing instrumentation (Microsoft Learn): ActivitySource, Activity, listeners and registering sources with OpenTelemetry.
• Creating metrics (Microsoft Learn): Meter, Counter, UpDownCounter, Histogram and observable instruments in System.Diagnostics.Metrics.
• Compile-time logging source generation (Microsoft Learn): The [LoggerMessage] source generator and why it beats extension-method logging on hot paths.
• Design a DDD-oriented microservice (Microsoft Learn): Domain, application and infrastructure layers of a .NET service and which depends on which.
• Implement a microservice domain model with .NET (Microsoft Learn): Entities, aggregates and encapsulated child collections in C#.
• Implement value objects (Microsoft Learn): Value objects without identity, compared by their values, and how to persist them with EF Core.
• Domain events: design and implementation (Microsoft Learn): Raising domain events in aggregates and dispatching them from the DbContext before or after commit.
• Implement reads/queries in a CQRS microservice (Microsoft Learn): Query side with Dapper returning ViewModels/DTOs, independent of the aggregates.
• Implement the microservice application layer using the Web API (Microsoft Learn): Commands, command handlers, the mediator pattern with MediatR and pipeline behaviors for cross-cutting concerns.
• Implementing event-based communication between microservices (Microsoft Learn): Integration events published through an event bus, and the outbox-style integration event log.
• Transactional Outbox pattern (Microsoft Learn): Saving a state change and its outgoing message in one transaction and relaying the message later.
• Saga distributed transactions pattern (Microsoft Learn): Sequences of local transactions with compensating actions, choreographed or orchestrated.
• Hangfire documentation (Hangfire): Persistent fire-and-forget, delayed and recurring background jobs with automatic retries.
• Circuit Breaker pattern (Microsoft Learn): Closed, open and half-open states and why an open breaker fails fast.
• Service discovery in .NET (Microsoft Learn): Microsoft.Extensions.ServiceDiscovery, logical service names and the https+http scheme.
• .NET Aspire overview (Microsoft Learn): The AppHost orchestration project, resources, integrations and the dashboard.
• .NET Aspire service defaults (Microsoft Learn): What AddServiceDefaults configures: OpenTelemetry, health checks, service discovery and HTTP resilience.
• .NET feature management (Microsoft Learn): Microsoft.FeatureManagement: feature flags, built-in filters, FeatureGate and IFeatureManagerSnapshot.
• ASP.NET API Versioning wiki (dotnet/aspnet-api-versioning): Asp.Versioning options: version readers, reporting API versions and deprecation.
• Message transfers, locks, and settlement (Microsoft Learn): Peek-lock receive mode and settling messages with complete, abandon, dead-letter and defer.
• Service Bus dead-letter queues (Microsoft Learn): When messages are moved to the dead-letter subqueue, including exceeding MaxDeliveryCount.
• Duplicate detection in Azure Service Bus (Microsoft Learn): Dropping messages resent with the same MessageId within the duplicate detection window.
• Message sessions in Azure Service Bus (Microsoft Learn): FIFO handling of related messages grouped by SessionId.
• MassTransit: exceptions, retry and redelivery (MassTransit): What happens when a consumer throws: retry filters, the _error queue and Fault<T> events.
• Static files in ASP.NET Core (Microsoft Learn): Serving wwwroot and other folders, default documents, directory browsing, content types, caching headers and authorization of static files.
• What's new in ASP.NET Core 9.0 (Microsoft Learn): Release notes for ASP.NET Core 9, including MapStaticAssets with build-time compression and fingerprinting.
• File Providers in ASP.NET Core (Microsoft Learn): IFileProvider, PhysicalFileProvider and how ASP.NET Core abstracts file system access.
• Configure JWT bearer authentication in ASP.NET Core (Microsoft Learn): AddJwtBearer options, token validation parameters, Authority and metadata discovery, and signing keys.
• Manage JSON Web Tokens in development with dotnet user-jwts (Microsoft Learn): Creating development JWTs with the dotnet user-jwts tool and how it configures the app.
• Policy schemes in ASP.NET Core (Microsoft Learn): Policy schemes that forward authentication actions to another scheme, chosen per request.
• Authentication and authorization in ASP.NET Core SignalR (Microsoft Learn): Sending bearer tokens to SignalR hubs, including the access_token query string and OnMessageReceived.
• TokenValidationParameters.ClockSkew Property (Microsoft Learn): API reference for the clock skew applied when validating token lifetimes; the default is 300 seconds.
• JwtBearerOptions.MapInboundClaims Property (Microsoft Learn): API reference for the switch that maps short JWT claim names such as sub to long ClaimTypes URIs.
• RFC 7519: JSON Web Token (JWT) (IETF): The JWT specification: compact serialization, registered claims such as exp, nbf and sub, and NumericDate.
• RFC 6750: OAuth 2.0 Bearer Token Usage (IETF): How bearer tokens are sent and the WWW-Authenticate error codes invalid_request, invalid_token and insufficient_scope.
• RFC 4648: The Base16, Base32, and Base64 Data Encodings (IETF): Defines base64 and the URL- and filename-safe base64url alphabet used by JWTs.
• JSON Web Token Cheat Sheet (OWASP): Common JWT pitfalls, including token revocation with a deny list and token storage on the client.
• HMACSHA256 Class (Microsoft Learn): API reference for HMAC with SHA-256, including the static HashData method.
• Convert.FromBase64String Method (Microsoft Learn): API reference for decoding base64 strings and the FormatException thrown for invalid input.
• DateTimeOffset.FromUnixTimeSeconds Method (Microsoft Learn): API reference for converting Unix time in seconds to a DateTimeOffset.
• Kestrel web server in ASP.NET Core (Microsoft Learn): Overview of Kestrel, when to use a reverse proxy, and host filtering.
• Configure options for the ASP.NET Core Kestrel web server (Microsoft Learn): Kestrel limits: body size, connections, keep-alive, header timeouts and minimum data rates.
• Use HTTP/2 with the ASP.NET Core Kestrel web server (Microsoft Learn): HTTP/2 requirements in Kestrel, TLS and ALPN, and cleartext HTTP/2.
• Use HTTP/3 with the ASP.NET Core Kestrel web server (Microsoft Learn): Enabling HTTP/3 over QUIC in Kestrel and how clients discover it through alt-svc.
• Configure ASP.NET Core to work with proxy servers and load balancers (Microsoft Learn): Forwarded Headers Middleware, X-Forwarded-For and X-Forwarded-Proto, KnownProxies and KnownNetworks.
• Web server implementations in ASP.NET Core (Microsoft Learn): Kestrel, IIS HTTP Server and HTTP.sys, and how they relate to hosting models.
• In-process hosting with IIS and ASP.NET Core (Microsoft Learn): How the ASP.NET Core Module hosts the app inside the IIS worker process with IIS HTTP Server.
• .NET Generic Host in ASP.NET Core (Microsoft Learn): Host lifetime, graceful shutdown and the ShutdownTimeout setting.
• Upload files in ASP.NET Core (Microsoft Learn): Large uploads, the Kestrel maximum request body size, RequestSizeLimit and DisableRequestSizeLimit.
• IPNetwork Struct (Microsoft Learn): API reference for the .NET 8 IP network type with Parse and Contains.
• Use hubs in ASP.NET Core SignalR (Microsoft Learn): Hub methods, the Clients object, strongly typed hubs, lifetime events and error handling.
• Manage users and groups in SignalR (Microsoft Learn): User identifiers, IUserIdProvider and connection-scoped group membership.
• Send messages from outside a hub (Microsoft Learn): Using IHubContext<THub> from controllers, middleware and background services.
• ASP.NET Core SignalR configuration (Microsoft Learn): Server and client options such as message size limits, timeouts and transports.
• Overview of ASP.NET Core SignalR (Microsoft Learn): What SignalR does, its transports and the fallback between them.
• ASP.NET Core SignalR .NET Client (Microsoft Learn): Connecting, automatic reconnect and handling lost connections from .NET.
• Use streaming in ASP.NET Core SignalR (Microsoft Learn): Server-to-client and client-to-server streaming with IAsyncEnumerable and ChannelReader.
• ASP.NET Core SignalR hosting and scaling (Microsoft Learn): Sticky sessions, backplanes and Azure SignalR Service for multiple servers.
• Set up a Redis backplane for SignalR scale-out (Microsoft Learn): Configuring the Redis backplane and what happens when Redis is unavailable.
• Use hub filters in ASP.NET Core SignalR (Microsoft Learn): Global and per-hub filters that run around hub method invocations.
• Use MessagePack Hub Protocol in SignalR (Microsoft Learn): Enabling the binary MessagePack protocol and its serialization differences.
• SignalR Hub Protocol specification (ASP.NET Core team): Message types, handshake and record-separator framing of the hub protocol.
• gRPC services with C# (Microsoft Learn): Proto files, Grpc.Tools code generation and the GrpcServices setting.
• gRPC services with ASP.NET Core (Microsoft Learn): Hosting gRPC in ASP.NET Core and configuring Kestrel endpoints for HTTP/2.
• Error handling with gRPC (Microsoft Learn): Status codes, RpcException and how unhandled server exceptions reach the client.
• Reliable gRPC services with deadlines and cancellation (Microsoft Learn): Setting deadlines, server-side cancellation and propagating them to child calls.
• gRPC client factory integration in .NET (Microsoft Learn): AddGrpcClient, client lifetimes and call context propagation.
• Call gRPC services with the .NET client (Microsoft Learn): Creating channels and clients, call types, headers and trailers.
• Performance best practices with gRPC (Microsoft Learn): Reusing channels, connection concurrency and load balancing long-lived connections.
• gRPC client-side load balancing (Microsoft Learn): Resolvers and load balancers in Grpc.Net.Client.
• gRPC-Web in ASP.NET Core gRPC apps (Microsoft Learn): Calling gRPC from browsers with gRPC-Web and its limitations.
• gRPC JSON transcoding in ASP.NET Core (Microsoft Learn): Exposing gRPC methods as RESTful JSON APIs with HTTP annotations.
• gRPC for .NET configuration (Microsoft Learn): Server and client options such as maximum message sizes.
• Create Protobuf messages for .NET apps (Microsoft Learn): Scalar types, well-known types, nullable wrappers and dates in Protobuf for .NET.
• Language Guide (proto3) (Protocol Buffers): Field numbers, default values, field presence, reserved fields and updating messages.
• Protocol Buffers Encoding (Protocol Buffers): How varints, tags and wire types are laid out on the wire.
• gRPC over HTTP2 protocol (gRPC Authors): Request and response frames, length-prefixed messages and status trailers.
• gRPC status codes (gRPC Authors): The list of gRPC status codes and when each is used.
• gRPC Metadata (gRPC Authors): Headers, trailers and binary metadata keys in gRPC.
• Error (MDN Web Docs): The Error constructor, its options bag with cause, and custom error subclasses.
• Object.defineProperty() (MDN Web Docs): Property descriptors, their default attributes and how writable affects assignment.
• Object.seal() (MDN Web Docs): How sealing compares with Object.preventExtensions and Object.freeze.
• Object.groupBy() (MDN Web Docs): Grouping iterable elements into a null-prototype object by a callback's key.
• Exponentiation (**) (MDN Web Docs): The exponentiation operator, its right associativity and the unary-operand restriction.
• Nullish coalescing operator (??) (MDN Web Docs): How ?? works and why it cannot be mixed with || or && without parentheses.
• Function: length (MDN Web Docs): How a function's length counts parameters before the first default or rest parameter.
• Function.prototype.bind() (MDN Web Docs): Bound functions, partial application and how they behave with new.
• The structured clone algorithm (MDN Web Docs): Which types structuredClone can copy and what it drops, such as prototypes and symbol keys.
• Symbol (MDN Web Docs): Symbols, the global registry and the well-known symbols such as toPrimitive, toStringTag and species.
• Private properties (MDN Web Docs): Private fields and methods, brand checks and the TypeError on foreign objects.
• export (MDN Web Docs): Named and default exports, and how export default of an expression differs from a live binding.
• Import attributes (MDN Web Docs): The with { type: 'json' } syntax for passing attributes to module imports.
• Regular expressions (MDN Web Docs): Regex syntax and flags, including sticky, unicodeSets (v) and lookbehind assertions.
• Object.hasOwn() (MDN Web Docs): Checking own properties safely, including on objects without a prototype.
• String.prototype.normalize() (MDN Web Docs): Unicode normalization forms and why visually identical strings can differ.
• Default parameters (MDN Web Docs): When default parameter values are evaluated and which earlier parameters they can see.
• Reflect.ownKeys() (MDN Web Docs): Listing every own key, string and symbol, in property order.
• Labeled statement (MDN Web Docs): Labels and which statements break and continue can target.
• FinalizationRegistry (MDN Web Docs): Cleanup callbacks after garbage collection and why they are not guaranteed to run.
• WeakMap (MDN Web Docs): Weakly held keys, including which symbols may be used as keys.
• Number.prototype.toFixed() (MDN Web Docs): Formatting numbers with a fixed number of decimals and the binary-rounding surprises.
• JavaScript execution model (MDN Web Docs): How agents, the job queue and the event loop run JavaScript code.
• Using microtasks in JavaScript with queueMicrotask() (MDN Web Docs): How tasks and microtasks are queued and when each queue is processed.
• Promise.resolve() (MDN Web Docs): How Promise.resolve returns, wraps or adopts the value it is given.
• Promise.try() (MDN Web Docs): Calls a callback synchronously and wraps its result or exception in a promise.
• Promise.withResolvers() (MDN Web Docs): Creates a promise together with its resolve and reject functions.
• Promise.race() (MDN Web Docs): Settles with the first input promise to settle, and what happens with an empty iterable.
• Using promises (MDN Web Docs): Guide to chaining, error handling, composition and timing of promises.
• async function (MDN Web Docs): How async functions run, suspend at await and settle their returned promise.
• await (MDN Web Docs): How await unwraps promises and thenables and resumes in a microtask.
• for await...of (MDN Web Docs): Looping over async iterables and sync iterables of promises.
• AsyncGenerator (MDN Web Docs): The object returned by async generator functions and its next, return and throw methods.
• AbortController (MDN Web Docs): Creating a controller whose signal cancels async operations.
• AbortSignal (MDN Web Docs): Abort signals, reasons, AbortSignal.timeout and AbortSignal.any.
• Window: setTimeout() method (MDN Web Docs): Scheduling timers, minimum delays, clamping and the maximum delay value.
• Window: setInterval() method (MDN Web Docs): Repeating timers and why recursive setTimeout guarantees a gap between runs.
• Window: queueMicrotask() method (MDN Web Docs): Queues a callback on the microtask queue.
• Window: structuredClone() method (MDN Web Docs): Deep-copies a value with the structured clone algorithm, optionally transferring buffers.
• The structured clone algorithm (MDN Web Docs): Which types can be cloned for postMessage and structuredClone, and what is lost.
• Transferable objects (MDN Web Docs): Moving ownership of buffers between contexts instead of copying them.
• Using Web Workers (MDN Web Docs): Running scripts on background threads that communicate by messages.
• SharedArrayBuffer (MDN Web Docs): Memory shared between agents, and the cross-origin isolation it requires.
• Atomics (MDN Web Docs): Atomic operations and waiting on shared memory.
• Atomics.wait() (MDN Web Docs): Blocking a thread on a shared memory location, and where that is not allowed.
• Window: unhandledrejection event (MDN Web Docs): The event fired when a rejected promise has no handler.
• Error: cause (MDN Web Docs): Attaching the original error when rethrowing a wrapped one.
• Faster async functions and promises (V8 team): How V8 implements await and zero-cost async stack traces.
• Timers (Node.js): Node.js timer functions and how out-of-range delays are handled.
• Exponential Backoff And Jitter (AWS Architecture Blog): Why adding jitter to retry backoff avoids synchronized retry storms.
• Node properties: type, tag and contents (Ilya Kantor): Covers node types, nodeType, innerHTML, outerHTML, textContent and the hidden property.
• Document: querySelectorAll() method (MDN Web Docs): Reference for querySelectorAll and the static NodeList it returns.
• Using templates and slots (MDN Web Docs): How template elements and named and default slots compose content into a shadow tree.
• Attributes and properties (Ilya Kantor): Explains how HTML attributes map to DOM properties, property-attribute synchronization and data-* attributes.
• Element: classList property (MDN Web Docs): Reference for the live DOMTokenList used to add, remove, toggle and replace classes.
• EventTarget: addEventListener() method (MDN Web Docs): Reference for addEventListener including the capture, once, passive and signal options.
• Dispatching custom events (Ilya Kantor): How to create and dispatch Event and CustomEvent objects, bubbles, cancelable and detail.
• Window: requestAnimationFrame() method (MDN Web Docs): Reference for scheduling a callback before the next repaint.
• Avoid large, complex layouts and layout thrashing (web.dev): Explains forced synchronous layouts and how batching reads and writes avoids them.
• Scripts: async, defer (Ilya Kantor): Compares regular, async, defer and dynamically inserted scripts and their relation to DOMContentLoaded.
• Using the Fetch API (MDN Web Docs): Guide to making requests with fetch, checking status and reading response bodies.
• Response (MDN Web Docs): Reference for the Response interface: ok, status, type, body, bodyUsed and clone().
• Cross-Origin Resource Sharing (CORS) (MDN Web Docs): Explains simple and preflighted requests, credentialed requests and the CORS response headers.
• Web Storage API (MDN Web Docs): Overview of localStorage, sessionStorage and the storage event.
• IndexedDB API (MDN Web Docs): Overview of IndexedDB databases, versions, object stores and transactions.
• Document: cookie property (MDN Web Docs): How to read, write and delete cookies from JavaScript with document.cookie.
• URLSearchParams (MDN Web Docs): Reference for parsing, reading and serializing URL query strings.
• History API (MDN Web Docs): Explains pushState, replaceState, history state and the popstate event used by SPA routers.
• Intersection Observer API (MDN Web Docs): How IntersectionObserver reports visibility changes asynchronously, with root, rootMargin and thresholds.
• MutationObserver (MDN Web Docs): Reference for observing DOM changes, mutation records and takeRecords().
• ResizeObserver (MDN Web Docs): Reference for observing element size changes and the entries it delivers.
• The service worker lifecycle (web.dev): Explains install, waiting, activate, skipWaiting and clients.claim for service workers.
• Using custom elements (MDN Web Docs): How to define custom elements and use their lifecycle callbacks and observedAttributes.
• Using shadow DOM (MDN Web Docs): How to attach shadow roots, what open and closed mode mean and how encapsulation works.
• ARIA (MDN Web Docs): Introduction to ARIA roles, states and properties and when to prefer native HTML elements.
• Canvas tutorial (MDN Web Docs): Tutorial on the 2D canvas context: sizing, paths, styles, state and pixel manipulation.
• Events: change, input, cut, copy, paste (Ilya Kantor): Explains when input and change fire and how clipboard events and the Clipboard API work.
• Don't Block the Event Loop (or the Worker Pool) (Node.js Docs): Covers the libuv worker pool, which APIs use it and how blocking hurts throughput.
• Timers (Node.js Docs): Reference for setTimeout, setImmediate, Timeout objects and ref/unref.
• Command-line API (Node.js Docs): Reference for Node.js CLI flags and environment variables such as UV_THREADPOOL_SIZE and --watch.
• Modules: ECMAScript modules (Node.js Docs): Reference for ES modules in Node: specifiers, import.meta, JSON modules and CommonJS interop.
• Modules: Packages (Node.js Docs): Reference for the type, main, exports and imports fields and module format detection.
• package.json (npm Docs): npm's reference for package.json fields such as engines, scripts and bin.
• scripts (npm Docs): npm's reference for lifecycle scripts, pre/post hooks and the PATH used by npm run.
• File system (Node.js Docs): Reference for the synchronous, callback and promise-based fs APIs.
• Stream (Node.js Docs): Reference for readable, writable and transform streams, pipeline and highWaterMark.
• Backpressuring in Streams (Node.js Docs): Guide to backpressure, write() return values and the drain event.
• Buffer (Node.js Docs): Reference for Buffer allocation, encodings and memory sharing.
• String decoder (Node.js Docs): Reference for decoding byte chunks without breaking multi-byte characters.
• HTTP (Node.js Docs): Reference for Node's HTTP server, client and Agent.
• Global objects (Node.js Docs): Lists Node's globals, including fetch, WebSocket and TextEncoder.
• Child process (Node.js Docs): Reference for spawn, exec, execFile and fork.
• Worker threads (Node.js Docs): Reference for Worker, workerData, postMessage and transferable objects.
• Cluster (Node.js Docs): Reference for forking worker processes that share a server port.
• Errors (Node.js Docs): Reference for error-first callbacks, error codes and system errors.
• Asynchronous context tracking (Node.js Docs): Reference for AsyncLocalStorage.
• Test runner (Node.js Docs): Reference for node:test, test file discovery and mocking.
• Permissions (Node.js Docs): Reference for the Node.js permission model and its --allow-* flags.
• Node.js Releases (Node.js Docs): Explains the Current, Active LTS and Maintenance LTS phases of release lines.
• Util (Node.js Docs): Reference for util.promisify and other utilities.
• DNS (Node.js Docs): Explains dns.lookup versus dns.resolve and their threading behaviour.
• TextEncoder (MDN Web Docs): Encodes strings into UTF-8 bytes; available in Node and browsers.
• TextDecoder (MDN Web Docs): Decodes bytes into strings, including streaming decoding.
• Everyday Types (TypeScript Handbook): Primitives, any, unions, type aliases, interfaces, literal types and non-null assertions.
• Narrowing (TypeScript Handbook): typeof, truthiness, in, instanceof, type predicates, discriminated unions and never.
• More on Functions (TypeScript Handbook): Function types, generics in functions, overloads, unknown, never and void.
• Object Types (TypeScript Handbook): Optional and readonly properties, excess property checks, extending and intersecting, tuples.
• Generics (TypeScript Handbook): Generic functions, constraints, defaults and using type parameters in constraints.
• Keyof Type Operator (TypeScript Handbook): How keyof produces a union of an object type's keys.
• Typeof Type Operator (TypeScript Handbook): Using typeof in a type position to refer to the type of a value.
• Indexed Access Types (TypeScript Handbook): Looking up property types with T[K], including T[number] for arrays.
• Conditional Types (TypeScript Handbook): Conditional types, infer, and distribution over unions.
• Mapped Types (TypeScript Handbook): Mapped types, readonly and optional modifiers, and key remapping with as.
• Template Literal Types (TypeScript Handbook): Template literal types, union cross products and intrinsic string types.
• Classes (TypeScript Handbook): Fields, access modifiers, parameter properties, abstract classes and #private.
• Modules (TypeScript Handbook): ES module syntax in TypeScript, including import type.
• Utility Types (TypeScript Handbook): Reference for Partial, Required, Pick, Omit, Record, ReturnType, Awaited, NonNullable and more.
• Enums (TypeScript Handbook): Numeric and string enums, reverse mappings and const enums.
• Type Compatibility (TypeScript Handbook): Structural typing, assignability, and parameter bivariance.
• Type Inference (TypeScript Handbook): Best common type and contextual typing.
• Declaration Merging (TypeScript Handbook): How interfaces, namespaces and other declarations merge.
• Declaration Files: Introduction (TypeScript Handbook): What .d.ts files are and how to write them.
• Consuming Declaration Files (TypeScript Handbook): Getting types for libraries from npm @types packages.
• TSConfig Reference (TypeScript): Every compiler option, including strict, target, module, lib and moduleResolution.
• Modules - Theory (TypeScript Handbook): How TypeScript models module systems, output format and module resolution.
• TypeScript 3.7 Release Notes (TypeScript): Introduces assertion functions, optional chaining and nullish coalescing.
• TypeScript 4.1 Release Notes (TypeScript): Introduces template literal types and key remapping in mapped types.
• TypeScript 4.9 Release Notes (TypeScript): Introduces the satisfies operator and unlisted property narrowing with in.
• TypeScript 5.0 Release Notes (TypeScript): Introduces const type parameters, verbatimModuleSyntax and standard decorators.
• TypeScript 5.5 Release Notes (TypeScript): Introduces inferred type predicates and control-flow narrowing for constant indexed accesses.
• DefinitelyTyped (DefinitelyTyped): The repository of community-maintained @types declaration packages.
• Creating Types from Types (TypeScript Handbook): Overview of generics, keyof, typeof, indexed access, conditional, mapped and template literal types.
• npm docs: semver (npm Docs): How npm interprets caret, tilde, x-ranges and prerelease tags in version ranges.
• Semantic Versioning 2.0.0 (Tom Preston-Werner): The specification for MAJOR.MINOR.PATCH versions and prerelease precedence.
• npm docs: package-lock.json (npm Docs): What the lockfile records and when npm reads or ignores it.
• npm docs: npm ci (npm Docs): The clean, lockfile-exact install command intended for CI and deployments.
• npm docs: npm install (npm Docs): How npm install resolves, saves and installs packages, including peer dependencies.
• npm docs: npx (npm Docs): Running a package's binary from the local project or a temporary install.
• npm docs: workspaces (npm Docs): Managing several packages from one root package.json and lockfile.
• pnpm: Motivation (pnpm): Why pnpm uses a content-addressable store, hard links and a non-flat node_modules.
• webpack: Tree Shaking (webpack): How bundlers drop unused ES module exports and what the sideEffects flag does.
• MDN: import() (MDN Web Docs): Dynamic import, which bundlers use as a code-splitting point.
• MDN: Source map (MDN Web Docs): How a source map links generated code back to the original source.
• Vite: Why Vite (Vite): Native-ESM dev server, dependency pre-bundling and why production is still bundled.
• Vite: Features (Vite): Vite's TypeScript handling (transpile only, no type check) and other built-in features.
• Vite: Env Variables and Modes (Vite): import.meta.env and the VITE_ prefix that controls what reaches client code.
• esbuild: Content Types (esbuild): esbuild strips TypeScript types without type checking, and its caveats.
• Babel: @babel/preset-env (Babel): Syntax transforms by target, and how polyfills are a separate concern.
• TSConfig Reference: noEmitOnError (TypeScript): tsc emits JavaScript despite type errors unless this option is set.
• ESLint: Core Concepts (ESLint): Rules, configuration files, fixes and what ESLint is for.
• Prettier vs. Linters (Prettier): Why formatting rules and code-quality rules belong to different tools.
• Vitest: expect (Vitest): Matchers such as toBe, toEqual, toStrictEqual, toThrow, resolves and expect.assertions.
• Vitest: vi utility (Vitest): vi.fn, vi.spyOn, vi.mock hoisting, vi.hoisted and fake timers.
• Vitest: Snapshot (Vitest): File and inline snapshots, updating them, and their behaviour in CI.
• Vitest: Coverage (Vitest): The v8 and istanbul coverage providers and the metrics they report.
• Playwright: Auto-waiting (Playwright): The actionability checks Playwright performs before clicking or typing.
• Playwright: Locators (Playwright): Lazy, strict locators and the recommended getByRole style.
• Playwright: Assertions (Playwright): Auto-retrying web-first assertions versus one-shot generic assertions.
• Playwright: Isolation (Playwright): Each test runs in its own browser context with separate cookies and storage.
• Cross Site Scripting Prevention Cheat Sheet (OWASP Cheat Sheet Series): Output encoding per context, safe sinks and the main XSS defenses.
• Content Security Policy (CSP) (MDN Web Docs): How CSP directives, nonces and hashes restrict what a page may load and run.
• Mitigate cross-site scripting (XSS) with a strict Content Security Policy (web.dev): Nonce- and hash-based CSP with 'strict-dynamic' instead of host allowlists.
• Trusted Types API (MDN Web Docs): Locking DOM XSS sinks so they accept only typed values created by a policy.
• Cross-Site Request Forgery Prevention Cheat Sheet (OWASP Cheat Sheet Series): Tokens, SameSite cookies, custom headers and origin checks against CSRF.
• Set-Cookie header (MDN Web Docs): Reference for cookie attributes such as HttpOnly, Secure and SameSite.
• SameSite cookies explained (web.dev): What Strict, Lax and None mean and how browsers default to Lax.
• Clickjacking Defense Cheat Sheet (OWASP Cheat Sheet Series): frame-ancestors, X-Frame-Options and other framing defenses.
• Prototype Pollution Prevention Cheat Sheet (OWASP Cheat Sheet Series): How unsafe merges pollute Object.prototype and how to prevent it.
• Regular expression Denial of Service - ReDoS (OWASP): Why nested quantifiers cause catastrophic backtracking and how attackers exploit it.
• Generating provenance statements (npm Docs): Linking a published package to its source repository and build, and verifying it.
• Window: postMessage() method (MDN Web Docs): Cross-origin messaging, targetOrigin and checking event.origin.
• Subresource Integrity (MDN Web Docs): Verifying that fetched scripts and styles match an expected hash.
• eval() (MDN Web Docs): Direct and indirect eval, scope rules and why eval is dangerous.
• HTML5 Security Cheat Sheet (OWASP Cheat Sheet Series): Web messaging, local storage and other HTML5 features from a security view.
• Trash talk: the Orinoco garbage collector (V8 team): V8's generational heap, scavenges and major mark-compact collections.
• Fix memory problems (Chrome DevTools): Finding leaks and detached DOM nodes with heap snapshots.
• Largest Contentful Paint (LCP) (web.dev): What LCP measures, its thresholds and which elements count.
• Interaction to Next Paint (INP) (web.dev): How INP measures interaction latency and its three phases.
• Cumulative Layout Shift (CLS) (web.dev): How layout shifts are scored and which ones are excluded.
• Optimize long tasks (web.dev): Why tasks over 50 ms block the main thread and how to break them up.
• HTTP caching (MDN Web Docs): Freshness, revalidation, no-cache versus no-store and caching hashed assets.
• Performance: now() method (MDN Web Docs): High-resolution, monotonic timestamps relative to the time origin.
• Reduce JavaScript payloads with code splitting (web.dev): Splitting bundles with dynamic import() so pages load less JavaScript up front.
• Debounce (MDN Web Docs): Glossary entry on debouncing and how it differs from throttling.

Questions · System design · Reading list