Re: What is wrong with Ada?

[Brian May <bam@snoopy.apana.org.au>]

>>>>> "adaworks" == adaworks  <adaworks@sbcglobal.net> writes:

    >> That will give them a really strong incentive to camouflage
    >> what really happens and make mistakes look like other peoples
    >> mistake or argue that they are other peoples mistakes. The
    >> organisation will get bogged down in a lot of "ass covering"
    >> and infighting.
    >> 
    adaworks> Any programmer who resorts to this kind of deception
    adaworks> needs to be fired, and quickly.  We all make mistakes.
    adaworks> We need to own up to those mistakes.  I am more inclined
    adaworks> to fire a programmer who tries to blame others than one
    adaworks> who acknowledges a mistake and works on correcting it.

This only works if management understands the problem. If your
relationship with management is strained, pointing out problems with
other programmers (whether deliberate or accidental issues that
regularly occur) can make you look like the bad programmer who is
blaming others. In this case in might be best just to leave the job.

In previous job I frequently had my commits reverted. One such
occasion, I asked the offender who initially argued he hadn't reverted
anything. I suggested "maybe you did an update with the file still
loaded in the editor". "No I didn't! Besides Subversion would take
care of that!". I reverted the previous revert after extracting the
changes that had been reverted from other changes that were also
committed in the same revision.

This was eventually followed by "your change broke my code so I
reverted it again". Finally! We come to the real reason. Another piece
of code was using the a function in a way that I never intended, so my
change broke it.

Whether these issues are minor issues or major show stoppers depends
on the culture of the company. Unfortunately, in this case, management
didn't care for quality code, they just wanted results. Documenting
code was seen as wasting time. Management was of the view that bugs
where going to occur anyway, and there was no point trying to do
anything about it.

As a result other programmers started adding code to my well defined
functions and classes to handle cases that these functions and classes
were never intended to handle. Eventually even I gradually forgot what
my original intentions were, so started doing the same thing myself. I
couldn't just look at my code to find out either as I wasn't sure
which parts of the code I originally wrote and which parts where
hacked in latter (and exploring subversion would have taken too long).

Not that my original design for these functions and classes were that
good anyway, they were based on existing concepts at the time which
had accumulated over the years.

It was pointless trying to argue that the code would be a lot cleaner
and more maintainable if we did a complete redesign followed by a
complete rewrite - we were too busy adding more features - so I left.
-- 
Brian May <bam@snoopy.apana.org.au>