[racket] Google Summer of Code 2012 Ideas

From: Eli Barzilay (eli at barzilay.org)
Date: Fri Mar 2 07:41:57 EST 2012

9 hours ago, Stephen Bloch wrote:
> I don't actually have a github account, but I wanted to mention the
> following idea both to current Racket developers and to potential
> student programmers.  Could somebody add it to the wiki for me?
> Summary: a DrRacket plug-in to enable real-time collaborative
> editing of a source file, possibly with fine-grained logging as
> well.  Two or more different programmers each edit the same file
> simultaneously, and edits one of them make show up immediately on
> the others' screens.

Having two (or more) people who *edit* the code simultaneously (in
contrast to having a shared screen such as a VNC session), is going to
be hard.  The easy implementation will require each edit to go to the
server that does the shared editing, which is likely going to be too
slow to be convenient even on a LAN.

But there is a perfect fit here: the "Operational Transformation"
thing that is used by etherpad and later by google wave.  Implementing
that might be difficult, but one possibility to make things easier is
to use etherpad-lite (a node.js server) to orchestrate the shared
editing.  As a bonus, it has the fine-grained edit history that you
want.  I don't know how hard it will be to plug into it from an
application though -- but another option is to do the editing in a
browser, using etherpad-lite for the editing backend, and showing the
result of clicking "run" in a window.  (But implementing this is a
different object...)

(BTW, I'm looking into using it for a wiki, with the same goal of
making it do the shared editing part.)

> Requirements/Difficulty: Will need to hook into DrRacket.  Will need
> some kind of server, with user authentication and permissions (so a
> specified set of students have access to the shared file); see the
> project already on the Wiki about adding git support to DrRacket.

Note that this kind of project is not really related to git.

> [...] I'm thinking of something that effectively pushes every few
> seconds, but only every several pushes become a distinct "commit"
> record.

(The problem with a naive approach like this is that it won't be able
to handle simultaneous edits to the same piece of text.)

          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
                    http://barzilay.org/                   Maze is Life!

Posted on the users mailing list.