Search Daily References & Topics

Topics: How the Web Works

Topics: HTML Document Structure

Topics: Text and Content Elements

Topics: Links and Navigation

Topics: Images and Media

Topics: Semantic HTML

Topics: Tables

Topics: Forms I

Topics: Forms II

Topics: HTML Validation

Topics: Accessibility Basics

Topics: HTML Page Architecture

Topics: Mini Project I

Topics: Mini Project I Finish

Topics: HTML Review

Topics: SEO Basics and Head Metadata

Topics: File Uploads, Character References, and Connecting HTML to the Rest of the Stack

Topics: What CSS Is

Topics: Selectors

Topics: Cascade and Specificity

Topics: Colors and Backgrounds

Topics: Typography

Topics: The Box Model

Topics: Sizing, Units, Constraints, and Overflow

Topics: Display and Normal Flow

Topics: Positioning

Topics: Flexbox I

Topics: Flexbox II

Topics: CSS Grid

Topics: Responsive Design

Topics: Media Queries and Mobile-First Enhancement

Topics: Responsive Landing Page Capstone

Topics: Pseudo-Classes, Pseudo-Elements, and Interaction States

Topics: CSS Custom Properties, Functions, and Design Tokens

Topics: Borders, Shadows, Opacity, Images, and Filters

Topics: Transforms, Transitions, and Keyframe Animations

Topics: Floats, Multi-Column Layout, Lists, and Tables

Topics: Container Queries and Component Responsiveness

Topics: CSS Architecture and Tooling — BEM, Sass, PostCSS, CSS Modules, and CSS-in-JS

Topics: CSS Accessibility, Performance, and Compatibility

Topics: Modern CSS — Cascade Layers, Nesting, Scope, Subgrid, Logical Properties, and Progressive Features

Topics: JavaScript: Runtime, Console, Versions, and Script Loading

Topics: Variables, Scope, Hoisting, and the Temporal Dead Zone

Topics: Values and Data Types

Topics: Type Conversion, Coercion, and Equality

Topics: Expressions and Operators

Topics: Control Flow: Conditions and Branching

Topics: Loops and Iteration

Topics: Functions I: Declarations, Expressions, Parameters, and Returns

Topics: Functions II: Scope, Closures, Recursion, and the Call Stack

Topics: The `this` Keyword, call, apply, bind, and Function Borrowing

Topics: Arrays and Indexed Collections

Topics: Array Methods I: Mutation, Copying, and Search

Topics: Array Methods II: Transform, Filter, and Find

Topics: Array Methods III: Reduce, Validation, and Sorting

Topics: Objects and Property Mechanics

Topics: Destructuring, Rest, Spread, and Copy Semantics

Topics: Nested Data, Immutability, and Functional Updates

Topics: Prototypes, Prototypal Inheritance, and Classes

Topics: JavaScript Data Structures: Map, Set, Weak Collections, JSON, and Typed Arrays

Topics: Iterators, Iterables, and Generators

Topics: Standard Built-ins: String, Number, Math, Date, Intl, and RegExp

Topics: Errors, Exceptions, and Recovery

Topics: JavaScript Modules: ESM, CommonJS, and Dynamic Imports

Topics: Core JavaScript Practice: In-Memory Product Management

Topics: Core JavaScript Practice: Shopping Cart Logic

Topics: Core JavaScript Review and Assessment

Topics: DOM Fundamentals and Browser DOM APIs

Topics: Selecting and Traversing DOM Elements

Topics: Creating, Updating, and Removing DOM Safely

Topics: Classes, Styles, Attributes, and Dataset

Topics: Events I: Event Objects, Listeners, and Propagation

Topics: Events II: Delegation, Default Actions, and Listener Lifecycle

Topics: Forms, FormData, and Client-Side Validation

Topics: Browser Storage: localStorage, sessionStorage, Cookies, and IndexedDB

Topics: Browser APIs Beyond the DOM: URL, History, Observers, and Web Components

Topics: DOM Project I: Todo Application Core

Topics: DOM Project II: Refactor, Accessibility, and Performance

Topics: Asynchronous JavaScript: Call Stack, Event Loop, Timers, and Callbacks

Topics: Promises and Promise Combinators

Topics: Async/Await and Concurrency

Topics: HTTP in JavaScript: Fetch, AbortController, CORS, and XHR

Topics: REST and API Integration

Topics: Memory Management and Garbage Collection

Topics: Browser DevTools, Debugging, and Performance

Topics: Testing JavaScript: Unit, DOM, and Async Testing

Topics: JavaScript Security, Reliability, and Production Readiness

Topics: Why React?

Topics: React Setup + JSX

Topics: Components

Topics: Props

Topics: Lists + Keys

Topics: Conditional Rendering

Topics: State

Topics: State + Events

Topics: Forms

Topics: useEffect + API

Topics: Canonical Task Manager React Vertical Slice

Topics: State Ownership, Lifting State, and Derived State

Topics: Reducers and Context Architecture

Topics: Refs, Portals, and DOM Escape Hatches

Topics: Effects Deep Dive — Lifecycle, Dependencies, and Effect Events

Topics: Custom Hooks and Advanced Built-in Hooks

Topics: Error Boundaries, Suspense, Lazy Loading, and `use`

Topics: React 19 and 19.2 — Actions, Optimistic UI, Form Status, and Activity

Topics: React Router — Route Structure, URL State, and Navigation

Topics: React Router Data APIs — Loaders, Actions, Fetchers, Errors, and Pending UI

Topics: API Boundaries and TanStack Query v5 Queries

Topics: TanStack Query v5 Mutations, Invalidation, Optimistic Updates, and Infinite Data

Topics: Client State Architecture and Redux Toolkit

Topics: Advanced Forms — React Hook Form, Zod, Server Errors, and Accessibility

Topics: Component Architecture, Headless Patterns, Styling, Animation, and Internationalization

Topics: React Testing — Components, Network, Accessibility, Contracts, and E2E

Topics: Performance, React Compiler, Transitions, Deferred Values, and Activity

Topics: Server Rendering, Hydration, React Server Components, Security, and Production Capstone

Topics: Node.js Runtime Fundamentals, Versions, REPL, and Node vs Browser

Topics: Node Modules, `package.json`, npm, Semantic Versioning, and Workspaces

Topics: Process, Environment Variables, CLI Input/Output, Signals, and Exit Codes

Topics: Node Async Runtime — Event Loop, Timers, Microtasks, `nextTick`, and libuv

Topics: Node Errors, Stack Traces, Async Failures, Assertions, and Diagnostic Context

Topics: Filesystem, Paths, URLs, OS APIs, File Watching, and Safe File Handling

Topics: Buffers, Binary Data, Encodings, Streams, Pipelines, and Backpressure

Topics: Events, EventEmitter, EventTarget, AbortController, and Async Event Design

Topics: Native Node HTTP/HTTPS, Fetch, URLs, Headers, Keep-Alive, and Consuming APIs

Topics: Building REST APIs with Native Node — Contracts, Validation, Pagination, Idempotency, and Boundaries

Topics: Express as a Node Framework — App, Router, Middleware, Routing, and Error Handling

Topics: Node/Express API Security — Validation, CORS, Cookies, Sessions, Headers, Rate Limits, and Abuse Resistance

Topics: Authentication and Authorization in Node — Passwords, Sessions, JWTs, OAuth/OIDC, RBAC, and ABAC

Topics: Worker Threads, Child Processes, Cluster, IPC, and CPU-Bound Work

Topics: Testing Node Applications — `node:test`, Assertions, Mocks, HTTP Integration, Vitest/Jest, and E2E Boundaries

Topics: Node Debugging, Profiling, Memory Leaks, `--inspect`, `perf_hooks`, and APM

Topics: Production Node Operations — Configuration, Graceful Shutdown, Health, Logging, Process Managers, Containers, and Reliability

Topics: Node.js Production Capstone — CLI, HTTP API, Express, Workers, Testing, Security, and Operations

Topics: MongoDB Fundamentals — Documents, BSON, Atlas, Data Types, and When to Use MongoDB

Topics: MongoDB Data Modeling — Access Patterns, Embedding, Referencing, Schema Validation, and Anti-Patterns

Topics: MongoDB CRUD and Query Language — Filters, Operators, Arrays, Projection, Cursors, Bulk Writes, and Safe Updates

Topics: MongoDB Indexes and Query Plans — Compound, Multikey, Unique, TTL, Text, Geospatial, Partial, and `explain()`

Topics: MongoDB Aggregation — Pipelines, Expressions, `$match`, `$group`, `$unwind`, `$lookup`, `$facet`, and Optimization

Topics: MongoDB Consistency — Atomicity, Transactions, Sessions, Read Concern, Write Concern, Read Preference, and Retryable Operations

Topics: MongoDB Replica Sets and High Availability — Elections, Oplog, Failover, Read Scaling, and Recovery Semantics

Topics: MongoDB Sharding and Horizontal Scaling — Shard Keys, Chunks/Ranges, `mongos`, Balancing, Zones, and Hotspots

Topics: MongoDB Security — Authentication, RBAC, TLS, Network Controls, Encryption, Auditing, and Queryable Encryption

Topics: MongoDB Backup, Recovery, Monitoring, Profiling, Maintenance, and Operational Diagnostics

Topics: MongoDB Native Node.js Driver — MongoClient, Pools, BSON, Cursors, Sessions, Transactions, and Change Streams

Topics: Mongoose Deep Dive — Schemas, Models, Validation, Middleware, `lean()`, Populate, Transactions, Discriminators, and Concurrency

Topics: Advanced MongoDB Features — Change Streams, Time Series, GridFS, Geospatial, Search, Vector Search, and Specialized Workloads

Topics: Node.js + Express + MongoDB Production Architecture — Repositories, Services, Validation, Tenancy, Pagination, Transactions, and Shutdown

Topics: Node.js + MongoDB Production Capstone — Multi-Tenant API, Query Plans, Transactions, Search, Tests, Security, and Recovery

Topics: Full-Stack Architecture and the End-to-End Request Lifecycle

Topics: Contract-First HTTP APIs, Validation, Errors, and Compatibility

Topics: Authentication: Passwords, Sessions, Tokens, OAuth, and OIDC

Topics: Authorization: RBAC, ABAC, Ownership, and Multi-Tenant Isolation

Topics: Client State, Server State, and TanStack Query v5 Architecture

Topics: Forms, File Uploads, Email, and Background Workflows

Topics: Real-Time Delivery: SSE, WebSockets, Polling, Queues, and Presence

Topics: Full-Stack Testing: Unit, Integration, Contract, Component, and E2E

Topics: Full-Stack Security, Performance, Observability, and Reliability

Topics: Deployment, CI/CD, Migrations, Rollback, and Full-Stack Capstone

Topics: TypeScript Mental Model, Installation, Compiler, and Strict Configuration

Topics: Primitive Types, Literals, Inference, any, unknown, never, and void

Topics: Object Types, Type Aliases, Interfaces, Optionality, readonly, and Index Signatures

Topics: Unions, Intersections, Narrowing, Type Predicates, and Exhaustiveness

Topics: Functions, Callbacks, Rest Parameters, Overloads, this, and Callable Types

Topics: Classes, Constructors, Access Modifiers, Abstract Classes, and Composition

Topics: Generics, Constraints, Defaults, Inference, and Variance

Topics: keyof, typeof, Indexed Access, Tuples, and Type Relationships

Topics: Mapped Types, Modifiers, Key Remapping, and Template Literal Types

Topics: Conditional Types, infer, Distributivity, and Advanced Type Logic

Topics: Utility Types and Reusable Type Transformations

Topics: Modules, Namespaces, Declaration Files, and Global Augmentation

Topics: ESM, CommonJS, Module Resolution, Package Exports, and Project References

Topics: Decorators, Metadata, and Advanced Class Integration

Topics: Async TypeScript, Promises, Errors, Result Types, and Cancellation

Topics: Runtime Validation, Parsing, Branded IDs, and Trust Boundaries

Topics: React with TypeScript: Props, Events, Refs, Forms, and Generic Components

Topics: TanStack Query v5 with TypeScript: Query Options, Mutations, Infinite Data, and Cache Contracts

Topics: Node and Express with TypeScript: Request Boundaries, DTOs, Services, and Error Contracts

Topics: TypeScript Tooling, Testing Types, Linting, Builds, and Monorepos

Topics: TypeScript Capstone: Strict Domain Library and Full-Stack Vertical Slice

Topics: Relational Thinking, Tables, Rows, Columns, Domains, and Data Types

Topics: Schemas, CREATE TABLE, ALTER TABLE, DROP, and DDL Safety

Topics: Constraints: PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK, NOT NULL, and Referential Actions

Topics: INSERT, UPDATE, DELETE, UPSERT, RETURNING, and Safe Writes

Topics: SELECT, Projection, Filtering, Expressions, Ordering, LIMIT, and Pagination

Topics: NULL and Three-Valued Logic: IS NULL, COALESCE, CASE, and Correct Predicates

Topics: Aggregation: COUNT, SUM, AVG, MIN/MAX, GROUP BY, HAVING, and Conditional Aggregates

Topics: Joins: INNER, LEFT/RIGHT/FULL, CROSS, SELF, and Join Cardinality

Topics: Subqueries, EXISTS, IN, Correlated Queries, and LATERAL

Topics: CTEs, Recursive Queries, UNION/INTERSECT/EXCEPT, and Query Composition

Topics: Window Functions: PARTITION BY, ORDER BY, Frames, Ranking, and Running Analytics

Topics: Data Modeling, Functional Dependencies, and Normalization

Topics: Transactions and ACID: Atomicity, Consistency, Isolation, and Durability

Topics: Isolation Levels, MVCC, Locks, Lost Updates, Write Skew, and Deadlocks

Topics: Indexes: B-Tree, Hash, GIN, GiST, BRIN, Composite, Partial, and Expression Indexes

Topics: EXPLAIN, ANALYZE, Buffers, Cardinality Estimates, and Query Optimization

Topics: Views and Materialized Views: Stable Read Models and Precomputation

Topics: Functions, Procedures, Triggers, Generated Logic, and When to Keep Logic in SQL

Topics: Database Security: Roles, GRANT/REVOKE, Row-Level Security, Injection, and Secrets

Topics: PostgreSQL JSON/JSONB, Arrays, Range Types, Full-Text Search, and Specialized Data

Topics: Partitioning, Replication Concepts, Backup, Restore, Vacuum, and Operational SQL

Topics: SQL from Node.js: Pools, Parameters, Prepared Statements, Transactions, and Repository Boundaries

Topics: SQL Capstone: Schema Design, Transactions, Analytics, Security, and Query Tuning

Topics: Complexity Analysis, Big-O/Theta/Omega, Space, and Amortized Reasoning

Topics: Arrays, Dynamic Arrays, Strings, Matrices, and Memory Locality

Topics: Hash Tables, Maps, Sets, Frequency Counting, and Collision Reasoning

Topics: Two Pointers, Sliding Window, Prefix Sums, Difference Arrays, and Running State

Topics: Linked Lists: Singly, Doubly, Sentinel Nodes, Reversal, and Pointer Invariants

Topics: Stacks, Queues, Deques, Circular Buffers, and Expression Processing

Topics: Recursion, Call Stacks, Divide and Conquer, and Recurrence Reasoning

Topics: Binary Search and Monotonic Search Spaces

Topics: Elementary Sorting: Selection, Bubble, Insertion, Stability, and Invariants

Topics: Merge Sort, Quick Sort, Heap Sort, and Hybrid Trade-Offs

Topics: Trees, Terminology, Traversals, Height, Depth, and Recursive/Iterative DFS

Topics: Binary Search Trees, Balanced Trees, AVL/Red-Black Concepts, and Ordered Sets

Topics: Heaps and Priority Queues

Topics: Tries, Prefix Trees, Radix Ideas, and String-Key Search

Topics: Graph Representation, BFS, DFS, Components, and Cycle Detection

Topics: Topological Sorting, DAGs, Dependencies, and Strongly Connected Components

Topics: Shortest Paths I: Unweighted BFS and Dijkstra

Topics: Shortest Paths II: Bellman-Ford, Floyd-Warshall, 0-1 BFS, and DAG Paths

Topics: Minimum Spanning Trees: Kruskal, Prim, Cut Property, and Use Cases

Topics: Disjoint Set Union: Union-Find, Path Compression, Rank, and Connectivity

Topics: Greedy Algorithms: Exchange Arguments, Interval Scheduling, and Local Choices

Topics: Backtracking: Decision Trees, Pruning, Permutations, Combinations, and Constraint Search

Topics: Dynamic Programming I: State, Recurrence, Memoization, and Tabulation

Topics: Dynamic Programming II: Knapsack, Subsequences, Grids, and State Compression

Topics: Bit Manipulation, Bitmasks, XOR, Subsets, and Integer Caveats

Topics: Mathematics for DSA: GCD, Primes, Modular Arithmetic, Combinatorics, and Overflow

Topics: Monotonic Stacks and Monotonic Queues

Topics: Intervals, Sorting by Endpoints, Sweep Line, and Event Processing

Topics: Fenwick Trees, Segment Trees, Sparse Tables, and Range Query Design

Topics: String Matching: Naive Search, KMP, Prefix Function, Z, and Rabin-Karp

Topics: Selection, Quickselect, Reservoir Sampling, and Randomized Algorithms

Topics: Problem-Solving Patterns: Invariants, Constraints, Reduction, and Counterexamples

Topics: Timed DSA Checkpoint: Unseen Problems, Communication, and Review

Topics: Machine Coding Strategy: Requirement Extraction, Scope, and Timeboxing

Topics: Project Structure, Boundaries, and Incremental Architecture

Topics: Data Modeling, Normalization, Derived State, and Reducers

Topics: Reusable Components, Composition, Headless APIs, and Controlled State

Topics: Forms, Validation, Accessibility, and Interaction States

Topics: Async Data and TanStack Query v5 in Machine Coding

Topics: Performance: Rendering, Lists, Search, Memoization, and Virtualization

Topics: Testing Under Time Pressure: Behavior, Async, Accessibility, and Edge Cases

Topics: Debugging, DevTools, Error Boundaries, and Failure Recovery

Topics: Frontend Machine-Coding Challenge: Data Table / Dashboard

Topics: Full-Stack Machine-Coding Challenge: CRUD, Auth Context, and Persistence

Topics: Machine-Coding Review, Refactoring, Hardening, and Explanation

Topics: System Design Interview Method: Functional Requirements, Non-Functional Requirements, and Scope

Topics: Back-of-the-Envelope Estimation: Traffic, Storage, Bandwidth, QPS, and Concurrency

Topics: Networking Foundations for System Design: IP, TCP/UDP, TLS, HTTP, and Connection Costs

Topics: DNS, Naming, Service Discovery, and Global Traffic Routing

Topics: Proxies, Reverse Proxies, Load Balancers, and API Gateways

Topics: CDNs, Edge Caching, Static Assets, and Edge Compute

Topics: Scaling Compute: Vertical/Horizontal Scaling, Stateless Services, Autoscaling, and Load Shedding

Topics: Storage Model Selection: Relational, Document, Key-Value, Wide-Column, Graph, and Time-Series

Topics: Indexes, Access Patterns, Query Models, and Read/Write Amplification

Topics: Replication: Leaders, Followers, Multi-Leader, Quorums, and Replication Lag

Topics: Partitioning and Sharding: Keys, Rebalancing, Routing, and Hotspots

Topics: Consistency Models, CAP, PACELC, Quorums, and Session Guarantees

Topics: Caching I: Cache-Aside, Read-Through, Write-Through/Behind, and Cache Placement

Topics: Caching II: TTL, Eviction, Invalidation, Stampedes, Hot Keys, and Consistency

Topics: Queues, Message Brokers, Pub/Sub, and Streams

Topics: Service Communication: REST, RPC/gRPC, GraphQL, WebSockets, SSE, and Polling

Topics: Identifiers, Time, Ordering, UUIDs, Snowflake IDs, and Distributed Clocks

Topics: Rate Limiting, Quotas, Backpressure, and Admission Control

Topics: Reliability Patterns: Timeouts, Retries, Exponential Backoff, Jitter, Circuit Breakers, and Bulkheads