Mailing-List: contact geronimo-dev-help@incubator.apache.org; run by ezmlm
Precedence: bulk
Reply-To: geronimo-dev@incubator.apache.org
Date: Tue, 12 Aug 2003 02:55:28 -0700
From: Greg Stein <gstein@lyra.org>
To: geronimo-dev@incubator.apache.org
Subject: Author Tags (was: geronimo-dev Digest 12 Aug 2003 07:13:43 -0000
 Issue 31)
Message-ID: <20030812095528.GC28130@lyra.org>
References: <1060672423.22162.ezmlm@incubator.apache.org>
Mime-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline
In-Reply-To: <1060672423.22162.ezmlm@incubator.apache.org>
User-Agent: Mutt/1.4i

On Tue, Aug 12, 2003 at 07:13:43AM -0000, geronimo-dev-digest-help@incubator.apache.org wrote:
>...
> From: Henri Yandell <bayard@generationjava.com>
> Subject: Re: Author Tags
> To: geronimo-dev@incubator.apache.org
> Date: Mon, 11 Aug 2003 21:09:13 -0400 (EDT)
>...
> Code ownership is bad. But only in terms of the old corporate concept that
> only Mr X can change a piece of code. Code responsibility is important
> however. I've found that when you throw away code ownership, you often end
> up with no one caring.
> 
> Code responsibility means that even though anyone may leap in and hack on
> a piece, the long term future of a piece of code is the responsibility of
> known people. Effectively code-ownership [bad] is implementation while
> code responsibility [good] is design. Author tags signify code
> responsibility.
>...
> From: "Daniel F. Savarese" <dfs@savarese.org>
> Subject: Re: Author Tags 
> To: geronimo-dev@incubator.apache.org
> Date: Mon, 11 Aug 2003 22:02:58 -0400
>...
> Although I agree with the conclusion, I disagree with the reasons.
> Whether it's author tags or change logs, the reason you list names
> is to maintain accountability, not to give credit.  The
>...
> Can you explain it to me so I can make this change?"  Anyway, that's my
> possibly misguided take on the Apache Way: it's not recognition
> that matters, but responsibility.

The Project Management Committee (PMC) is responsible for the code. Period.
That is very clear and is quite specific. The entire point of the ASF is to
ensure that that happens, which is also the reason that all active
committers need to be on the PMC.

Why? Because the PMC (i.e. the committers) operates at the direction of the
ASF. Thus, the code is developed and maintained at the direction of the ASF.
Thus, the ASF can defend those developers against any legal attacks on the
codebase by saying, "they're just following our instructions/desires; they
did not act independently, so you cannot say they are at fault."

If there is any way for a third party [bringing suit against us] to show
that a specific developer is "responsible" for a chunk of code, then there
isn't much the ASF can do to help that person. The ASF exists (primarily) to
provide code to the public, but our secondary responsibility is to provide
an environment where that is possible. And that means to operate within a
legal context. The structure of the ASF and its PMCs is a way to establish
that shield without imposing a burden on the developers.

Lastly, recall that the ASF exists to provide a _LONG_TERM_ home to code.
The ASF exists to provide a place for code to outlive any individual
contributor. Many developers will be interested in some code, but eventually
will move on to other things. This is part of why the ASF cares so much
about the community -- it outlives individual developers. If you can build
an effective community, then it doesn't matter that a developer moves on.
The community is there to pick up and continue where that person left off.
Because of the natural shift in the developer base, it is not possible to
assign any kind of (long term) responsibility to individuals. That
responsibility must fall to the PMC. Only the PMC will exist in the long
term to provide the necessary care and feeding of the codebase.

Maybe there are reasons to have author tags, but I would *really* discourage
their use as a mechanism to establish responsibility for any piece of code.

I think the real problem that you want to solve is how to build a community
that cares about the code, no matter who may happen to have contributed it
in the first place, or who happens to change it the most. To build a
community where everybody feels responsible for the code, and who feels
empowered to make the necessary changes.

Cheers,
-g

p.s. to clarify for those who haven't seen me post much: this post was from
gstein@lyra.org meaning "me"; when I post from gstein@apache.org, then I'm
speaking with an ASF hat on; in other words, my opinions (above) don't
represent the ASF, although my comments about the structure and purpose of
the ASF are "real" rather than personal opinion.

-- 
Greg Stein, http://www.lyra.org/