2009-12-15

constitution for federated development

6.18:

. after reading about getting over benevolent dictating
I began to think about ways to make forking part of the process .
. each contributer would have their own root-level subfolder
within a familiar svn (subversion) repository .
. this would virtually turn svn into a git or mercurial
in that the primary design goal of git was to facilitate forking,
and make that a religion rather than a problem .

. svn can be used to talk with eachother via
writing comments and suggestions in each other's forks .
. you are not expected to keep these comments in your code
but you give them a quick review and either roll changes back
or merge the changes by following the advice .

. contributors can have various combinations of
both the implementation and interface forks;
eg,
interface forks will be for trade-off's between
efficiency and security,
while an implementation fork may be used for
practicing a different coding religion (language, format, ...);
[12.15: or,
they may do the documentation after the coding rather than before,
whereas, a major reason I started my own project
was that I wanted documentation written first
and I wanted the code written in my own language .

. another reason to fork is the interface religion:
eg, the mac strives for consistency through dictatorship,
whereas, the constitution of addx requires that
the user have intuitive access to an interface editor .

. the shared.subfolder would contain the constitution;
this includes any contributor requirements .
. for the most part, sharing between contributors is done by
viewing the code of other forks,
and linking to (rather than copying)
the modules of those that are either doing a great job on their own,
or are willing to negotiate mergings .
]
. if the forks can share much code,
then there is no issue with forks taking up limited resources;
otherwise, the shared.subfolder can point to where
various forks have migrated .
[12.15:
. the shared.subfolder will introduce each interface fork;
and, explain the extent to which the modules from various contributors
can be used interchangeably within a selected interface .
]
. the shared system described by the constitution
makes it easy to select a combination of modules
and have the system built from source without giving the user
headaches for making choices .