It is almost impossible to write good imperative update code — not because you are careless, but because the number of cases grows faster than any review can cover. Streams don't make you more careful; they make the cases disappear.

This is a hands-on course. Every lesson runs code on the page, and every lesson ends with a check battery you drive to green — including one exercise that ships looking finished and hides a bug you will most likely miss.

Who this is for

Developers who write event handlers, OnChanged callbacks, or UI update logic and suspect there must be a better way — and anyone building on MeshWeaver, where the better way is the only way that works. You should be comfortable reading C#. No Rx background required — we build the essence of a stream in twenty lines before we ever import a library.

What you'll be able to do at the end

• Count the update paths in handler-style code — and say precisely why they outgrow review
• Wire a dependency graph with CombineLatest and Select so stale-value bugs become unwritable
• Explain what Reactive Extensions is, where it came from, and how the same paradigm powers React, Angular and most of the modern web
• Use pure functions and immutable records — and say why distributed systems, where every actor consumes at its own speed, leave you no other choice
• Read and write MeshWeaver's stream surface: GetQuery snapshots, select: projections and why content is the one special column, and GetMeshNodeStream for the non-stale read
• Bind editors to the node stream instead of a replica with a Save button — and derive view models as streams instead of storing copies
• Design layout areas that are always up to date — and name the two habits that freeze them
• Tell Rx from Ix (push from pull), explain mechanically why await deadlocks a message hub, why re-entrancy is the escape hatch nobody can afford, and why Task is banned from MeshWeaver hub code

How each lesson works

Every lesson has the same three bands:

The running example

One quote calculator carries the whole course: quantity, unitPrice and discountPercent in; subtotal, a threshold-gated discount and total out. Small enough to hold in your head — and already big enough that four of the six possible input arrival orders break a plausible hand-written implementation.

Every lesson rebuilds that same spec at a higher level:

• 1 · The combinatorial trap — count the ways it goes wrong
• 2 · Specify it imperatively — fall into one yourself
• 3 · Combine the streams — the same spec, declared
• 4 · Functional foundations — folds
• 5 · Mesh queries — live data in
• 6 · Data binding — bound editors
• 7 · View models — shaping what the view needs
• 8 · Living layout areas — never stale
• 9 · Rx versus Ix — a descent into push against pull

Ready? Start with Lesson 1 — The combinatorial trap.

Contents