A sequential update method is the update method pattern (e.g. as described here) where all game entities have their update methods called sequentially, even if this means the order of the entities ends up impacting the end result.
This has two obvious downsides (simplified, of course):
Order matters, which also makes its results technically incorrect (since you're meant to be simulating simultaneous action).
Because it is sequential it can't be parallelized very easily.
Simplicity is always good, and it really does shine on that front. Still, is it really acceptable? Do real-world games actually use this?
As far as finding a more acceptable solution (which thus far I haven't): The previously linked article mentions Double Buffering as a possible solution, and most alternatives I've thought up thus far seem to boil down to some form of that.
Based on my own research and experimentation, alternatives to the sequential update method have problems of their own:
Simple double buffering isn't enough in practice. Changes from multiple sources end up overriding each other, so some way to cumulate them is needed (incrementing a value in the next buffer instead of just writing to it). At best this means a tiny bit of extra complexity, at worst it ends up being order-dependent again.
Complexity spirals out of control. Say you seperate out the physics into its own series of order-independent updates (e.g. move entities, check collisions, adjust positions), it quickly follows to do the same thing for every mechanism, which ends up becoming unmanageable.
Physics seem to want to be order-independent the most, though - and maybe I just haven't looked in the right places - I wouldn't know of good way of seperating physics from other updating logic. I've been going in circles on this for a while now. Maybe I'm missing something really obvious here.
My problem boils down to how to deal with update ordering. More specifically, is there a way to structure a game update that is order-independent (and parallelizable if possible) that doesn't drastically escalate complexity? If not, is there some reasonable middle ground? E.g. doing only the physics in a seperate order-independent update and everything else in a naive order-dependent sequential update.