Share, the thesis project of Yannick Assogba in the MIT Media Lab Sociable Media Group, is an interesting idea in coding: it’s basically a peer-to-peer sketchbook for creative code. All of your sketches are synced to everyone else’s sketches, and Share tracks the connections between users.

You get more from Share than you would from simply, say, sharing a Subversion repository. Share not only syncs code and changes, but also tracks each time you copy and paste code from elsewhere, so that code snippets borrowed from others can be traced through the people using the system.

Up to 30 people are now invited for an online competition using the tool.

The Share Experiment is an online competition/design-a-thon/hack-a-thon and exhibition that invites 30 participants form to use Share to make new creative works over the course of ten days. The theme of this competition is "Inspired By Pong". Though the final result need not be games, artists/hackers are invited to reinterpret and remix the concept of pong while at the same time being open to reinterpretations and sampling of their own work as it being created. The Share Experiment will run from June 5th – June 14th and we are inviting applications. There will be some prizes awarded to winners (including iPod Touch[es] and Arduino kits) and we have some interesting ideas about mechanics for awarding prizes! (via toxi on Twitter)

What is the Best Way to Share?

It’s a very cool idea, but this does raise some questions about implementation. It’s too bad that Share can’t run as some sort of plug-in; it loses some of the functionality of the bare-bones Processing editor, let alone the capabilities of an IDE like Eclipse or NetBeans. If it used a standard IDE, too, it’d be easier to be “language-agnostic” as the creator suggests. (OpenFrameworks or Flash or Processing, it wouldn’t really matter.)

But as a concept and an experiment, this looks really fascinating. It should be interesting to see how people use the code. And will users in a “competition” do a lot of copying and pasting, or focus mainly on their own work?

Part of the reason I bring up this is that we’re interested on CDM in doing some shared work. “Share” I think would be too limiting; it’s back to the old-fashioned Subversion approach.

So, for instance, we’re organizing a hackday around tangible interfaces in June, the first of what I hope will be many more. We’ll have people working on it in person in New York, but also folks collaborating around the world online. I’ll post more details, but just to kick off the discussion:

(Note: that page mostly talks about using LusidOSC and Trackmate, but I really like their physical design ideas – you can easily substitute reacTIVision and TUIO if you like, and I’m definitely looking forward to the TUIO2 update soon. One advantage of the Trackmate tracker itself is that it’s built in OpenFrameworks, if that’s an environment of choice for you.)

Part of the idea is that we’d like people to contribute shared code and experiments, whether they’re advanced users or novices. I think a tool like Subversion can be ideal for that – students at NYU’s ITP, for instance, work with Subversion for Processing very early on, even though many of those students are pretty new to programming.

A traditional solution like Google Code or Sourceforge for hosting Subversion seems like not a bad idea in this case. I was likewise interested to see Project Kenai support built into a recent version of NetBeans, another example of how these sorts of things can be integrated with the IDE.

So, how would you prefer to share code – for the hackday, or any other reason? Subversion vs. Git? Google Code vs. Sourceforge? And what would an ideal tool do for you in terms of facilitating collaboration?

  • Nek

    My 10 cents goes for Mercurial. It has got local repositories and nice TortoiseHG frontend.

  • Max Hawkins
  • GitHub, sorry, I find kinda ass-backwards. It starts with the tool and builds the code around it, rather than assuming the code / projects are the core. And didn't Sourceforge or Kenai or one of these sites just add Git support anyway?

    Mercurial is indeed awesome.

    I'm happy to hear *why* Git should be the choice, though. Linus Torvalds is brilliant, but why a choice for *this particular job*, I mean.

    Compatibility is key, too, so that people can easily use whatever repository you use in their file manager / editor / IDE of choice.

  • "GitHub, sorry, I find kinda ass-backwards. It starts with the tool and builds the code around it, rather than assuming the code / projects are the core."

    I really don't see that. Can you elaborate?

  • Oooh, actually, speaking of which —

    Google Code + Mercurial.

    That could be a delicious combination.

    And since both Eclipse and NetBeans support Mercurial, a quick how-to tutorial for the Processing people (and I hope eventually a decent OpenFrameworks template) could mean just about anyone could use it.

  • Nat

    I really like Google Code, simple and elegant, and they added Mercurial support (which I am testing) and it works great ! Much easier than SVN.

  • I don't know, GitHub is limited to Git – I guess that's my problem with it. 😉 And then, on top of that, it doesn't have the toolset that Google Code or Sourceforge do (or Launchpad, or Kenai…). So I wonder if it wouldn't make more sense to use one of those tools with whatever repository tool made the most sense.

    But anyway, I'm game to use anything, really. Mercurial allows easy branching, which is good, and has plug-in support, and Google Code seems pretty friendly, so that's why I made that argument.

    But other thoughts?

    Discuss. I'll stop cutting in. 😉

  • chompy omega

    sourceforge sucks compared to the other tools. SUCKS. I mean, really.

    any version control thing would work fine. the distributed ones are cool because then you can have an easy local way to keep and rollback changes and then push them up somewhere public.

    what do sourceforge and google code have that github doesn't? if you put it somewhere else, someone will fork it and then put it on github anyway, so it doesn't really matter.

    github is nice because they focused on making it easy to share code. put something up there, others fork it and pull it down. the other sites have too many steps and focus on a bunch of other features you don't really need.

  • Yeah, but isn't it a whole lot better if you do your forking *within* the repository? Hence, back to Mercurial… if someone can explain the popularity of Git and GitHub, I'm happy to hear it. It seems to make some tasks harder.

  • (I agree Sourceforge can be overcomplicated.)

  • Nat

    Peter, Mercurial is written in Python, makes it the best choice 😛
    Kidding apart,
    There seems to be a war between GIT and Mercurial similar to vim vs emacs (though not as intense) I'd be curious to hear about the pros and cons of each. I have used both, but not extensively enough to be able to say if one is better than the other.

  • Nice guide to Mercurial here:

    And some nice examples of use with NetBeans (have to check out Eclipse's plug-in implementation):

    It just looks easier and better-supported than Git to me, unless I'm missing something.

    Certainly, the fundamental advantage over SVN is to have distributed code, which I think makes a lot of sense for this particular application.

  • What tools are you referring to that other code hosts provide that GitHub doesn't?

    We're also working on a mercurial plugin that'll allow you to push and pull your hg repos to GitHub:

  • PB

    I really like Google Code, simple and elegant, and they added Mercurial support (which I am testing) and it works great ! Much easier than SVN.