Author's Note: The intro is written as cyberpunk fiction because writing tech blogs can be fun. If you're here just for compression benchmarks and UI state management, skip to the technical bits.
Sure, Your UI State is Immutable, But Have You Tried Just gzipping Everything
Posted from Terminal #8675309, Corporate Refresh Pod B-42 Compliance Notice: This post contains 0.03% unauthorized cognitive surplus, within acceptable limits
I was working on an R&D project exploring a different take on search filtering: instead of converting filter parameters directly into SQL, what if we materialized query results at each filtering layer? The idea was that adding filters, undo, and redo would be lightning fast. The backend would already have the intermediate results ready.
The first prototype was built around undo/redo of a list of filters. I needed two things: fast operations when users hit undo/redo, and a way to identify different versions of the filter list for cache keys. The path of least resistance led me to an immutable list backed by a tree structure. This meant storing pointers to list tails in the undo/redo system for instant navigation between states. The raw pointers became the cache keys (prefixed by the user session, of course).
Following that architectural decision, we built a UI that literally showed a stack of filters you could rearrange -- making it obvious that filter order mattered. Each filter got its own specialized input: price ranges with sliders plus direct text input, category selection with checkboxes and a search box for filtering many options, and so on. The code kept growing.
Then during my approved cognitive innovation window (thank you, HR, for the generous three-minute allotment), I tuned into some chatter on a back net bulletin. They were showing off an UI experiment of their own. They implemented a recursive descent parser and picked for their example a search DSL that could handle everything our UI did, but in a single textbox. We're talking field-specific searches like price:10..20, quoted phrases with "neural implants", even complex logical operations like (category:"neural implants" OR category:"ice ") AND price:<100 AND legal:maybe. Clever integration of the Monaco text editor gave free grammar aware completions as you typed. Look at that. Clean. Simple. Dangerous in its elegance.
I was drowing in my sea of UI component code. Of course a synapse fired. What if I ditched the immutable data structure system entirely? What if each filter stack state was just... a string? When users hit undo/redo, we'd parse the string into our UI state. On paper, it seemed feasible -- we have a 16ms budget for undo operations to feel instant, and even a complex filter stack might only be 1-2KB of text. Our hero didn't benchmark their parser but sniff test it could't be more than a couple hundred mikes. Store a few thousand of those strings for undo history, and we're still talking reasonable memory.
If memory become an issue, there was a plausible backup plan: compress the whole thing. I was already planning to gather the undo/redo strings into a buffer, intern them to deduplicate common patterns, and keep a list of offsets. Gzip would be the obvious first choice for compression, with zlib and zstd via WASM and Web Workers as easy follow-up experiments if we needed better ratios or performance.
But here's where my back of the envelope math hit the 10 seconds until workstream restart watchdog wall: I blanked on order of estimating client side compression performance. Sure, my dev machine could do it <1ms, but what about the target devices? Those budget with their thermal throttled processors? How would gzip compression perform in a client-side app on hardware that still runs legacy silicon? My time was up. This thought would have to wait.
Later, after my standard 13-hour neural-load optimizing search relevancy vectors (Efficient Minds Drive Growth!), I stayed for my three Voluntary Team Contribution Hours™. The evening shift was dedicated to training the new sentiment classifier to detect unauthorized worker satisfaction in internal communications (Because Happy Workers Are Productive Workers - But Too Happy Means Idle Cycles!). Three extra hours of manually labeling edge cases until my hippocampus hit the UN daily throughput cap (Exceed Expectations! Break Barriers!).
That's when I found my loophole. Corporate Training Module THX-1138: "Optimizing Neural Throughput via Quaternary Logic Gates" was flagged as unwatched in my profile. Someone in Underground Hub 451 had been busy - they'd remixed the original with imperceptible adversarial patterns. To the monitoring systems, my neural response would match the expected learning curve for first-time viewing. But I'd seen the original back in Q3. Those "learning" cycles? Mine to burn.
I slipped into my economist-approved refresh creche, adjusted the haptic recalibrator to standard relaxation pose. The re-education headset booted up, its familiar phosphenes dancing across my vision. The trick was keeping the terminal interface in the periphery - anything in the center 40° of vision would trigger the attention monitors. I'd practiced the technique: defocus, let the visual cortex settle into theta-wave patterns, then execute commands through muscle memory alone.
My optic nerve monitors had to register the expected insight spikes. Too flat - they'd know I wasn't learning. Too sharp - they'd catch the unauthorized processing. I needed to maintain a steady 0.8-1.3 sigma from the baseline learning curve for this module. The adversarial remix helped, generating just enough noise in my visual processing centers to mask the actual computation.
Time to implement the compression benchmarks.
Compliance Notice: Cognitive surplus measured at 0.97%, borderline but within acceptable limits. Employee has been flagged for supplementary throughput optimization training.
Compression Benchmarks
Compliance Notice: Cognitive surplus measured at 0.97%, borderline but within acceptable limits. Employee has been flagged for supplementary throughput optimization training.