Re: Do we need "Mission-Critical" software? Was: What to Do?

[mark_lundquist@my-deja.com]

In article <93fnao$49u$1@nnrp1.deja.com>,
  dmitry6243@my-deja.com wrote:

> To make a language popular,
> one need advertising. It must be as insolent as "Ada is an extension
of
> C++ especially designed for Windows", then it works.

Of course this is hyperbole, but I see your point.

I think a good case could be made that Ada is Java++...

Ada runs on the JVM.

Java believes in strong static typing.  That's a step in the right
direction, but they kept the impoverished type system of C++.  Ada has
a type system that's not only strong, but rich as well.  To start with,
you can have subtypes, and you have the ability to create user-defined
primitive types, etc.

Java wanted to get rid of pointer-related bugs.  Unfortunately, you
kind of have to have pointers!  So Java is a by-reference language,
hiding the pointer-ness of everything so that it's impossible to do
math on pointers.  By-reference languages have their own problems,
though.  Ada solves the pointer arithmetic problems by distinguishing
between pointers and addresses, and by defining pointers to be
something other than scalar types.

Java figured out that truth value has nothing to do with integer math,
so it got a Boolean type like Ada's.

Java believes that support for concurrency belongs in the language, not
just some random OS library.  Java is right about that!  They just
didn't think it through all the way and botched the details.

Java wanted to have better namespace control, so Java has packages.
These are better than C++ namespaces and more like Ada packages. But
the encapsulation construct in Java is still the "class", and in at
least two important senses (there are several) of the value
of "separation of interface and implementation", Java classes fall
short, because method bodies are defined in the class declaration.
(And no, Java "interface"s are not the answer to this).

Java's arrays are bounds-checked.  That's good.  Ada has a more
generalized system of range constraints that is involved with both
arrays and the subtyping system.  This allows for automated range
assertions beyond just for array accesses, and makes it possible for
the compiler to eliminate many run-time array bounds checks.

All these things can be viewed either negatively as half-measures, or
positively as steps in the right direction.  The idea is that Java
incorporated all these elements for good reasons, and the fuller
support that Ada gives them is better.

So that's one way to spin it, what do you think?

-- mark



Sent via Deja.com
http://www.deja.com/