Web Development, Performance, Distributed Systems, APIs, Databases, Backend Engineering — Daily Update 2026-11-02
WebAssembly: Component Model & WasmGC
WebAssembly Component Model — WIT, wit-bindgen, Component Linking
The Component Model (standardized in WebAssembly Community Group) is the missing link for polyglot Wasm. Instead of ad-hoc JS glue, components declare interfaces in WIT (Wasm Interface Types):
// math.wit
package math:calculator@1.0.0;
interface calculator {
add: func(a: s32, b: s32) -> s32;
multiply: func(a: s32, b: s32) -> s32;
}
world calculator-world {
export calculator;
import log: func(msg: string);
}
wit-bindgen generates bindings for Rust, Go, TypeScript, Python, C#, Java. Components link at load time — no JS shim. A Rust component can call a Go component via canonical ABI.
Toolchain Status (Nov 2026)
| Tool | Status | Languages |
|---|---|---|
wasm-tools (component) |
Stable | Component compose, link, validate |
wit-bindgen |
0.35 (stable) | Rust, Go, TS, Python, C#, Java, C++ |
cargo component |
Stable | Rust component build |
go:wasmcomponent |
Beta | Go 1.23+ component target |
jco (Bytecode Alliance) |
Stable | JS/TS component runtime |
wasmtime / wasmedge |
Stable | Component execution (server) |
Production Use Case: Plugin Architecture
Replace dynamic loading (dlopen, plugin crates, WASM imports) with components:
- Host defines WIT world (exports host functions, imports plugin interface).
- Plugins compile to
.wasmcomponent. - Host loads via
wasmtime::component::Linker— sandboxed, typed, no memory safety risk.
Used in: Envoy Wasm filters (proxy-wasm ABI migrating to Component Model), Spin (Fermyon serverless), Extism (plugin SDK).
WasmGC — Managed Language Support Without Bundling Runtime
WasmGC (Garbage Collection) adds struct, array, i31 (reference types) to Wasm. Languages with GC (Kotlin, Dart, Java, C#, OCaml) compile to WasmGC without bundling their GC — browser/host provides it.
// Before WasmGC: Kotlin compiles to Wasm + bundles GC (~2MB)
// After WasmGC: Kotlin compiles to WasmGC (~200KB), uses host GC
Chrome 131+, Firefox 133+, Safari TP 203 support WasmGC. Node 23 (V8 13.1) enables by default. Production readiness: Kotlin/WasmGA, Dart/WasmGC, TeaVM (Java) — all shipping production apps. .NET 9 (Nov 2026) targets WasmGC.
SQLite as Application Database — Not Just for Embedded
Why SQLite in 2026
- Zero ops: No server, no config, no connections, no pooling. File = database.
- WAL mode:
PRAGMA journal_mode=WAL— concurrent readers, single writer, no lock contention for read-heavy workloads. - JSON1, FTS5, RTREE: Built-in extensions — document store, full-text search, geospatial.
- Vacuuming:
PRAGMA auto_vacuum=INCREMENTAL— no downtime. - Backup:
sqlite3 backupAPI — online, consistent, streaming to S3.
When It Works (and When It Doesn’t)
| Workload | Fit | Notes |
|---|---|---|
| Single-node app, < 100GB, read-heavy | Excellent | Most SaaS, internal tools, edge |
| Multi-node, write-heavy | Poor | Use PostgreSQL, CockroachDB |
| High concurrency writes (> 100 TPS) | Limited | Single writer bottleneck |
| Analytics / OLAP | Good (DuckDB) | DuckDB reads SQLite files directly |
| Edge / serverless / mobile | Excellent | Turso (libSQL), Cloudflare D1 |
libSQL / Turso — SQLite for Distributed
libSQL (Turso fork) adds: native replication (leader-follower), HTTP/WebSocket access, embedded replicas (read locally, write to primary), vector search (vector type). libsql_client for Node/Python/Go/Rust.
// Turso HTTP API
const db = createClient({ url: 'libsql://mydb.turso.io', authToken: '...' });
await db.execute('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, embedding VECTOR(384))');
await db.execute('INSERT INTO users (name, embedding) VALUES (?, ?)', ['alice', new Float32Array(384)]);
const results = await db.execute('SELECT * FROM users WHERE embedding MATCH ? AND name = ?', [queryVec, 'alice']);
// Vector similarity search in SQLite!
Optimistic UI Patterns — Latency Compensation That Works
The Pattern
- User action (click, submit) → immediately update local state (optimistic).
- Send request to server in background.
- On success: confirm (no-op if server returns same state).
- On failure: rollback to previous state + show error + offer retry.
Implementation: React + TanStack Query (or SWR)
function useOptimisticMutation(mutationFn, { onMutate, onError, onSettled }) {
const queryClient = useQueryClient();
return useMutation(mutationFn, {
onMutate: async (variables) => {
await queryClient.cancelQueries({ queryKey: onMutate.key });
const previous = queryClient.getQueryData(onMutate.key);
queryClient.setQueryData(onMutate.key, (old) => onMutate.updater(old, variables));
return { previous };
},
onError: (err, variables, context) => {
queryClient.setQueryData(onMutate.key, context.previous);
onError?.(err);
},
onSettled: () => {
queryClient.invalidateQueries({ queryKey: onMutate.key });
onSettled?.();
},
});
}
// Usage
const { mutate } = useOptimisticMutation(api.updateTodo, {
key: ['todos'],
updater: (old, { id, ...changes }) => old.map(t => t.id === id ? { ...t, ...changes } : t),
onError: (err) => toast.error('Failed to update: ' + err.message),
});
Critical: Server Must Return Canonical State
Optimistic update assumes server returns the authoritative result. If server transforms data (e.g., sanitizes, adds computed fields, assigns IDs), the client must replace optimistic state with server response — not merge. onSettled invalidation handles this.
Idempotency + Optimistic UI = Bulletproof
Combine with idempotency keys (Article 2). Retry on network error doesn’t duplicate server-side mutation. Client can safely re-send; server returns same canonical response; UI stays consistent.
The Cost of Coordination — Why Distributed Systems Are Hard
Coordination = achieving agreement across nodes. Every coordination primitive has a cost.
| Primitive | Typical Latency | Throughput Limit | Failure Mode |
|---|---|---|---|
| Distributed lock (etcd/Consul) | 2-5ms (same AZ) | ~1000 ops/sec | Lock holder dies → TTL expiry delay |
| Consensus (Raft/Paxos) | 5-20ms (3-node) | ~5000 ops/sec | Leader election ~100-500ms |
| 2PC (distributed transaction) | 10-50ms | ~1000 txn/sec | Coordinator failure = blocked |
| Saga (choreography) | Async (ms-sec) | Unlimited | Compensation complexity |
| CRDT (conflict-free) | Local (0ms) | Unlimited | Merge semantics, not all types |
The Coordination Tax
Each coordination point adds latency variance (tail latency), reduces availability (CAP), and increases cognitive load. Design principle: minimize coordination — push to edges, use eventual consistency, accept conflicts and resolve asynchronously.
Patterns to Reduce Coordination
- Partition by identity — User data stays on one shard (no cross-shard transactions).
- Event sourcing — Append-only log; projections rebuild asynchronously.
- CQRS — Separate read/write models; reads from replicas, writes to primary.
- Optimistic concurrency — Version numbers,
WHERE version = X— no locks. - Idempotency + retry — Replace coordination with commutativity.
TL;DR — Action Items This Week
| Area | Action | Effort |
|---|---|---|
| Wasm | Evaluate Component Model for plugin/extension system (replace ad-hoc WASM) | High |
| Wasm | Test WasmGC target for Kotlin/Dart/Go — measure bundle size reduction | Medium |
| Database | Prototype SQLite + libSQL for new microservice (read-heavy, single-node) | Medium |
| Frontend | Add optimistic updates to high-latency mutations (TanStack Query pattern) | Low |
| Architecture | Audit coordination points in critical path — can any become async/eventual? | High |
Next daily update: 2026-11-03. Subscribe to the Backend Engineering category for direct delivery.