Re: Any research putting c above ada?

[kaz@vision.crest.nt.com (Kaz Kylheku)]

In article <336148DD.4BC0@mindspring.com>,
Larry Wissig  <lwissig@mindspring.com> wrote:
>> 
>> The requirements call for overloadable functions. It's religious issue
>> whether these are a good thing. IMHO, they are bad. I avoid overloading
>> function names even in languages that offer the feature. Overloaded function
>> names are extremely poor programming practice. To figure out which function
>> is called, you have to look at all the argument types and apply all kinds
>> of rules. In Ada, the rules are particularly arcane. Not only do the
>> actual argument types matter, but also the expected type that is inherited down
>> the expression tree. You have to be a compiler expert just to understand
>> what's going on.
>> 
>> 
>
>Definitely religious. Overloading functions of the same name with diff
>types little different in effect (albiet less effort) than generating
>unique names for them yourself. Figuring out which function should be
>called is the complilers business. 

It is the compiler's business, but the human who is reading the program
has to understand the compiler's business in order to figure out which
function is called. I think it's a plus that C doesn't have function
overloading, and should count as a point against the other languages.

To add support to my position, consider this snippet from the Eiffel FAQ:

L08)

Why doesn't Eiffel allow function overloading?

In Eiffel, no two features of a class may have the same identifier, regardless
of their respective signatures. The prevents the use of function overloading
("multiple polymorphism"), a common programming technique in languages like
C++.

Eiffel is designed to be minimal: it includes exactly the features that its
designer considered necessary, and nothing else.

Because Eiffel already supports (single) polymorphism through its inheritance
system, the only positive thing that function overloading buys you is reducing
the number of feature names you have to learn. This is at the expense of
reducing the ability of the compiler to trap mistakes (often type errors).

Readability is also enhanced when overloading is not possible. With overloading
you would need to consider the type of the arguments as well as the type of the
target before you can work out which feature is called. With multiple
inheritance and dynamic binding this is awkward for a compiler and error-prone
for a human. There is no intuitive rule which could be used to disambiguate
routine calls where there is no "nearest" routine.

>Agreed Ada's rules are arcane.

Nobody's perfect.

>Point for C++.

No, point against C++. C++ also has function overloading. It also has arcane
rules governing which version of the function gets called.

Point for C, Eiffel, Pascal, and others.