Re: Perhaps there _is_ a conspiracy against Ada

[Alan Brain <aebrain@dynamite.com.au>]

Matthew Givens wrote:
> 
> No conspiracy, just the realization that Ada doesn't fit in most
> environments.  Or rather, that other languages fit better in most
> business environments.

The first real-world C program I did was in 1980. Since 1983 I've been
trying to convince C hackers about the benefits of Ada. Those that
actually were forced to do some real project in Ada were quickly
converted. But mainly, no-one tried.

Trying to tell people about the benefits often leads to complete
stonewalling. There has to be a logical reason for this - few
programmers have low IQs.

I've finally become convinced that C really IS better than Ada, for the
following reasons:


FOR THE PROGRAMMER

..Hacking away in C is fun, you can add trapdoors and trojan horses real
easy

..You can write neat stuff like the following code fragments:

    #define BITCOUNT(x)      (((BX_(x)+(BX_(x)>>4)) & 0x0F0F0F0F) % 255)
    #define BX_(x)            ((x) - (((x)>>1)&0x77777777)  \
                                   - (((x)>>2)&0x33333333)  \
                                   - (((x)>>3)&0x11111111)
    p = BX_(n);

    n = ((n>>1)  & 0x55555555) | ((n<<1)  & 0xaaaaaaaa);
    n = ((n>>2)  & 0x33333333) | ((n<<2)  & 0xcccccccc);
    n = ((n>>4)  & 0x0f0f0f0f) | ((n<<4)  & 0xf0f0f0f0);
    n = ((n>>8)  & 0x00ff00ff) | ((n<<8)  & 0xff00ff00);
    n = ((n>>16) & 0x0000ffff) | ((n<<16) & 0xffff0000);

   which is difficult to understand, and makes you look really, really
clever, even though it does something utterly trivial ( p is the number
of
bits in n, and n ends up with its bit order reversed )

..You'll always have a secure job, trying to make sense of other
people's code after they've left

..You'll always have a secure job, as with well-written, terse, tight
and efficient C YOU are the ONLY one who can easily understand your own
code!

..You'll always have a secure job, as large C programs always have lots
of bugs, and require oodles of maintenance

..Compiling is really easy - even when the stuff you're compiling is
utter garbage, the compiler won't tell on you

..You can ignore most of your coding errors until quite late in the day
- with any luck, until you've left the project


FOR THE SUPPLIER

..You can always find C hackers, and they're dirt cheap

..With C, you get the initial build done quick, cheap and dirty, and
make a fortune over the next 10 years putting in new bugs while removing
old
ones.


FOR THE CUSTOMER

..Because programmers and suppliers tell you so.



Ada is worse than C because

..Only Anal-retentive weenies who mumble about Quality and
Professionalism would get any fun out of Ada

..You'd get into the habit of writing stuff like

   with MACHINE_SPECIFIC;

   procedure COUNT_BITS_AND_REVERSE
     ( THE_WORD  : in out MACHINE_SPECIFIC.WORD_TYPE,
       THE_COUNT :    out MACHINE_SPECIFIC.BIT_COUNT_TYPE
     ) is

   declare

     package BIT_OPS renames MACHINE_SPECIFIC.BIT_OPERATIONS;

   begin

     THE_COUNT := BIT_OPS.BIT_COUNT_OF(THE_WORD);
     BIT_OPS.REVERSE_BIT_ORDER_OF(THE_WORD);

   exception
 
     when others => raise CODE_CORRUPTED_OR_HARDWARE_ERROR;

   end COUNT_BITS_AND_REVERSE;

   which any programmer can easily understand, even though it does trap
some of the errors caused by the over-running array bounds in the C
you've
had to PRAGMA INTERFACE to, soft errors, and hardware glitches.
   Not only that, it works on 16, 32, 64, 48 etc bit machines as well.
So you can't get lots of bucks writing different versions.
   And then the compiler barfs, and tells you what you've done wrong!

..You spend a long time looking for a job, as your code on the last
project worked so well that the project completed on time, and you were
no
longer needed.

..You spend a long time looking for a job, as the maintenance effort
needed consisted of 2 part-timers rather than the whole development team

..You spend a long time looking for a job, as no-one uses Ada

..Getting a Clean Compile of anything non-trivial is quite difficult.

..Your Ego takes a hammering by the compiler constantly showing you
where you made mistakes. And if not the compiler, the Linker!


FOR A SUPPLIER

..Ada programmers are rare and expensive. You can't hire cheap graduate
coolies.

..It costs more initially to make a system, and it takes longer. Much
worse, there's almost no maintenance, so your only revenue is from the
initial sale.


FOR A CUSTOMER

..Because the programmers and suppliers tell you so.


That's the bottom line, people. The only people who benefit from Ada are
the customers and users. The user riding on a 777 generally doesn't know
that any programming was involved, and the customers rely on advice from
their
suppliers.

Until we understand that, all arguments regarding the qualities of Ada
are irrelevant.     


aebrain@dynamite.com.au     <> <>    How doth the little Crocodile
| Alan & Carmel Brain|      xxxxx       Improve his shining tail?
| Canberra Australia |  xxxxxHxHxxxxxx _MMMMMMMMM_MMMMMMMMM
100026.2014 compuserve o OO*O^^^^O*OO o oo     oo oo     oo  
                    By pulling MAERKLIN Wagons, in 1/220 Scale
See http://www.z-world.com/graphics/z/master/8856.gif for picture