Skip to content
academia.sh
tr
Log in

Course Advanced

Rendering Strategies and Infrastructure

By the end of this course

Start course

01

Rendering Models

Producing markup on the client, on the server, at build time, or at the edge; incremental regeneration, hydration and streaming, and the criteria for choosing among these models.

  1. 01 Client-Side Rendering Producing markup in the browser; what the empty shell carries, the serial request chain leading up to first content, and the trade-off between the cost this model pays at first paint and the speed it gains on subsequent navigation.
  2. 02 Server-Side Rendering Producing markup while answering a request; how time to first byte grows, the serial request chain collapsing to a single round trip, the round trip's weight, and the computation cost the server pays per request.
  3. 03 Static Site Generation Producing markup at build time and writing it to a file; the same template called at two separate moments, build duration that grows linearly with the page count, and static output's freshness limit.
  4. 04 Incremental Regeneration Selective refreshing of static output; the freshness window, the background revalidation queue, miss–hit counting, and the trade-off window length sets up between production load and content delay.
  5. 05 Hydration and Streaming Server-produced markup gaining interactivity on the client; hydration's cost, its partial and lazy forms, moving the first byte earlier with chunked delivery, and the balance the two techniques strike together.
  6. 06 Edge Rendering Bringing rendering geographically closer to the user; converting distance into latency, the edge node's passthrough, combination, and full-production forms, the edge runtime's constraints, and the question of where the data sits.
  7. 07 Strategy Selection Choosing the rendering model per page; tying the content freshness, personalization, and scale axes to measurement, a sequential decision rule, and comparing uniform policies against the mixed policy by daily work and violation count.

02

Build and Bundling

The source tree turning into executable output; producing chunks from the dependency graph, code splitting, tree shaking, the asset pipeline, content-hashed naming, the development server, and build-time configuration.

  1. 01 Module Bundling The source tree turning into an executable output; extracting the dependency graph from entry points, evaluation order, producing output chunks by usage signature, and the runtime inside a chunk.
  2. 02 Code Splitting Separating static and dynamic edges; determining chunk roots, computing what downloads at first load versus later, per-request cost, and merging over-split chunks.
  3. 03 Tree Shaking Bringing the graph down from module level to name level; propagation of live exports, the module with side effects that cannot be eliminated, the three settings of the package manifest's side-effect declaration, and the source syntaxes that block elimination.
  4. 04 Asset Processing Images, fonts, and static files entering the build output; extracting asset links into the graph as nodes, the embed-threshold decision, rewriting references, the asset manifest, and the directly copied directory.
  5. 05 Cache Busting Binding the file name to its content; hash generation and determinism, the chained change of the hash across dependent chunks, breaking the chain with an import map, and cache policy by name.
  6. 06 Development Server The compile's second mode; transforming and serving modules on request, reuse via a validator, modeling hot module replacement as invalidation propagation, and the correctness conditions of the accept boundary.
  7. 07 Environment Configuration How build-time variables enter the output; the constants substitution produces, every value that reaches the client bundle being public, turning the passable-versus-not-passable distinction into an auditable rule, and the trade-off of runtime configuration.

03

Deployment

Getting build output to the user; static hosting over a content delivery network, deployment forms that require a server process, per-change preview environments, gradual rollout with automated rollback, and packaging for non-web targets.

  1. 01 Static Hosting Publishing build output without a server process; measuring the edge cache's hit, miss, validated, and refreshed states, converting a name-based cache policy into request and byte hit ratios, invalidation, and path resolution.
  2. 02 Server-Requiring Deployment The hosting forms for code that runs at request time; measuring the long-lived process, per-request instance, and edge runtime along the axes of cold start, latency, reserved capacity, and state, plus the readiness endpoint and graceful shutdown sequence.
  3. 03 Preview Deployments Producing a separate environment for every change; a deterministic deployment id derived from content, a content-addressed store that shares blobs, previews served side by side with the release, data and side-effect isolation, and how long deployments live.
  4. 04 Gradual Rollout and Rollback Bounding release risk with a share of traffic; sticky assignment, an observation window, and a noise-resistant threshold for automatic rollback, atomic version switching through a pointer change, and handling non-revertible changes with an expand-contract sequence.
  5. 05 Non-Web Targets Distributing the same build output through a desktop shell, a web view embedded in a native body, and an app store package; auditing the broken root assumption, narrowing the bridge surface, and the divergence between shell and content versions.

Start typing to search.

↑↓ ↵ Esc navigate · open · close