Marginal Structure |

on sunday robbie and i were driving back to cupertino after visiting my mom and brian in santra barabara on their vacation. we had a while, so we got to brainstorming about this idea of note sharing software. that is, software through which you can share notes you take in meetings and discussions, with a trusted network of friends. the goal is to make us all more effective by exposing what would normally be personal content to deeply trusted networks, thereby tightening the loop around making connections, routing information, and acting in sync on our efforts.

each set of notes has to be sharable with a distinct subset of people. i might want to share notes from one meeting with robbie and will, but notes from a different meeting with josh, matt and will. other than that, it’s fairly similar to a file share. new notes need to be pushed out to those people with whom they are shared. ideally, there would be a web interface as well, with a way to view and run queries against notes you have permissions on. in the nice-to-have category, you can add tags, and run queries on content,  attendees, or other types of metadata.

we’ve been looking into ways to use existing tools– everything from text files, to google groups, to evernote’s API. all of these have their merits for sure. but an interesting idea came up recently, which is to push the architecture for such a system below the application layer, into the filesystem layer. this has the distinct advantage, in my opinion, of not requiring any specific application for note taking. not only does this mean we dont have to agree with each other, it means we dont even have to agree with ourselves over time. the platform is application agnostic, freeing us up to use what we want, where we want, depending on the situation or content.not changing user behaviour

in this version of the note sharing software then, we would use the addition of a file to a specific directory to indicate that this is a note to be shared. the simplest way to think of it is as a subversion repository. svn add, svn up.

but the number of distinct sharing groups is huge. i am not just potentially sharing with every other person in the note sharing universe, i am potentially sharing with every distinct subgroup in that universe. this goes as something like n!. that’s a LOT of svn directories. among other absurdities, it suggests that perhaps a correlation of directories to sharing groups is not the optimal one.

so currently i’ve been wondering about using something like AMQP. it might be overkill, but it’s actually a lot simpler to use than you’d think for a low level messaging protocol. more importantly, the general concept of using a messaging-type approach is interesting. it would support queueing messages and delayed delivery in offline situations. the notes could be replicated across exchanges for each person being shared with. you could even let users define (or select) different queues for them to go to depending on various attributes– tags, sender, etc. hey, it’s practically a webhook!

i’d still like to find a way to specify the recipients of a shared set of notes in such a way that the user’s behaviour is minimally changed, and that is platform (and OS) indepedent. perhaps a script that detects a new file in the relevant directory, and runs a python based popup to request recipients?

we’ll be hacking on this next tuesday, and similar collaboration projects every other tuesday for the next few months at the rainbow mansion. the idea is to build a suite of tools that increase the ability of kick ass people to make kick ass decisions. too often, the “right” decision would have been informed by what others are working on. creating natural ways for that information to be available in trusted groups would, in itself, be kick ass .