Well, the ACE programming language strikes out on all three counts. ACE
does not support abstract data types (see section 7 for details). Since
objects don't exist, it doesn't make sense to allow for inheritance. If
an ACE module needs to use a function or procedure of another module,
then the two modules are just linked together. If a function of one
module is useful or a need for a similar type function is needed, the
ACE programmer could write it as a generic subprogram. By making that
generic subprogram public, multiple modules could use it. This would
serve the same purpose inheritance would, especially in a language like
ours that doesn't support the existence of objects. Inheritence isn't
neccessary for the ACE programming language.
-
And finally, ACE generally doesn't do binding dynamically, with the
exception of the "UNDEF" suit. In an
object-oriented language, dynamic binding must be used so that if a
function in a parent class is inherited by any subclass, whenever there
is a reference to that function then the compiler will know which
instance of that function is being refered to. Take, for example, C++.
Suppose we have a class called "RECTANGLE" with a function
"AREA". Suppose also we have a derived class called
"SQUARE" that also has a function called "AREA".
When "AREA" is called, to which one are we refering to?
Dynamic binding allows for flexibility and lets the compiler link the
reference to "AREA" to the proper class or subclass. Of
course, with ACE we don't have to worry about it.
-
-
-
What paradigm does ACE use, if not object-oriented? The best answer we
can give is that ACE is kind of a cross between a procedure-oriented
language and an imperative language. An imperative language follows a
set, logical order to perform an algorithm and finish a task. This is
what each of ACE's subprograms do to complete a problem. A
procedure-oriented language is one in which data is sent to subprograms
to perform computations or to solve some problem. ACE has elements of
both of these paradigms.
-
-
The basic upshot of all this is that ACE offers no object-oriented
programming support, because ACE does not follow the object-oriented
paradigm.