who owns the code? was Re: Distinguishing type names from other identifiers

[nabbasi@earthlink.net]

In article <dewar.885126007@merv>, dewar@merv.cs.nyu.edu says...
>
>Nasser says
>
><<Otherwise, it becomes programming by committe, no one is responsible for
>any thing going wrong, becuase no one owns the code. If one part of the
>software is not working, one can't hold any person responsible, this seems
>to me to allow lazy and bad programmers to ride on the shoulder of better
>programmers.
>>>
>
>
>The trouble is that if your view is that one particular person is
>*the* person responsible for fixing a bug if it occurs in unit X, then
>what if that person is on vacation, or suddenly leaves the company.
>Inevitably this kind of ownership discourages others from learning
>that code, or fixing it, and, as you note, taking responsibility for it.
>

But this is not a problem, we always face this, and it never caused much 
of a problem, when once person leaves, another takes over his/her tasks.
this does not just happen in software it happens in ever other field.

I am not saying one should not be familiar what what others are working on,
but having 2 or more programmers working on the code at the same time JUST
to cover the basis in case one quits or goes to vacation seems too drastic
a solution for me.

>My ideal of a project is that everyone takes responsibility for everything,
>and that every part of the system has more than one person knowing it 
>well enough to fix or modify things. 

well, having 2 or more programmers working on the same peice code 
could not work well. It is like having 2 cooks making the same 
meal. or 2 or more painters drawing on the same picture at the same time. 

I for one, could not work on a package or class, where 
I came in the morning to see my code has been modifed, and I could 
never modify someone else code on the project without a very good 
reason (customer on the phone screeming, the owner of the package is out
sick, etc..) and without at least asking first if at all possible.

I am all for the team spirit and the little community feeling, but 
I beleive that each programmer should be assigned a task, and they 
own up to it, and they are resposible for it and no one else. 

After all in Ada, of all the languages, encourages having a well defined
interfaces between parts of the software system. What should happen then, is 
after agreeing on the interfaces between packages, each programmer will own
1 or more packages, and they implement these to the interface agreed upon.

I am resposible for the implementation and testing and fixing bug in my
package, I would not want someone to be fixing my bugs for me, or modifying
my package as long as I own it. Offcourse there will be design meeting and
continue groups discussions, but it is known who owns what.

>Ideally testing procedures should
>be set up to minimize the problem of introducing bugs into a system
>but if someone *does* introduce a bug, then what should happen is that
>they feel a strong sense of responsibility to the little community that
>is the project they are involved in, and rush to fix the problem.
>

BUT who should rush to fix a bug that person A caused? Who is better to 
fix a bug made by person A that person A? offcourse if A asks for help,
or code review from another person on the team, I'll be the first to volunteer
to help look at the problem with person A untill the problem is solved, 
but having every one in the team somehow be held resposible for a 
problem caused by person A does not seem right to me. 

>Furthermore, everyone needs to work together, so that if someone does
>make a mistake, other people's reaction is to work to help sort it out,
>rather than sit around being annoyed.
>

Offcourse they should help each others, but there is a big difference
between helping each others, and between having no one owning anything,
then where is the personal resposibilty?

>A good test for me is how the "owner" of unit A reacts if someone else
>fixes a problem or makes a modification in unit A. All to often the
>reaction is a defensive one ("what's this guy doing messing with my code?").
>What you are aiming at is that the reaction is more like "great, thanks,
>now I don't have to fix that bug myself".
>

But if they don't fix their own bugs, they will not learn not to do it again !

Soory Dr Dewar, I can't agree with your style of running a software
project. it is obviously has been successfull for you and your team, but  
I like to think where I work that I am held responsible for my bugs, and I 
should be the one to fix them, and If I need help, I'll ask, and if I am
working one some part of the system, I do not want others to be working
on it at the same time,(they must have their own parts of the system
to write that will keep them busy!) this is just practical thing for me, I 
just don't see how a group of programmers be all working on the same 
piece of code at the same  time. it just plain cofusing to me.


Nasser