At the first sight, I though it was a new version of <a href="https://www.cis.upenn.edu/~bcpierce/unison/" rel="nofollow">https://www.cis.upenn.edu/~bcpierce/unison/</a> but it seems completely different.
I personally like the (language-dependent) "series of actions" approach.<p>So, you quite literally send to the VCS "add this parameter with default value <foo> to this function", "make a copy of this function", "add this function", etc. With transactions.<p>And the VCS "just" replays the edits. Note that the VCS will occasionally have to munge the human-readable names in the case of what would be otherwise a conflict. But the VCS doesn't deal with things at that level anyways. You really should end up dealing with things at the AST level and rebuilding the source code when necessary.<p>Think of it like a refactoring tool integrated with the VCS.
This is a huge surprise! I had been under the assumption that asynchronous semantic edits were the only true way forward. Synchronous large-scale edits?! If you can make it work, even only half of the time... that is an enormous productivity boost.<p>Well--fair warning, it's happy hour--but allow me dump my incoherent gut armchair objections.<p>- Large-scale edits mess with large-scale invariants. Can this edit calculus and scoping mechanism truly deal with arbitrary changes? Or is "arbitrary changes" a white rabbit, and can you come up with a calculus that handles all "reasonable" changes?<p>- I had previously thought that the only way we're going to get past the {software upgrade,data migration} bottleneck is through semantic VC. Developers make mistakes. Software evolution as a gradient (rather than the status quo of progress in fits-and-starts) seems extremely unsafe. Does Unison make all mistakes undo-able?<p>- Won't "branchless" conflict-free versioning be the same as constant forking, creating an enormously fragmented software project? (So postmodern!) How do you get everyone back on the same "master" mainline; surely not all possible Edits can commute?<p>I guess all these concerns are irrelevant if you treat synchronous editing as the golden path, and fall back to async for the hard stuff.