#Performance
17 articles — newest first.
- 8 min read
When useMemo actually helps in React 19, and how to measure it
A blunt, practical guide to useMemo in React 19: where it genuinely helps, where it’s noise, and how to profile renders before you cargo‑cult memoization.
- 8 min read
Flamegraphs over Tauri IPC: from Rust event to React paint
A practical, end-to-end method to profile Tauri apps: correlate Rust spans with React paints, align clocks, and read a single cross-IPC flamegraph.
- 9 min read
Pinning a 1.8% Idle CPU: Evented vs Polling in Tauri Tray Apps
A ruthless, code-first look at hitting a ~1.8% idle CPU budget in long‑running Tauri tray apps by replacing polling with event‑driven plumbing.
- 7 min read
Crossbeam SPSC ring buffers for 60 FPS Rust audio meters
Build a zero-allocation, lock-free SPSC ring buffer with crossbeam to stream audio metering data to a 60 FPS UI in Rust without contention.
- 7 min read
A reproducible RAM-regression workflow in Rust with dhat + heaptrack
A practical, deterministic workflow to catch and bisect memory regressions in a Rust media pipeline using dhat for budgets and heaptrack for call stacks.
- 8 min read
Halving Tauri v2 IPC: Batch Events + rmp-serde MessagePack
Cut Tauri v2 Rust↔WebView IPC overhead by batching events and serializing with rmp-serde MessagePack, with concrete code for both sides.
- 6 min read
serde_json to simd-json in streamerOS IPC: hot-path deserialization
We replaced serde_json with simd-json in streamerOS’s IPC layer and benchmarked the deserialize hot path, showing where SIMD wins and where it doesn’t.
- 8 min read
Tauri v2 + tokio-console: 1.8% CPU with 4 concurrent streams
A field-tested workflow to profile and tune a Tauri v2 Rust backend using tokio-console, slashing wake storms and sustaining 1.8% CPU across 4 streams.
- 7 min read
Custom Serialization Adapters: 94% Payload Compression
Rich UI objects make terrible database records. The Serialization Adapter pattern that separates render model from transport record — and cut IntegrateX payloads by 94%.
- 8 min read
Redis Caching Strategies That Don't Serve Stale Data
On a busy portal I learned Redis caching strategies live or die on details: one interceptor boundary, cache-aside vs write-through, TTL jitter, stampede guards.
- 7 min read
MongoDB Aggregation Pipelines: Stage Order Is the Win
Profiling a clinical workflow API taught me MongoDB aggregation lives or dies on stage order: $match first on indexes, $lookup treated as the join it is, then read explain.
- 6 min read
React useMemo: Measured Wins, Not Cargo-Cult Habit
In React reviews, useMemo is the hook I see cargo-culted most: what it truly costs, the two cases that justify it, and why I open the Profiler before memoizing.
- 8 min read
Adaptive Extended Thinking: Trading Latency for Compute
Reasoning isn't free. Adaptive extended thinking lets Claude spend tokens proportional to difficulty — tune budget_tokens per task tier so hard problems get depth and easy ones stay fast.
- 8 min read
Compressing the Wire: A 94% Payload Reduction in React Flow
Node-graph editors serialize enormous JSON. A custom Serialization Adapter pattern that separates the React Flow render model from the transport record cut IntegrateX payloads by 94%.
- 7 min read
Semantic Caching That Actually Hits: Matching Meaning at the Edge
The streamerOS support agent kept re-answering the same question phrased ten ways, so I built a semantic cache that matches meaning, not the string.
- 6 min read
Cutting a Payload 94% With Custom Serialization Patterns
I cut a React Flow agent-graph payload 94% without losing a node — not with gzip, but by shaping a custom serialization format around the data: schema, not prose.
- 6 min read
Latency-First AI: Streaming from the Edge with Hono
Users forgive a wrong answer faster than a slow one. Latency-first AI streams the first token in under 300ms from the edge — Hono on Workers, parallel retrieval, and semantic caching — instead of a monolith waiting to think.