Wow... Humans computed those dependence graphs? Yipe! This feels a little like the "sufficient thrust" principle was applied: With sufficient thrust, any pig will fly.
I've programmed in assembly language on VLIW computers (and still do from time to time). These computers allow you to schedule many instructions in parallel, but you have to take into account their resource usage, their latencies, and most importantly the dependences[*] between instructions. For short programs (10s of instructions), this isn't too difficult to do. For anything non-trivial, it very, very quickly gets unmanageable for a human.
That's why we use code generation tools that know about the architecture and can compute and track the dependence chains for the programmer. The programmer may still be picking the individual instructions, but the tool computes the actual dependence edges.
And, when it comes time to enhance the architecture, the tool itself needs to be reconfigured. Rather than manually write all the new rules, it makes more sense to provide higher level descriptions of how the features all relate, and let the tool figure out how to apply that to new code. (This can be invaluable when exploring different potential tweaks to a CPU architecture.)
I see this as a direct analog to the dependence discovery one needs to do on a filesystem to implement soft-updates, at least based on Valerie's description above.
It seems like it ought to be possible to describe the on-disk format in some higher level form that allows a tool to work out the dependences between various updates automatically, dramatically improving the maintainability of the filesystem. If nothing else, it seems like it ought to reduce the chance of error.
Is the argument that the filesystem is fairly static, and therefore it's not worth the cost of building the tool the first time? That could be short sighted. For one, such a tool may open the way for another level filesystem optimization that focuses on reorganizing things to achieve different objectives: reduce the depth of dependence chains, or minimizing the number of rewrites to sectors, or what-have-you. Depending on the type of media you're writing to, different objectives become more or less important. Rewrites are a bigger issue on SSDs due to wear leveling concerns, but seeking for reads is "free." etc. etc. etc.
[*]Yes, "dependences", not "dependencies." Flip open a copy of Hennessy and Patterson if you disagree... Call me a curmudgeon. ;-)