Big fan of Draft (and Nate). It's got the version control part down, and I think it works well for gathering feedback on blog posts and other short form content, but it isn't designed for longer form content as far as I can tell. It's also missing the community aspect that GitHub has, which is huge, as well as features that would make writing an ebook or textbook feasible. Definitely a great tool though.
I am trying to do the same. I never even thought about sharing this concept till I could launch. I know for sure this a great area to work on and it will make a huge impact for collaborative story telling.
I was looking for something like this. I'm planning to write an epic sci-fi novel and make it available under some open license (Creative Commons BY-SA probably). Since I'm not a native English speaker, I'm hoping those who are would jump in and help me perfect the text.
My final hope is to see a Hollywood movie made out of it one day, because many recent SF movies lack good story.
My other idea is to make the story branch into different directions. I would write the main storyline, but another writer could come and fork it at some point. The reader would be left with a choice at some point: would you like this character to take that decision or the other - and after choosing, the reader could read the forked variant.
This is the first time I'm publicly writing about this idea. I'm still undecided what technology to use to create it.
I think Max is talking about the Z-Machine interpreter that Infocom created to make games like Zork and Hitchhiker's Guide to the Galaxy. There are many of modern ways to use it, like Inform (I recommend Inform 6 over 7), and even a web interpreter, Parchment.
That's if you want someone to PLAY the choice in the story. Which is slightly different from what you're talking about.
Yeah, the Z-Machine interpreter. But I think it is reasonable to look at choose your own adventure as a fairly straightforward game, so Z-code presumably provides the necessary features for it.
I've used git with my sci-fi novel, Planet Oz, since I first drafted it back in 2008. Quite glad I did since it makes the editing process much easier to track.
> I'm still undecided what technology to use to create it.
I've got friends working on projects a bit like this. Markdown served from github pages is nice, as you edit and compare diffs in markdown, but you can get it automatically rendered into a nice readable form too.
My own view though is that the most likely way to fail is to lose motivation, and having interminable discussions over minutia early on while writing is likely to suck away your energy. I'd probably get at least the skeleton of the whole story into your repos before encouraging others to contribute.
Yep, the skeleton for the whole story is ready. I have been pondering about all those main story parts in the past 2-3 years. My next step would be breaking each chapter into smaller parts, without writing down any specific sentence. The last part of the process would be actually writing it.
I know that Michael Hartl of RailsTutorial is working on something very much like this, but will be a full end-to-end product including things like sales.
How are you solving the diff problem? Word based diffs tend to be jumpy and hard to follow. On the other hand line based diffs do not work well for text (prose).
Yeah, prose.io uses word diffs and it's definitely hard to follow.
I'm doing 'fragment diffs' (doesn't really have a name) - but basically, all the text is displayed as you would read it (sentences and paragraphs), with diffs displayed inline and colored. Added content in green, removed content in red - doesn't matter if it's characters/words/sentences/paragraphs - it all works.
Screenshot is not the best, but something like this:
Don't know if you've already thought of / planned this, but please please implement a side-by-side diff view.
Code is easy enough to read in a unified diff because lines are usually short (unless java). Prose flows a lot more fluidly, and there is no formal grammar for human language. I have had the displeasure of having to read "redlines" (prose with inline diffs marked in red strikeout) and I find them completely impenetrable.
I'm using latex+vim+git for this purpose currently. I put two spaces after a period to signal the end of a sentence in Latex. Which helps me break the document up by sentences with vim.
If you're using markup then encouraging the period-double-space could be a harmless way of easily breaking the document up by sentences
We've been working on a similar problem. Writing in markdown, pre-processing the saved markdown to truncate to 80 column (best fit) paragraphs and then diffing on the markdown.
"Sentence-based" diffs would work well for prose, but the problem is recognizing sentences, given the other uses for full stops. If you use hard line breaks at, and only at, sentence ends, you could use line-based diffs to do this (but this may run into editing convenience issues.)
A lot of programmers already find it awfully hard to wrap their heads around how git works. I can only imagine how hard it will be for non-programmers to (it doesn't suprise me that the successful example used is written by mathematicians).
HOWEVER, that doesn't mean it can't be done. In fact, if there are ways to visually simplify git and make it more intuitive for non-programmers, those techniques could wind up making git even better for programmers too.
I could also imagine a convergence of the git model and the wiki model someday -- where anyone can edit (like Wiki), but where there are branches, merging, etc. Obviously, a lot of internal wiki's don't need such complicated version control, but for things like Wikipedia, it could be amazing.
I think there are a lot of areas for working on writing collaboration -- group projects in school, business proposals, technical manuals, all sorts of things.
And the main attraction for users over, say, Google Docs, is that your changes don't overwrite others'. The fact that your edits create a "branch", that then others can accept/reject/modify/merge, is a vast improvement in creative collaboration.
> In fact, if there are ways to visually simplify git and make it more intuitive for non-programmers, those techniques could wind up making git even better for programmers too.
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.
The intersection of git and wikis is interesting, it's one of those things that sounds compelling but then the details usually end up making it hugely complicated. Worth thinking about.
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.
> 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.
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.
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.
Learn Git Branching is best learning tool I ever tried!
With this tool and a little practice on the side I was able to learn the basics of git within a couple of hours so that I can confidently branch, merge, push, pull and rebase and I know what I'm doing! Programmers should invert more learning tool like this!
"And the main attraction for users over, say, Google Docs, is that your changes don't overwrite others'. The fact that your edits create a "branch", that then others can accept/reject/modify/merge, is a vast improvement in creative collaboration."
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.
I love git, but some of the metaphors and inconsistencies it makes are definitely not good and make it much harder to pick up than it should be. I think with the right set of metaphors and ui it can work.
Honestly, I think writers could benefit more from the collaborative editing model than the git branching model.
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.
For something like that you would need a way to mark parts of text, that deal with certain subplots/plots. Like different colors for different plots, but what happens, when they intersect? Or you could use flags, or something like that.
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.
Haha! Agreed, but like lots of software things--I think that's mostly because the instructions are written by the programmers. I'm management at my company (don't code), but have never had trouble grasping the conceptual issues and intricacies of code, and that makes me really good at teaching it. You just have to contextualize it properly for their perspective. Writers, or anyone that's not a programmer, doesn't care what a git is or how it work technically. They want to know how it will fulfill their wants/needs, and they want big buttons labeled with those solutions. I could teach my grandma to use to the github client if there was a shortcut to it on her desktop.
I'm currently using GitHub to collaborate on writing a book with a non-technical coauthor. Generally it works great, but there are two key issues:
* Changes are tracked by line which is equivalent to a paragraph in a book. If I go in and add a comma to a paragraph and my coauthor simultaneously changes a word in that paragraph that can create issues.
* Errors are very difficult to solve for my coauthor. When Github Window's app encounters an error, it basically says "Just open up the command line and you should be able to figure out how to solve this". Of course this isn't feasible for a non-technical audience.
If your product can fix these two issues (which it looks like it is trying to) it could be very valuable.
> Changes are tracked by line which is equivalent to a paragraph in a book.
When using Markdown, I usually split paragraphs over multiple lines (usually between sentences) which makes diffs much easier to read, while still rendering as a single paragraph.
Same here. "Single line paragraphs" are a pet hate of mine - they have no place in plain text files even if those files are intended to be post-processed.
I'm still undecided on this. Say you have a long paragraph and have to add one word at the beginning. You have two options - either rewrap and introduce a silly diff, or don't rewrap and exceed your chosen text width.
Single line paragraphs don't put such a difficult choice in front of you. If your diff software is any useful, it'll highlight your change within the line.
Perhaps you could have a special kind of commit, a "text-rewrap" commit (similar to merge commits), which might let your diff presentation tool alternate between diffing lines, pararaphs, or the like. I agree, the presentation layer really needs to be as granular as your editing team needs to be. I __really__ like how Github shows the differences within a line that is different.
Absolutely, but you still have the issue that a minor wording change can cause an entire paragraph to be marked as changed if your editor re-wraps the paragraph. Or, if the editor doesn't rewrap the paragraph, then they slowly get more and more ragged over time, making it annoying to read through.
A diff tool that understands paragraphs is an essential tool for this project.
I disagree with this. In a plain text file that consists of prose, line breaks are presentation, not content. Hardcoding them into the file doesn't appeal to me. It makes editing a pain in the neck. It also means the line breaks have to be removed again if you want to move between formats.
That sounds like an editor issue, though. You should be able to reflow a paragraph, indent it or whatever it as you like.
A compromise might be to break lines on sentence boundaries: edits are often constrained within sentence or paragraph boundaries, and then diff would give more meaningful output for most sentences.
^-- This one sentence is two lines long, though, so perhaps my idea is not that good. Diffs would still be easier to read than if each paragraph were one line.
I know people who break lines per phrase/clause, rather than per sentence. You wind up with lots of very short lines, but that doesn't matter after Markdown is done processing. The benefit is some _very_ granular diffs that are easy to read, as you work out rewording things in the editing process.
i write quite a bit with git, and recently brought an old collab project with a friend onto it.
i do all of the git work, and i just have my friend add my edits to his document, then he sends it back and i diff the two for potential errors... he requested it be this way because he is stuck in his ways, but we've agreed to go full git on book two in the series...
that said, when i first started sending him diff files we both saw this as a problem... my solution?
i just wrote a script that i run on the diff to just highlight the changes made, then send him the new edited diff.
-PARAGRAPH
+PARAGRAPH
becomes :
-SENTENCE
-word...word
+word...word
+SENTENCE
...
i place git's diff at the bottom of the file in case he wants to look that over as well, but this cleans up the edits real nice
Disclaimer. I'm the creator of GitSense which is working on building advanced power tools for Git and GitHub.
The diffing problem is solved quite easily with the Google Diff, Match, Patch algorithm and our Smart View technology. When GitSense was created, it was obvious that we all work differently and we all have different needs which was why we made it insanely customizable. If you are not familiar with the Google Diff, Match, Patch algorithm, you can learn more about it here:
I've been loving draft to the point that I haven't really engaged with any of the other new platforms out there, like editorially. I sign up to beta just about any of them that come along, but Draft just feels like home already. That said, I can't imagine I wouldn't at least play around on the platform the author describes.
My biggest issue with Draft is consistency in behavior. Personal anecdotes are frowned upon here, but for most of last week the ability to export files wasn't working at all for me. When I'm dealing with Markdown, this is the last thing I want to happen.
I much prefer a system that's geared to projects and not specific types of document too. For example, if this supported housing a collection of documents and an image or two - with changes able to be made on each file, it would be amazing. Google Docs I edit with others quickly tends to devolve into three different types of sharing/permissions issues, and I'm left frustrated or wondering why some people can access one thing or another.
> I much prefer a system that's geared to projects and not specific types of document too. For example, if this supported housing a collection of documents and an image or two - with changes able to be made on each file, it would be amazing.
Draft's editing/version control is rather awesome and easy to use. It would be neat if Loren and Nate could work together to get some of the github-like "social" features into Draft--following updates and broadcasting progress.
My feeling would be that having one platform with both features would be better than having two very similar things here.
I think this is a really interesting idea; however, I don't think it's a very good method to build it as 'Github for Writers' since coding and writing are two very different processes. For instance, writers often create their work on their own instead of with multiple contributions. Contributors is more of a code project attribute, for anyone who knows how to program well can add/modify code while not anyone who knows write well can add/modify to a story.
It is true that writers need editors but editors are certainly not writers. If there was a system where all of the contributors acted more like 'editors' rather than writers than I personally think it would be an awesome version control program.
One question is, do writers create their own work because of the nature of writing, or because they lacked the tools for collaboration. I have seen several examples of collaborative writing.
The first example that comes to my mind is the SCP Foundation [1].
I think this may be true for fiction (. . .writen often create their work on their own. . .not anyone. . .can add/modify a story), but I think it's a great idea for non-fiction, such as the textbook and research paper examples that the OP cited. Other examples include user or technical manuals, requirements documentation. . .The team members are often more akin to contributors (code or otherwise) than to editors. Individual but interlinked units have to come together to form a whole.
Absolutely. My wife's job as a professional editor involved editing hundred-page documents, often with more than one author. A tool which made version control simple, yet writing easy, would be a godsend.
The down side is, many such organizations (e.g., military) have standardized on Word, which is terrible for collaborative review, editing, and version control of long documents. (Of any documents?) She would have been extremely happy had her employer allowed them to use LaTeX or similar.
> Absolutely. My wife's job as a professional editor involved editing hundred-page documents, often with more than one author. A tool which made version control simple, yet writing easy, would be a godsend.
I hope you signed up - I want to that editing process easier!
As someone who writes software and fiction (heck, even software-fiction in the form of visual novels), I actually keep finding more and more parallels between the craft.
I like to explain the fiction creation process as "writing code that targets the Human BIOS."
> Just like 'forking' code was frowned about before open source software came about ;)
Long after that, in fact. Forking an open source project was a desperate measure to free it from unresponsive/difficult/differently opinioned maintainers, that could leave a rift in the community for years (see Lucid/XEmacs). GitHub made forking something that was normal, common and expected.
It's sad for me to see what you are doing because I had the same idea like 5 months ago. But I'm not that good on putting ideas into actions so it didn't go that far. :(
That'd be an awesome tool for witers, bloggers, editors, etc.
But Markdown as UI... is less than ideal. It's great for hackers, but there's already a GitHub for hackers, and it's called GitHub. No matter how much prose.io prettifies it, you still get those damn asterisks all over the place.
Personally, I write in TextEdit, Helvetica 12pt. That's not a universal answer, but it works for me. (Previously I used MacWrite Pro, ClarisWorks and Word 5.1 at different times, but the basic appearance was the same.) Anything that makes a bold word look like "* * this * *" breaks 20 years of habit, and I won't do it.
Markdown as backend storage, fine. But not as the primary editing interface.
At work we are trialling Lyx + Subversion for collaborative creation of developer documentation. The stored data is in a text + markup format which allows for easy diffing. Lyx being a layer over Latex means we can easily transform into a wide variety of formats, but mostly we output to PDF and HTML. Subversion was chosen as we already had a server available and there isn't really the same need to branch/merge documents compared to code. Writing in Lyx took a little time to get used but I definitely feel more in control that when trying to wrangle complex docs in Word.
I used to write my documents in Lyx too but spreading the tool amongst my colleagues involved a lot of evangelism.
Markdown is a backend storage easier to adopt as developers are used to it (stackoverflow, github) but it produces output for the web : no pagination, header/footer, etc.
Throw pandoc+tex template into the mix, and it starts to get really interesting : a quickly hacked markdown file transforms into nice pdf will all needed attributes.
But why stop there? Now that you have a build process, move it to a server and add some hooks to injects traceability infos (author, last edit date, commit hash...) into the generated document, etc...
I went down this road, and it works surprisingly well.
If you're trialling different solution for writing technical developer documentation, see a more precise description of the workflow that I pushed on my blog yesterday: http://kray.me/pro/doclegit-git-documentation-server/
(sorry for the copy quality, english not my first langage, corrections by mail are welcomed)
Interesting. When we set this up we looked at maybe adding an automated build (transform) step on commit via our CI (Jenkins) server.
While the software developers are comfortable learning and using Markdown or other markup syntaxes, I eventually would like to spread this approach to other technical people in the company. In previous attempts at teaching basic scripting (Awk, Ruby, Python) to engineers who are comfortable writing complex logic operations in Excel and who can dabble in VBA - I found a lot of resistance to the idea of learning a new syntax. So I expect the evangelism required to get these colleagues to write in Markdown will be greater than showing them Lyx, which at least looks like one of the editing modes in Word.
I thought the main technical hurdle (for not dev crowd) in my current workflow was git as there exist a lot of good Markdown editors on all platforms ;)
I wonder if Github is working on something like this.
I'm sure they're familiar with the idea and they seem like the best team to bring it online. They're still a startup looking for growth opportunities: this one seems obvious.
What I mostly want, when writing collaborative documents, isn't a git equivalent - it's a code-review equivalent.
I want to leave comments on individual words, sentences, paragraphs, etc., with suggestions for changes. And that's something that git doesn't allow, because the smallest change you can comment on is a file, with no ability to comment on specific parts of it.
You can usually do it with shared Google docs. I know a few writers who share their content with a few trusted betas. It provides the necessary features, I think. Highlights, commenting etc.
I think there is also a "real-time" feature that it provides (not sure about that), so there is usually more than one eye on the doc as the chapter is being typed.
Git doesn't support it, but GitHub does. You can comment on individual lines via GitHub. I'm going to do something similar - maybe on a more granular level (words/sentences).
It sounds like you're looking for Microsoft Word, which has offered this feature for more than a decade (albeit though not online until this past year).
Latex has line comments and since it is compiled into a document you can place line breaks anywhere. It does break the flow of the sentence though.
I've used Latex+vim+git to write scientific papers recently. It is unfortunately much too complicated for my colleagues to adopt. They're holding onto MS Word which is far inferior in terms of markup, citing, and VCS.
I've been converting my Latex documents to ugly word documents for collaborating and editing. The MS Word editing isn't great either. The strikethrough method breaks up flow. I've also had problems deleting side comments in Libre office. And the MS Word experience isn't always the same on Macs.
An idea is to think about rendering/typesetting as a feature. For many, getting an environment set up to turn the project files into final files of whatever form is a huge barrier. It would be great to have a bunch of back-end rendering be just a click: Markdown->HTML, Markdown->PDF, Markdown->epub, Latex->PDF, Latex->HTML.
especially when you throw in citations for scientific articles. Which often require compilation of the citation database, citation order, and citation insertion. Adding 3 more steps to the process.
I've recently switched to papers to help with this. It seems to have a strong community and supports both MS word, libre office, and vim. Jury's still out though.
Is this going to be focused on those who use latex and markdown, or the the broader audience of 'people who write'?
If the latter, you run into a problem pretty quickly - MS Word. It's still one of the most popular document editing tools out there. More recent versions do store content in zipped XML, but are you willing to put the work into parsing that content at a level sufficient to let it integrate into the kind of flow you discuss?
(EDIT: That said: if your target is those creating text-based documents, then I think this is an excellent idea. )
Have you asked a representative sample of writers whether they write this way, and would like to use your site to write this way? Outside of business, collaborative writing seems to be pretty minimal (I say this as a novelist)...
Also, if there could be some cross-compatibility with MS Word's Track Changes (I know, I can dream...) that would be great.
146 comments
[ 2.4 ms ] story [ 197 ms ] threadI wonder if some key CS concepts are so fundamentally ingrained, but that writers think about their work flow differently.
http://www.roughdraft.io/ - Also, I like it.
I don't think it's a bad idea to proceed with it, I would just find a way to differentiate it from what's out there.
My final hope is to see a Hollywood movie made out of it one day, because many recent SF movies lack good story.
My other idea is to make the story branch into different directions. I would write the main storyline, but another writer could come and fork it at some point. The reader would be left with a choice at some point: would you like this character to take that decision or the other - and after choosing, the reader could read the forked variant.
This is the first time I'm publicly writing about this idea. I'm still undecided what technology to use to create it.
Can you give me some URL?
That's if you want someone to PLAY the choice in the story. Which is slightly different from what you're talking about.
I'd love to know when this book gets off the ground - I enjoy both sci-fi and correcting other people's English.
I've used git with my sci-fi novel, Planet Oz, since I first drafted it back in 2008. Quite glad I did since it makes the editing process much easier to track.
Can't wait to begin the Kickstarter in October.
I've got friends working on projects a bit like this. Markdown served from github pages is nice, as you edit and compare diffs in markdown, but you can get it automatically rendered into a nice readable form too.
My own view though is that the most likely way to fail is to lose motivation, and having interminable discussions over minutia early on while writing is likely to suck away your energy. I'd probably get at least the skeleton of the whole story into your repos before encouraging others to contribute.
I can't wait to see what he comes up with.
I'm doing 'fragment diffs' (doesn't really have a name) - but basically, all the text is displayed as you would read it (sentences and paragraphs), with diffs displayed inline and colored. Added content in green, removed content in red - doesn't matter if it's characters/words/sentences/paragraphs - it all works.
Screenshot is not the best, but something like this:
http://www.flickr.com/photos/madebyloren/9620674181/
Code is easy enough to read in a unified diff because lines are usually short (unless java). Prose flows a lot more fluidly, and there is no formal grammar for human language. I have had the displeasure of having to read "redlines" (prose with inline diffs marked in red strikeout) and I find them completely impenetrable.
If you're using markup then encouraging the period-double-space could be a harmless way of easily breaking the document up by sentences
HOWEVER, that doesn't mean it can't be done. In fact, if there are ways to visually simplify git and make it more intuitive for non-programmers, those techniques could wind up making git even better for programmers too.
I could also imagine a convergence of the git model and the wiki model someday -- where anyone can edit (like Wiki), but where there are branches, merging, etc. Obviously, a lot of internal wiki's don't need such complicated version control, but for things like Wikipedia, it could be amazing.
I think there are a lot of areas for working on writing collaboration -- group projects in school, business proposals, technical manuals, all sorts of things.
And the main attraction for users over, say, Google Docs, is that your changes don't overwrite others'. The fact that your edits create a "branch", that then others can accept/reject/modify/merge, is a vast improvement in creative collaboration.
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.
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
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.
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.
* Changes are tracked by line which is equivalent to a paragraph in a book. If I go in and add a comma to a paragraph and my coauthor simultaneously changes a word in that paragraph that can create issues.
* Errors are very difficult to solve for my coauthor. When Github Window's app encounters an error, it basically says "Just open up the command line and you should be able to figure out how to solve this". Of course this isn't feasible for a non-technical audience.
If your product can fix these two issues (which it looks like it is trying to) it could be very valuable.
When using Markdown, I usually split paragraphs over multiple lines (usually between sentences) which makes diffs much easier to read, while still rendering as a single paragraph.
Single line paragraphs don't put such a difficult choice in front of you. If your diff software is any useful, it'll highlight your change within the line.
A diff tool that understands paragraphs is an essential tool for this project.
A compromise might be to break lines on sentence boundaries: edits are often constrained within sentence or paragraph boundaries, and then diff would give more meaningful output for most sentences.
^-- This one sentence is two lines long, though, so perhaps my idea is not that good. Diffs would still be easier to read than if each paragraph were one line.
i do all of the git work, and i just have my friend add my edits to his document, then he sends it back and i diff the two for potential errors... he requested it be this way because he is stuck in his ways, but we've agreed to go full git on book two in the series...
that said, when i first started sending him diff files we both saw this as a problem... my solution? i just wrote a script that i run on the diff to just highlight the changes made, then send him the new edited diff.
becomes : ... i place git's diff at the bottom of the file in case he wants to look that over as well, but this cleans up the edits real niceThe diffing problem is solved quite easily with the Google Diff, Match, Patch algorithm and our Smart View technology. When GitSense was created, it was obvious that we all work differently and we all have different needs which was why we made it insanely customizable. If you are not familiar with the Google Diff, Match, Patch algorithm, you can learn more about it here:
https://code.google.com/p/google-diff-match-patch/
I've also put some screen shots of what the diff results for two markdown files would look like at:
http://screenshots.gitsense.com/google-diff-patch-match.html
The context aware source code that is used in GitSense to display the diff can be found here:
http://screenshots.gitsense.com/google-diff-match-patch-inte...
Check it out! It's awesome!
I am also working on something similar called Papyrus. It lets authors create and edit ebooks simultaneously.
http://papyruseditor.com/en/home/collaborate/new
I much prefer a system that's geared to projects and not specific types of document too. For example, if this supported housing a collection of documents and an image or two - with changes able to be made on each file, it would be amazing. Google Docs I edit with others quickly tends to devolve into three different types of sharing/permissions issues, and I'm left frustrated or wondering why some people can access one thing or another.
There's definitely room to innovate here.
Nailed it. That's what I'm building :)
My feeling would be that having one platform with both features would be better than having two very similar things here.
It is true that writers need editors but editors are certainly not writers. If there was a system where all of the contributors acted more like 'editors' rather than writers than I personally think it would be an awesome version control program.
[1] http://www.scp-wiki.net/
EDIT: Actually posting the link might help. (Although redacting it has a nice sense of irony too).
The down side is, many such organizations (e.g., military) have standardized on Word, which is terrible for collaborative review, editing, and version control of long documents. (Of any documents?) She would have been extremely happy had her employer allowed them to use LaTeX or similar.
I hope you signed up - I want to that editing process easier!
I believe that sentence no verb.
I like to explain the fiction creation process as "writing code that targets the Human BIOS."
(I guess it goes without saying, I do not have any experience or knowledge about the writing process authors follow)
Long after that, in fact. Forking an open source project was a desperate measure to free it from unresponsive/difficult/differently opinioned maintainers, that could leave a rift in the community for years (see Lucid/XEmacs). GitHub made forking something that was normal, common and expected.
That'd be an awesome tool for witers, bloggers, editors, etc.
Keep up the good work! =)
But Markdown as UI... is less than ideal. It's great for hackers, but there's already a GitHub for hackers, and it's called GitHub. No matter how much prose.io prettifies it, you still get those damn asterisks all over the place.
Personally, I write in TextEdit, Helvetica 12pt. That's not a universal answer, but it works for me. (Previously I used MacWrite Pro, ClarisWorks and Word 5.1 at different times, but the basic appearance was the same.) Anything that makes a bold word look like "* * this * *" breaks 20 years of habit, and I won't do it.
Markdown as backend storage, fine. But not as the primary editing interface.
That's interesting - hadn't thought about storing in markdown and just displaying as html. Hmmm.
I went down this road, and it works surprisingly well. If you're trialling different solution for writing technical developer documentation, see a more precise description of the workflow that I pushed on my blog yesterday: http://kray.me/pro/doclegit-git-documentation-server/ (sorry for the copy quality, english not my first langage, corrections by mail are welcomed)
While the software developers are comfortable learning and using Markdown or other markup syntaxes, I eventually would like to spread this approach to other technical people in the company. In previous attempts at teaching basic scripting (Awk, Ruby, Python) to engineers who are comfortable writing complex logic operations in Excel and who can dabble in VBA - I found a lot of resistance to the idea of learning a new syntax. So I expect the evangelism required to get these colleagues to write in Markdown will be greater than showing them Lyx, which at least looks like one of the editing modes in Word.
I am thinking of accounting systems such as ledger-cli which let you keep your accounts in plain text files.
I'm sure they're familiar with the idea and they seem like the best team to bring it online. They're still a startup looking for growth opportunities: this one seems obvious.
I want to leave comments on individual words, sentences, paragraphs, etc., with suggestions for changes. And that's something that git doesn't allow, because the smallest change you can comment on is a file, with no ability to comment on specific parts of it.
I think there is also a "real-time" feature that it provides (not sure about that), so there is usually more than one eye on the doc as the chapter is being typed.
I've used Latex+vim+git to write scientific papers recently. It is unfortunately much too complicated for my colleagues to adopt. They're holding onto MS Word which is far inferior in terms of markup, citing, and VCS.
I've been converting my Latex documents to ugly word documents for collaborating and editing. The MS Word editing isn't great either. The strikethrough method breaks up flow. I've also had problems deleting side comments in Libre office. And the MS Word experience isn't always the same on Macs.
I believe Operational Transforms are the way to go, but I have no basis for that.
Check out this interview where one of the Github trainers, Brent Beer, talks about these ideas. You might want to get in contact with him.
http://blog.begriffs.com/2013/08/an-interview-with-brent-bee...
Yep, they're doing it, just not quickly enough :)
Neat, I'll check out the interview. Thanks!
I've recently switched to papers to help with this. It seems to have a strong community and supports both MS word, libre office, and vim. Jury's still out though.
http://www.papersapp.com/papers/
If the latter, you run into a problem pretty quickly - MS Word. It's still one of the most popular document editing tools out there. More recent versions do store content in zipped XML, but are you willing to put the work into parsing that content at a level sufficient to let it integrate into the kind of flow you discuss?
(EDIT: That said: if your target is those creating text-based documents, then I think this is an excellent idea. )
Also, if there could be some cross-compatibility with MS Word's Track Changes (I know, I can dream...) that would be great.