Re: NOACE- End of the road for Ada?

[Jared <nowhere@nowhere.nowhere>]

I could be wrong about all of this.  I often am.

<adaworks@sbcglobal.net> wrote in news:vQ%Yd.19429$OU1.18883
@newssvr21.news.prodigy.com:
> The move toward Java has nothing to do with
> whether Java is superior to
> Ada. It's not.   Is it easier to learn than Ada?
> No.   Is it more efficient
> than Ada?  Certainly not.   Is it easier to code
> than Ada?  Not at all.
> Does it produce better executables?   Not at all.

This is wrong.  I'm sorry.  I like Ada.  I want to believe it is right, but 
it isn't.

Sun is behind Java.  They've been hyping it.  They've been pushing it.  
They've been doing everything they can to keep it in the press.  That's 
great, and it gives Java a chance to succeed, but that's all it gives it.  
Java really is better, in a marketing sense, and sort of better in a 
conceptual sense.

> So why is it taking over the programming landscape
> like kudzu or crabgrass
> on an Alabama lawn?

Rant abstract: Java is more popular because its syntax better represents 
OO.  If you're bored of that argument, there is another, much shorter one, 
at the first separator.  If you're bored of that one, there's a third one, 
but it isn't very constructive.


Java, as has been pointed out elsewhere on this group, is basically C++ 
with all the bad parts removed and with garbage collection added.  Java is 
comfortable to all the C people, because of its syntax, because of its 
culture, and because it pretends to share the C++ idioms.  Nobody is going 
to switch to a language that feels uncomfortable unless it has some really 
neat gimmick.  (For example, Oz and Piccola have really neat gimmicks.)  In 
a market sense, even without the hype, this makes Java better.

It's worse than that, though.  Java got namespaces mostly right.  It got 
packaging mostly right.  A package isn't a namespace.  It's really tempting 
to identify them, but the real namespaces are the variables.

Why do you think Object.Method syntax is so popular?  What was the big deal 
with the 'use type' clause?  And what are all those Smalltalk people 
yammering about when they talk about sending messages to objects?  The 
variable is the namespace.  The method exists within it.  It isn't in the 
package.  The package isn't really a real thing; it's a variable of 
anonymous type.  The reason that Object.Method and Package.Method are 
indistinguishable it that they are indistinct.

So, for example, suppose I have:

package thing is
  a: integer := 0;
  procedure do_something;
end thing;

...

type thing_type is tagged record
  a: integer := 0;
end record;

procedure do_something (t: in out thing);

thing: thing_type;

There's not much difference when I declare it, except that the latter is 
much more verbose and has to be embedded in a package.  There's no 
difference at all when I use it.  There is a difference when I try to 
extend it, but was anyone paying attention when Dmitry suggested that 
'use' be transitive?

What I mean by getting packaging mostly right should be clear by now.  The 
type (class, or whatever one wants to call it) is the natural unit of 
packaging.  Consider the following common idiom:

package shoes is
  type shoe is tagged record with private;
  ...
end shoes;

With no other types declared in the package.  Wouldn't it just be easier to 
let the type be a package?  That's about all I have to say about that.

So, in conclusion, Java represents a cleaner presentation of OO than Ada.

But that's all it is.  Java's model is not really any better from Ada's; it 
just looks better, or rather, it's presented in a way that people prefer.  
It's just presentation, but presentation is critical.  Many industries 
exist almost entirely on presentation, with substance coming in a distant 
second.

Yes, I know Ada was meant to be legible.  But it has a low signal to noise 
ratio.

Want Ada to be more popular?  Write an alternate syntax.  Play up objects.  
Make them the focus.  Read up on the pi calculus, and compare with 
protected types and streams.  Above all, if something doesn't need to be 
said more than once, it shouldn't be.

For example, see:
http://www.cs.uofs.edu/~beidler/Ada/gnat/win_task-threads.html

The package at that link was the fifth hit for 'pragma import' on Google.  
It contains 'pragma Import (StdCall, foo, "foo")' 18 times and 'pragma 
Import (C, foo, "foo")' twice.  Not one of the StdCall functions is 
renamed.  The sum of the renaming for the C functions is to strip the 
leading underscore.  That's noise.  It makes every single function 
declaration two lines longer than necessary without conveying a single bit 
of information more than, say,

import StdCall "CreateThread" (args).

There are many many great features in the language, but the syntax bogs it 
all down in a ton of noise.

---

Actually, I do have one argument besides the old "the syntax sucks" dead 
horse.  Think about Perl.

Perl was created to solve a problem.  It thrives because it filled a niche, 
and did it well.  Ada didn't have that kind of focus.  The ARG needs to 
find new niches and fill them well.  It needs to defend hard real-time and 
do so quickly, because that's being lost to Java.  A garbage collected 
language!  For real-time systems!

Government contracting isn't a niche.  It's a hog trough; a place to become 
bloated and lazy.

And that's about all I have to say, unless somebody needs a clarification.  
That quite likely; I doubt the previous made much more sense than it did 
the first time I tried to formulate it.

---

Now, you don't have to buy into any of that.  So here's an alternate 
theory, based on the grass analogy.  From an article in a university 
newspaper:

 "One of the more common questions I'm asked is how to control Bermuda 
grass in the lawn. My standard reply is 'asphalt'," says Jerry Goodspeed, 
Utah State University Extension horticulturist. Unfortunately, Bermuda 
grass can grow through asphalt and really thrive.

There you go.  Java is the weed that won't die and Sun (pun not intended) 
is making sure it stays that way.


> I continue to believe that Ada is as good, often
> better, as a programming language
> than either Java or C++.   But that is not a
> widespread belief throughout the DoD.

Myopically focusing on Java and C++ is a good way to ensure that Ada is 
never more than marginally better than either.  There's a lot of research 
going on out there.  For example,
www.cis.upenn.edu/~bcpierce/ papers/tng-lics2003-slides.pdf

Much of this research is geared at making functional and denotational 
languages more efficient.  I have full confidence that the Mozart/Oz people 
will screw up their chance to become the Next Big Thing.  But somebody 
won't, and that could happen tomorrow.

> There is no large company currently pushing Ada.
> There are no substantial financial
> resources behind it.   Even the companies that
> publish Ada compilers, with the exception
> of Ada Core, RR Software, and Irvine Compiler, are
> focusing their attention and their
> advertsising dollars on other products.

Where are the big bucks behind, say, Ruby?  What is Ruby's growth rate, 
compared to Ada's?  What can be learned here?


> Who will champion Ada?

AWS.  APQ, maybe.  Maybe Nick Roberts, if he ever gets anywhere.  The other 
projects.  You.  Maybe me.  We don't need big companies.  We don't need 
money.  We need, if you'll forgive me for putting it this way, the coolness 
factor.

Step 2: ???

Step 3: Profit!

I'm still working on step 2.