v1.0.0 vs v2.0.0

Summary

v2 ships two fundamental changes: a new recursive-descent parser that eliminates overhead from the old parser's fixed startup cost, and a compiled expression engine. The AOT compiler generates a native JS function for each expression at build time; at runtime rs-x looks up and calls the pre-generated function directly. The compiled engine is the source of most update improvements.

The one regression is upfront bind cost: v2 does more work per binding than v1 — it compiles the expression, sets up a plan cache entry, and registers typed watchers. For applications that are update-heavy relative to bind count (the common case), this cost pays back quickly.

~ = high variance measurement; treat as indicative. Positive gain % = v2 faster than v1.

Parsing: up to 87% faster

The v2 parser uses a hand-written recursive-descent approach instead of the general-purpose parser used in v1. The most dramatic improvement is at the low end: a single-identifier expression dropped from 5.5 µs to 0.7 µs — 87% faster. Larger expressions improve 20–30% as the fixed overhead becomes a smaller fraction of total parse time.

Both modes use the same parser — the parse performance numbers are identical for tree and compiled modes.

Binding: v2 costs more upfront

Bind cost in v2 is slightly higher than v1, but this is largely a cost shift. v2 resolves all expression dependencies and builds the full watch graph once at bind time — work that v1 deferred to every individual update evaluation. In tree mode, bind cost is within ~10% of v1 for unique expressions. Compiled mode has a similar bind profile; the savings show up at evaluation time.

The tradeoff is that subsequent calls to update the same binding are significantly faster, and memory usage is lower (compiled plans are shared). For most applications that bind once and update many times, this is a net positive.

Updates: 60–70% faster

Updates are where v2 wins clearly. Tree mode is already faster than v1 for bulk updates — the new watcher architecture notifies only affected expressions more efficiently. Compiled mode is faster still: it calls the pre-compiled JS function directly, which V8 JIT-optimises as a regular function call.

At 10,000 bindings with a bulk update, v2 compiled mode takes 61 ms vs 146 ms in v1 — 58% faster. Single update times are very small in all versions and not the meaningful comparison.

Parse cache (parse + clone): v2 tree is faster

When an expression is already cached and a new binding clones the cached AST, v2 tree mode is consistently faster than v1. The v1 clone included more allocations per node; v2 uses a tighter object structure. Compiled mode replaces AST cloning with a plan cache lookup, which has different cost characteristics.