The rough concept of this one is a website where one can show up
and give some amount of money to a project that interests you.
On the backend, though, that project has a number of members and
sub-projects, and the money automatically trickles through the
system, giving everyone their dues.
Uses
I originally wrote this when I was thinking of remix culture. The
idea was that if I wrote a song that used samples from a few
different sources, then I could make a project representing this song
that would list the songs I'd pulled from as sub-projects. That way,
when someone gave me money for my song, the other artists also
automatically get their share, without me having to collect or
distribute anything.
Then, I thought, one could use this for any back-end payment
structure.
One could make a project for each song on an album, with
sub-accounts for each of the people associated with that song. Then,
one makes a project for the album that just has each song under it.
That way, someone could give you money for a particular song, or the
whole collection. Or, the artist could go one higher and make a
project for themselves that just lists all the albums, so one could
just give money to the artist for existing, and it'd go through the
whole system.
If one were making a movie or, really, any kind of project like
that, where everyone agrees to not get paid upfront, but rather they
all get some cut of the backend, then all you need to do is put all
of the cast and crew into the system under the movie. Then any time
someone paid for the film, it'd automatically go out to all
stakeholders.
That got me thinking that one could use it, in general, as really
simple payroll structure. Make a project representing the company,
put the employees under it, then just put money in the top. Bam,
people get paid fairly.
Open source coding projects are also really suited to it. Not only
are certain people core on the project, and could be remunerated when
the project receives a donation, but often projects use other open
source tools. So, a certain project may be some sort of web app, and
it has developers, but it also might rely on RubyOnRails, and MySQL,
and other such things. If these projects were also all on the system,
then the first project could distribute money to its devs, but then
also pass some of that money on to the projects it requires. That way
everyone helps each other out, etc.
One could even use it for personal income management. Make a
project for ones-self, then subprojects for "rent",
"food", "spending money", and the different
buckets fill up as a quick and dirty money-segregation.
There are probably other uses I haven't thought of.
Setup
I want it to be really really simple and easy to make new
projects, because I want people to throw them together like crazy.
Also, to make sub-accounts so I can go in and simply divide up the
money without each person having to go through a whole process.
So, I think making a new project would just be "Type in a
name, maybe give it an icon, maybe give it a description, maybe give
it a link". I want GitHub style user-centric, rather than
project-centric, so there can be 50 projects with the same name,
because mine is psycotica0/super-project, and I don't care about the
others. That means that I don't have to worry too much about telling
people "No, that project name is taken, think of a new one"
Anyway, now there's a new empty project.
I want to allocate to people based on abstract "points"
rather than fractions. In the end there will be fractions, but those
can be automated. For example, when I add people to a project, I may
add myself with 2 points and someone else with 1, and some technology
I use with 1. That means that when money comes in, half of it goes to
me, and the other half is divided between the other guy and the tech
I use.
I like that feeling a lot more, where I put people in, and all
that really matters is the relative sizes of their contributions. If
I add someone with "10" and someone else with
"20", I don't really care what the final breakdown is, so
long as person two gets twice as much in the end as person 1.
It also, then, makes adding people much easier, since I don't have
to go through and screw with all the fractions to try to squeeze them
in, I can just put them in with their amount of points, and the
system works out the new breakdown.
Adding People
Just like making projects, I want it to be really easy to add
people, since those two things are basically the only thing one does
with the tool. The easier it is to do these, the more likely people
will actually use it.
So, I think one can easily make a new sub-account just by putting
a name in.
For an even simpler thing, I think one could give a text box, and
just have people write in:
1, John Smith
5, Super Bob
3, Todd
1, Mr Kittens
And it'll go through and add them all in bulk, creating
sub-accounts for people that don't already have one. (Having some
sort of a system for "Are you sure you didn't mean..."
seems like a good idea, but adds cognitive load)
This way people can jump in, make a project with just a name, then
add people to it in one step. Done.
Then they can tweak it later, or add other stuff, later. The bulk
is done.
Technical Info
Money Format
I want to represent all the money inside the system as fractions
with as much precision I can afford.
That way, even if someone gets 1/375th of a cent for each dollar
in, it does still build up, and if the project makes $10 000 000,
then they get their $266.66 That's important to me.
Given transaction costs, it's possible I'd have to say "No,
you can't take any money out until you have more than $X", which
I hate, but if that's how it has to work, then ok.
It's possible I can allow smaller payments than that if people
coming in have an account with donatabase. That way we can keep a
balance with them, and then they can pay out of it, refilling it as
required.
I don't know the best way to allow multiple currencies, etc. I'll
have to think about that.
Computing the Tree
So, when money comes in to a given project, that project may
distribute to projects which distribute to projects, on and on.
Sometimes project A may give to project B, which gives back to
project A.
So, it'd be best if I could know upfront where the money is
supposed to go, and then just dump it in those boxes.
Turns out that you can represent each project as an equation, with
projects and accounts in it, and coefficients representing the
fraction that goes to each project and account. Then, if you put the
equations together into a system of equations, you can solve the
system and get a full set of all of the endpoints for each project.
This takes care of long trees, and loops, and other such things
and just flattens everything into "this much goes here, this
much goes here, this much goes here, then you're done"
When someone makes a change to their project, the system must be
recomputed.
Code
I started writing a bit of code, and it's here