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

[gwinn@res.ray.com (Joe Gwinn)]

We are again in one of these circular discussions.   I don't think I can
explain it any better than I already have, so I'm not going to try.  

I will summarize my point:

One can go on and on about what people should or should not do, but I very
much doubt that our immediate customer will ever use Ada again.  It
matters not at all if they are right or wrong; as our customers, they are
by definition right, and we will do as they ask.  What they see is zero
trouble with C, but lots of trouble with Ada.  

I have been trying to report how it works in the world, and all I get is
yards of text trying to convince us that because the belief is wrong, they
cannot think as they think.  Well, think again.  It doesn't really matter
if they're wrong, they're tired of surprises and expenses, and C/C++
beckons.  It may be that C/C++ is all hype, but it's certainly effective
hype.

What one would have hoped for here was focused effort on solving the
problems that are driving customers away, not an argument claiming that
there is no problem, or that everybody is stupid, too stupid to use Ada.  

On the other hand, perhaps you're right, and, in view of their limited
capabilities, they should run immediately to a language simple enough for
them to handle?

Joe Gwinn



In article <dewar.882020417@merv>, dewar@merv.cs.nyu.edu (Robert Dewar) wrote:

> 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