Bigsley the Oaf

Strong Open Groups (notional)

Posted in Uncategorized by bigsleytheoaf on September 23, 2013

I want there to exist a solution to the problem of group
creation/maintainance, online. Specifically, a system which allows users
to form groups in whatever way they desire.

For instance, suppose you wanted to create a group online which accepted
new members through the following process:

– In order to become a new member, you must submit a maximum 500-word
written account of why you would like to be included in the group.

– The current members of the group are allowed to vote on whether or not
the new member will be allowed. Either a 70% quorum must be reached in
10 days for the vote to be considered valid. 66% of responding group
members must agree on acceptance for the new member to be accepted.

How would you create such a group? What’s more, how could you integrate
such a solution seemlessly into a system like reddit, or quora, where
you might want to interact with a limited number of people?

How do you build walls in the internet?

There are obviously some requirements for such a system to function:

1. The identity of group members must be unique (one person must not be
allowed to have multiple accounts)

2. Group members must have a means of identifying themselves which is
protected. E.g. each member might have a cryptographic key which is a
hash of some group secret key and their own personal key.


Potential Applications:

– Imagine if reddit integrated this system. It might be able to solve
the problem where having too many random new members dillutes the
material. You could invite a core group of friends, then only allow
members into the group which has access to the usual reddit interface.

– The example of a rule set which I gave above would be useful for a
social media site, but imagine a system in which you want to give
rights to an admin to allow new members into the system, e.g. in
creating new accounts in business software. They might write out rules
— In order to become a new member, a member of a special class of
members (admins) must approve the new member.



– One big question is how to give a language for defining the “system of
rules” which allows new members to be added, old members to be deleted,
etc. A specification for such a groups system might be written in an actual
DSL, such is the generality required.

– Another big question is how to bootstrap the process. E.g. how to add
initial members, though I suppose this could just be included in the
initial request.

– Obviously the set of rules should be visible by everyone – e.g. there
should be no back doors allowed.

– Canonical group modifications are: add member, delete member, delete
group, validate membership

– How does group membership checking work? Probably some crypto shit
like the server sends you a key which you hash with your private key
(which it also has) and then checks the hash…
— some of this may be able to be handled by having users’ membership
keys on a secure server and give them access to these keys through a
password (otherwise they can keep their keys on their own computer)


API (first pass):

POST group
members: [member]
rules: string
-> id: integer

display_name: string
uuid: string

DELETE group
id: integer
-> success: boolean

PUT group
id: integer
member_id: integer
modification: string

GET membership_challenge
group_id: integer
-> challenge: string

GET membership_solution
group_id: integer
member_id: integer
challenge: string
solution: string
-> success: boolean


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: