Subject: ethics of code usage

From: [email-masked]
Date: Tue, 16 Nov 1993 12:46:03 -0800

Well, prompted by this discussion, I have kind of on-the-fly 
thrown together some thoughts I have had running around in my 
head for a while and which, when polished, will comprise a 
"help porting" text on my MOO, ForeMOO. (Whenever ForeMOO can 
be loaded back into existance, that is). Anyhow, I have 
included the (long, bureaucratic) first draft here...
 
help porting-----------------
 
On many MOOs, the question is raised, "Who actually owns a 
piece of code written on this MOO? Whose permission (if any) 
do I need to get before I copy code from this MOO to another 
MOO?"
 
The answer is, of course, individual to each MOO.
 
On ForeMOO, the Archwizard has deemed that any code written on 
this MOO is the property of the administrative body of the 
MOO. This may seem harsh to some, but consider that most 
corporations consider any code written using corporate 
resources to be property of the company. As is frequently 
stated, ForeMOO is not a democracy. There is a definite power 
structure on ForeMOO, and this will not change. To experience 
VR democracy in action, we recommend LambdaMOO (13.2.116.36 8888).
 
Of course, to say that we maintain control of all code 
existing in the database does not imply a strict policy. It 
merely says that there *is* a policy, and the formation and 
application of this policy rests solely with the ForeMOO 
wizards.
 
The current policy (16 November 1993):
 
CODE -- Used to refer to any functional discrete element of the MOO
        which may be transported to another MOO, including all verbs, 
        objects, and properties. Algorithms are also considered
        elements of code unless accompanied by a comment reserving
        intellectual ownership of the algorithm.

1) CODE owned by you:
        a) CODE created by you:
                You may freely port CODE which is the
                product of your own effort. No restrictions.
        b) CODE you have ported from other MOOs:
                If you have ported CODE from another MOO
                to ForeMOO and you wish to port that CODE from
                ForeMOO to yet another MOO, you must follow the
                guidelines for porting set up on the MOO from 
                which you originally ported the CODE. (IE if 
                BigMOO specifies that the owner should be asked
                before porting CODE, and you did ask Owner_X for
                permission to port his object from BigMOO to 
                ForeMOO, you must ask his permission again to
                port his object from ForeMOO to LittleMOO.)
                Credit must be given to the original author. 
                (See 'Credit for CODE') In cases where the
                MOO from which the CODE was originally ported
                has no policy regarding porting of CODE, the
                ForeMOO wizards recommend obtaining the
                permission of the author.
2) CODE owned by other players:
        a) CODE created by another player:
                You must ask permission of the original author
                before copying any CODE. No modifications to the
                CODE are permissable unless approved by the
                author. Credit must be given to the original
                author. (See 'Credit for CODE')
        b) CODE another player has ported from another MOO:
                In order to do this, you must satisfy the
                requirements of BOTH sections 1b and 2a above.
3) System CODE:
        ForeMOO is based on the publicly released LambdaCore. Most
        features of the system are available for anonymous ftp
        from parcftp.xerox.com: /pub/MOO.  ForeMOO does, however
        implement a number of changes to/improvements on/deviations
        from the original core. If you are interested in porting
        elements of the ForeMOO Core, please contact a wizard.
        Credit must be given to the original author. (See 
        'Credit for CODE')
4) Credit for CODE:
        a) For entire objects:
                A single property, .credits_for_object, will be
                placed on the ported object. It's contents will 
                be determined in part e) below.
        b) For single verbs:
                Verbs which are not part of a ported object (the
                verbs on whole objects are considered 
                collectively) should have a tagline at the 
                beginning of the verb code (so as to appear in
                help object:verb) which contents will be 
                determined in part e) below.
        c) For single properties:
                Properties which are not part of a ported object
                (the properties on whole objects are considered
                collectively) should be cited in a property,
                .property_credits on the destination object.
                Contents to be determined in part e) below.
        d) For algorithms:
                Less restrictions are placed on algorithms as
                they are less tangible than the above elements.
                If there is a comment in a piece of code (and 
                we assume you study and understand what you
                port) stating that the author retains rights
                to an algorithm, credit will be given in a
                manner deemed appropriate by the author of the
                algorithm.
        e) Contents of Credits:
                The credits must contain the following elements:
                        * Author's (Authors') name(s)
                        * Author's (Authors') object number on
                          MOO where CODE was created.
                        * Identifier (object#, object#:verbname,
                          object#.propertyname) for CODE on MOO
                          where CODE was created.
                        * Appropriate dates of creation/
                          modification and revision numbers 
                          where appropriate and provided by
                          the author.
                        * Date on which porting of the CODE was
                          completed.
 
5) Incoming ports of CODE:
        Any code ported into ForeMOO from another MOO must be
        brought in using the appropriate policy from the source
        MOO. In cases where there is no policy on the source 
        MOO, the ForeMOO wizards recommend asking the author's
        permission.
6) Violation of Policy:
        Violation of ForeMOO's policy regarding CODE porting 
        will result in disciplinary measures to be determined
        by the wizards of ForeMOO. A likely punishment is
        temporary or permanent loss of programming privileges
        on ForeMOO, depending on the severity of the violation
        as judged by the wizards of ForeMOO and the author of
        the illegally ported CODE. Objects ported into ForeMOO
        which do not conform to the policy requirements of the
        source MOO may be deleted entirely or stored in an 
        unusable form until such time as the source MOO's policy
        requirements have been fulfilled.
 
(End of help text.) ----------------------
 
I'd really like to hear suggestions on ways this could be 
improved, or just opinions in general.
 
====Rob (Gelfin@LambdaMOO, OpalMOO, JaysHouseMOO, ForeMOO)
 
P.S. Also, as a despiser of complicated bureaucracy, do you think
     this sort of thing is really necessary? (I mean *I* am a
     despiser of bureaucracy, of course..)