«

Just a related thought. You can safely interchange C with Verilog and
ADA with VHDL


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>> & 0x00ff00ff) | ((n<< & 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.