Re: Programming language vote - results

[Alan E & Carmel J Brain <aebrain@dynamite.com.au>]

Ingemar Ragnemalm wrote:

> There are plenty of people who use C since it is "cool", but just can't
> say what is so cool with it. It is cool because Mom can't understand it.
> No, they won't say that. You can identify that kind of people by the
> lack of comments in the code. They *want* it that way - and they are
> many!

> When you show the bad way to those kids, they think it is WAAAY cool!
> They will use any stinking obscure construction just because "it is
> valid C code".
> 
> Simple example from real life:
> 
> if (call_this() || call_that());
> 
> Valid, yes. Better than
> 
> if (!call_this()) call_that();
> 
> or more clear forms in other languages?
> Some people actually think so.


Here's a post from some time ago. I've had numerous requests from people
to circulate it around their offices. But no rebuttals....


> C is better than Ada because....
> 
> 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 fool 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
>    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
 abrain@cs.adfa.oz.au  o OO*O^^^^O*OO o oo     oo oo     oo  
                    By pulling MAERKLIN Wagons, in 1/220 Scale