Re: Beware: Rep spec on an enumeration type ...

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Joe said

<<Well, let me tell you another saying from the retail world:  For every
  customer that complains, there are ten who will simple never come back.
  Silence is not golden.>>

Ah, but we never get silence. Our product is immediate response to questions
and problems, and our customers most certainly take advantage of this. Silence
is not something we get (or expect) from our customers! This is quite a 
different situation from most software vendors, where they get their money
from selling you stuff, and hope you don't call. We hope you will call, so
that you see how valuable to the support is, and most of our customers
most definitely take advantage of this.

<<Well, this certainly allows us to size the problem:  One must have a
  graduate degree in language design and compiler techniques to use Ada.
  That's quite a revelation.  We would have never suspected that Ada was
  that hard to use.

  This gets to the heart of the problem.  Our programmers, being domain
  experts, would rather take graduate degrees in their respective fields of
  interest, in their chosen professions.  If they were interested in being
  compiler experts, they would have instead studied compilers, and they
  would probably work for a compiler vendor, not a system vendor, because
  few system vendors build compilers.  Nor would they be experts at other
  than compilers; there are only so many hours in the day.  Domain expert
  and compiler expert are very different fields.>>

First, Joe has a giant misconception. There is a HUGE gap between taking
a basic course in programming languages and compiler construction at the
graduate level and being an expert, or having a graduate degree in the
subject. Sounds like Joe does not have much familiarity with CS as a
discipline so perhaps this confusion is understandable, but this is a bit
like thinking taking the first graduate physics course turns you into an
expert in particle physics, Sorry it ain't so.

Second, I think he is right, this does get to the heart of the problem. Sounds
like the projects Joe is involved in are making the mistake of trying to build
big programs using ONLY domain experts. That might have worked in Fortran with
simple numerical stuff in the 60's, but it is a major mistake at this stage,
when even scientific programming more and more is getting into the realm of
highly complex algorithms. 

To think that you can be a domain expert and pick up what you need to know
about programming by reading a few FAQ's is as silly as as computer scientist
thinking they can become an expert in physics by reading some "helpful hints
about nuclear physics" FAQ.

What you need these days is a mixture of people who know the domain well, and
programming some, and people who know programming well, and the domain some.
By programming here, I mean the union of language, compiler, software
engineering, design etc knowledge that is required these days to construct
complex systems.

I cetainly am not saying that the only way to get this knowledge is to take
CS courses (my background is a PhD in chemistry, although I did take a couple
of grad courses in Computer Science, one in compilers). Certainly there
are people who not only have the basic knowledge corresponding to these
subject areas, but are world-class experts in these areas, who have NOT
taken courses, but for most people the path to this kind of knowledge is
a specialized higher degree.

Now from reading what Joe has said, the folks in his group simply lack this
kind of knowledge, and they get into trouble because of it. That is not at
all surprising, and I am afraid it will not be corrected by reading a few
posts on CLA. 

Note also that this is nothing to do with Ada. Whether you are programming in
Fortran-66 or C, or one of the newer more complex languages such as C++ or
Fortran-90, you need to know what you are doing. Some of the worst applications
code I have seen has been hacked together by experts in their areas who clearly
have a dismal knowledge of how to program. Often they have the form, but not
the substance, I have seem beautifully laid out and documented implementations
of perfectly horrible and inappropriate algorithms.

One of my favorites was a routine to convert from lower case letters to
upper case letters. I will try to reproduce it from memory. It was something
like:

  function Convert_Lower_Case_Letter_To_Upper_Case_Letter
    (Input_Character : Character) return Character is
  
  -- (piles of documentation about preconditoins and postconditions etc)
  
    subtype Letter_Range is Natural range 1 .. 26;
  
    type Letter_Array is array (Letter_Range) of Character;
    Lower_Case_Letters : Letter_Array := (1 => 'a',
                                          ...
  
  --  (piles of helpful comments throughout, beautifully formatted)
  
    Upper_Case_Letters : Letter_Array := (1 => 'A',
  
  begin
     for Character_Index in Letter_Range loop
        if Input_Character = Lower_Case_Letters (Character_Index) then
           return Upper_Case_Letters (Character_Index);
        end if;
     end loop;
  
     raise Character_Is_Not_Lower_Case;
  
  exception
     when Constraint_Error =>
        raise Convert_Lower_Case_Letter_To_Upper_Case_Letter_Constraint_Error;
  
  end Convert_Lower_Case_Letter_To_Upper_Case_Letter;

The sad thing is that the programmer who wrote this probably thought they
were doing a good job. Certainly this is a nice example of A for effort,
F for content.

I should say that I see this mistake made FAR less often these days. Most
big projects I am familiar with do indeed have a mixture of folks with
different backgrounds, some domain experts, some more expert in the technical
aspects of programming, who work well together. This approach is very
effective. Joe's group should give it a try :-)

Joe, you really *have* put your finger on it. What we have here is a situation
of a bunch of architects designing a house, and then figuring they can do the
carpentry themselves even though they are not expert carpenters. All they need
to do is to go to alt.carpentry.helpful_hints, and read the FAQ, and they
will be fine. When they fail, they complain that obviously it is absurd that
tools like saws require experts to use them, and that saw experts could not
possibly design houses!

Robert Dewar
Ada Core Technologies