Evergreen posts about tflo — architecture deep dives, indicator implementations, performance notes, and real-world usage patterns.
Most browser analytics either ships raw events to a SaaS that decides what counts as engagement, or hand-rolls a tangle of addEventListener calls that drifts from what marketing asked for. There's a third option.
How we compiled tflo's temporal event processing engine to WebAssembly and built an interactive playground with live charts, CEL rules, and real-time signal detection.
SMA treats every value the same. EMA forgets old values exponentially. Time-based vs count-based, half-life mechanics, and why irregular data changes everything.
You've written a moving average a hundred times. Running it on an event stream instead of an array changes how you think about it — warmup, sliding mechanics, running sums, and the mental shift from batches to samples.
Most engineers think 'signal' means 'crossing detected.' In tflo, it's a typed event mode plus payload — and it's how a noisy detection stream becomes clean lifecycle events.
When an operator's output has to match a reference implementation to six decimal places, unit tests won't cut it. Here's how tflo uses golden vectors to lock in correctness.
Extension traits, closure-based primitives, and the Operator trait all solve different problems. Here's when each one fits, with runnable examples.
A rolling deviation band — Bollinger Bands, in the finance domain — looks like a single indicator. It's not. It's a moving average plus standard deviation, composed together. tflo lets you build it that way.
RSI is a bounded 0-100 momentum gauge — useful for spotting saturation in any signal. But different references compute it differently, and the difference matters at the edges.
Variance looks simple until you try it on large numbers. Welford's algorithm keeps it stable. Here's how tflo uses it for streaming variance, skewness, kurtosis, and correlation.
NaN is silent. It doesn't crash your program. It just makes your outputs meaningless. Here's how tflo catches it before it poisons your pipeline.
You develop against a CSV file. You test against an async stream. You deploy against Kafka. Same graph. Three execution modes.
The built-in operators cover a lot. They don't cover everything. Here's how the Operator trait lets you define your own runtime computation nodes for the tflo graph.
Your service restarted. Every streaming graph forgot its state. SMA is cold. RSI starts from zero. Here's how tflo snapshots and restores graph state so you don't lose your place.
Crossovers, glitch filters, runt detectors, pulse width validators, and window detectors. How each one works, when to use it, and why you need more than a crossover.
One graph, one output. But you never want one output. Seven combinators turn any indicator into a multi-stage pipeline — zip, map, filter, fold, pipe, reduce, filter_map.
Five-minute SMA and 20-sample SMA look interchangeable in examples. They behave completely differently when your data stream has a hiccup.
CEL, Rego, and Rhai each solve a different problem. Picking the wrong one costs you weeks. Here's how to decide.
The two most common reasons your graph produces fewer outputs than you fed it. How to spot them, how to fix them, and how to enable strict validation so they never surprise you again.
Most analysis libraries work on fixed arrays. tflo, a temporal event processing engine, uses a declarative computation graph instead. Here's why that matters when your events never stop flowing.
Why this blog exists, what you'll find here, and how tflo approaches temporal event processing differently.