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 .