Complexity, humans are not good at complexity beyond certain levels. One good example of such model is in React + Redux story. Based on single variable your view might have 10/20 changes and to this day I see people debating what is the right way to do it (React hooks vs Redux is latest episode).
In my experience/opinion as a programmer, property-bound state tracking (where you say C = A + B, and changing A or B changes C) is easier to understand than push-based updating of C when you change either A or B. Property binding (FRP?) causes the exact set of values dependent on an input to change when the input changes, with no chance to forget (though you can still forget to register a change callback on C). But it's not a complete solution for when you want to take different actions based on what changed (eg. pushing a button to send an email).
When you want to take different actions, you can use the Stream metaphor (a.k.a. Observables) instead of variable bindings.
Streams maintain the same functional reactive execution paradigm of spreadsheets and property bindings, but you can compose several of them into a new stream with complex conditional logic. You can use the streams as event propagators, and understand the program state as a series of successive updates every time a new event appears on the stream.
That's essentially what the "copy formula down the entire column, updating relative references as you go" pattern of Excel abuse does, right? Might be quite interesting to have a UI that takes all the tedious and distracting column-filling from your shoulders but keeps the tabular representation for debug/understanding.
A stream allows you to generalice the computation, not depending on the number of data items that were available when you defined the function; i.e. not different from a function with a loop.
Applications like AirTable and other modern outliners are exploring interfaces to model that kind of generalized data tables and relations with visual metaphors.
