Engrain by ByteRush

Render vs commit: what React actually does when state changes

Sun, 01 Nov 2026 00:00:00 GMT

React elements are plain objects; rendering calls your components to describe the UI, and committing changes the DOM. Learn what triggers a re-render, and why a render is not a DOM update.

State as a snapshot, and batching: why setCount(count + 1) three times adds one

Sun, 01 Nov 2026 00:00:00 GMT

Each render sees a fixed snapshot of state. Learn updater functions, how React queues and batches updates (everywhere since React 18), when to use flushSync, and how to predict the result of several updates.

Conditional types and infer: types that make decisions

Sun, 01 Nov 2026 00:00:00 GMT

Write T extends U ? X : Y, understand why conditional types spread over unions and how to stop it, and pull types out of other types with infer.

Mapped types and key remapping: transforming every property at once

Sun, 01 Nov 2026 00:00:00 GMT

Build new object types from old ones with { [K in keyof T]: ... }, add or remove readonly and ?, rename keys with as, and drop keys by mapping them to never.

Implementing utility types: Pick, Omit, Exclude, Awaited and friends from scratch

Sun, 01 Nov 2026 00:00:00 GMT

Write the built-in utility types yourself, test types with Expect>, and learn why Omit breaks unions and how DistributiveOmit fixes it.

Typing hooks, reducers and context in React

Sun, 01 Nov 2026 00:00:00 GMT

Type useState with unions, useReducer with discriminated actions, useRef for DOM nodes and mutable values, context with a non-null guard hook, and custom hooks that return tuples.

Runtime validation at boundaries: types do not check your API

Sun, 01 Nov 2026 00:00:00 GMT

TypeScript types disappear at runtime, so JSON from fetch can be anything. Parse it with a schema (Zod), infer types from the schema, validate env vars and forms, and know end-to-end type tools.

Browser processes and navigation: what happens before the first byte of HTML

Sun, 01 Nov 2026 00:00:00 GMT

How a modern browser splits work into processes, why each site gets its own renderer, what happens step by step when you open a URL, and why one crashed tab does not take the browser down.

Parsing HTML and CSS: the DOM, the CSSOM and what blocks them

Sun, 01 Nov 2026 00:00:00 GMT

How the browser turns bytes into the DOM and CSSOM, why CSS blocks rendering and scripts block parsing, what the preload scanner does, and exactly when async, defer and module scripts run.

Style, layout, paint and composite: how a frame is made

Sun, 01 Nov 2026 00:00:00 GMT

The stages after the DOM and CSSOM: style calculation, layout, paint, raster and compositing on the GPU, and which CSS property changes rerun which stages, so animations stay smooth.

Forced synchronous layout and layout thrashing

Sun, 01 Nov 2026 00:00:00 GMT

Why reading offsetHeight right after changing a style forces the browser to lay out at once, how a loop of reads and writes thrashes, and how to fix it by batching reads before writes.

The critical rendering path: getting to the first paint sooner

Sun, 01 Nov 2026 00:00:00 GMT

What the browser needs before it can paint, how critical CSS and resource hints (preload, preconnect, dns-prefetch, modulepreload, fetchpriority) shorten the wait, font-display, and 103 Early Hints.

Efficient DOM updates: adding 10,000 rows without freezing the page

Sun, 01 Nov 2026 00:00:00 GMT

Batch DOM changes, build off-screen with DocumentFragment and template cloning, swap content with replaceChildren, know innerHTML's cost and risk, and skip off-screen work with virtualization and content-visibility.

IntersectionObserver: knowing what is on screen without scroll listeners

Sun, 01 Nov 2026 00:00:00 GMT

Use IntersectionObserver for lazy loading, infinite scroll sentinels and visibility analytics. How root, rootMargin and threshold work, and why its callbacks keep scrolling smooth.

Cookies in depth: every Set-Cookie attribute and when to use it

Sun, 01 Nov 2026 00:00:00 GMT

What Domain, Path, Expires, Max-Age, Secure, HttpOnly, SameSite and Partitioned really do, the __Host- prefix, size limits, and where third-party cookies stand in each browser today.

Web Workers, SharedArrayBuffer and cross-origin isolation

Sun, 01 Nov 2026 00:00:00 GMT

Move heavy work off the main thread with Web Workers: postMessage and structured cloning, transferable objects, module workers, what workers cannot touch, RPC wrappers, and why SharedArrayBuffer needs COOP and COEP.

The service worker lifecycle: install, wait, activate, and update safely

Sun, 01 Nov 2026 00:00:00 GMT

How a service worker registers, installs, waits and activates, what scope means, the trade-offs of skipWaiting and clients.claim, and how to show a "new version available" prompt so users are never stuck.

Caching strategies and offline: cache-first, network-first and stale-while-revalidate

Sun, 01 Nov 2026 00:00:00 GMT

Choose the right service worker caching strategy for each kind of request, precache with versioned URLs, serve an offline page, use navigation preload, and avoid bugs where users get stale content forever.

Forms in depth: validation, autocomplete and mobile keyboards

Sun, 01 Nov 2026 00:00:00 GMT

Use the Constraint Validation API for custom messages, autocomplete tokens so browsers fill forms, inputmode and enterkeyhint for the right mobile keyboard, FormData, and :user-invalid styling.

dialog, popover and details: modals and menus without a library

Sun, 01 Nov 2026 00:00:00 GMT

What

The cascade, specificity and inheritance: why that color won

Sun, 01 Nov 2026 00:00:00 GMT

The real order the cascade uses (origin and importance, layers, specificity, scope, order), how to calculate specificity, why !important flips layer order, and inherit, initial, unset, revert and revert-layer.

Custom properties and modern selectors: var(), @property, :is, :where, :has and nesting

Sun, 01 Nov 2026 00:00:00 GMT

How CSS custom properties inherit and resolve at use time, fallbacks, typed properties with @property, the difference between :is() and :where(), what :has() makes possible, and native CSS nesting.

Formatting contexts and margin collapsing: the rules behind odd gaps

Sun, 01 Nov 2026 00:00:00 GMT

Block and inline formatting contexts, what creates a block formatting context (flow-root, overflow, flex and grid), exactly how vertical margins collapse, and how floats are contained.

Positioning and containing blocks: why your fixed header moved

Sun, 01 Nov 2026 00:00:00 GMT

Which box each position value is placed against, why transform, filter and contain on an ancestor trap position: fixed, what sticky needs to work, and the inset shorthand.

Stacking contexts and z-index: why z-index: 9999 still loses

Sun, 01 Nov 2026 00:00:00 GMT

What creates a stacking context, how painting order works inside one, why a huge z-index cannot escape its parent's context, and how the top layer goes above everything.

Overflow, scrolling and containment: carousels and panels without JavaScript

Sun, 01 Nov 2026 00:00:00 GMT

Overflow values and scroll containers, CSS scroll snap for carousels, overscroll-behavior to stop scroll chaining, scrollbar-gutter to stop layout jumps, and CSS containment for performance.

Responsive images: srcset, sizes, picture and the right loading hints

Sun, 01 Nov 2026 00:00:00 GMT

How srcset with width descriptors and sizes lets the browser pick the right file, when to use density descriptors, picture for art direction and AVIF/WebP, lazy loading, decoding, fetchpriority, and why width and height matter.

Container queries and fluid design: components that fit wherever they go

Sun, 01 Nov 2026 00:00:00 GMT

Style components by the size of their container with container-type and @container, use container units, build fluid type with clamp(), and fix mobile 100vh bugs with svh, lvh and dvh.

HTTP semantics in depth: methods, status codes and negotiation

Sun, 01 Nov 2026 00:00:00 GMT

Which HTTP methods are safe and idempotent and why it matters, the status codes interviewers ask about (301/302/307/308, 401 vs 403, 409, 412, 422, 429), content negotiation, and compression with gzip, Brotli and zstd.

TCP, TLS and connection setup: the round trips before your first byte

Sun, 01 Nov 2026 00:00:00 GMT

Count the round trips before a request: the TCP handshake, the TLS 1.3 handshake and 0-RTT resumption with its replay risk, certificate chains, HSTS, and head-of-line blocking.

HTTP/1.1, HTTP/2 and HTTP/3: what changed and which old tricks still help

Sun, 01 Nov 2026 00:00:00 GMT

Why HTTP/1.1 needed domain sharding and sprites, how HTTP/2 multiplexes streams on one connection with HPACK, why server push was removed, and how HTTP/3 over QUIC fixes head-of-line blocking.

HTTP caching headers: Cache-Control, ETags and deploying without stale files

Sun, 01 Nov 2026 00:00:00 GMT

Read and write Cache-Control (max-age, s-maxage, no-cache vs no-store, private, immutable, stale-while-revalidate), validate with ETag and 304, understand heuristic freshness and Vary, and ship new JavaScript safely.

Cache layers: memory, disk, service worker, CDN and the back/forward cache

Sun, 01 Nov 2026 00:00:00 GMT

Every cache a request can hit, in order: memory and disk caches, the service worker, the CDN edge and its cache key. Plus versioned URLs vs purging, and the back/forward cache and what blocks it.

The same-origin policy: origins, sites and what one page may do to another

Sun, 01 Nov 2026 00:00:00 GMT

What an origin is (scheme, host, port) and how it differs from a site, what the same-origin policy blocks and what it still allows, and how to use postMessage safely with origin checks.

CORS in depth: preflights, credentials and fixing the errors

Sun, 01 Nov 2026 00:00:00 GMT

How CORS lets a server allow cross-origin reads, when the browser sends an OPTIONS preflight, every Access-Control header, why * cannot be used with cookies, why curl ignores CORS, and how to fix common errors.

REST API design for frontend engineers

Sun, 01 Nov 2026 00:00:00 GMT

Design APIs your UI can use well: resources and URLs, methods and status codes, problem-details errors (RFC 9457), offset vs cursor pagination, filtering, idempotency keys, versioning and the backend-for-frontend pattern.

Polling, long polling and Server-Sent Events

Sun, 01 Nov 2026 00:00:00 GMT

Get live updates from a server: the cost of short polling, how long polling works, Server-Sent Events with EventSource (the stream format, auto-reconnect, Last-Event-ID), SSE over HTTP/2, and SSE for streaming LLM tokens.

WebSockets: two-way real time that survives a bad network

Sun, 01 Nov 2026 00:00:00 GMT

How the WebSocket upgrade works, full-duplex messaging, heartbeats, reconnecting with backoff and resyncing missed messages, message ids and ordering, authentication on connect, scaling with sticky sessions and pub/sub, and WebTransport.

Request, Response, headers and bodies: fetch beyond the basics

Sun, 01 Nov 2026 00:00:00 GMT

The Request and Response objects behind fetch, why a body can be read only once (bodyUsed, clone), the credentials, mode, cache, redirect, keepalive and priority options, and a fetch wrapper with proper errors.

Client-side routing: the History API, the Navigation API, and SPA vs MPA

Sun, 01 Nov 2026 00:00:00 GMT

How client-side routing works with pushState and popstate, hash routing, why deep links 404 without a server fallback, scroll and focus after navigation, the Navigation API, SPA vs MPA vs islands, prefetching and speculation rules.

Tool calling: how a model asks your code to act

Sat, 31 Oct 2026 00:00:00 GMT

The model never runs your functions. It asks; your code runs the tool and sends the result back. Learn the tool-use loop, schemas, parallel calls and errors as results.

Callbacks and timers: telling JavaScript to do something later

Sat, 31 Oct 2026 00:00:00 GMT

Pass a function to run later, schedule it with setTimeout or setInterval, cancel it, and see why setTimeout(fn, 0) still runs after your other code.

Call stack and run-to-completion: why a long function freezes the page

Sat, 31 Oct 2026 00:00:00 GMT

JavaScript runs one function at a time on a call stack, and finishes it before anything else runs. That is why a long loop freezes the page.

Tasks and the task queue: how the event loop picks what runs next

Sat, 31 Oct 2026 00:00:00 GMT

Timers, clicks and messages become tasks. The event loop runs one task at a time, which is why setTimeout(fn, 0) never means 0 ms.

Microtasks: why promise callbacks run before timers

Sat, 31 Oct 2026 00:00:00 GMT

Promise callbacks are microtasks. They all run right after the current task, before any timer — which explains most event-loop interview puzzles.

Rendering steps: where requestAnimationFrame fits in the event loop

Sat, 31 Oct 2026 00:00:00 GMT

The browser paints between tasks, at the screen's refresh rate. requestAnimationFrame runs your code right before that paint — the right place for animation.

async/await in the event loop: what really happens at each await

Sat, 31 Oct 2026 00:00:00 GMT

await pauses only the async function and resumes it in a microtask. See why code after await runs later, and why forEach does not wait.

The Node.js event loop: phases, setImmediate and process.nextTick

Sat, 31 Oct 2026 00:00:00 GMT

Node.js runs its event loop in phases. Learn the phase order, why setImmediate beats setTimeout inside I/O callbacks, and where nextTick fits.

Yielding to the main thread: keep pages responsive during heavy work

Sat, 31 Oct 2026 00:00:00 GMT

Long tasks make clicks wait and hurt INP. Split work into chunks, yield with scheduler.yield or a timer, and know what React's scheduler does.

Lexical scope and the scope chain: where JavaScript looks for a variable

Sat, 31 Oct 2026 00:00:00 GMT

A variable is found by where the code is written, not where it is called. Learn global, module, function and block scope, the scope chain and shadowing.

Hoisting and the temporal dead zone: why some names exist before their line

Sat, 31 Oct 2026 00:00:00 GMT

JavaScript sets up every name in a scope before running it. Learn what var, function, let and const look like before their line, and what the TDZ is.

Closures: functions that remember where they were made

Sat, 31 Oct 2026 00:00:00 GMT

A closure is a function plus the variables around it. Use closures for private state, understand the var-in-a-loop trap, and write once().

Closures and memory: how a small function can keep big data alive

Sat, 31 Oct 2026 00:00:00 GMT

A closure keeps its variables alive as long as it lives. See how forgotten listeners leak memory, a V8 detail that surprises people, and how to find leaks.

Strict mode and the global object: turning silent mistakes into errors

Sat, 31 Oct 2026 00:00:00 GMT

Strict mode makes typos and failed writes throw instead of failing silently. Modules and classes are strict by default. Learn what changes, and globalThis.

The four rules of this: how JavaScript decides what this is

Sat, 31 Oct 2026 00:00:00 GMT

this is set by how a function is called, not where it is written. Learn the four binding rules, their order, and why passing a method as a callback loses this.

Arrow functions and lexical this: when to use them, and when not to

Sat, 31 Oct 2026 00:00:00 GMT

Arrow functions take this from the code around them. That fixes callbacks inside methods, breaks object methods, and costs memory as class fields.

call, apply and bind in depth — and how to write bind yourself

Sat, 31 Oct 2026 00:00:00 GMT

call and apply run a function now with a chosen this; bind returns a new function. Learn partial application, why bound functions stay bound, and new on them.

Prototypes and the prototype chain: where an object finds what it does not have

Sat, 31 Oct 2026 00:00:00 GMT

Every object links to a prototype. Property lookup walks that chain until it finds the name or reaches null. Learn own vs inherited and __proto__ vs prototype.

What new really does: constructors, instanceof and Object.create

Sat, 31 Oct 2026 00:00:00 GMT

new creates an object, links it to the constructor's prototype, runs the constructor, and returns the object. Build new and instanceof yourself.

Classes: private fields, static members and inheritance, built on prototypes

Sat, 31 Oct 2026 00:00:00 GMT

class is a cleaner way to write constructors and prototypes, plus real private fields. Learn methods, #private, static, getters, extends, super and brand checks.

Primitive types and typeof: the seven primitives and the null surprise

Sat, 31 Oct 2026 00:00:00 GMT

JavaScript has seven primitive types plus objects. Learn what typeof returns for each, why typeof null is 'object', and how primitives get methods.

Type coercion and ToPrimitive: how JavaScript converts values for you

Sat, 31 Oct 2026 00:00:00 GMT

When types do not match, JavaScript converts them to numbers, strings or booleans. Learn the rules, why + is special, and how objects become primitives.

Equality in JavaScript: ==, ===, Object.is and SameValueZero

Sat, 31 Oct 2026 00:00:00 GMT

JavaScript has four kinds of equality. Learn the == steps, why NaN !== NaN, how +0 and -0 differ, and which one includes, Map and Set use.

Numbers in JavaScript: why 0.1 + 0.2 is not 0.3, and how to handle money

Sat, 31 Oct 2026 00:00:00 GMT

JavaScript numbers are 64-bit floating point. Learn why decimals drift, the safe integer limit, parseInt traps, BigInt, and how to store money in paise or cents.

Map, Set, WeakMap and WeakRef: choosing the right collection

Sat, 31 Oct 2026 00:00:00 GMT

Map takes any key and keeps order; Set keeps unique values and now has union and intersection; WeakMap keys objects without keeping them alive.

Shallow vs deep copy: why changing a copy changed the original

Sat, 31 Oct 2026 00:00:00 GMT

Spread and Object.assign copy only the top level. Learn reference semantics, what structuredClone can and cannot copy, and why a JSON round-trip loses data.

Higher-order functions and composition: building pipelines from small functions

Sat, 31 Oct 2026 00:00:00 GMT

Functions that take or return functions power map, filter, reduce, middleware and React hooks. Learn to compose small steps with pipe and compose.

Currying and partial application: fixing some arguments now, the rest later

Sat, 31 Oct 2026 00:00:00 GMT

Currying turns f(a, b, c) into f(a)(b)(c); partial application fixes some arguments up front. Learn both, fn.length and its limits, and write curry.

Memoization: caching results without caching your bugs

Sat, 31 Oct 2026 00:00:00 GMT

Memoization stores a function's results by input. Learn cache keys, eviction, memoizing async functions safely, and when caching makes things worse.

Recursion and the stack: when a function calls itself

Sat, 31 Oct 2026 00:00:00 GMT

Recursion solves nested problems in a few lines. Learn base cases, tree walks, stack depth limits, tail calls, and how to rewrite recursion with your own stack.

Destructuring, spread, rest and defaults: modern syntax you read every day

Sat, 31 Oct 2026 00:00:00 GMT

Unpack objects and arrays, collect extra arguments, copy with spread, and know when default values run. With the traps interviewers ask about.

Optional chaining and ??: safe access without hiding real values

Sat, 31 Oct 2026 00:00:00 GMT

Read nested data that may be missing with ?., pick fallbacks with ?? instead of ||, and use ??=, ||= and &&=. With the 0 and empty-string traps.

ES modules: import, export and live bindings

Sat, 31 Oct 2026 00:00:00 GMT

How import and export really work: named and default exports, live bindings, why modules are strict and deferred, and why each module runs only once.

CommonJS vs ES modules: require, import and making them work together

Sat, 31 Oct 2026 00:00:00 GMT

Why require and import behave differently, how Node.js decides which one a file uses, require(esm) in current Node.js, and how dual packages use the exports field.

Dynamic import, top-level await and code splitting

Sat, 31 Oct 2026 00:00:00 GMT

Load code only when it is needed with import(). How bundlers split routes, why top-level await delays every importer, and what import maps and import attributes do.

Promise internals: states, reactions and resolution

Sat, 31 Oct 2026 00:00:00 GMT

What a promise really is: three states, settling once, reaction jobs, then() returning a new promise, errors that skip ahead, and why resolving with a promise costs extra ticks.

Error handling in async code: where errors go, and where they get lost

Sat, 31 Oct 2026 00:00:00 GMT

Place catch and finally correctly, avoid forgotten awaits, know why return await matters inside try, and what browsers and Node.js do with unhandled rejections.

Promise combinators: all, allSettled, race and any

Sat, 31 Oct 2026 00:00:00 GMT

Pick the right way to wait for many promises. How Promise.all fails fast, what allSettled, race and any return, their empty-array cases, and how to write Promise.all.

Cancellation with AbortController: stopping work nobody needs

Sat, 31 Oct 2026 00:00:00 GMT

Cancel fetch requests and your own async functions with AbortController and AbortSignal. Timeouts with AbortSignal.timeout, combining signals with any, and cleanup in React effects.

Race conditions in the UI: when the old answer arrives last

Sat, 31 Oct 2026 00:00:00 GMT

Why a search box shows results for an older query, and how to fix it: last-request-wins with abort or request IDs, debounce races, optimistic updates with rollback, and double-submit guards.

Retry, timeout and backoff: failing well when the network does not

Sat, 31 Oct 2026 00:00:00 GMT

Retry only safe operations, wait longer each time with exponential backoff and jitter, respect Retry-After, and use timeouts that really stop the work.

Concurrency control: run many async tasks, but not all at once

Sat, 31 Oct 2026 00:00:00 GMT

Promise.all on 500 uploads gets you rate-limited; one at a time is too slow. Build a promise pool that runs N at a time and keeps results in order.

Garbage collection: how JavaScript frees memory you no longer use

Sat, 31 Oct 2026 00:00:00 GMT

Reachability, mark-and-sweep, V8's young and old generations, concurrent marking in Orinoco, and why GC pauses cause jank. Explained with a runnable demo.

Finding and fixing memory leaks in a single-page app

Sat, 31 Oct 2026 00:00:00 GMT

The common leaks (listeners, timers, closures, detached DOM, unbounded caches), how to prove them with heap snapshots and the allocation timeline, and how to stop them on route change.

Error types, cause and custom errors: errors that tell you what went wrong

Sat, 31 Oct 2026 00:00:00 GMT

The built-in error types, wrapping errors with cause, writing custom error classes that work with instanceof, AggregateError, Error.isError, and why you never throw strings.

Global error handling and source maps: seeing the errors your users see

Sat, 31 Oct 2026 00:00:00 GMT

Catch every uncaught error with the error and unhandledrejection events, fix the cross-origin "Script error.", read minified stack traces with source maps, and report errors safely.

Discriminated unions and exhaustive checks: making illegal states impossible

Sat, 31 Oct 2026 00:00:00 GMT

Model loading, success and error states with a tag field, let TypeScript narrow each case, and use never so the compiler tells you about every case you forgot.

Type guards and assertion functions: teaching TypeScript what you checked

Sat, 31 Oct 2026 00:00:00 GMT

Write x is T type predicates and asserts functions, know when TypeScript 5.5 infers predicates for you, and filter arrays to the right type, without lying to the compiler.

as const, satisfies and literal inference: precise types without lying

Sat, 31 Oct 2026 00:00:00 GMT

Why TypeScript widens "md" to string, how as const keeps literal types, how satisfies checks a value without losing its type, and why as is an assertion, not a conversion.

keyof, typeof and indexed access: building types from your values

Sat, 31 Oct 2026 00:00:00 GMT

Derive types from data instead of writing them twice: keyof for property names, typeof in type position, T[K] to read a property's type, and T[number] for array items.