..
    This file is part of Invenio.
    Copyright (C) 2015-2018 CERN.

    Invenio is free software; you can redistribute it and/or modify it
    under the terms of the MIT License; see LICENSE file for more details.

.. _code-of-conduct:

Code of Conduct
===============

We endorse the `Python Community Code of Conduct
<https://www.python.org/psf/codeofconduct/>`_:

   The Invenio community is made up of members from around the globe
   with a diverse set of skills, personalities, and experiences.  It is
   through these differences that our community experiences great
   successes and continued growth.  When you're working with members of
   the community, we encourage you to follow these guidelines which
   help steer our interactions and strive to keep Invenio a positive,
   successful, and growing community.

   A member of the Invenio community is:

   1. **Open.** Members of the community are open to collaboration,
   whether it's on RFCs, patches, problems, or otherwise.  We're
   receptive to constructive comment and criticism, as the experiences
   and skill sets of other members contribute to the whole of our
   efforts.  We're accepting of all who wish to take part in our
   activities, fostering an environment where anyone can participate
   and everyone can make a difference.

   2. **Considerate.** Members of the community are considerate of
   their peers -- other Invenio users.  We're thoughtful when
   addressing the efforts of others, keeping in mind that often times
   the labor was completed simply for the good of the community.
   We're attentive in our communications, whether in person or online,
   and we're tactful when approaching differing views.

   3. **Respectful.** Members of the community are respectful.  We're
   respectful of others, their positions, their skills, their
   commitments, and their efforts.  We're respectful of the volunteer
   efforts that permeate the Invenio community.  We're respectful of
   the processes set forth in the community, and we work within them.
   When we disagree, we are courteous in raising our issues.

   Overall, we're good to each other.  We contribute to this community
   not because we have to, but because we want to.  If we remember
   that, these guidelines will come naturally.

We recommend the "egoless" programming principles (Gerald Weinberg,
`The Psychology of Computer Programming
<http://en.wikipedia.org/wiki/Special:BookSources/0-932633-42-0>`_,
1971):

   1. **Understand and accept that you will make mistakes.** The point
      is to find them early, before they make it into production.
      Fortunately, except for the few of us developing rocket guidance
      software at JPL, mistakes are rarely fatal in our industry, so
      we can, and should, learn, laugh, and move on.

   2. **You are not your code.** Remember that the entire point of a
      review is to find problems, and problems will be found.  Don't
      take it personally when one is uncovered.

   3. **No matter how much "karate" you know, someone else will always
      know more.** Such an individual can teach you some new moves if
      you ask.  Seek and accept input from others, especially when you
      think it's not needed.

   4. **Don't rewrite code without consultation.** There's a fine line
      between "fixing code" and "rewriting code."  Know the difference,
      and pursue stylistic changes within the framework of a code
      review, not as a lone enforcer.

   5. **Treat people who know less than you with respect, deference,
      and patience.** Nontechnical people who deal with developers on
      a regular basis almost universally hold the opinion that we are
      prima donnas at best and crybabies at worst.  Don't reinforce
      this stereotype with anger and impatience.

   6. **The only constant in the world is change.** Be open to it and
      accept it with a smile.  Look at each change to your
      requirements, platform, or tool as a new challenge, not as some
      serious inconvenience to be fought.

   7. **The only true authority stems from knowledge, not from
      position.** Knowledge engenders authority, and authority
      engenders respect – so if you want respect in an egoless
      environment, cultivate knowledge.

   8. **Fight for what you believe, but gracefully accept defeat.**
      Understand that sometimes your ideas will be overruled.  Even if
      you do turn out to be right, don't take revenge or say, "I told
      you so" more than a few times at most, and don't make your
      dearly departed idea a martyr or rallying cry.

   9. **Don't be "the guy in the room".** Don't be the guy coding in
      the dark office emerging only to buy cola.  The guy in the room
      is out of touch, out of sight, and out of control and has no
      place in an open, collaborative environment.

   10. **Critique code instead of people** – be kind to the coder, not
       to the code.  As much as possible, make all of your comments
       positive and oriented to improving the code.  Relate comments
       to local standards, program specs, increased performance, etc.
