跳到主要内容

31 篇文档带有标签「quadrant:platform」

查看所有标签

Batch Processing

Spark: the shuffle, the DAG and the cost of a wide transformation.

CDN

Edge delivery as a tiered cache: anycast ingress, origin shield, cache key, purge propagation, edge TLS and multi-CDN steering, plus the failures that look like origin bugs.

CI/CD

GitHub Actions and Jenkins: pipeline stages, caching and the failure modes of a shared runner.

DNS

The delegation chain, resolver roles, record types and TTL rules that decide why a name resolves or silently does not.

DNSSEC and DNS Operations

The DS/DNSKEY/RRSIG chain, why validation fails, and the TTL, registrar and migration sequencing that keeps a zone resolvable.

Docker

An image is a stack of layers, a container is one process; how to build, run and review one without leaking the toolchain into production.

DOM and Events

The document object model as a programming surface: node types, query and mutation APIs, the capture and bubble flow, delegation, observers and shadow roots.

Ecosystem: Standard Library

Node core modules as a surface: fs in three styles, Buffer, streams and backpressure, HTTP and net, worker threads, child processes, and the errno conventions that carry through.

Global Traffic Management

Cross-region steering with GeoDNS, latency-based routing, GSLB and anycast, where failover is bounded by DNS TTL and active-active capacity assumptions break first.

Health Checks and Draining

Probe design and the exit path: liveness versus readiness, active and passive detection thresholds, draining in-flight requests, and failures that remove every backend at once.

HTTP Caching

Freshness, validators and the shared-versus-private split: how Cache-Control directives, Vary and conditional requests decide reuse, and where invalidation fails.

Kubernetes

The control plane and the pod lifecycle: how a declared state becomes running containers.

Lakehouse

Iceberg and Delta Lake: table formats that bring ACID and time travel to object storage.

Load Balancing

Connection and request distribution: what L4 and L7 can see, how NAT, DSR and PROXY protocol move traffic, where TLS terminates, and why affinity blocks scale-out.

Messaging & Events

Kafka, RabbitMQ and Pulsar: the log, the queue and the delivery guarantees between them.

Navigation and Network

How an address becomes a document: navigation steps, the History API, back-forward cache, Fetch options, CORS preflight, and the HTTP cache headers that decide reuse.

Network Metrics

Which network signals to instrument, how to aggregate them honestly, and how to turn RTT, retransmits and handshakes into SLOs that page early.

NoSQL Databases

Redis, MongoDB and Neo4j: the data models that justify giving up a relational schema.

Private Registry

Nexus and Verdaccio: hosting private packages, proxying upstreams and controlling what a build can resolve.

Relational Databases

PostgreSQL and MySQL: the relational model, the planner and the operational differences between them.

Rendering Pipeline

From bytes to pixels: parsing, the render tree, layout, paint and compositing, which properties trigger which stage, and the long task and layout thrash that break the frame budget.

Runtime

Node.js on V8 and libuv: the event loop, the thread pool and the boundary between JavaScript and the OS.

Runtime: Class Loading

The class file, the loading and linking phases, class loader hierarchy, reflection and the leaks a class loader can hold.

Runtime: JIT and Threads

Tiered compilation, inlining and deoptimization, safepoints, the Java Memory Model and how virtual threads change the cost of blocking.

Runtime: Memory and GC

Runtime data areas, allocation, the garbage collectors compared, pause budgets and the OOM types that follow.

Service Mesh

Istio and Envoy: moving retries, mTLS and telemetry out of the application.

Storage

Cookies, local and session storage, IndexedDB and the cache API: scope, lifetime, quota, eviction, and the one decision that matters most, where a session token lives.

Vector Search

pgvector and Milvus: approximate nearest-neighbour indexes and the recall/latency trade-off.