RE: Anybody in US using ADA ? One silly idea..

["Robert C. Leif" <rleif@rleif.com>]

I disagree! A very simple construct is a generic set of types and objects
that are also part of a private tagged record. This structure can be
extended and manipulated. For instance, when dealing with hardware, Intel
input-output registers and memory locations can be 8, 16, and 32 bits. A
generic is a simple way to model this. In fact if it were possible, I would
greatly prefer generic constructs to pointers. I must note that generics can
be instantiated at run-time and, I believe, still be located on the heap. No
need for garbage collection. Oberon.NET, which is very new, has generics.
Bob Leif

-----Original Message-----
From: comp.lang.ada-admin@ada.eu.org [mailto:comp.lang.ada-admin@ada.eu.org]
On Behalf Of Dmitry A. Kazakov
Sent: Sunday, January 05, 2003 6:13 AM
To: comp.lang.ada@ada.eu.org
Subject: Re: Anybody in US using ADA ? One silly idea..

Hillel Y. Sims wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
> news:av6hla$cggao$1@ID-77047.news.dfncis.de...
>> Kevin Cline wrote:
>>
>> > Today, the features that Ada provides have little value
>> > compared with the features that C++ provides and Ada lacks:
>> > the STL, automatic template function instantiation,
>>
>> Generics in any form is an illness of programming languages.
> 
> As someone who uses C++ template functionality extensively, I find that a
> very odd statement and completely inconsistent with my own experience. Can
> you provide some rationale?

In short generics is a meta language and no more than dressed macros used to

patch the source code. More elaborated:

1. Generics are static. You cannot have an object or dynamic-link library of

generics.

1.a. This kills code reuse at run-time.

1.b. You cannot have a true polymorphism with generics. [A fake, "static" 
polymorphism was invented to hide the truth.]

1.c. You have geometric code size explosion if you consequently use 
generics.

2. You have no ADT with generics. All generic types are hard-wired. In C++ 
you have only one generic type: "class". In Ada there are few: "private", 
"range <>" etc. This is Stone Age. Theoretically one could leverage 
generics to full ADT, but what for? It is much better to have a better ADT 
in the core language and abadon generics.

3. Generics are inconsistent with type relationships. When you instantiate 
something, this something is absolutely unrelated to everything else. A 
generic container instantiated with a subtype will never become a subtype 
of same container instantiated with the base type.

4. Generics are inconsistent with DbC. In C++ you just instantiate and pray.

In Ada it is better, but still you have reemergence of predefined 
operations and other contract violations. The reason is clear, while the 
core language operates with types and their relations, generics are sort 
of: let's substitute one string for another and see if the result go 
through the compiler. I think it was Kernigan and Ritchie who said that 
preprocessor does not know C. Substitute generics for preprocessor and 
language X for C.

5. Generics are unstructured and too powerful. They are comparable with 
gotos. Gotos arbitrarely change control flow. Generics arbitrarely produce 
new language objects. You can have a generic type, subroutine, package, 
everything. The consequences of an instantiation is almost impossible to 
predict. As with gotos, you should admit, that a program with generics is 
very difficult to understand and maintain. [For C++ replace difficult to 
impossible, because of automated instantiation]

6. Generics completely fall out of the language, because in fact they form a

meta-langauge. A generic object does not exist for the core language. What 
could be done with a generic object? The answer is: nothing. One cannot 
pass a generic function as a parameter to a normal function. Even a generic 
parameter cannot be generic (:-)), only instances [= objects of the core 
language] are allowed. So even as a meta-language, generics represent an 
inconsistent one.

------------------------
A little of bad philosophy as a conclusion. (:-)) If we consider the 
evolution of programming languages, we could note maybe unconscious, but 
constant and very successfull attempts to solve the problem of 
parametrization in a more civilized way than just by brute force of 
preprocessing = generics.

A subroutine is parametrized by the values of the arguments [FORTRAN]

A subroutine is a value which can be a parameter [?]

A type is parametrized by the values of the discriminants [Ada 83]

A type set (=class-wide type) is parametrized by a type (=type tag) [OOPL 
with dispatching]

In the end of this process we will need generics as much as we need gotos 
now.

-- 
Regards,
Dmitry A. Kazakov
www.dmitry-kazakov.de