http://pcottle.github.io/learnGitBranching/

If you take that approach and update with precise but plain english vernacular (redundant?) and domain specific examples, then you are halfway there to making it understandable by regular people.

The most important thing to help people really get it is to promote small commits to their work. The real value of git only makes sense when you start making small commits. Having worked as an editor in a past life, having something like cherry-pick and interactive rebase would have been most dope. In a way, maybe editors are the best audience for driving adoptions among writers in general. For professional editors, version control is a painkiller. For writers, it is a painkiller if the writer is an obsessive editor. For those who write and commit once, but don't go back and review commits and refactor, it doesn't provide much value.

Think about how Apple Time Machine made a stab at operating system backups and snapshotting. Was it perfect? No. But it was a step in the right direction.

Loren and others may not solve all the problems right out the gate, but they will lay the groundwork for new approaches to teaching version control to writers and other audiences.

Progress has slowed a bit since work has ramped up, but now that intern season is over I'm expecting to make some progress

That's the goal. I want git to handle everything behind the scenes, and everything that the user touches just 'makes sense' - ie its not all that different from what they're already doing. A 'save' button makes a git commit, editing somebody else's content automatically creates a new branch, 'submitting' that content on the new branch creates a pull request .. etc.

Wikipedia is largely prose, but of a nonfiction variety. This would be a good intersection for git, which was born out of code.

You could call it..."geeky"...too bad it wouldn't be for geeks.

For general writing collaboration I would seriously consider not allowing arbitrary branches. Most people just get confused managing multiple independent outstanding branches that potentially branched from different points in the history.

One restriction could be that each user gets a single branch (their suggested change). As changes get merged into HEAD each user's branch must be rebased (with a click) before they can add more changes to it. From a programming point of view this is restrictive; why can't I suggest two independent features? But keeping track of dependencies is precisely what's hard for people.

Yep, absolutely true.

> One restriction could be that each user gets a single branch (their suggested change). As changes get merged into HEAD each user's branch must be rebased (with a click) before they can add more changes to it.

Heavily considering this approach.

When do writers need to branch their stories/articles into two forks? If they do that, why not just copy the document and work on it there? The large bodies of text don't have the filesystem dependence that programs do; it doesn't matter what the manuscript is called if nothing #include s it or require()s it.

Instead, it can be quite valuable to have a collaborative text editor: your colleagues' changes are shown in real time as they make them. If you go on a plane ride, they're synced when you get more internet access, with conflicts clearly shown and deliminated so you can resolve them simply.

The collaborative editing would be useful in the later phases of a book -- i.e., working with an editor and copyeditor, it's be great to have a really efficient way to review changes made to the actual text (instead of reviewing a hard-copy with hand-written corrections, and then hoping those corrections are accurately hand-merged into the text...).

But for most of the life of a manuscript, it's just the author working completely solo (from what I've seen). In the standard flow, there's no editor until the book (in a fairly complete and polished draft) is sold to a publisher. A literary agent may read drafts along the way, but normally wouldn't touch the text, just write up higher-level feedback.

On the other hand, the task of designing a narrative that flows well at the scope of a novel is really hard, and can take a lot of large-scale trial and error to improve. She usually does have several "branches" of her current project, as well as large chunks that she has cut from the current draft but doesn't discard (and sometimes may be re-added).

Her first published novel shed more than 300 pages that were never re-added on its way to the final version... it's hard to keep track of all that. It wasn't like "drop this chapter", generally, more like "remove this subplot from the hundred or so places it shows up".

I'm not sure how well the git model would address the problems -- the big problem is scale, and visualizing large structures made up of lots and lots of tiny little words. They are plenty of pain points worth attacking, though, except that most writers don't have much cash to spend on tools.

An easy way to trace a plot throughout the novel. Interestingly, a tool, that enables this could even be used by literature students, when analyzing texts for an interpretation (been there, studied that). The only problem with this is copyright and the inability to get your hands on a digital os-/reader-independent format, to work with in the first place.

I worked mostly with texts from medieval times and it was a pain to get hold of (good) digital versions. May be, that this is because language processing approaches are not that widely used in my former field of study.

So to wrap it up - a great tool, enabling authors with this could enable also a better understanding of novels for literature students alike.

This.

Version control is a capital-P Pain In The Ass for group writing projects. Anything that improves the version control problem in collaborative writing solves a very real need. Perhaps not a huge TAM at first glance, but a real need nonetheless.