the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kent Paul Dolan]

Richard Riehle <richard@adaworks.com> wrote:

> The Ada mandate was poorly managed by the DoD.

Talk about praising with faint damnation.  They couldn't
have done worse by avowedly working against adoption of Ada.

Creating an unenforced underfunded mandate only accomplished
sowing confusion and a burning desire to find a way around
the rules, which all services but the USMC then took up as
the latest "fun frustrating feeble feckless DoD management
by paid professional footdragging" game.  Which DoD lost to
its component parts.

> The language is structured around a few simple principles.

Which seem to be "simple" only in the minds of computer
language theorists, not in the minds of us mere programmers,
to whom the reasons for which these principles are
meritorious and why they should govern our lives are still
quite convincingly opaque.

> Some of those principles are more rigorously defined in
> Ada than in other languages.

If only the same rigor had been applied to furnishing
_readable explanations_ of these principles, in
self-contained, self-standing "why, not merely what" style,
in words clear enough to have been penned by Hemmingway, the
pain and suffering of programmers new to Ada might be much
diminished.

> One principle, separation of scope from visibility, is so
> different that even Ada programmers have difficulty with
> it at first.

Last time I checked by comp.lang.ada [which the mannerless
arrogance of certain posters there toward newbies finally
made unstomachable], this issue still seemed to consume the
bulk of the newsgroup.  Are the questions now settled, and
is there somewhere available an online tutorial explaining
the issues clearly enough for a sixth grader to read and
use?

> Once they stop fighting it and understand it, the rest of
> the language falls into place.

Much like certain editors better not brought up again, or
lots of other software cobbling tools, for that matter.

xanthian.

RE: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert C. Leif]

DoD could have made Ada if they had only forbidden its use by the public.
Universities would then have been motivated to teach it.
Bob Leif

-----Original Message-----
From: Kent Paul Dolan [mailto:xanthian@well.com] 
Sent: Wednesday, February 26, 2003 2:49 PM
To: comp.lang.ada@ada.eu.org
Subject: the Ada mandate, and why it collapsed and died (was): 64 bit
addressing and OOP

Richard Riehle <richard@adaworks.com> wrote:

> The Ada mandate was poorly managed by the DoD.

Talk about praising with faint damnation.  They couldn't
have done worse by avowedly working against adoption of Ada.

Creating an unenforced underfunded mandate only accomplished
sowing confusion and a burning desire to find a way around
the rules, which all services but the USMC then took up as
the latest "fun frustrating feeble feckless DoD management
by paid professional footdragging" game.  Which DoD lost to
its component parts.

> The language is structured around a few simple principles.

Which seem to be "simple" only in the minds of computer
language theorists, not in the minds of us mere programmers,
to whom the reasons for which these principles are
meritorious and why they should govern our lives are still
quite convincingly opaque.

> Some of those principles are more rigorously defined in
> Ada than in other languages.

If only the same rigor had been applied to furnishing
_readable explanations_ of these principles, in
self-contained, self-standing "why, not merely what" style,
in words clear enough to have been penned by Hemmingway, the
pain and suffering of programmers new to Ada might be much
diminished.

> One principle, separation of scope from visibility, is so
> different that even Ada programmers have difficulty with
> it at first.

Last time I checked by comp.lang.ada [which the mannerless
arrogance of certain posters there toward newbies finally
made unstomachable], this issue still seemed to consume the
bulk of the newsgroup.  Are the questions now settled, and
is there somewhere available an online tutorial explaining
the issues clearly enough for a sixth grader to read and
use?

> Once they stop fighting it and understand it, the rest of
> the language falls into place.

Much like certain editors better not brought up again, or
lots of other software cobbling tools, for that matter.

xanthian.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Preben Randhol]

Robert C. Leif wrote:
> DoD could have made Ada if they had only forbidden its use by the public.
> Universities would then have been motivated to teach it.

Irony, right?

-- 
Preben Randhol ---------------- http://www.pvv.org/~randhol/ --
"Violence is the last refuge of the incompetent", Isaac Asimov

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Tom Welsh]

In article <a3eaa964.0302261448.6f38de58@posting.google.com>, Kent Paul
Dolan <xanthian@well.com> writes
>Richard Riehle <richard@adaworks.com> wrote:
>
>> The language is structured around a few simple principles.
>
>Which seem to be "simple" only in the minds of computer
>language theorists, not in the minds of us mere programmers,
>to whom the reasons for which these principles are
>meritorious and why they should govern our lives are still
>quite convincingly opaque.
>
Which "computer language theorists" are you talking about? Surely not
Jean D. Ichbiah, Bernd Krieg-Bruechner, Brian A. Wichmann, Henry F.
Ledgard, Jean-Claude Heliard, Jean-Loup Gailly, Jean-Ryanmond Abrial,
John G. P. Barnes, Mike Woodger, Olivier Roubine, Paul N. Hilfinger, and
Robert Firth.

Do you actually know any of these people? Have you heard of them?

Maybe very clever, experienced programmers sometimes seem like "computer
language theorists" to programmers who are not quite so clever or
experienced.

When you are programming away on your Intel-based or Sparc-based
computer, do you often pause to contemplate the foolishness of the chip
designers, who followed principles that are not entirely clear to you?
Or do you just learn how to use the results of their work?
-- 
Tom Welsh

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kent Paul Dolan]

Tom Welsh <news@tom-welsh.co.uk> wrote:
> Kent Paul Dolan <xanthian@well.com> writes:
>> Richard Riehle <richard@adaworks.com> wrote:

>>> The language is structured around a
>>> few simple principles.

>> Which seem to be "simple" only in the
>> minds of computer language theorists,
>> not in the minds of us mere
>> programmers, to whom the reasons for
>> which these principles are
>> meritorious and why they should
>> govern our lives are still quite
>> convincingly opaque.

> Which "computer language theorists"
> are you talking about? Surely not Jean
> D. Ichbiah, Bernd Krieg-Bruechner,
> Brian A. Wichmann, Henry F. Ledgard,
> Jean-Claude Heliard, Jean-Loup Gailly,
> Jean-Ryanmond Abrial, John G. P.
> Barnes, Mike Woodger, Olivier Roubine,
> Paul N. Hilfinger, and Robert Firth.

> Do you actually know any of these people?

Not a one, I participated in ANSI X3H3
computer graphics programming language
standards efforts, not the Ada ANSI
X3J-whatever standards efforts.

> Have you heard of them?

Jean Ichbiah, Jean-Loup Gailly, John
Barnes, Paul Hilfinger, and Robert Firth
are familiar names to me, the rest are
not. I twice owned a copies of John
Barnes textbooks on learning Ada
programming, but they were lost to me in
the disintegration of one marriage or
another.

> Maybe very clever, experienced
> programmers sometimes seem like
> "computer language theorists" to
> programmers who are not quite so
> clever or experienced.

Nice try, but with 41 years programming
experience and a wealth of algorithmic
inventions to my name, you'll have to
find someone else to slander.

I merely lack the level of specific
formal education in computer language
design that make most of what the OP
thinks of as "simple principles" look
simple when reduced to standards-ese, or
look simple when trying to convince
other mid-level and junior programmers
that Ada is an "easily understood
language".

If that claim were true, the years of
language lawyering that have filled and
continue to fill comp.lang.ada would not
have been necessary. In the case, Ada is
conceptually an extremely difficult
language to understand, and I'm not sure
why that needed to be so.  Pascal [from
which Ada mostly derives], at least in
its early incarnations, is in contrast
supremely easy to understand from the
practicing programmer's viewpoint, which
made it a splendid learning langauge and
quite fair in practice as well.

> When you are programming away on your
> Intel-based or Sparc-based computer,
> do you often pause to contemplate the
> foolishness of the chip designers, who
> followed principles that are not
> entirely clear to you?  Or do you just
> learn how to use the results of their
> work?

Well, no, I bothered to learn why and
how the chips work the way they do, down
to the gate level originally, in higher
level chunks more recently.

[Not all that many people in the world
have ever memorized the logic gates and
software running therein of an entire
computer, but I am one of that few [not
that it was all that complicated a
computer: the guidance computer for the
Polaris Missile; and I did it as a way
to gain promotion in my military
specialty, not for the sheer joy of the
task]].

[Do you often answer months-old articles
and expect current answers?  Are you not
often disappointed?]

xanthian.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Tom Welsh]

In article <a3eaa964.0304162216.60978001@posting.google.com>, Kent Paul
Dolan <xanthian@well.com> writes
>Tom Welsh <news@tom-welsh.co.uk> wrote:
>
>> Maybe very clever, experienced
>> programmers sometimes seem like
>> "computer language theorists" to
>> programmers who are not quite so
>> clever or experienced.
>
>Nice try, but with 41 years programming
>experience and a wealth of algorithmic
>inventions to my name, you'll have to
>find someone else to slander.
>
I think "slander" is an exaggeration; I didn't even specifically say my
comment applied to you. It was more along the lines of "if the cap
fits..."

Anyway, if you take it personally I apologise - I certainly didn't mean
to make an ad hominem remark. And I wrote in haste, before having a
chance to read enough of your articles and get a clear idea of your
experience. 

I also wrote emotionally, because I like Ada and think it is a valuable
contribution to software engineering. My introduction to it was reading
Grady Booch's "Software Engineering with Ada" in about 1983, and shortly
thereafter taking a two-week training course with Dee deCristofaro (sp?)
at DEC's Landover, MD offices. While I was by no means an effective Ada
programmer at that stage, I think I understand the basic principles of
the language. And I also believed that it was a big improvement on
languages like Fortran, Cobol and Basic.

The canard that Ada was designed by a committee, by the DoD, or by
ivory-tower academics, has been so widely promoted that I tend to have a
knee-jerk reaction to it by now.

>
>[Not all that many people in the world
>have ever memorized the logic gates and
>software running therein of an entire
>computer, but I am one of that few [not
>that it was all that complicated a
>computer: the guidance computer for the
>Polaris Missile; and I did it as a way
>to gain promotion in my military
>specialty, not for the sheer joy of the
>task]].
>
Touche! And congratulations. I think we would all be a lot better off it
more people had a wide and balanced understanding of computer systems.

>[Do you often answer months-old articles
>and expect current answers?  Are you not
>often disappointed?]
>
Only when they are interesting and I feel the need to speak up. And in
this case, you did not disappoint me!  8-)
-- 
Tom Welsh

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

Kent Paul Dolan wrote:

> I merely lack the level of specific
> formal education in computer language
> design that make most of what the OP
> thinks of as "simple principles" look
> simple when reduced to standards-ese, or
> look simple when trying to convince
> other mid-level and junior programmers
> that Ada is an "easily understood
> language".

I suppose I should interpret that as a response to my
contention that Ada is not as hard to learn as many
have suggested.    In fact,  Ada, once some fundamental
ideas are understood, is not that difficult.   However,
in its early days, when those fundamental ideas were
new, even  revolutionary, they were difficult for even
experienced programmers to grasp.    Now, so many of
those ideas have been adopted in the design of other
programming languages, that, when one mentions one
of them in the context of Ada, the response is often, "So
what?  Language XYZ has that feature too."

True, not all of the ideas have been adopted.  The most
difficult  idea for many programmers to grasp is the set
of visibility rules in Ada.   In my experience, once those
are understood, everything else falls into place.  Some
Ada programmers spend years fighting the visibility
rules, and continue to raise questions, debate, and
engage in endless language lawyering in an attempt to
subvert, thwart, or whine about them.

> If that claim were true, the years of
> language lawyering that have filled and
> continue to fill comp.lang.ada would not
> have been necessary. In the case, Ada is
> conceptually an extremely difficult
> language to understand, and I'm not sure
> why that needed to be so.  Pascal [from
> which Ada mostly derives], at least in
> its early incarnations, is in contrast
> supremely easy to understand from the
> practicing programmer's viewpoint, which
> made it a splendid learning langauge and
> quite fair in practice as well.

I disagree.  Ada is not conceptually difficult to
learn or understand.  It does include some new
ideas, and new ideas are sometimes difficult to
grasp at first.  That is quite different.

Again, many people who were required to learn
Ada for their work were resentful of the mandate
and spent their time inventing reasons why they
believed they could not do something instead of
discovering how easily they could do it.

If a programmer wants to fight the visibility rules,
for example, he can do so, can grumble about them,
find reasons why writing a particular program is so
hard,  and so on.   This attitude reminds me of my
first experience on a part-time high-school job in
which I was required to use a floor-buffer.   The
standard floor-buffer uses a large circulating brush
which, as it polishes the floor, can exert a powerful
thrust vectored over its clockwise motion.   A human,
regardless of their strength, cannot overcome the force
of the brush using brute strength.   That same human,
learning to gently balance the rotating brush, can make
it go anywhere.  I became quite skilled at controlling
the buffer and could eventually command it using a
single finger.

The Ada visibility rules are a powerful force in the language
design.  The programmer can exert all kinds of energy in
complaints about it.  However, once one understands this
feature, takes charge of its inherent force, and incoporates it
into a design and corresponding source code, it makes the
Ada programming (and especially the maintenance) process
much more pleasant than one might find in competing programming
languages.

Most of Ada is pretty simple.   Besides the visibility rules,
there are two other parts of the language that are a bit
difficult for some newcomers:  accessibility rules (for
objects and access types) which prevent many of the pointer
related mistakes so common in many languages,  and tasking,
a feature designed to incorporate concurrency in the language.

Most of the other features of the language, such as type safety rules,
separate compilation,  type derivation,  object aggregates, abstract
data types,  control over defined scope,  generic templates,  exception
handling,  packaging of common entities,  information hiding,
encapsulation, etc;  these features that once seemed so strange to
programmers experienced in procedural abstractions, are now
commonplace throughout the programming language community.
When introduced in Ada, they seemed strange, even bizzare. Now
they are accepted practice.

Even so, Ada is not intended for one-person, single program, projects
where an individual programmer can grasp every detail of the program.
It is intended for large-scale projects where many programmers and
designers must interact over a set of complex requirements and integrate

those requirements into a single, well-functioning whole.  Ada makes
that kind of project easier to develop, easier than one might experience

in most other languages.

One can make the case that Ada is not the best choice for certain
classes
of software.  I still believe it is not appropriate, using the current
compiler
technology, for eight-bit microcontrollers (e.g., I-8051),  but a subset
of
Ada might be.   Smalltalk is still a better language for some kinds of
software, especially where one needs a lot of dynamic properties and
frequent modification of the code.  Smalltalk is, however, a terrible
choice for the kinds of software Ada is targeted to build.

There are other languages one can compare to Ada that also have serious
potential for embedded-real-time safety-critical software.   As I
examine
them, in some detail, I keep discovering that they simply fall short.
It is
said, "The Devil is in the details."    C++, for example, when I look at
it
closely, seems inappropriate for developing software of the kind I just
described.   Each time I look for a competing technology, when compared
to Ada, it simply falls short.

A better Ada could be designed.   There are things about the language
that could be improved.   I hope someone will eventually design a
language that is better than the current Ada design.  At this point,
though,
when I am looking for a language that has a high regard for reliability
and dependability,  Ada still has the edge.

Richad Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EA04A1E.CAFC1FEF@adaworks.com>...
> Kent Paul Dolan wrote:
> 
> > I merely lack the level of specific
> > formal education in computer language
> > design that make most of what the OP
> > thinks of as "simple principles" look
> > simple when reduced to standards-ese, or
> > look simple when trying to convince
> > other mid-level and junior programmers
> > that Ada is an "easily understood
> > language".
> 
> I suppose I should interpret that as a response to my
> contention that Ada is not as hard to learn as many
> have suggested.    In fact,  Ada, once some fundamental
> ideas are understood, is not that difficult.   However,
> in its early days, when those fundamental ideas were
> new, even  revolutionary, they were difficult for even
> experienced programmers to grasp.    Now, so many of
> those ideas have been adopted in the design of other
> programming languages, that, when one mentions one
> of them in the context of Ada, the response is often, "So
> what?  Language XYZ has that feature too."

I think nobody complained about any particular
feature.  The major complaint was that it
had all the itsy-bitsy little ideas that anybody
had thought at the time.  And no truly innovative
or revolutionary ones.

Take something trivial, e.g. string slicing.
Not a terribly useful feature, but not entirely
useless either.  The trouble is, there was
a whole lot of such mildly useful features
that Ichbiah had seen somebody use somewhere
(this one from PL/1 I think), or was able to
think up.

Also, Ada proponents made much of its strong
typing.  But it was not at all novel or revolutionary.
It was a very common language idea
at that time, and then-popular Pascal had it too.
That wasn't bad by itself.  But from a practical
point of view, over-emphasizing strong typing made
interfacing to C a virtual necessity
for projects of any significant complexity.
(C and later C++ style of type-safety turned out to
be good enough for real-world projects.)

But the huge collection of mostly mildly useful
features made the language too large and complex, which
is what got Hoare and other lights of
the time (relatively unknown in the DoD
circle) upset with Ada.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Larry Kilgallen]

In article <9fa75d42.0304221126.7112b7d5@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:

> Also, Ada proponents made much of its strong
> typing.  But it was not at all novel or revolutionary.
> It was a very common language idea
> at that time, and then-popular Pascal had it too.

As a Pascal programmer I was thrilled to use Ada since the typing
system is so much stronger than in Pascal.

> That wasn't bad by itself.  But from a practical
> point of view, over-emphasizing strong typing made
> interfacing to C a virtual necessity
> for projects of any significant complexity.

Not at all.  I have a 180,000 line Ada project which does interface
to another language for other reasons (not to get weak typing). But
the language I chose was certainly not C.  Are you under the impression
there are only two languages in the world.

> (C and later C++ style of type-safety turned out to
> be good enough for real-world projects.)

Like Windows ?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert A Duff]

Kilgallen@SpamCop.net (Larry Kilgallen) writes:

> In article <9fa75d42.0304221126.7112b7d5@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:
> 
> > Also, Ada proponents made much of its strong
> > typing.  But it was not at all novel or revolutionary.
> > It was a very common language idea
> > at that time, and then-popular Pascal had it too.
> 
> As a Pascal programmer I was thrilled to use Ada since the typing
> system is so much stronger than in Pascal.

Much more flexible, too.

- Bob

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304221126.7112b7d5@posting.google.com...
> Take something trivial, e.g. string slicing.
> Not a terribly useful feature, but not entirely
> useless either.

Array slicing is a wonderfully useful feature.  I use this feature in almost
every program of mine.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

> Array slicing is a wonderfully useful feature.  I use this feature in almost
> every program of mine.

And I have lots of fun trying to code around the lack of it in Java.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert A Duff]

"Chad R. Meiners" <crmeiners@hotmail.com> writes:

> "soft-eng" <softeng3456@netscape.net> wrote in message
> news:9fa75d42.0304221126.7112b7d5@posting.google.com...
> > Take something trivial, e.g. string slicing.
> > Not a terribly useful feature, but not entirely
> > useless either.
> 
> Array slicing is a wonderfully useful feature.  I use this feature in almost
> every program of mine.

Really!?  I think of array slicing as a pretty minor feature of Ada,
which causes a lot of trouble for compiler writers, that could be
dispensed with.  After all, you could write a function that grabs those
components.

I'm thinking particularly of slices as L-values.  Do you ever use that?

- Bob

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Dale Stanbrough]

Robert A Duff wrote:

> > > Also, Ada proponents made much of its strong
> > > typing.  But it was not at all novel or revolutionary.
> > > It was a very common language idea
> > > at that time, and then-popular Pascal had it too.
> > 
> > As a Pascal programmer I was thrilled to use Ada since the typing
> > system is so much stronger than in Pascal.
> 
> Much more flexible, too.

If i'm asked to quickly describe Ada, I often say it is an
industrialised Pascal...


Dale

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
news:wccadeiglef.fsf@shell01.TheWorld.com...
> Really!?  I think of array slicing as a pretty minor feature of Ada,
> which causes a lot of trouble for compiler writers, that could be
> dispensed with.  After all, you could write a function that grabs those
> components.

> I'm thinking particularly of slices as L-values.  Do you ever use that?

Usually I pass slices of arrays as parameters to procedures and functions.
For example Ada.Strings.Fixed would be far less convenient without the
ability to pass part of an array to a procedure or function.  As for
L-values I assume you mean something like

x(1..80) := (others => y);
?
If so, I use slices less often for that purpose.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Dr Chaos]

Robert A Duff <bobduff@shell01.TheWorld.com> wrote:
> "Chad R. Meiners" <crmeiners@hotmail.com> writes:
>> Array slicing is a wonderfully useful feature.  I use this feature in almost
>> every program of mine.
> 
> Really!?  I think of array slicing as a pretty minor feature of Ada,
> which causes a lot of trouble for compiler writers, that could be
> dispensed with.  After all, you could write a function that grabs those
> components.
 
> I'm thinking particularly of slices as L-values.  Do you ever use that?

Ask everybody who likes MATLAB:

in other words "yes".

And it's in Fortran 90/95, for similar reasons.  Note that F90 was
designed after Ada.

Getting arrays right definitely helps lower bugs, because
off-by-one counting in iteration are frequent source of
errors.
 
> - Bob

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Larry Kilgallen]

In article <wccadeiglef.fsf@shell01.TheWorld.com>, Robert A Duff <bobduff@shell01.TheWorld.com> writes:
> "Chad R. Meiners" <crmeiners@hotmail.com> writes:

>> Array slicing is a wonderfully useful feature.  I use this feature in almost
>> every program of mine.
> 
> Really!?  I think of array slicing as a pretty minor feature of Ada,
> which causes a lot of trouble for compiler writers, that could be
> dispensed with.  After all, you could write a function that grabs those
> components.
> 
> I'm thinking particularly of slices as L-values.  Do you ever use that?

Yes, although in a minority of cases.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

> Really!?  I think of array slicing as a pretty minor feature of Ada,
> which causes a lot of trouble for compiler writers, that could be
> dispensed with.  After all, you could write a function that grabs those
> components.

Having used it a lot, I really appreciated the fact
that the compiler writers went to that trouble.

Now I'm finishing up a Java class, and I am getting tired
of repeating that same trouble in nearly every program.

> I'm thinking particularly of slices as L-values.  Do you ever use that?

I did that a lot in Ada days, too.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

soft-eng wrote:

> I think nobody complained about any particular
> feature.  The major complaint was that it
> had all the itsy-bitsy little ideas that anybody
> had thought at the time.  And no truly innovative
> or revolutionary ones.

There were a few itsy-bitsy ideas that were unique
in the language at the time of Ada's introduction.

> Take something trivial, e.g. string slicing.
> Not a terribly useful feature, but not entirely
> useless either.  The trouble is, there was
> a whole lot of such mildly useful features
> that Ichbiah had seen somebody use somewhere
> (this one from PL/1 I think), or was able to
> think up.

String slicing was unnecessary, still is, when one
used a Strings package.   In contemporary Ada, this
is handled quite nicely with language-defined packages.

However, aside from that, the interesting an powerful idea
in Ada was not the string slicing, but the array management
model.  A string, in Ada is a first class type.  It is a kind
of array type.   Arrays in Ada are quite powerful.  This is
one of the features I most like about the language at the
algorithm design level.   From my experience with C and
C++, I would much rather program with Ada arrays than
with C or C++ arrays.

> Also, Ada proponents made much of its strong
> typing.  But it was not at all novel or revolutionary.
> It was a very common language idea
> at that time, and then-popular Pascal had it too.

We  should probably re-phrase this phrase, "strong
typing" to type-safety.   Even though we saw some
movement in the direction of type-safety in Pascal,
PL/I, and other earlier languages, Ada went well
beyond those earlier attempts and actually achieved
what they did not.

> That wasn't bad by itself.  But from a practical
> point of view, over-emphasizing strong typing made
> interfacing to C a virtual necessity
> for projects of any significant complexity.

Well, this, of course is dead wrong.   Type safety did not
drive the move to interfacing with C.   Also, Ada was,
and is, designed to permit a programmer to get to a very
low-level of programming, even to the machine code
level, if it seems appropriate.

One can, in Ada, relax the type safety as necessary.  Some
organizations set up rules that prohibited using such features,
and opted, instead, for writing the code in C.   In such cases,
they gained nothing, lost a lot, and often created a mess.  If
they had remained with straight Ada, they would have been
better off.

That being said, there is a lot of operational code written in
C, C++, Fortran, Assembler, and other languages.   Contemporary
Ada is designed to make it easy to use existing code regardless
of how it is coded.   Mature code that works is often better than
new code that has not been tested in the real world, regardless
of what spiffy new language one might use.  Ada allows the
developer to leverage the best of existing code while building
better and more reliable code than would be likely in
C or C++.

> (C and later C++ style of type-safety turned out to
> be good enough for real-world projects.)

Once again, dead wrong.  C++ is not type-safe.  It offers
an illusion of type-safety under some circumstances, but
such oddities as type-promotion (also in Java) fly in the
face of type safety.   There all sorts of holes in C++ that
make the idea of type-safety there somewhat at odds with
what it ought to be.

> But the huge collection of mostly mildly useful
> features made the language too large and complex, which
> is what got Hoare and other lights of
> the time (relatively unknown in the DoD
> circle) upset with Ada.

Actually, Hoare later wrote a tribute to Ada in one of the
Ada 83 books.  His earliest criticism of Ada had to do
mostly with the inclusion of exception handling in the
language.   Ooooops!  We now have exception handling
in C++, Java, Eiffel, etc.    So when you mention  Hoare
and Ada, you need to understand that, subsequent to his
Turing lecture, he had some pretty nice things to say
about the language.

Richard Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Volkert]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EA62B54.49580F4F@adaworks.com>...
> soft-eng wrote:

 < deleted> 
> 
> Actually, Hoare later wrote a tribute to Ada in one of the
> Ada 83 books.  His earliest criticism of Ada had to do
> mostly with the inclusion of exception handling in the
> language.   
Yepp. The book was published in the famous prentice hall -
international series in computer science. The Series Editor 
was >> Tony Hoare <<.

Volkert

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EA62B54.49580F4F@adaworks.com>...

> drive the move to interfacing with C.   Also, Ada was,
> and is, designed to permit a programmer to get to a very
> low-level of programming, even to the machine code
> level, if it seems appropriate.

How many times in your whole life have you done this?
Or known of other people who have done this?

And how many instances do you know when this
was done by interfacing with C?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

"Chad R. Meiners" <crmeiners@hotmail.com> wrote in message news:<b84gku$2i5l$1@msunews.cl.msu.edu>...
> "soft-eng" <softeng3456@netscape.net> wrote in message
> news:9fa75d42.0304221126.7112b7d5@posting.google.com...
> > Take something trivial, e.g. string slicing.
> > Not a terribly useful feature, but not entirely
> > useless either.
> 
> Array slicing is a wonderfully useful feature.  I use this feature in almost
> every program of mine.

Any itsy-bitsy feature *will* be found wonderful by somebody.

That's exactly the problem -- because there were so
many itsy-bitsy features in Ada, a novice needed to
learn all of them, because somebody somewhere finds
it useful and it will be found in real-world code.

Having tons of features in auxiliary libraries
in the "C" style make mastering the language much simpler
by chunking the task of learning without complicating
the syntax issues.

But having them directly in the language itself makes
just learning the basic language unnecessarily harder.
And the trouble is, you don't get anything really
worthwhile out of all the time you spend on
mastering all that syntax.  You would have
been better off mastering concepts instead.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Larry Kilgallen]

In article <9fa75d42.0304230439.55d28e70@posting.google.com>, softeng3456@netscape.net (soft-eng) introduces the term "itsy-bitsy feature":

> Any itsy-bitsy feature *will* be found wonderful by somebody.
> 
> That's exactly the problem -- because there were so
> many itsy-bitsy features in Ada, a novice needed to
> learn all of them, because somebody somewhere finds
> it useful and it will be found in real-world code.

Most shops restrict their usage of Ada (or any language) to the needs
of their particular domain.  I do not believe I have ever used floating
point in Ada, and for the first 10 years I did not use tasking.  I had
no trouble skipping over those parts of the documentation.

> Having tons of features in auxiliary libraries
> in the "C" style make mastering the language much simpler
> by chunking the task of learning without complicating
> the syntax issues.

I am sorry you had trouble learning Ada syntax, but rest assured there
are many others who have had no such problem.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Kilgallen@SpamCop.net (Larry Kilgallen) wrote in message news:<d3xFAUvBYizb@eisner.encompasserve.org>...
> In article <9fa75d42.0304221126.7112b7d5@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:
> 
> > Also, Ada proponents made much of its strong
> > typing.  But it was not at all novel or revolutionary.
> > It was a very common language idea
> > at that time, and then-popular Pascal had it too.
> 
> As a Pascal programmer I was thrilled to use Ada since the typing
> system is so much stronger than in Pascal.
> 
> > That wasn't bad by itself.  But from a practical
> > point of view, over-emphasizing strong typing made
> > interfacing to C a virtual necessity
> > for projects of any significant complexity.
> 
> Not at all.  I have a 180,000 line Ada project which does interface
> to another language for other reasons (not to get weak typing). But
> the language I chose was certainly not C.  Are you under the impression
> there are only two languages in the world.
> 
> > (C and later C++ style of type-safety turned out to
> > be good enough for real-world projects.)
> 
> Like Windows ?


You must live in a different world from me -- I look
around, and from the web-browser to the newsreaders
to the email software to the software transporting
your packets full of Ada praise to the software
controlling the switching stations enroute to...

You don't like Windows, so you must be using
what?  Unix and X-Windows?  Written/extended/in Ada?
Surely Ada was there when most of X-Windows
and Motif happened?  Or at least when the
CD-ROM device drivers were being written?

What now did you say these very expensive
Ada projects actually do?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Stephen Leake]

softeng3456@netscape.net (soft-eng) writes:

> Any itsy-bitsy feature *will* be found wonderful by somebody.
> 
> That's exactly the problem -- because there were so
> many itsy-bitsy features in Ada, a novice needed to
> learn all of them, because somebody somewhere finds
> it useful and it will be found in real-world code.

Um, the definition of a "novice" is "someone who doesn't yet know
everything they need to know". So they can't be expected to be reading 
"real-world code" yet.

If a "slice" is useful, "real-world code" will use it, whether it is
directly supported by the language or not. So any programmer will
eventually have to understand it.

In other words, the fact that Ada directly supports "slices" and other
"isty-bitsy" features does not impact how much of Ada a novice "must"
learn before writing programs. Instead, it impacts the productivity of
the expert; it is easier to use "slices" in Ada than in Java.

> Having tons of features in auxiliary libraries in the "C" style make
> mastering the language much simpler by chunking the task of learning
> without complicating the syntax issues.

Most people say you have to master the C libraries before you can be
called a C master, which is exactly my point.

You can write real programs in the C subset of Ada, just as you
can write real programs in C. It's just easier to write more complex
programs in full Ada.

> But having them directly in the language itself makes just learning
> the basic language unnecessarily harder. 

Not if I distinguish between "essential features" and "nice but
non-essential features". Any good book on Ada will start with the
essential features, and leave the non-essential features till later.

If I never learned what a slice was, I could still write good Ada code.

> And the trouble is, you don't get anything really worthwhile out of
> all the time you spend on mastering all that syntax. You would have
> been better off mastering concepts instead.

Right; concepts like "slice" :).

-- 
-- Stephe

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Larry Kilgallen]

In article <9fa75d42.0304230515.48064263@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:
> Kilgallen@SpamCop.net (Larry Kilgallen) wrote in message news:<d3xFAUvBYizb@eisner.encompasserve.org>...
>> In article <9fa75d42.0304221126.7112b7d5@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:

>> > (C and later C++ style of type-safety turned out to
>> > be good enough for real-world projects.)
>> 
>> Like Windows ?

> You don't like Windows, so you must be using
> what?  Unix and X-Windows?  Written/extended/in Ada?

At this instant I am using VMS, which thankfully written mostly before
the current C-mania started.  Even when they use C on Alpha and Itanium
now, those who develop VMS tend to use the safer techniques they learned
with Bliss in place of the null-terminated strings and other garbage that
is encouraged by C.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[H. S. Lahman]

Responding to Kilgallen...

> At this instant I am using VMS, which thankfully written mostly before
> the current C-mania started.  Even when they use C on Alpha and Itanium
> now, those who develop VMS tend to use the safer techniques they learned
> with Bliss in place of the null-terminated strings and other garbage that
> is encouraged by C.

I agree that as a 3GL systems programming language Bliss is without 
peer.  It blows the socks off C for speed, power, and portability.

OTOH, if one doesn't need to count cycles or talk to individual bits, it 
has some problems.  It also offers the developer a lot more alternatives 
for foot-shooting.  I am reminded of a great quote from one of the 
designers of Bliss (Lahovsky), "When I program in Bliss I feel I am in 
complete control of the machine.  But when I program in Pascal my 
programs tend to work the first time."  B-)


*************
There is nothing wrong with me that could
not be cured by a capful of Drano.

H. S. Lahman
hsl@pathfindersol.com
Pathfinder Solutions  -- We Make UML Work
http://www.pathfindersol.com
(888)-OOA-PATH

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Georg Bauhaus]

In comp.lang.ada Richard Riehle <richard@adaworks.com> wrote:
:     In fact,  Ada, once some fundamental
: ideas are understood, is not that difficult. 
 
:  The most
: difficult  idea for many programmers to grasp is the set
: of visibility rules in Ada.

Could it be that rules like these are not enough at the
center of introductions to Ada? I remember an exposition
of child packages (somewhere in GNAT documentation?)
pointing readers to their relation to nested packages.
It does so at some length, and I think it was the length,
including examples, that I found so helpful.

-- Georg

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Marc A. Criley]

softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304230424.10612b1a@posting.google.com>...
> Richard Riehle <richard@adaworks.com> wrote in message news:<3EA62B54.49580F4F@adaworks.com>...
> 
> > drive the move to interfacing with C.   Also, Ada was,
> > and is, designed to permit a programmer to get to a very
> > low-level of programming, even to the machine code
> > level, if it seems appropriate.
> 
> How many times in your whole life have you done this?

Uh, like, lots.

> Or known of other people who have done this?

You mean the various coworkers of mine over the years?

> And how many instances do you know when this
> was done by interfacing with C?

Only when having to hook up to code written by others--whatever we
did, we did in Ada.  The only times we ever had to dip into C was when
some supplied function was defined as a macro and we had to put it
into a function wrapper so that it could be called.

Marc A. Criley
Quadrus Corporation
www.quadruscorp.com

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Stephen Leake <Stephe.Leake@nasa.gov> wrote in message news:<ufzo91fww.fsf@nasa.gov>...
> > And the trouble is, you don't get anything really worthwhile out of
> > all the time you spend on mastering all that syntax. You would have
> > been better off mastering concepts instead.
> 
> Right; concepts like "slice" :).

Uh, I meant something a little deeper...

(In fact, that was my whole point!)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[P S Norby]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304230439.55d28e70@posting.google.com...
> Any itsy-bitsy feature *will* be found wonderful by somebody.
>
> That's exactly the problem -- because there were so
> many itsy-bitsy features in Ada, a novice needed to
> learn all of them, because somebody somewhere finds
> it useful and it will be found in real-world code.
>
> Having tons of features in auxiliary libraries
> in the "C" style make mastering the language much simpler
> by chunking the task of learning without complicating
> the syntax issues.
>

But mastering just the "C" syntac is never enough... you will need to master
the libraries.  So why is that any easier?  And if it's so easy (to learn
"C"), Why do the ad's all want 5+ years experience?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[tmoran]

> > and is, designed to permit a programmer to get to a very
> > low-level of programming, even to the machine code
> > level, if it seems appropriate.
>
> How many times in your whole life have you done this?
> Or known of other people who have done this?
>
> And how many instances do you know when this
> was done by interfacing with C?
  My first real Ada program used some machine code inserts to control
a video capture card.  It also used tasking to interact with the user
and to control audio capture.  No C drivers were available.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Bill Findlay]

On 23/4/03 13:39, in article
9fa75d42.0304230439.55d28e70@posting.google.com, "soft-eng"
<softeng3456@netscape.net> wrote:
...
> 
> Any itsy-bitsy feature *will* be found wonderful by somebody.
> That's exactly the problem -- because there were so
> many itsy-bitsy features in Ada, a novice needed to
> learn all of them, because somebody somewhere finds
> it useful and it will be found in real-world code.

Novices in Ada, even programming novices learning through Ada,
do not need (note, present tense) to deal with any language features
apart from those that support the programming concepts
they are currently learning.

It is the experience of those who are teaching large numbers of novices
(400-500 per year) that they do better in Ada than in any previous language
of instruction. That includes Pascal, which was designed for teaching.

> Having tons of features in auxiliary libraries
> in the "C" style make mastering the language much simpler
> by chunking the task of learning without complicating
> the syntax issues.

And don't novices in C have to spend time learning about itsy-bitsy
libraries because somebody somewhere depends on them in 'real-world' code?

> But having them directly in the language itself makes
> just learning the basic language unnecessarily harder.

Syntax is (almost) completely irrelevant to learning programming or a
programming language, except insofar as a language actively undermines the
student's confidence by virtue of error-prone inconsistencies.


> And the trouble is, you don't get anything really
> worthwhile out of all the time you spend on
> mastering all that syntax.  You would have
> been better off mastering concepts instead.

You *do* get something that is very worthwhile for a minor investment
in learning a very consistent and robust syntactic framework.

What you get is compiler assistance with the much more difficult and
important issues of semantics.

Providing useful semantics via well-defined, built-in language features
makes those semantics accessible to the compiler, which can exploit them to
benefit the efficiency and the reliability of the object program.

No compiler can do this effectively with external library code, or with
programmer-constructed equivalents of Ada's built-in high level features.

I mention, at random: machine-independent integer types, for loops that
always terminate, secure dynamic arrays (including strings), secure variant
records, exceptions, tasks, automatic mutual exclusion ...

-- 
Bill-Findlay chez blue-yonder.co.uk ("-" => "")

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Simon Wright]

softeng3456@netscape.net (soft-eng) writes:

> Richard Riehle <richard@adaworks.com> wrote in message news:<3EA62B54.49580F4F@adaworks.com>...
> 
> > drive the move to interfacing with C.   Also, Ada was,
> > and is, designed to permit a programmer to get to a very
> > low-level of programming, even to the machine code
> > level, if it seems appropriate.
> 
> How many times in your whole life have you done this?
> Or known of other people who have done this?
> 
> And how many instances do you know when this
> was done by interfacing with C?

The problem was to interface to the PPC timebase register (the mftb
instruction) which is not supported in C either. So the choice, learn
the asm features of GNAT vs learn the asm features of GCC (which are
of course very similar) seemed a no-brainer; we did the GNAT version.

Later I tried the GCC version (this was on VxWorks) and took a couple
of hours to realise that in that environment you need to say __asm,
because WindRiver use -ansi in C compilations.

Whereas the GNAT version worked first time (it took rather longer to
get the 64-bit version working, though).

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Dr Chaos]

On 23 Apr 2003 05:39:04 -0700, soft-eng <softeng3456@netscape.net> wrote:
> "Chad R. Meiners" <crmeiners@hotmail.com> wrote in message news:<b84gku$2i5l$1@msunews.cl.msu.edu>...
>> "soft-eng" <softeng3456@netscape.net> wrote in message
>> news:9fa75d42.0304221126.7112b7d5@posting.google.com...
>> > Take something trivial, e.g. string slicing.
>> > Not a terribly useful feature, but not entirely
>> > useless either.
>> 
>> Array slicing is a wonderfully useful feature.  I use this feature in almost
>> every program of mine.
> 
> Any itsy-bitsy feature *will* be found wonderful by somebody.
> 
> That's exactly the problem -- because there were so
> many itsy-bitsy features in Ada, a novice needed to
> learn all of them, because somebody somewhere finds
> it useful and it will be found in real-world code.
> 
> Having tons of features in auxiliary libraries
> in the "C" style make mastering the language much simpler
> by chunking the task of learning without complicating
> the syntax issues.
> 
> But having them directly in the language itself makes
> just learning the basic language unnecessarily harder.
> And the trouble is, you don't get anything really
> worthwhile out of all the time you spend on
> mastering all that syntax.  You would have
> been better off mastering concepts instead.

It's not just syntax---which in Ada and similar languages (Eiffel) is
quite easy versus C and C++---but the semantical concepts. 

There's no substantial difference for a novice between learning new
language features, new concepts, and new libraries.

There's a certain quantity of knowledge necessary to learn.

The choice of what goes in a library and what is "in a language" is
important intellectually primarily to the more expert language
designers and implementors.

Once both a base language and libraries are assumed the precise point
of division has little substantial effect for typical programming tasks:
you have to know a both. 

If the goal is truly a minimal "core" language, then C is only barely
a contender (and C++ laughable)---Smalltalk and Lisp are the obvious
endpoints there.  They're great languages, but in design very
substantially different from C or C++ or Ada.  

What I find bizzare and remarkable is the consistent assumption by
many others (especially those that don't use languages like Ada,
Eiffel and post F77 Fortran) that "C" and "C++" are almost-by-default,
the "correct" choice not just economically but in engineering quality.

There's nothing kashrut about them there.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Dr Chaos]

On 23 Apr 2003 06:15:57 -0700, soft-eng <softeng3456@netscape.net> wrote:
> 
> You must live in a different world from me -- I look
> around, and from the web-browser to the newsreaders
> to the email software to the software transporting
> your packets full of Ada praise to the software
> controlling the switching stations enroute to...
> 
> You don't like Windows, so you must be using
> what?  Unix and X-Windows?  Written/extended/in Ada?
> Surely Ada was there when most of X-Windows
> and Motif happened?  Or at least when the
> CD-ROM device drivers were being written?

No, there were no free Ada compilers and the native
interface to the operating system (Unix) required
being able to parse not just syntax but semantics
of C include files. 

> What now did you say these very expensive
> Ada projects actually do?


-- 
---------------------------------------------
Matthew Kennel, mkennel@ucsd.edu
Institute For Nonlinear Science, UC San Diego
---------------------------------------------

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Samuel Tardieu]

>> Also, Ada was,
>> and is, designed to permit a programmer to get to a very
>> low-level of programming, even to the machine code
>> level, if it seems appropriate.
> 
> How many times in your whole life have you done this?

Many many times. And I hope my life is not over yet :)

  Sam
-- 
Samuel Tardieu -- sam@rfc1149.net -- http://www.rfc1149.net/sam

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kent Paul Dolan]

Robert A Duff <bobduff@shell01.TheWorld.com> wrote:
> "Chad R. Meiners" <crmeiners@hotmail.com> writes:

>> Array slicing is a wonderfully useful feature.  I use this feature
in almost
>> every program of mine.

> Really!?  I think of array slicing as a pretty minor feature of Ada,
> which causes a lot of trouble for compiler writers, that could be
> dispensed with.  After all, you could write a function that grabs those
> components.

> I'm thinking particularly of slices as L-values.  Do you ever use that?

It might be "minor" now, but if Ada is ever to stand beside Fortran as
a programming language for supercomputers, it is awfully nice that
this much of the needed semantics are "already in there"; they were a
huge shock when they first hit Fortran all in a lump.

[And by the way, since I've drifted away from Ada for lack of job
prospects for an Ada beginner without a current security clearance, is
there any effort underway to add the syntactic sugar for supercomputer
programming to Ada in an upcoming standard's language revision, or is
Ada down to "don't rock the boat" editorial cleanup standards (that
would eventually doom the language) for the foreseeable future, or is
there some big worthwhile effort but in another direction?]

xanthian.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Dr Chaos]

On 23 Apr 2003 16:06:58 -0700, Kent Paul Dolan <xanthian@well.com> wrote:
> [And by the way, since I've drifted away from Ada for lack of job
> prospects for an Ada beginner without a current security clearance, is
> there any effort underway to add the syntactic sugar for supercomputer
> programming to Ada in an upcoming standard's language revision,

It takes more than just syntacic surgar, it takes explicit
semantically important assertions and constructions, e.g. Fortran's
distinction between FORALL and DO loops.

> or is
> Ada down to "don't rock the boat" editorial cleanup standards (that
> would eventually doom the language) for the foreseeable future, or is
> there some big worthwhile effort but in another direction?]

I have no particular knowledge, but I think it's doubtful.

For massively parallel computation, modern Fortran (i.e. 95 and soon 200x) 
is where the compiler makers and the users are concentrating.

Modern Fortran is not substantially inferior as a language versus Ada 
in conventional "data structure ability" for such tasks, and there is
already substantial experience at parallelization.  Fortran 200x is
getting more Adaish anyway, and that's the future. 

Problems worthy of being solved on a large scale on a supercomputer
usually come with a long history of legacy code anyway.  A global
circulation model is not something to be whipped up in a week.  Also,
extreme embedded-system-quality reliability is less important there
than having the immediate researchers who know the subject
matter---scientists not full time programmers---running and modifying
the code.

> xanthian.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

tmoran@acm.org wrote in message news:<rVzpa.583781$3D1.323774@sccrnsc01>...
> > > and is, designed to permit a programmer to get to a very
> > > low-level of programming, even to the machine code
> > > level, if it seems appropriate.
> >
> > How many times in your whole life have you done this?
> > Or known of other people who have done this?
> >
> > And how many instances do you know when this
> > was done by interfacing with C?
>   My first real Ada program used some machine code inserts to control
> a video capture card.  It also used tasking to interact with the user
> and to control audio capture.  No C drivers were available.

Ok, I am sure a few instances happened.  But if you
had to develop device drivers for a living, and if
the language was truly your choice, would you chose Ada as
the language?

I think the only "yes" answers would be from
people who only know Ada and/or have never
written a device driver.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Dr Chaos <mbkennelSPAMBEGONE@NOSPAMyahoo.com> wrote in message news:<slrnbadndp.o8q.mbkennelSPAMBEGONE@lyapunov.ucsd.edu>...

> The choice of what goes in a library and what is "in a language" is
> important intellectually primarily to the more expert language
> designers and implementors.

Syntax is core to the language.  So it should not be
unnecessarily overloaded.  Libraries can be learned
in specialized variations, as needed.  But every
programmer needs to know the syntax.  (Should anyway;
if people are chunking the language syntax so
their programmers can get their heads around it,
I think the syntax is too complex.)

> Once both a base language and libraries are assumed the precise point
> of division has little substantial effect for typical programming tasks:
> you have to know a both. 
> 
> If the goal is truly a minimal "core" language, then C is only barely
> a contender (and C++ laughable)---Smalltalk and Lisp are the obvious
> endpoints there.  They're great languages, but in design very
> substantially different from C or C++ or Ada.  
> 
> What I find bizzare and remarkable is the consistent assumption by
> many others (especially those that don't use languages like Ada,
> Eiffel and post F77 Fortran) that "C" and "C++" are almost-by-default,
> the "correct" choice not just economically but in engineering quality.

It's the other way around.  Software engineering is a fake field
full of charltans, simply because it stands on a false premise -- you
can take anybody and turn them into good disciplined programmers by 
applications of certain principles.  The actual fact is, results
in software are to a *very* large part related to aptitude.  If you
can't hire well, the project is doomed no matter how many software
engineering principles you apply.  Once you have the right people,
engineering quality will appear; you just need to make sure
the design is good, the management is good (which
often means not getting in the way of good quality),
there is good quality assurance, and such less-than-flashy things.

So there are no "engineering quality" correct choices.
Some languages with straight-jacket mentalities make people
think they are rigorous, disciplined tools that will
make quality magically appear.  That is deluded thinking.

If Ada projects had actually succeeded in producing good quality
software, it would have been everywhere today.

The real solution -- for a language -- is on the opposite tack.
You just need to find the tools that will fit best
the "right aptitude" people.  And that was C's success.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Larry Kilgallen]

In article <9fa75d42.0304240446.493ca906@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:

> Ok, I am sure a few instances happened.  But if you
> had to develop device drivers for a living, and if
> the language was truly your choice, would you chose Ada as
> the language?
> 
> I think the only "yes" answers would be from
> people who only know Ada and/or have never
> written a device driver.

You would be wrong.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Vinzent Hoefler]

softeng3456@netscape.net (soft-eng) wrote:

>Ok, I am sure a few instances happened.  But if you
>had to develop device drivers for a living, and if
>the language was truly your choice, would you chose Ada as
>the language?

Yes.

>I think the only "yes" answers would be from
>people who only know Ada and/or have never
>written a device driver.

Well, I know Ada well enough to know that I can express low-level
hardware information definitely better, easier and safer than in C.


Vinzent.

-- 
Parents strongly cautioned  --  this  posting  is  intended for mature
audiences  over  18.  It  may  contain some material that many parents
would not find suitable for children and may include intense violence,
sexual situations, coarse language and suggestive dialogue.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[John R. Strohm]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304240446.493ca906@posting.google.com...
> tmoran@acm.org wrote in message
news:<rVzpa.583781$3D1.323774@sccrnsc01>...
> > > > and is, designed to permit a programmer to get to a very
> > > > low-level of programming, even to the machine code
> > > > level, if it seems appropriate.
> > >
> > > How many times in your whole life have you done this?
> > > Or known of other people who have done this?
> > >
> > > And how many instances do you know when this
> > > was done by interfacing with C?
> >   My first real Ada program used some machine code inserts to control
> > a video capture card.  It also used tasking to interact with the user
> > and to control audio capture.  No C drivers were available.
>
> Ok, I am sure a few instances happened.  But if you
> had to develop device drivers for a living, and if
> the language was truly your choice, would you chose Ada as
> the language?
>
> I think the only "yes" answers would be from
> people who only know Ada and/or have never
> written a device driver.

Over the course of some 33 years spent in and around computers, I have
probably dealt with some twenty different computer instruction set
architectures and assembly languages (PDP-8, PDP-11, Nova, Intel 8080, 8086,
68000, 68020, CDC 6600, DEC-10, to name a few) and probably half a dozen or
more high-level languages (FORTRAN IV, FORTRAN 77, PASCAL, COBOL, LISP, Ada,
FORTH, C, JOVIAL J73, that I remember offhand), and I have written quite a
few device drivers in my day.

As a matter of fact, I *would* usually choose to do the driver in Ada.

From the sound of what you have said so far, I conjecture that you have
never in your life done any serious work in Ada, and that you intend to keep
it that way if you possibly can.  Am I correct?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

> It's the other way around.  Software engineering is a fake field
> full of charltans, simply because it stands on a false premise -- you
> can take anybody and turn them into good disciplined programmers by 
> applications of certain principles.  The actual fact is, results
> in software are to a *very* large part related to aptitude.  If you

That's _partly_ true.  No tool can turn an idiot into
a genius.  But no true genius would be stupid enough
to insist on using inferior tools.

> If Ada projects had actually succeeded in producing good quality
> software, it would have been everywhere today.

That's a crock.  The few times people have
bothered to make empirical comparisons, Ada
has come out ahead.

But why am I answering a troll?  (If you are
not merely trying to stir up a fight, why are
you cross-posting to "misc.misc" ?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Mike Silva]

softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304240503.54dbc5d1@posting.google.com>...
> 
> If Ada projects had actually succeeded in producing good quality
> software, it would have been everywhere today.

Yeah, I see your point.  Kind of like why nobody runs Windows anymore.

Mike

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kent Paul Dolan]

Wesley Groleau <wesgroleau@despammed.com> wrote

> But why am I answering a troll?  (If you are
> not merely trying to stir up a fight, why are
> you cross-posting to "misc.misc" ?

Because in the article at the top of the thread
_I_ crossposted it to misc.misc, the Net's all
purpose newsgroup, for reasons I've explained
half a dozen times at length elsewhere [not
having anything to do with trolling, and for
sure not trolling by the person you accuse], and
not worth repeating here, but a crosspost I try
_always_ to include in my postings.

Sheesh.

xanthian.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kaz Kylheku]

softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304240446.493ca906@posting.google.com>...
> Ok, I am sure a few instances happened.  But if you
> had to develop device drivers for a living, and if
> the language was truly your choice, would you chose Ada as
> the language?
> 
> I think the only "yes" answers would be from
> people who only know Ada and/or have never
> written a device driver.

For developing a device driver for an operating system, the best
language is that one which all the other drivers are written in and
consequently for which there is toolchain and run-time support.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"soft-eng" <softeng3456@netscape.net> wrote in message >
> Syntax is core to the language.

True.

>So it should not be
> unnecessarily overloaded.

Of course--please show how Ada is unnecessarily overloaded.  That was your
unsupported implication wasn't it?

>Libraries can be learned
> in specialized variations, as needed.

But then you can have competing and inconsistent libraries which is an issue
raised before that you failed to address.

>But every
> programmer needs to know the syntax.

A programmer only needs to know enough syntax of a language to be an
effective developer.

>(Should anyway;
> if people are chunking the language syntax so
> their programmers can get their heads around it,
> I think the syntax is too complex.)

You must realize that most languages fail this test since programmers often
only learn a subset of the language that they find useful.  If you are to
take your view seriously, then you will most likely have to declare all
languages too complex.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

soft-eng wrote:

> If Ada projects had actually succeeded in producing good quality
> software, it would have been everywhere today.

That is the silliest thing you have said so far.

      1)  Ada projects have succeeded in producing many millions
           of lines of quality software.

      2)  It is no more difficult to learn to write programs in Ada than
           it is in any other language.   I know this from experience,

      3) The fact that something is available in abundance has no relationship
           to its inherent quality.   For example, many low quality fast-food
           purveyors have managed to dominate the marketplace by distracting
           customers with all kinds of gimmicks that have nothing to do with
           the quality of their food.

       4) I suspect your knowledge about Ada is a little out-of-date.  This tends
           to make your observations somewhat irrelevant.

Richard Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

Georg Bauhaus wrote:

> In comp.lang.ada Richard Riehle <richard@adaworks.com> wrote:
> :     In fact,  Ada, once some fundamental
> : ideas are understood, is not that difficult.
>
> :  The most
> : difficult  idea for many programmers to grasp is the set
> : of visibility rules in Ada.
>
> Could it be that rules like these are not enough at the
> center of introductions to Ada? I remember an exposition
> of child packages (somewhere in GNAT documentation?)
> pointing readers to their relation to nested packages.
> It does so at some length, and I think it was the length,
> including examples, that I found so helpful.

In my experience, once the Ada programmer understands the
visibilty rules, everything else falls into place.  It is, therefore,
important to gently introduce some of those rules as part of
the learning process.  If one tries to introduce all of them at
once, it can overwhelm the student to the point where they
throw up their hands screaming things such as, "I hate this
f........ing bureaucratic language."

A programmer who learns to use the visibility rules to advantage
will eventually be an outstanding Ada programmer.

Richard Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304240503.54dbc5d1@posting.google.com...
> It's the other way around.  Software engineering is a fake field
> full of charltans, simply because it stands on a false premise -- you
> can take anybody and turn them into good disciplined programmers by
> applications of certain principles.

This is blatantly false!  While there might be a good deal of people that
claim to be software engineers that are charlatans, this fact (if true) does
not discredit the actually field of software engineering.  Furthermore,
your claim the software engineering stands upon a faulty premise is a
strawman argument.

>The actual fact is, results
> in software are to a *very* large part related to aptitude.  If you
> can't hire well, the project is doomed no matter how many software
> engineering principles you apply.

True, software engineering principles do not solve all problem (they don't
claim too either), but they are not worthless either, and yes, you need
competent people in order to succeed in anything.

> Once you have the right people,
> engineering quality will appear;

Eventually--the point of software engineering is to facilitate and teach
methodologies that help the right people work more effectively.

> you just need to make sure

I think your use of 'just' severely understates the difficulty of
accomplishing the below

> the design is good, the management is good (which
> often means not getting in the way of good quality),
> there is good quality assurance, and such less-than-flashy things.


> So there are no "engineering quality" correct choices.
> Some languages with straight-jacket mentalities make people
> think they are rigorous, disciplined tools that will
> make quality magically appear.  That is deluded thinking.

Nothing can prevent deluded thinking.  Just like nothing can prevent people
from making silly strawman arguments.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Tom Welsh]

In article <9fa75d42.0304240503.54dbc5d1@posting.google.com>, soft-eng
<softeng3456@netscape.net> writes
>
>If Ada projects had actually succeeded in producing good quality
>software, it would have been everywhere today.
>
Although I don't think this argument holds water, it raises an issue
which I think is very important. Perhaps the most important issue for
software development today.

Observation suggests that good software products do not necessarily
become popular; and the methods and processes adopted in successful
software projects do not necessarily get widely imitated. 

Why is this? Anecdotally, we have the old joke about how any project
failure is followed by steps including (but not limited to):

* Punishment of the innocent;
* Promotion of the guilty;
* Scattering of the project team to the four winds;

and (most significantly for our purposes)

* Burying of the evidence.

These steps are calculated to block dissemination of knowledge about
what works well, as opposed to what fails consistently. Feedback is
stifled, and learning prevented.

How about successful projects? Well, for a start these are in a small
minority - partly because of the syndrome described above. Moreover,
some of the most strikingly successful projects are considered strategic
(whether in government or business) and are therefore kept secret. Once
again, the feedback loops are blocked and learning does not take place
on any significant scale.

The Software Engineering Institute's Capability Maturity Model - while
arguably rather bureaucratic in its implementation - aims to strike at
the root of the problem, by prescribing mechanisms by which an
organization can ensure that it learns as much as possible from its own
experience, at least. The CMM sets out to institutionalize learning.

Of course, many people dislike the culture associated with initiatives
like the CMM (and Ada, for that matter). So it is lucky that the open
source movement is exerting a similar influence from the grass roots
level. Open source developers do not nurse secrets - technical or
otherwise - and, time permitting, are usually more than happy to discuss
the way they work.

There are, of course, many other reasons for the relatively low level of
software quality - notably the absence of explicit demand (as expressed
through the traditional medium of cash).
-- 
Tom Welsh

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[AG]

"Tom Welsh" <news@tom-welsh.co.uk> wrote in message
news:WLKGbLATlNq+EwiQ@nildram.co.uk...

> There are, of course, many other reasons for the relatively low level of
> software quality - notably the absence of explicit demand (as expressed
> through the traditional medium of cash).

That's true. There is also a small matter that no customer
is really interested in quality as such. As long as the software
performs as expected it's fine (as far as the user is concerned
it may be made of duct tape).

The quality as in language/methodology/process is or
should be a primary concern of the developer - since
it is  [a bit :-)]  involved in making a project a success
or not in the first place.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Tom Welsh <news@tom-welsh.co.uk> wrote in message news:<WLKGbLATlNq+EwiQ@nildram.co.uk>...
> In article <9fa75d42.0304240503.54dbc5d1@posting.google.com>, soft-eng
> <softeng3456@netscape.net> writes
> >
> >If Ada projects had actually succeeded in producing good quality
> >software, it would have been everywhere today.
> >
> Although I don't think this argument holds water, it raises an issue
> which I think is very important. Perhaps the most important issue for
> software development today.
> 
> Observation suggests that good software products do not necessarily
> become popular; and the methods and processes adopted in successful
> software projects do not necessarily get widely imitated. 

Where do you get this?  People in the industry adopt what
they see succeeding.  It's a feedback loop -- if a pilot
C project in a company succeeds wildly, everybody in the company
wants to do C projects.  If this happens in many companies,
C programmer demand goes up, salaries go up, more students
learn C, then other managers have to use C because all
college graduates know C...

Of course, the feedback loop could go much faster and
start fully grown in terms of rewards, if you have
billions of dollars backing up some language.
But Ada is proof that there has to be more than billions
of dollars.  There have to be _results_.

> Why is this? Anecdotally, we have the old joke about how any project
> failure is followed by steps including (but not limited to):
> 
> * Punishment of the innocent;
> * Promotion of the guilty;
> * Scattering of the project team to the four winds;
> 
> and (most significantly for our purposes)
> 
> * Burying of the evidence.
> 
> These steps are calculated to block dissemination of knowledge about
> what works well, as opposed to what fails consistently. Feedback is
> stifled, and learning prevented.
> 
> How about successful projects? Well, for a start these are in a small
> minority - partly because of the syndrome described above. Moreover,
> some of the most strikingly successful projects are considered strategic
> (whether in government or business) and are therefore kept secret. Once
> again, the feedback loops are blocked and learning does not take place
> on any significant scale.

So you are saying the Ada projects that succeeded were secret,
and the ones that were not secret did not succeed?

I suppose then commercial interests were right in leaving
Ada.  Unless they were going to keep their projects secret,
it would not have succeeded!!

It's probably nothing to do with Ada -- the secret projects
would have succeeded in any language because too much
money was going to be thrown at them in secret.  Believe
it or not, before Ada the DoD had many successful projects
in assembly language.  That doesn't mean assembly language
is the best tool.

Of course, perhaps a non-Ada language could have cut the project
costs and time to a quarter, but since the project was a secret,
there wasn't anybody around to point it out, was there?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

"AG" <ang@xtra.co.nz> wrote in message news:<k05qa.27935$mZ4.329924@news.xtra.co.nz>...
> "Tom Welsh" <news@tom-welsh.co.uk> wrote in message
> news:WLKGbLATlNq+EwiQ@nildram.co.uk...
> 
> > There are, of course, many other reasons for the relatively low level of
> > software quality - notably the absence of explicit demand (as expressed
> > through the traditional medium of cash).
> 
> That's true. There is also a small matter that no customer
> is really interested in quality as such. As long as the software
> performs as expected it's fine (as far as the user is concerned
> it may be made of duct tape).

So you think quality has nothing to do with performing as expected?

When I buy a car, I want it to perform as expected,
I don't CARE what methodology they used or didn't
use to get it to perform as expected.  If they
used a methodology that they though was the epitome
of perfection, but the car broke down every six months,
I would not buy it.  And if some other company
was able to use duct tape, but had a product
that ran for 20 years without maintenance, I would
buy it.  Whether they use duct tape or not
is not my concern.

Why should I expect software buyers to be any different?

(Thanks for illuminating the Ada advocates' mentality
perfectly, btw!)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

snarflemike@yahoo.com (Mike Silva) wrote in message news:<20619edc.0304240953.221ac70f@posting.google.com>...
> softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304240503.54dbc5d1@posting.google.com>...
> > 
> > If Ada projects had actually succeeded in producing good quality
> > software, it would have been everywhere today.
> 
> Yeah, I see your point.  Kind of like why nobody runs Windows anymore.
> 
> Mike

Works for me (plus several million other people.)

I even used Unix for years, even when it DIDN't
work 1/10th as reliably as today's Windows.

It's good to see operating systems progress to
the point where anybody off the streets can
realiably use them and the only people complaing
about the reliability are ones with axes to grind.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EA87284.59CD9FA4@adaworks.com>...
> soft-eng wrote:
> 
> > If Ada projects had actually succeeded in producing good quality
> > software, it would have been everywhere today.
> 
> That is the silliest thing you have said so far.
> 
>       1)  Ada projects have succeeded in producing many millions
>            of lines of quality software.
> 
>       2)  It is no more difficult to learn to write programs in Ada than
>            it is in any other language.   I know this from experience,
> 
>       3) The fact that something is available in abundance has no relationship
>            to its inherent quality.   For example, many low quality fast-food
>            purveyors have managed to dominate the marketplace by distracting
>            customers with all kinds of gimmicks that have nothing to do with
>            the quality of their food.
> 
>        4) I suspect your knowledge about Ada is a little out-of-date.  This tends
>            to make your observations somewhat irrelevant.
> 
> Richard Riehle

*Any* observations about Ada, in 2003, are somewhat irrelevant :-)
But if we didn't want to discuss irrelevancies, we wouldn't
subscribe to a .advocay group, would we?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

"Chad R. Meiners" <crmeiners@hotmail.com> wrote in message news:<b89nj1$1ikp$1@msunews.cl.msu.edu>...
> "soft-eng" <softeng3456@netscape.net> wrote in message >
> > Syntax is core to the language.
> 
> True.
> 
> >So it should not be
> > unnecessarily overloaded.
> 
> Of course--please show how Ada is unnecessarily overloaded.  That was your
> unsupported implication wasn't it?
> 
> >Libraries can be learned
> > in specialized variations, as needed.
> 
> But then you can have competing and inconsistent libraries which is an issue
> raised before that you failed to address.
> 
> >But every
> > programmer needs to know the syntax.
> 
> A programmer only needs to know enough syntax of a language to be an
> effective developer.
> 
> >(Should anyway;
> > if people are chunking the language syntax so
> > their programmers can get their heads around it,
> > I think the syntax is too complex.)
> 
> You must realize that most languages fail this test since programmers often
> only learn a subset of the language that they find useful.  If you are to
> take your view seriously, then you will most likely have to declare all
> languages too complex.

I think you need some actual experience with programmers
of different language.  Then you will be able to
make valid arguments on this.  E.g. how much of
the syntax of Java or VB the typical programmer
knows.  Language libraries are a (philosophically
and in practice) different issue, but most of the syntax
is well understood by most programmers.

Note that his argument does not apply to C++ -- most
C++ programmers only know a subset of the C++ syntax well.
(Specially since the syntax has been relentlessly expanded.)
But that's the reason for C++'s losing a lot
of ground.  Very soon advocates will start appearing
to claim C++ is the best thing since sliced bread,
and absolutely the best language for *everything*.
When that happens, C++ will be in the same
land where Ada is now.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304250443.47bd2aa9@posting.google.com...

> So you think quality has nothing to do with performing as expected?

That is not what AG said.  You are obviously mischaracterizing other's
arguments.

> (Thanks for illuminating the Ada advocates' mentality
> perfectly, btw!)

Ah, so you are a troll.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304250437.38893d8c@posting.google.com...
> Where do you get this?  People in the industry adopt what
> they see succeeding.  It's a feedback loop -- if a pilot
> C project in a company succeeds wildly, everybody in the company
> wants to do C projects.  If this happens in many companies,
> C programmer demand goes up, salaries go up, more students
> learn C, then other managers have to use C because all
> college graduates know C...

People feed money into slot machines because they see people winning money;
however, although a very few win most lose.  People rarely notice all those
that lose money.

> So you are saying the Ada projects that succeeded were secret,
> and the ones that were not secret did not succeed?

You're trolling.  You have mischaracterize yet another argument.  This
raises the question why you even bother to write such obviously nonsensical
arguments.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304250937.36a7897e@posting.google.com...
>
> I think you need some actual experience with programmers
> of different language.

I have such experience; do you?

> Then you will be able to
> make valid arguments on this.  E.g. how much of
> the syntax of Java or VB the typical programmer
> knows.

I have work on projects in both VB and Java.  In both cases competent
programmers only knew subsets of the language's syntax.  This subsetting did
not hamper the projects' success.

> but most of the syntax
> is well understood by most programmers.

Ha!  Just the other day I ran into a competent programmer that never
realized that the {} defines a block in C that you can declare variables in.
Sure he used {}'s all the time, but he didn't understand their flexibility
until told him.  Still he produced acceptable work when he had to work in C.
How many competent Java programmers don't know about the synchronize keyword
because they never have writen a multithreaded application?

Also are you talking just about syntax or about both syntax and semantics?
If you are only concerned with syntax then we have an uninteresting
discussion, however, if you are interested in semantics, then almost all
programmers only know of subset of each programming language's syntax.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Kilgallen@SpamCop.net (Larry Kilgallen) wrote in message news:<kKoVGF55fYtj@eisner.encompasserve.org>...
> In article <9fa75d42.0304230515.48064263@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:
> > Kilgallen@SpamCop.net (Larry Kilgallen) wrote in message news:<d3xFAUvBYizb@eisner.encompasserve.org>...
> >> In article <9fa75d42.0304221126.7112b7d5@posting.google.com>, softeng3456@netscape.net (soft-eng) writes:
>  
> >> > (C and later C++ style of type-safety turned out to
> >> > be good enough for real-world projects.)
> >> 
> >> Like Windows ?
>  
> > You don't like Windows, so you must be using
> > what?  Unix and X-Windows?  Written/extended/in Ada?
> 
> At this instant I am using VMS, which thankfully written mostly before
> the current C-mania started.  Even when they use C on Alpha and Itanium
> now, those who develop VMS tend to use the safer techniques they learned
> with Bliss in place of the null-terminated strings and other garbage that
> is encouraged by C.

You are living in a Jurassic Park world.

When VMS was first done, C was not on the lansdcape.
But as awareness of C grew, it was adopted very widely
within VMS Product Engineering.  Many of the products
in your VMS product-listing book were done in C!

But if you are complaining of null-terminated
strings, you couldn't have very well actually seen much
Bliss code now, could you?  It was hardly what you would
call a "safe" language.  Very far from it, it
didn't even have standard data types.  And you could
do all kinds of address arithmetic.  In fact, you 
had to be aware of memory address issues
all the time in Bliss. In Bliss, you don't
write (except when you mean it)

   A = B;

instead you write

   A = .B;

so the compiler knows that you want to store the contents of
memory address B into the contents of memory address A, (as
opposed to storing the memory address B into the contents of
memory address B, which is what it would happily do if
you forgot the dot!)  The rules got worse as you got into
procedure calls...  Soon you find yourself fixing bugs
involving wrong number of dots.  Bliss was certainly not
for the faint of heart!

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

soft-eng wrote:

> So you are saying the Ada projects that succeeded were secret,
> and the ones that were not secret did not succeed?

Go to www.adaic.org.   There are plenty of case histories
of Ada projects that succeeded.    This includes a large
number of Air Traffic Control systems, commercial
aircraft avionics,  power industry systems,  manufacturing
process control systems,  transportation systems, the global
positioning satellites,  many communication satellites (Intelsat
VII, for one), and more.   They are not secret.   They are
simply not widely publicized.

Notice that these systems tend to be large-scale, safety-related,
and have long lifetimes.   The fact that you are personally ignorant
of Ada, its successes, and its benefits does not detract from its
history in the building of successful systems.   The fact that some
software developers have used Ada badly does not imply there
is a problem with the language.   Rather, it implies that those
developers are less competent than those who have used it
successfully.

I have seen people take on Ada projects and fail.   I have seen others
take on Ada projects and succeed beyond what they would have believed
possible when they first started.   Those who failed would probably
have failed using any other toolset or language.   More often than not,
the failure is due to stupid project management.  At least one huge
project in Ada failed because the people managing it were incompetent,
and Ada was their scapegoat.    All they could do, for years afterward,
was denigrate the language.   The programmers,  many of whom I know
quite well, knew the real cause was not Ada, but the people in charge
of making it work.

One well-known company, a manufacturer of office copying machines,
allowed one of its software development groups to build the embedded
software in Ada.   The group, and the manager, was amazed at their
success and decided they wanted to use Ada for future projects.  The
corporate level management of this company (a company already known
for its record of grabbing defeat from the jaws of victory) dictated that
all software would henceforth be written in C, this in spite of the
phenomenal success of Ada.

There are plenty of success stories outside the Department of Defense. In
fact, Ada in the hands of competent commercial developers may have been
more successful, if not more widespread, than in the weapon systems
area.

You may want to grouse about the language you seem not to understand,
and that is your right.   However, those of us who do understand it find
your deprecatory commentary to be the ranting of an uniformed person
whose opinion is based on nothing more than hot air or personal
failure.   When you look at the successes of those who do know how
to build software, you will find that Ada measures up quite well against
any competing technology.

Richard Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[AG]

"Chad R. Meiners" <crmeiners@hotmail.com> wrote in message
news:b8c07f$kot$1@msunews.cl.msu.edu...
>
> "soft-eng" <softeng3456@netscape.net> wrote in message
> news:9fa75d42.0304250937.36a7897e@posting.google.com...

> > Then you will be able to
> > make valid arguments on this.  E.g. how much of
> > the syntax of Java or VB the typical programmer
> > knows.
>
> I have work on projects in both VB and Java.  In both cases competent
> programmers only knew subsets of the language's syntax.  This subsetting
did
> not hamper the projects' success.

Just to take on the VB claim up there. How many
practicing VB programmers realise that this construct
(subject to typos and such) is a perfectly valid syntax:

select case true
case a = b
 ...
case a = c
 ...

[omittting the alphabet]

case a = z
...


It will even work if used.

>
> > but most of the syntax
> > is well understood by most programmers.

Is it?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

> Ah, so you are a troll.

Speaking of trolls, can someone other than
"Kent Paul Dolan" educate me on why we should
or should not keep cross-posting this to misc.misc ?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[AG]

"Wesley Groleau" <wesgroleau@despammed.com> wrote in message
news:YvmdnVI0i9K-YjSjXTWcrg@gbronline.com...
>
> > Ah, so you are a troll.
>
> Speaking of trolls, can someone other than
> "Kent Paul Dolan" educate me on why we should
> or should not keep cross-posting this to misc.misc ?

No idea. Is it where the bad bits go when they die?

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Mike Silva]

softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304250448.5107afef@posting.google.com>...
> snarflemike@yahoo.com (Mike Silva) wrote in message news:<20619edc.0304240953.221ac70f@posting.google.com>...
> > softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304240503.54dbc5d1@posting.google.com>...
> > > 
> > > If Ada projects had actually succeeded in producing good quality
> > > software, it would have been everywhere today.
> > 
> > Yeah, I see your point.  Kind of like why nobody runs Windows anymore.
> > 
> > Mike
> 
> Works for me (plus several million other people.)
> 
> I even used Unix for years, even when it DIDN't
> work 1/10th as reliably as today's Windows.
> 
> It's good to see operating systems progress to
> the point where anybody off the streets can
> realiably use them and the only people complaing
> about the reliability are ones with axes to grind.

You are one funny guy!  In comedy a straight face is everything!  :-)

Gotta get back to those axes now...

Mike

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"Wesley Groleau" <wesgroleau@despammed.com> wrote in message
news:YvmdnVI0i9K-YjSjXTWcrg@gbronline.com...
> Speaking of trolls, can someone other than
> "Kent Paul Dolan" educate me on why we should
> or should not keep cross-posting this to misc.misc ?

I thought it was so KPD could keep track of all the discussions he started
in different news groups.  At least that what he claimed before when he was
previously questioned about it.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Dale Stanbrough <dstanbro@bigpond.net.au> wrote in message news:<dstanbro-70C9D2.10010223042003@mec2.bigpond.net.au>...
> Robert A Duff wrote:
> 
> > > > Also, Ada proponents made much of its strong
> > > > typing.  But it was not at all novel or revolutionary.
> > > > It was a very common language idea
> > > > at that time, and then-popular Pascal had it too.
> > > 
> > > As a Pascal programmer I was thrilled to use Ada since the typing
> > > system is so much stronger than in Pascal.
> > 
> > Much more flexible, too.
> 
> If i'm asked to quickly describe Ada, I often say it is an
> industrialised Pascal...
> 

A better description would be "Pascal concepts taken to extreme".

Take highway lane dividing lines painted on the road, for
example.  These are a *good* idea and promote safety.  Now
give them to Jean Ichbiah, and instead of simple painted
lines, you would have brilliantly colered dividers that are
one foot high and electrically shock anybody who tries to cross
them except at approved lane crossing points.  It is not clear
that all concepts are helpful beyond a point.  In fact,
Ichbiah's dividers may deter safety, because many drivers
may accidentally run into the dividers, and once in a while
when to avoid running into the multi-car pileup you have
to change lanes *right now*, you wouldn't be able to do it.
All in the name of safety.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

snarflemike@yahoo.com (Mike Silva) wrote in message news:<20619edc.0304252116.621a4bf4@posting.google.com>...
> softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304250448.5107afef@posting.google.com>...
> > snarflemike@yahoo.com (Mike Silva) wrote in message news:<20619edc.0304240953.221ac70f@posting.google.com>...
> > > softeng3456@netscape.net (soft-eng) wrote in message news:<9fa75d42.0304240503.54dbc5d1@posting.google.com>...
> > > > 
> > > > If Ada projects had actually succeeded in producing good quality
> > > > software, it would have been everywhere today.
> > > 
> > > Yeah, I see your point.  Kind of like why nobody runs Windows anymore.
> > > 
> > > Mike
> > 
> > Works for me (plus several million other people.)
> > 
> > I even used Unix for years, even when it DIDN't
> > work 1/10th as reliably as today's Windows.
> > 
> > It's good to see operating systems progress to
> > the point where anybody off the streets can
> > realiably use them and the only people complaing
> > about the reliability are ones with axes to grind.
> 
> You are one funny guy!  In comedy a straight face is everything!  :-)

No, I am serious.  Many people who use computers today, simply
wouldn't have been able to, 20 years ago.  That's progress,
excpet if you have a personal reason to say "no, it's not.".

NOBODY except computer programmers complain about reliability
of Windows.  They might claim it's frustrating, but not
unreliable.

I think there used to be many complaints in this NG because Windows
crashed when somebody loaded a buggy device driver into it.
That kind of complaint HAS to come from a Computer Programmer
with an axe to grind.  Common people would NEVER complain
that Honda makes junk cars because they took out the batteries
and replaced it with experimental junk, and the car refused
to start!

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

"Chad R. Meiners" <crmeiners@hotmail.com> wrote in message news:<b8c07f$kot$1@msunews.cl.msu.edu>...
> "soft-eng" <softeng3456@netscape.net> wrote in message
> news:9fa75d42.0304250937.36a7897e@posting.google.com...
> >
> > I think you need some actual experience with programmers
> > of different language.
> 
> I have such experience; do you?
> 
> > Then you will be able to
> > make valid arguments on this.  E.g. how much of
> > the syntax of Java or VB the typical programmer
> > knows.
> 
> I have work on projects in both VB and Java.  In both cases competent
> programmers only knew subsets of the language's syntax.  This subsetting did
> not hamper the projects' success.
> 
> > but most of the syntax
> > is well understood by most programmers.
> 
> Ha!  Just the other day I ran into a competent programmer that never
> realized that the {} defines a block in C that you can declare variables in.
> Sure he used {}'s all the time, but he didn't understand their flexibility
> until told him.  Still he produced acceptable work when he had to work in C.
> How many competent Java programmers don't know about the synchronize keyword
> because they never have writen a multithreaded application?
> 
> Also are you talking just about syntax or about both syntax and semantics?
> If you are only concerned with syntax then we have an uninteresting
> discussion, however, if you are interested in semantics, then almost all
> programmers only know of subset of each programming language's syntax.

I think you have to use common sense.

When I say most programmers know most of the syntax/semantics, it still
means most programmers might not know some of the syntax/semantics,
and some programmers might not know much of the syntax/semantics.
And we are comparing C vs Ada, so if you really want to be
fair, you have to compare how well the average programmer
knows the language details.  (But I think the key phrase is "really
want to be fair".  Do you?)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EA9E194.BAC2A2B6@adaworks.com>...
> soft-eng wrote:
> 
> > So you are saying the Ada projects that succeeded were secret,
> > and the ones that were not secret did not succeed?
> 
> Go to www.adaic.org.   There are plenty of case histories
> of Ada projects that succeeded.    This includes a large

Amazingly enough, I don't think there are any such sites for
C, C++, Java...

Instead, when you read my message and typed a respnse in your
newsreader, you provided testimony that these languages have been
used by actual people to provide actually useful software.

You may claim that these were all stupid people who couldn't
chose the right language for the tool, couldn't understand
Ada, or didn't realize they could have done a better job in Ada.

But given that Ada was not only available, but actively
supported by HUGE amounts of tax money, I may choose
to believe you are arguing from nothing but personal biases.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

"Chad R. Meiners" <crmeiners@hotmail.com> wrote in message news:<b8a4jk$1v1t$1@msunews.cl.msu.edu>...
> "soft-eng" <softeng3456@netscape.net> wrote in message
> news:9fa75d42.0304240503.54dbc5d1@posting.google.com...
> > It's the other way around.  Software engineering is a fake field
> > full of charltans, simply because it stands on a false premise -- you
> > can take anybody and turn them into good disciplined programmers by
> > applications of certain principles.
> 
> This is blatantly false!  While there might be a good deal of people that
> claim to be software engineers that are charlatans, this fact (if true) does
> not discredit the actually field of software engineering.  Furthermore,
> your claim the software engineering stands upon a faulty premise is a
> strawman argument.
> 
> >The actual fact is, results
> > in software are to a *very* large part related to aptitude.  If you
> > can't hire well, the project is doomed no matter how many software
> > engineering principles you apply.
> 
> True, software engineering principles do not solve all problem (they don't
> claim too either), but they are not worthless either, and yes, you need
> competent people in order to succeed in anything.
> 
> > Once you have the right people,
> > engineering quality will appear;
> 
> Eventually--the point of software engineering is to facilitate and teach
> methodologies that help the right people work more effectively.
> 
> > you just need to make sure
> 
> I think your use of 'just' severely understates the difficulty of
> accomplishing the below
> 
> > the design is good, the management is good (which
> > often means not getting in the way of good quality),
> > there is good quality assurance, and such less-than-flashy things.
> 
> 
> > So there are no "engineering quality" correct choices.
> > Some languages with straight-jacket mentalities make people
> > think they are rigorous, disciplined tools that will
> > make quality magically appear.  That is deluded thinking.
> 
> Nothing can prevent deluded thinking.  Just like nothing can prevent people
> from making silly strawman arguments.

What strawman argument?

I presented my _conclusion_ regarding the underlying fallacy of
the various "Software Engineering Methodologies" and why
they have been continuously failing for more than two
decades, while tools and language improvements have
had amazingly great success in that timeframe.

I didn't say the Methodology people made this argument.  (That
would have made it a strawman.) I just saw it as the
underlying premise (which some Methodology
people may not even realize) which ends up turning
the Methodology people into charltans (because they are
forced to come up with more and more false reasons as to why
their Methodology didn't do what it claimed... as well
as newer improved claims...)

You may disagree with my conclusions, but questioning
my integrity because of that disagreement is disingenuous.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[AG]

"soft-eng" <softeng3456@netscape.net> wrote in message

> NOBODY except computer programmers complain about reliability
> of Windows.  They might claim it's frustrating, but not
> unreliable.

Really? How about some truck drivers who have
to be put on hold while the Windoze system
reboots, reloads, gets up to snuff and finally
prints that piece of paper that would have
taken about 20 seconds to write by hand?
Or the poor despatcher who wouldn't know
Windoze from bit-bucket except that he/she
needs to reboot it every half-hour or so just
to get rid of the frozen parts of it and get the
trucks moving.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

>>NOBODY except computer programmers complain about reliability
>>of Windows.  They might claim it's frustrating, but not
>>unreliable.
> 
> Really? How about some truck drivers who have
> to be put on hold while the Windoze system
> reboots, reloads, gets up to snuff and finally
> prints that piece of paper that would have
> taken about 20 seconds to write by hand?
> Or the poor despatcher who wouldn't know
> Windoze from bit-bucket except that he/she
> needs to reboot it every half-hour or so just
> to get rid of the frozen parts of it and get the
> trucks moving.

You people are talking about two different things.
There are TWO operating systems called Windows.

Windows 3.1 / 95 / 98 / ME crashes daily for many users

Windows NT / 2000 / XP is a completely different O.S.
It still crashes, but it is reliable enough for most
people.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Frank J. Lhota]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304260649.366530c5@posting.google.com...
> NOBODY except computer programmers complain about reliability
> of Windows.  They might claim it's frustrating, but not
> unreliable.

Complains about Windows hangs and reboots have made it to TV shows such as
"Saturday Night Live", comic strips like "Dilbert" and "Cathy", and even the
pages of "Mad" magazine. It would be comforting for us Software Engineers to
believe that the general public does not notice our errors, but I assure you
that would be delusional thinking.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Mike Silva]

"AG" <ang@xtra.co.nz> wrote in message news:<NXCqa.32967$mZ4.383971@news.xtra.co.nz>...
> "soft-eng" <softeng3456@netscape.net> wrote in message
> 
> > NOBODY except computer programmers complain about reliability
> > of Windows.  They might claim it's frustrating, but not
> > unreliable.
> 
> Really? How about some truck drivers who have
> to be put on hold while the Windoze system
> reboots, reloads, gets up to snuff and finally
> prints that piece of paper that would have
> taken about 20 seconds to write by hand?
> Or the poor despatcher who wouldn't know
> Windoze from bit-bucket except that he/she
> needs to reboot it every half-hour or so just
> to get rid of the frozen parts of it and get the
> trucks moving.

Obviously they're only drivers and dispatchers *by day*.  At night, in
the privacy of their own homes, I'll bet they're *computer
programmers*!  They can try to hide it, but Windows knows!

Mike

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Vinzent Hoefler]

"Frank J. Lhota" <NOSPAM.FrankLho@rcn.com> wrote:

>It would be comforting for us Software Engineers to
>believe that the general public does not notice our errors, but I assure you
>that would be delusional thinking.

At least we have an excuse:

<http://www.thinkgeek.com/tshirts/frustrations/5765/>

Yes, I wear this at work. :-P


Vinzent.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Steve]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304260644.764b8674@posting.google.com...
[snip]
>
> A better description would be "Pascal concepts taken to extreme".
>
> Take highway lane dividing lines painted on the road, for
> example.  These are a *good* idea and promote safety.  Now
> give them to Jean Ichbiah, and instead of simple painted
> lines, you would have brilliantly colered dividers that are
> one foot high and electrically shock anybody who tries to cross
> them except at approved lane crossing points.  It is not clear
> that all concepts are helpful beyond a point.  In fact,
> Ichbiah's dividers may deter safety, because many drivers
> may accidentally run into the dividers, and once in a while
> when to avoid running into the multi-car pileup you have
> to change lanes *right now*, you wouldn't be able to do it.
> All in the name of safety.

I prefer a different analogy.

Imagine having 100 different electronics devices, all which have 30 pin
ribbon cable connections.  Some of the devices have different pinouts, and
connecting two devices with different pinouts can either cause damage to the
devices or cause the devices to malfunction.

The typing mechanism in Ada is like keying all of the connectors such that
it is impossible to connect two devices in a way that will cause damage.

BTW: A better place to take this discussion would be team-ada@acm.org.

Steve
(The Duck)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[AG]

"Mike Silva" <snarflemike@yahoo.com> wrote in message
news:20619edc.0304261803.5d26f40e@posting.google.com...

> Obviously they're only drivers and dispatchers *by day*.  At night, in
> the privacy of their own homes, I'll bet they're *computer
> programmers*!

Well, no, not really :) In fact that almost always happens in
the middle of the night or wee hours of the morning (when
do you think the trucks get loaded for delivery?)

Unfortunately, most programmers and/or sys admins
have a bad habit of liking to sleep at that sort of time.

Which brings us back to the question of reliability:

- Option one: have a stand-up on-call professional
support with a pager available 24 by 7. Sort of
what fire brigades do [that will cost of course]

- Option two: have a reliable system with the chance
of catastrophic failure so low that you (or your clients)
are willing to risk it just on statistical basis.

Which one would you choose if you had to fund it?

[Besides, you've said "I'll bet". What do you bet?]

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kent Paul Dolan]

softeng3456@netscape.net (soft-eng) wrote:

> No, I am serious.

How sad for you then.

> Many people who use computers today, simply wouldn't have been
> able to, 20 years ago.  That's progress, exc[ep]t if you have
> a personal reason to say "no, it's not.".

Except that you are revising history beyond recognition: the
vi() editor was written for the use of secretaries, and it is
lots more than 20 years old. Visicalc, the first spreadsheet,
was a tool for managers, and it is over 20 years old.  Computers
have been used by non-programmer types pretty much since their
inception; we programmers have always worked as a service class
to the needs of end users, and there have always been end users
who were not computer sophisticates.

> NOBODY except computer programmers complain about reliability
> of Windows.  They might claim it's frustrating, but not
> unreliable.

That's not true either; my bookkeeper/secretary/billing clerk
wife regaled me with horror stories of time lost to Windows and
other M$ "productivity" tools for over a decade, and started
that period by saying "and thus it has always been". Among the
haters of MS-Windows, clerical types probably have pride of
place far ahead of mere knowledgable programmers, the latter
having the advantage of knowing not merely that MS-Windows is
unfit for use, but also why that is so, and so are not
inconsolable like the clerks.

> I think there used to be many complaints in this NG because
> Windows crashed when somebody loaded a buggy device driver
> into it.  That kind of complaint HAS to come from a Computer
> Programmer with an axe to grind.  Common people would NEVER
> complain that Honda makes junk cars because they took out the
> batteries and replaced it with experimental junk, and the car
> refused to start!

Except that what is really happening with MS-Windows has nothing
to do with "buggy device drivers" and everything to do with "bad
M$ OS writer design decisions that put the device drivers inside
the OS address space".  Your analogy is flawed, it is more like
Hondas refusing to start if the driver wears plaids with
stripes.

xanthian.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert A Duff]

"Chad R. Meiners" <crmeiners@hotmail.com> writes:

> "Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
> news:wccadeiglef.fsf@shell01.TheWorld.com...
> > Really!?  I think of array slicing as a pretty minor feature of Ada,
> > which causes a lot of trouble for compiler writers, that could be
> > dispensed with.  After all, you could write a function that grabs those
> > components.
> 
> > I'm thinking particularly of slices as L-values.  Do you ever use that?
> 
> Usually I pass slices of arrays as parameters to procedures and functions.
> For example Ada.Strings.Fixed would be far less convenient without the
> ability to pass part of an array to a procedure or function.  As for
> L-values I assume you mean something like
> 
> x(1..80) := (others => y);
> ?
> If so, I use slices less often for that purpose.

Yes, by "L-value", I meant on the left-hand side of an assignment, or an
'out' parameter, or similar things.  If X(1..80) is just syntactic sugar
for a function call Slice(X, 1, 80) or Slice(X, First => 1, Last => 80),
then it would be little trouble for the Ada compiler.  And I would think
it would be but a minor convenience for the programmer.

But when slices are used as L-values, there are various interactions
with packing and whatnot that cause compiler complexity.

- Bob

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert A Duff]

Dr Chaos <mbkennelSPAMBEGONE@NOSPAMyahoo.com> writes:

> Robert A Duff <bobduff@shell01.TheWorld.com> wrote:
> > "Chad R. Meiners" <crmeiners@hotmail.com> writes:
> >> Array slicing is a wonderfully useful feature.  I use this feature in almost
> >> every program of mine.
> > 
> > Really!?  I think of array slicing as a pretty minor feature of Ada,
> > which causes a lot of trouble for compiler writers, that could be
> > dispensed with.  After all, you could write a function that grabs those
> > components.
>  
> > I'm thinking particularly of slices as L-values.  Do you ever use that?
> 
> Ask everybody who likes MATLAB:
> 
> in other words "yes".

Sorry; I know nothing of MATLAB.  Perhaps you could give an example of
why array slicing (as an L-value!) is so useful.  I don't doubt that it
is (in MATLAB and Fortran).

> And it's in Fortran 90/95, for similar reasons.  

Well, Fortran's array-slicing capabilities are more powerful than Ada's.
My comment that slicing-as-L-value is a frill was specific to Ada.

>...Note that F90 was
> designed after Ada.

The latest version of Ada was designed in the period 1990 to 1995 or so.
I would think F90 is roughly the same vintage.

> Getting arrays right definitely helps lower bugs, because
> off-by-one counting in iteration are frequent source of
> errors.

Indeed.

- Bob

P.S. Sorry, I'm disobeying your followup-to.  I'm reading this in
comp.lang.ada, and would otherwise never see replies.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert A Duff]

Wesley Groleau <wesgroleau@despammed.com> writes:

> > I'm thinking particularly of slices as L-values.  Do you ever use that?
> 
> I did that a lot in Ada days, too.

An example, please?

- Bob

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert A Duff]

xanthian@well.com (Kent Paul Dolan) writes:

> Robert A Duff <bobduff@shell01.TheWorld.com> wrote:
> > "Chad R. Meiners" <crmeiners@hotmail.com> writes:
> 
> >> Array slicing is a wonderfully useful feature.  I use this feature
> in almost
> >> every program of mine.
> 
> > Really!?  I think of array slicing as a pretty minor feature of Ada,
> > which causes a lot of trouble for compiler writers, that could be
> > dispensed with.  After all, you could write a function that grabs those
> > components.
> 
> > I'm thinking particularly of slices as L-values.  Do you ever use that?
> 
> It might be "minor" now, but if Ada is ever to stand beside Fortran as
> a programming language for supercomputers, it is awfully nice that
> this much of the needed semantics are "already in there"; they were a
> huge shock when they first hit Fortran all in a lump.

I'm afraid that Ada's array-slicing capabilities are too restrictive
(compared to Fortran) to qualify for the "already in there".

> [And by the way, since I've drifted away from Ada for lack of job
> prospects for an Ada beginner without a current security clearance,

Sorry to hear that.  I've been working on-and-off on Ada-related stuff
for many years, with no security clearance.  It's not just military
stuff, you know.

>... is
> there any effort underway to add the syntactic sugar for supercomputer
> programming to Ada in an upcoming standard's language revision,

No, as far as I know, there is no serious work underway for such
syntactic sugar.  (Or, as Dr Chaos points out -- it's really semantic
sugar.)  Some proposals were made during the development of Ada 95.
It wouldn't take much...

But:

>... or is
> Ada down to "don't rock the boat" editorial cleanup standards (that
> would eventually doom the language) for the foreseeable future, or is
> there some big worthwhile effort but in another direction?]

No, it's not in "don't rock the boat" mode -- changes to Ada are being
made in other directions.

- Bob

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Eric G. Miller]

In article <d%Jqa.34014$mZ4.393336@news.xtra.co.nz>, AG wrote:
> "Mike Silva" <snarflemike@yahoo.com> wrote in message
> news:20619edc.0304261803.5d26f40e@posting.google.com...
> 
>> Obviously they're only drivers and dispatchers *by day*.  At night, in
>> the privacy of their own homes, I'll bet they're *computer
>> programmers*!
> 
> Well, no, not really :) In fact that almost always happens in
> the middle of the night or wee hours of the morning (when
> do you think the trucks get loaded for delivery?)

As a former truck driver, I have to say that loading/unloading occurs
all around the clock.  In my experience, it was as likely to be 3am as
1pm.  It really depends on the type of shipper and receiver, the type of
"trucks" your talking about (van, refrigerated van, flatbed, container, 
etc.), the type of load, and the distance involved.  There are a number
of niches in the trucking world.

Also, a number of larger shippers tend to have possession of a rotating
stock of various trucking companies' trailers.  In those cases, drivers
are often not present when the vans get loaded or unloaded.  It's sort
of an extended warehouse system.  Just In Time and all that...  The
driver shows up with an empty, exchanges it for a loaded trailer and is
gone in 15 minutes or so.

> Unfortunately, most programmers and/or sys admins
> have a bad habit of liking to sleep at that sort of time.
> 
> Which brings us back to the question of reliability:
> 
> - Option one: have a stand-up on-call professional
> support with a pager available 24 by 7. Sort of
> what fire brigades do [that will cost of course]
> 
> - Option two: have a reliable system with the chance
> of catastrophic failure so low that you (or your clients)
> are willing to risk it just on statistical basis.

The company I worked for ran much of their logistics system off an IBM 
main frame and trucks were satellite dispatched.  The shipper was 
responsible for preparing the bill of lading by whatever means.  I
suspect the company had 24/7 technical support (considering they had
24/7 dispatching).  I don't think this is unusual among the larger
freight haulers...  Smaller or local/regional companies may not need
such a system if the truck movement patterns are less dynamic than an
over-the-road company.  I haven't seen any satellite dispatched logging
trucks, for instance.

-- 
echo ">gra.fcw@2ztr< eryyvZ .T pveR" | rot13 | reverse

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

Robert A Duff wrote:
>>>I'm thinking particularly of slices as L-values.  Do you ever use that?
>>
>>I did that a lot in Ada days, too.
> 
> An example, please?

Replacing a section of an array with other values
instead of looping through it assigning one element
at a time.

Often, I also used the trick of declaring an
array that was actually a renaming of a slice
from another array.  The new name can be used
on either side of an assignment.

I have also often used a slice as an actual
for an out-mode parameter.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

Option three.  Have a redundant system, hoping that
only one will crash at a time.  Then network them
all together, so that the one that crashes will
take out the rest of them.  :-)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Peter Hermann]

In comp.lang.ada Richard Riehle <richard@adaworks.com> wrote:
Richard,
thank you for your contribution which found the way into my 
advocacy records.
BTW, it's a good feeling to use that wonderful kill-file mechanism.

-- 
--Peter Hermann(49)0711-685-3611 fax3758 ica2ph@csv.ica.uni-stuttgart.de
--Pfaffenwaldring 27 Raum 114, D-70569 Stuttgart Uni Computeranwendungen
--http://www.csv.ica.uni-stuttgart.de/homes/ph/
--Team Ada: "C'mon people let the world begin" (Paul McCartney)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Dmitry A. Kazakov]

Robert A Duff wrote:

> Yes, by "L-value", I meant on the left-hand side of an assignment, or an
> 'out' parameter, or similar things.  If X(1..80) is just syntactic sugar
> for a function call Slice(X, 1, 80) or Slice(X, First => 1, Last => 80),
> then it would be little trouble for the Ada compiler.

Do you mean that Slice (...) would always have a copy semantics? 

> And I would think it would be but a minor convenience for the programmer.

> But when slices are used as L-values, there are various interactions
> with packing and whatnot that cause compiler complexity.

Isn't it already there because array elements can be also L-values? Or that 
objects of some types have to be constructed in-place? I mean, with or 
without slices, one cannot get rid of this problem anyway.

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

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[AG]

"Robert A Duff" <bobduff@shell01.TheWorld.com> wrote in message
news:wccn0ibnc5e.fsf@shell01.TheWorld.com...
> Wesley Groleau <wesgroleau@despammed.com> writes:
>
> > > I'm thinking particularly of slices as L-values.  Do you ever use
that?
> >
> > I did that a lot in Ada days, too.
>
> An example, please?

I can't say that I used that "a lot"
but one example does come to mind:
An existing interface which requires
a string with a number of (almost
unrelated) fields which must be
placed at given offsets with given
lengths. Since the fields are next
to non-related except that they
must fit into the same string it's
quite a bit tempting to implement
it as:

X(L1..H1) := F1;
X(L2..H2) := F2; etc

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

xanthian@well.com (Kent Paul Dolan) wrote in message news:<a3eaa964.0304262224.264593d4@posting.google.com>...
> softeng3456@netscape.net (soft-eng) wrote:
> 
> > No, I am serious.
> 
> How sad for you then.
> 
> > Many people who use computers today, simply wouldn't have been
> > able to, 20 years ago.  That's progress, exc[ep]t if you have
> > a personal reason to say "no, it's not.".
> 
> Except that you are revising history beyond recognition: the
> vi() editor was written for the use of secretaries, and it is

And you are accusing me of revising history!

When vi was the standard editor and unix was
the standard workstation, there was a thriving market
for specialized secretary-machines.  These used to be
called "word processors" and came with rulers
along the top etc.  DEC had them, Wang had
them (it was their specialty), many other companies did.

The term "word processor" slowly changed
its meaning and came to mean software,
because it became no longer necessary to
purchase specialized hardware for word processing
for use by secretaries.

> That's not true either; my bookkeeper/secretary/billing clerk
> wife regaled me with horror stories of time lost to Windows and
> other M$ "productivity" tools for over a decade, and started
> that period by saying "and thus it has always been". Among the
> haters of MS-Windows, clerical types probably have pride of
> place far ahead of mere knowledgable programmers, the latter
> having the advantage of knowing not merely that MS-Windows is
> unfit for use, but also why that is so, and so are not
> inconsolable like the clerks.

If people truly saved less time than they gained, they
would not use PCs.

It is always fun to joke about something or the
other.  But that still doesn't actually mean
any given set of "ethnic"s all behave the same way.

Btw,  emacs is better than vi :-)

(Well, at one point I used to think so.  Haven't bothered
with either since editing became so much simplified
that any tom-dick-harry's editor is highly
usable compared to either vi or emacs,
except for those who are religious about these things,
or highly un-retrainable.)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Mike Silva]

"AG" <ang@xtra.co.nz> wrote in message news:<d%Jqa.34014$mZ4.393336@news.xtra.co.nz>...
> "Mike Silva" <snarflemike@yahoo.com> wrote in message
> news:20619edc.0304261803.5d26f40e@posting.google.com...
> 
> > Obviously they're only drivers and dispatchers *by day*.  At night, in
> > the privacy of their own homes, I'll bet they're *computer
> > programmers*!
> 
> Well, no, not really :) In fact that almost always happens in
> the middle of the night or wee hours of the morning (when
> do you think the trucks get loaded for delivery?)
> 
> Unfortunately, most programmers and/or sys admins
> have a bad habit of liking to sleep at that sort of time.
> 
> Which brings us back to the question of reliability:
> 
> - Option one: have a stand-up on-call professional
> support with a pager available 24 by 7. Sort of
> what fire brigades do [that will cost of course]
> 
> - Option two: have a reliable system with the chance
> of catastrophic failure so low that you (or your clients)
> are willing to risk it just on statistical basis.
> 
> Which one would you choose if you had to fund it?

A lot of people would argue that the reliable system costs no more to
develop, when you factor in the higher costs of mid-stream redesign,
longer debugging and more customer support for the unreliable version.
 Then there's also the damage to the vendor's reputation, which can
translate into lost sales when it's time to buy new software.
> 
> [Besides, you've said "I'll bet". What do you bet?]

Hold on, I think I've got some change here in my car ashtray...  (Or
how about Easter candy that the kids got too much of and we're looking
for an excuse to throw out now?)  I mean, really, this is only usenet!
:)

Mike

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Randy Brukardt]

Robert A Duff wrote in message ...
>Yes, by "L-value", I meant on the left-hand side of an assignment, or
an
>'out' parameter, or similar things.  If X(1..80) is just syntactic
sugar
>for a function call Slice(X, 1, 80) or Slice(X, First => 1, Last =>
80),
>then it would be little trouble for the Ada compiler.  And I would
think
>it would be but a minor convenience for the programmer.
>
>But when slices are used as L-values, there are various interactions
>with packing and whatnot that cause compiler complexity.


I certainly agree with that, but slices as L-Values is one of the more
useful features of Ada, because they allow you to do efficient
operations safely that otherwise would have to be done much more
verbosely AND inefficiently.

Virtually any string manipulation needs L-Value slices. For instance, I
constructed a normalized URL by allocating a large string for the URL,
and then copying in the parts as they are identified:

   ...
   Len := Last - First + 1;
   if Next_Len > Final_URL'Last then Set_Bad_Command_Result; return; end
if;
   Final_URL(Next .. Next+Len) := Info.Command(First .. Last);
   ...

(Note that the check is needed only if we want to do something other
than raise Constraint_Error if the URL is excessively long. In this
case, we want to return a Bad_Command result to the client.)

Another example is using slices to expand a buffer (the Janus/Ada
compiler does this a lot):

     declare
           New_Buffer : Buffer_Type;
     begin
           New_Buffer := new Buffer_Contents(1 .. Buffer'Last +
Expansion_Amount);
           New_Buffer (1 .. Buffer'Last) := Buffer.all;
           Free (Buffer);
           Buffer := New_Buffer;
     end;

This generates some checking (all of which can be eliminated) and then
memory-to-memory copying, without any extra overhead. In theory, a
compiler could optimize a loop the same way, but I've never seen it done
for a case like this one (where both items are access to unconstrained
arrays, so there is a lot of descriptor manipulation and virtually all
of the values are not known at compile time). Eliminating the checking
in a loop is very hard (it requires algebraic propogation), and that's
necessary (but not sufficient) to convert the loop into direct memory
operations.

                   Randy.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kent Paul Dolan]

softeng3456@netscape.net (soft-eng) wrote:
> xanthian@well.com (Kent Paul Dolan) wrote:
>> softeng3456@netscape.net (soft-eng) wrote:

>>> No, I am serious.

>> How sad for you then.

>>> Many people who use computers today, simply wouldn't have been
>>> able to, 20 years ago.  That's progress, exc[ep]t if you have
>>> a personal reason to say "no, it's not.".

>> Except that you are revising history beyond recognition: the
>> vi() editor was written for the use of secretaries, and it is

> And you are accusing me of revising history!

> When vi was the standard editor and unix was
> the standard workstation, there was a thriving market
> for specialized secretary-machines.

So? It is still the case that your paragraph to which I disagreed
is plain wrong, and for the reasons I said: computers usable by
low skilled clerical employees have been the norm since the earliest
commercial computers: the IBM 1620 on which I programmer in 1961 was
primarily used by office staff, not programmers; so there isn't some
large class of people who have suddenly become capable of using
computers in the past 20 years that were not capable of so doing before,
invaliating your claim.

Please attempt to use sane methods of argumentation; this kind is
tedious, as you continue to trim away material which counters the
points you then insist on making incorrectly again and again.

xanthian.

There is a small class, however; computers catering especially to the
severely handicapped have probably mostly appeared in the last 20 years.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[The Ghost In The Machine]

In comp.lang.java.advocacy, Wesley Groleau
<wesgroleau@despammed.com>
 wrote
on Sun, 27 Apr 2003 16:40:55 -0500
<wBSdnTfmO5TK0zGjXTWcog@gbronline.com>:
> Option three.  Have a redundant system, hoping that
> only one will crash at a time.  Then network them
> all together, so that the one that crashes will
> take out the rest of them.  :-)
> 

I'll admit I wonder about this option, but, if one has
a system that's down 10% of the time (90% uptime), one
could in theory put 5 of those systems in back of a perfect
loadserver (well, OK, it's only a theory!) and get 99.999%
uptime -- the target for one of Microsoft's campaigns some
time back.

I think Windows can manage that, even if it crashes 3-4
times every 8-hour day: assuming a full reboot takes 2
minues, that would translate into 8 minutes down, out of
480 minutes, or a 98.3% uptime.  Of course, the user
having to use such a system may feel 90% aggravated... :-)

Of course, if one system can take out the webfarm,
all hope is lost.  And Microsoft has introduced a new
(or maybe not so new) idea: the "webgarden".  This idea
is to webfarms as threads are to processes, apparently.
I'll leave the possible problems as an exercise for the
interested reader... :-)

ObAda: I'll admit the closest I've come thereto is Modula-2,
       and the closest I've come coding is Pascal.

ObJava: JBOSS and Tomcat look like a webgarden to me, for example. :-)
        Apache does, too, as it can support multiple virtual hosts.

-- 
#191, ewill3@earthlink.net
It's still legal to go .sigless.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Robert A Duff]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> Robert A Duff wrote:
> 
> > Yes, by "L-value", I meant on the left-hand side of an assignment, or an
> > 'out' parameter, or similar things.  If X(1..80) is just syntactic sugar
> > for a function call Slice(X, 1, 80) or Slice(X, First => 1, Last => 80),
> > then it would be little trouble for the Ada compiler.
> 
> Do you mean that Slice (...) would always have a copy semantics? 

Yes.

> > And I would think it would be but a minor convenience for the programmer.
> 
> > But when slices are used as L-values, there are various interactions
> > with packing and whatnot that cause compiler complexity.
> 
> Isn't it already there because array elements can be also L-values? Or that 
> objects of some types have to be constructed in-place? I mean, with or 
> without slices, one cannot get rid of this problem anyway.

No, I think slices-as-L-values cause compiler complexity beyond what
components-as-L-values do.

- Bob

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

The Ghost In The Machine wrote:
> In comp.lang.java.advocacy, Wesley Groleau
> <wesgroleau@despammed.com>
>  wrote
> on Sun, 27 Apr 2003 16:40:55 -0500
> <wBSdnTfmO5TK0zGjXTWcog@gbronline.com>:
> 
>>Option three.  Have a redundant system, hoping that
>>only one will crash at a time.  Then network them
>>all together, so that the one that crashes will
>>take out the rest of them.  :-)
> 
> I'll admit I wonder about this option, but, .....
> 
> I think Windows can manage that, even if it crashes 3-4
> times every 8-hour day: assuming a full reboot takes 2

Even Windows 95/98 wasn't that bad on average (people
like me who make their machines work hard would probably
get crashes more than once a day).  But Windows NT/2000
are far more reliable.  HOWEVER, my comment was an allusion
to an actual event.  Someone will probably post a URI, but
here's the executive summary:  A program on a Windows NT
machine did a divide by zero.  The exception was propagated
to all other machines on the Windows LAN, and they all crashed.
Unfortunately, one of the undesirable results of this was
that the ship that was entrusted to these machines had to
be towed back to port.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Dmitry A. Kazakov]

Robert A Duff wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> Robert A Duff wrote:
>> 
>> > Yes, by "L-value", I meant on the left-hand side of an assignment, or
>> > an
>> > 'out' parameter, or similar things.  If X(1..80) is just syntactic
>> > sugar for a function call Slice(X, 1, 80) or Slice(X, First => 1, Last
>> > => 80), then it would be little trouble for the Ada compiler.
>> 
>> Do you mean that Slice (...) would always have a copy semantics?
> 
> Yes.

Ooch

>> > And I would think it would be but a minor convenience for the
>> > programmer.
>> 
>> > But when slices are used as L-values, there are various interactions
>> > with packing and whatnot that cause compiler complexity.
>> 
>> Isn't it already there because array elements can be also L-values? Or
>> that objects of some types have to be constructed in-place? I mean, with
>> or without slices, one cannot get rid of this problem anyway.
> 
> No, I think slices-as-L-values cause compiler complexity beyond what
> components-as-L-values do.

I suppose it is not a big problem to generate a loop, so it must be 
something else. Maybe you mean things like optimization of an assignment 
into a memory copy if no element finalization required? But we do need 
that! Randy Brukardt have already mentioned a buffer extension technique 
based on slices. I am using it all the time in generic containers in hope 
that for non-controlled types it will become just a memory copy. Now let we 
remove slices. Then to achive the same level of optimization, the compiler 
has to be able to redice a hand-written loop (+unpack/pack rubbish 
generated) to a memory copy. Is it easier?

From a global perspective. To me slices is a good example of how things 
*should* be done. I mean the issues like:

- unconstrained string vs. constrained string;
- unconstrained discriminated object vs. a dynamically constrained one;
- class-wide object vs. specific one

Only strings and slices have it right. The dope is used only when necessary. 
On contrary discriminants and tags are always there. Which makes, for 
instance, the problem of measurement units unsolvable. From this point of 
view removing slices would be a step back.

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

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

soft-eng wrote:

> Richard Riehle <richard@adaworks.com> wrote in message news:<3EA9E194.BAC2A2B6@adaworks.com>...
> > soft-eng wrote:
> >
> > > So you are saying the Ada projects that succeeded were secret,
> > > and the ones that were not secret did not succeed?
> >
> > Go to www.adaic.org.   There are plenty of case histories
> > of Ada projects that succeeded.    This includes a large
>
> Amazingly enough, I don't think there are any such sites for
> C, C++, Java...

So ....

> Instead, when you read my message and typed a respnse in your
> newsreader, you provided testimony that these languages have been
> used by actual people to provide actually useful software.

I also provided testimony that Ada has been used by intelligent
developers for successful projects.  In fact, there are so many
successful Ada projects that anyone who suggests it is useless
for developing software is simply not paying attention.

> You may claim that these were all stupid people who couldn't
> chose the right language for the tool, couldn't understand
> Ada, or didn't realize they could have done a better job in Ada.

People select programming languages for all kinds of reasons,
few of which have to do with the quality of the language.

> But given that Ada was not only available, but actively
> supported by HUGE amounts of tax money, I may choose
> to believe you are arguing from nothing but personal biases.

I am arguing, if you please, from personal/professional experience
with the language.  I am also arguing from the many successes
I know about.

As for that "HUGE amounts of tax money" much it was wasted
by bureaucrats shuffling paper around.   Few of them knew anything
about software.  The successes of Ada have been in spite of, not
because of, support from the government.   One reason why Ada is
enjoying a resurgence of interest in some quarters is because the
government is no longer mandating it.   People who use it now
are doing so because they see its virtues, not because they
are required to do so.

Those who have adopted Ada, in recent years, are enjoying its
benefits.  Those who have abandoned it are not doing  all that
well with, for example, C++ (a horrid language full of surprises
and gotchas).

Many of us continue to prefer Ada precisely because it is fun,
easy to use, and easy to develop software.   There are aspects
of the language that do not come easily.    However, most of
the language does come easily, and the advanced features are
not necessary for someone to enjoy it.

I am currently teaching an Ada class for a group of graduate
students.   Their responses, so far (many with C++ and Java
background), are quite favorable.    We write programs for
Windows, as well as for other environments in this class.

Sorry you had such bad Ada training.   There was a lot of that
going around at one time, perpetrated by people who simply
failed to understand some elementary ideas and made them
more complicated than necessary.

Richard Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EAF3464.9E06145F@adaworks.com>...
> 
> Sorry you had such bad Ada training.   There was a lot of that
> going around at one time, perpetrated by people who simply
> failed to understand some elementary ideas and made them
> more complicated than necessary.

Do you really think my views on Ada are a result of
bad training?

I suppose that is a very fair representation of the
analysis and insight capabilities of those who
choose to espouse the cause you are championing here...

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[John R. Strohm]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0304300412.3c9f8157@posting.google.com...
> Richard Riehle <richard@adaworks.com> wrote in message
news:<3EAF3464.9E06145F@adaworks.com>...
> >
> > Sorry you had such bad Ada training.   There was a lot of that
> > going around at one time, perpetrated by people who simply
> > failed to understand some elementary ideas and made them
> > more complicated than necessary.
>
> Do you really think my views on Ada are a result of
> bad training?
>
> I suppose that is a very fair representation of the
> analysis and insight capabilities of those who
> choose to espouse the cause you are championing here...

Why don't you *tell* us where your views on Ada come from?

So far, you have said a great deal that suggests that you have NO actual
experience with Ada.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

xanthian@well.com (Kent Paul Dolan) wrote in message news:<a3eaa964.0304281225.3a52ebce@posting.google.com>...

> Please attempt to use sane methods of argumentation; this kind is
> tedious, as you continue to trim away material which counters the
> points you then insist on making incorrectly again and again.

I don't read tons of quoted material and I assume others
don't either -- your insistence that every triviality
be addressed, would make the thread extremely boring.
It is very much like the people who insist that
no off topic items ever be discussed.

So rather than refrain from trimming material, I would prefer
to trim it down to - in good faith - what I see is your objection.

You are saying that you have proved wrong the paragraph:

  Many people who use computers today, simply wouldn't have been
  able to, 20 years ago.

by claiming vi was written for secretaries.

This makes little sense to me, and I even fail to see
any serious argument here.  To remind you of the
actualities of history, I even mentioned the
Wang word processors in case you had forgotten.
But it seems you didn't forget, you simply
observed it very differently.

Today, computers are used in lots of places and
by lots of people (not just handicapped access)
that simply were not possible twenty years ago.

Even if you are living in a cardboard box, if
you have to go grocery shopping, probably your
cashier is doing the checkout using a Windows based
application.

So what I see is that I stated a fact from
observation, and you are disputing the fact.
At this point, there is no logic involved.
The best I could have done was little
memory joggers, not present any more logic.
If you still insist that no more people are
using computers today, there just isn't much
more to be said about it.

RE: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Lionel.DRAGHI]

..
| So far, you have said a great deal that suggests that you 
| have NO actual experience with Ada.
So far, he said a great deal that cause him to end up in my killfile. 
Don't waste your time, he is just trolling.

-- 
Lionel Draghi

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Rod Davison]

On Wed, 30 Apr 2003 10:48:25 -0400, soft-eng wrote:

> Even if you are living in a cardboard box, if you have to go grocery
> shopping, probably your cashier is doing the checkout using a Windows
> based application.
> 

Ah-hah!

That explains why upgrade my portabello mushrooms to the more expensive
Shitaki before they could be rung through.


-- 
====================================================
Rod Davison 
Critical Knowledge Systems Inc.
rod @ critsys . com
====================================================
Maybe, just once, someone will call me "sir" without 
adding, "you're making a scene."
====================================================

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Adam Ruth]

> Ok, I am sure a few instances happened.  But if you
> had to develop device drivers for a living, and if
> the language was truly your choice, would you chose Ada as
> the language?
> 
> I think the only "yes" answers would be from
> people who only know Ada and/or have never
> written a device driver.

I recently had the [mis]fortune of writing a device driver for
NetWare.  The only language choices are C and C++.  I used C, since
C++ support wasn't really up to snuff on NetWare and I'm more
comfortable in C.  At the time I was writing the driver, I was
learning Ada, and by the end of the project I really wish I could have
used it.  There were entire classes of error I encountered, and had a
hard time debugging, that would simply not have existed in Ada.  Of
course, there were plenty of bugs that would have existed regardless
of language, and I'm sure that there are new problems that the use of
Ada would introduce.  But I'm constantly amazed at the errors that are
so easy to avoid in Ada because they simply don't exist.

If I had it to do again (I hope I don't!) and Ada was a choice, I'd
give it a shot.  I'm convinced that the quality of the product would
have been superior.

Adam

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Adam Ruth]

> > > (C and later C++ style of type-safety turned out to
> > > be good enough for real-world projects.)
> > 
> > Like Windows ?
> 
> 
> You must live in a different world from me -- I look
> around, and from the web-browser to the newsreaders
> to the email software to the software transporting
> your packets full of Ada praise to the software
> controlling the switching stations enroute to...
> 
> You don't like Windows, so you must be using
> what?  Unix and X-Windows?  Written/extended/in Ada?
> Surely Ada was there when most of X-Windows
> and Motif happened?  Or at least when the
> CD-ROM device drivers were being written?
> 
> What now did you say these very expensive
> Ada projects actually do?

I always find it interesting how some people think that the software
they use is the only software in the world...  "If I haven't used it,
it doesn't exist!"  There's much more to life than desktop O/Ss, GUIs,
and productivity apps.

Adam

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Tom Welsh]

In article <uv2cnfY-WcxAjTajXTWcow@gbronline.com>, Wesley Groleau
<wesgroleau@despammed.com> writes
>
>You people are talking about two different things.
>There are TWO operating systems called Windows.
>
>Windows 3.1 / 95 / 98 / ME crashes daily for many users
>
>Windows NT / 2000 / XP is a completely different O.S.
>It still crashes, but it is reliable enough for most
>people.
>
That's because it is as close as they could get to VMS, under the
covers. 

It still crashes and hangs too much because the Windows GUI was a non-
negotiable legacy - which is probably harder to make reliable than a
conventional mainframe OS.

VMS used to be less than 10 million lines of code (C, Bliss, whatever).
DECwindows added another 5-7 million or so.

Windows 2000 is said to be in the region of 40 million LOC. If that's
true, I think it's an amazing accomplishment that it works at all. And
it is far more reliable than the older Windows variants.

But it still seems to me that much less reliable than VMS was 10-15
years ago. (And yes, that had a GUI too).
-- 
Tom Welsh

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

"John R. Strohm" <strohm@airmail.net> wrote in message news:<98BC68183770643E.43B22CFE5F4D5EFD.5566989BE627964B@lp.airnews.net>...
> "soft-eng" <softeng3456@netscape.net> wrote in message
> news:9fa75d42.0304300412.3c9f8157@posting.google.com...
> > Richard Riehle <richard@adaworks.com> wrote in message
>  news:<3EAF3464.9E06145F@adaworks.com>...
> > >
> > > Sorry you had such bad Ada training.   There was a lot of that
> > > going around at one time, perpetrated by people who simply
> > > failed to understand some elementary ideas and made them
> > > more complicated than necessary.
> >
> > Do you really think my views on Ada are a result of
> > bad training?
> >
> > I suppose that is a very fair representation of the
> > analysis and insight capabilities of those who
> > choose to espouse the cause you are championing here...
> 
> Why don't you *tell* us where your views on Ada come from?
> 
> So far, you have said a great deal that suggests that you have NO actual
> experience with Ada.

Mostly peripheral and theoretical.  Taught Ada to graduate students for
evening class.  Had to learn about it from an academic viewpoint.
Did have some previous familiarity during my own graduate
school work, because lots of people were thinking that's where
the grants would be coming from, and there was very high
academia interest in Ada.  I even owned a copy of the first language
manual sets, that came out right after the announcement
"Ada is green".  (Talking of "green", briefly also worked with
some ex-"red" team members.)  Also briefly worked with some
government Ada type people (my own project was a proof-of-concept
prototype for some small-potatoes $5 mill contract, and therefore
my project had an "exception" or something so I could work
in C, which was very much of a break and I could wrap it
up quickly), and got to observe their behaviors.

No recent experience at all, but of course, any recent
changes to Ada had little to do with the collapsing
of the Ada mandate.  These days, probably even Add-1-to-Cobol
is object oriented, and I would be surprised if
Ada-2002 (or whatever) weren't virtually a copy of Java
or C++.  I figure I already know Java and C++...

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

soft-eng wrote:

> "John R. Strohm" <strohm@airmail.net> wrote in message news:<98BC68183770643E.43B22CFE5F4D5EFD.5566989BE627964B@lp.airnews.net>...
>
> > Why don't you *tell* us where your views on Ada come from?
> >
> > So far, you have said a great deal that suggests that you have NO actual
> > experience with Ada.
>
> Mostly peripheral and theoretical.  Taught Ada to graduate students for
> evening class.  Had to learn about it from an academic viewpoint.

One more amateur teaching Ada with no experience using it on
projects.   There was so much of this going around that no one
should be suprised that so many students came away from their
Ada classes with a distorted view of the language.

Richard Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[soft-eng]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EB1C603.7788E194@adaworks.com>...
> soft-eng wrote:
> 
> > "John R. Strohm" <strohm@airmail.net> wrote in message news:<98BC68183770643E.43B22CFE5F4D5EFD.5566989BE627964B@lp.airnews.net>...
> >
> > > Why don't you *tell* us where your views on Ada come from?
> > >
> > > So far, you have said a great deal that suggests that you have NO actual
> > > experience with Ada.
> >
> > Mostly peripheral and theoretical.  Taught Ada to graduate students for
> > evening class.  Had to learn about it from an academic viewpoint.
> 
> One more amateur teaching Ada with no experience using it on
> projects.   There was so much of this going around that no one
> should be suprised that so many students came away from their
> Ada classes with a distorted view of the language.
> 
> Richard Riehle

There weren't any Ada projects at that time to have experience in!
Believe it or not, that's how teaching of new languages has to start,
particularly of languages like Ada with no existing industrial base.

But you are still insisting on arguing by insult, which I have little
interest in because it merely shows to me you have nothing valid to say.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Chad R. Meiners]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0305020520.20859901@posting.google.com...

> But you are still insisting on arguing by insult,

It is more likely that Richard did not intend it to be insulting;  it is
just that you have demonstrated that you lack to ability to form sound
argument, to listen reasonability to others viewpoint and that you do not
understand Ada very well.  This qualifies you for the title of amateur along
with all the implication.  You dug your own ditch, and you should not be
insulted because someone points out that you are still in it.

> which I have little
> interest in because it merely shows to me you have nothing valid to say.

This too is a very foolish argument since Richard often has many valid
things to say ;)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Martin Dowie]

"soft-eng" <softeng3456@netscape.net> wrote in message
news:9fa75d42.0305020520.20859901@posting.google.com...
> > One more amateur teaching Ada with no experience using it on
> > projects.   There was so much of this going around that no one
> > should be suprised that so many students came away from their
> > Ada classes with a distorted view of the language.
>
> There weren't any Ada projects at that time to have experience in!

However, there are projects now and plenty of people continuing to
use it (and not just militery types either - networking, digital tv,
financial
services, etc). The language you are describing doesn't match very well
with what my experiences (particularly *recent* experiences) have been.

I've had experience of a couple of pretty awful Ada83 compilers and
one good one but my experience of Ada95 compilers is that they are
hugely improved and amoung the best compilers out there - in any
language. Perhaps this isn't too surprising - a lot was being asked of
the Ada83 compilers. Suddenly compiler writers were being asked
to include a lot of the work of an OS (in particular tasks).

The language itself has undergone one large increment from
Ada83 -> Ada95. It sounds to me like you haven't seen or used
much Ada95.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kevin Cline]

Richard Riehle <richard@adaworks.com> wrote in message news:<3EB1C603.7788E194@adaworks.com>...
> soft-eng wrote:
> 
> > "John R. Strohm" <strohm@airmail.net> wrote in message news:<98BC68183770643E.43B22CFE5F4D5EFD.5566989BE627964B@lp.airnews.net>...
> >
> > > Why don't you *tell* us where your views on Ada come from?
> > >
> > > So far, you have said a great deal that suggests that you have NO actual
> > > experience with Ada.
> >
> > Mostly peripheral and theoretical.  Taught Ada to graduate students for
> > evening class.  Had to learn about it from an academic viewpoint.
> 
> One more amateur teaching Ada with no experience using it on
> projects.   There was so much of this going around that no one
> should be suprised that so many students came away from their
> Ada classes with a distorted view of the language.

Do you think the situation is better for other languages?  It
certainly isn't for C++.  I've interviewed people who taught evening
classes in C++ and OOP at the university level and they were
hopelessly confused.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Graham Perkins]

"Kevin Cline" <kcline17@hotmail.com> wrote in message
news:ba162549.0305020720.4da44159@posting.google.com...
> > One more amateur teaching Ada with no experience using it on
> > projects.   There was so much of this going around that no one
> > should be suprised that so many students came away from their
> > Ada classes with a distorted view of the language.
>
> Do you think the situation is better for other languages?  It
> certainly isn't for C++.  I've interviewed people who taught evening
> classes in C++ and OOP at the university level and they were
> hopelessly confused.

The text books don't help.  So hard to find the
wheat amongst the chaff.

I once found a C++ book which doesn't start on classes
until chapter nine!

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Richard Riehle]

soft-eng wrote:

> There weren't any Ada projects at that time to have experience in!
> Believe it or not, that's how teaching of new languages has to start,
> particularly of languages like Ada with no existing industrial base.
>
> But you are still insisting on arguing by insult, which I have little
> interest in because it merely shows to me you have nothing valid to say.

OK.  Not intending to insult you.   My point was that there was a lot
of Ada teaching going on by people with little experience in it.  You
were not the only one, and you may have been better than most.

This was also true of C++ in the beginning, so it is not unique to Ada.
And you are probably correct that any new technology with a minimal
installed base will take time for those teaching it to get up to speed.

Today, there is such a large number of successful Ada projects that
we would hope the quality of teaching it would be better.   However,
for both C++ and Ada (and probably other languages) I still see
people teaching them who have not written any serious programs,
have not stretched themselves in their learning how to make the
languages work well for real programming.

When Ada was first introduced, there were a lot of ideas that
were foreign to the programming community as a whole.  The
most important of these, one that is still not understood by a
lot of educators, is the importance of the visibility rules.  This
is one of Ada's most unique and powerful features, one that
lends itself to taking an engineering view of the software
process, but those teaching Ada (and many who are using it)
miss out on valuable opportunities by overlooking it.  Many
of the early Ada trainers totally missed the point  with regard
to this capability.   Many still do.

Richard Riehle

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

> I once found a C++ book which doesn't start on classes
> until chapter nine!

I own a "C Primer" which NEVER informs the reader that
C is case-sensitive.  And the only hint I could find
(and I was hunting for one) was a code snippet

void funcname (FILE file)
{
.....

and this was in chapter eleven!

If you're thinking that case-sensitivity is something
the reader already knew... this book was allegedly aimed
at beginners in the MSDOS world!

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Hyman Rosen]

Wesley Groleau wrote:
> I own a "C Primer" which NEVER informs the reader that
> C is case-sensitive.
> 
> If you're thinking that case-sensitivity is something
> the reader already knew... this book was allegedly aimed
> at beginners in the MSDOS world!

MS-DOS had case-insensitive file names, but that doesn't mean
that case-insensitivity is an assumed default. If it was, so
many people on c.l.a wouldn't complain when people discuss ADA.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[The Ghost In The Machine]

In comp.lang.java.advocacy, Wesley Groleau
<wesgroleau@despammed.com>
 wrote
on Fri, 02 May 2003 23:24:38 -0500
<MdmdnaZFI5fz2S6jXTWcpA@gbronline.com>:
> 
>> I once found a C++ book which doesn't start on classes
>> until chapter nine!
> 
> I own a "C Primer" which NEVER informs the reader that
> C is case-sensitive.  And the only hint I could find
> (and I was hunting for one) was a code snippet
> 
> void funcname (FILE file)
> {
> .....
> 
> and this was in chapter eleven!

It's also wrong; it should be

void funcname(FILE * file)

:-)

Sounds like that C Primer is better used in making primer
than in being one... :-)

> 
> If you're thinking that case-sensitivity is something
> the reader already knew... this book was allegedly aimed
> at beginners in the MSDOS world!
> 

-- 
#191, ewill3@earthlink.net
It's still legal to go .sigless.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Wesley Groleau]

>>I own a "C Primer" which NEVER informs the reader that
>>C is case-sensitive.  And the only hint I could find
>>(and I was hunting for one) was a code snippet
>>
>>void funcname (FILE file)
>>and this was in chapter eleven!
> 
> It's also wrong; it should be
> void funcname(FILE * file)

I think that's my mistake, not the book
(not handy to look up right now)

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[The Ghost In The Machine]

In comp.lang.java.advocacy, Wesley Groleau
<wesgroleau@despammed.com>
 wrote
on Tue, 06 May 2003 20:28:09 -0500
<m9SdndluvPKW_CWjXTWcpw@gbronline.com>:
> 
>>>I own a "C Primer" which NEVER informs the reader that
>>>C is case-sensitive.  And the only hint I could find
>>>(and I was hunting for one) was a code snippet
>>>
>>>void funcname (FILE file)
>>>and this was in chapter eleven!
>> 
>> It's also wrong; it should be
>> void funcname(FILE * file)
> 
> I think that's my mistake, not the book
> (not handy to look up right now)
> 

No problem, the C compiler would have caught it. :-)

-- 
#191, ewill3@earthlink.net
It's still legal to go .sigless.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Frank J. Lhota]

"The Ghost In The Machine" <ewill@sirius.athghost7038suus.net> wrote in
message news:83jno-vjm.ln1@lexi2.athghost7038suus.net...
> No problem, the C compiler would have caught it. :-)

Not necessarily! Most C compilers will compile the following code without
warning, although actually calling this version of funcname is bound to
cause trouble.

/**************************************/
#include <stdio.h>

void funcname (FILE file)
{
   fprintf( &file, "Hello, World!\n" );
}

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[Kevin Cline]

"Graham Perkins" <gperkins@gperkins.co.uk> wrote in message news:<b8u3m2$emd$1@south.jnrs.ja.net>...
> "Kevin Cline" <kcline17@hotmail.com> wrote in message
> news:ba162549.0305020720.4da44159@posting.google.com...
> > > One more amateur teaching Ada with no experience using it on
> > > projects.   There was so much of this going around that no one
> > > should be suprised that so many students came away from their
> > > Ada classes with a distorted view of the language.
> >
> > Do you think the situation is better for other languages?  It
> > certainly isn't for C++.  I've interviewed people who taught evening
> > classes in C++ and OOP at the university level and they were
> > hopelessly confused.
> 
> The text books don't help.  So hard to find the
> wheat amongst the chaff.

That's the instructor's responsibility, but an instructor with minimal
knowledge is likely to choose poorly.  OTOH, Lippman's _C++ Primer_,
and Koenig's & Moo's _Accelerated C++_ have been well-reviewed.

The confusion of my interviewees was directly attributable to their
poor choice of a textbook.  They learned C++ about as well as it was
presented in their text book.
 
> I once found a C++ book which doesn't start on classes
> until chapter nine!

There are a LOT of bad books covering any popular technology.  I have
discovered that book quality is inversely proportional to the
garishness of the cover.

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[apm]

kcline17@hotmail.com (Kevin Cline) wrote in message > There are a LOT of bad books covering any popular technology.  I have
> discovered that book quality is inversely proportional to the
> garishness of the cover.

Oh? I thought it was inversely proportional to the weight.

-apm

Re: the Ada mandate, and why it collapsed and died (was): 64 bit addressing and OOP

[The Ghost In The Machine]

In comp.lang.java.advocacy, Frank J. Lhota
<NOSPAM.lhota.adarose@verizon.net>
 wrote
on Thu, 08 May 2003 15:21:37 GMT
<5Cuua.10$tc5.3@nwrdny03.gnilink.net>:
> "The Ghost In The Machine" <ewill@sirius.athghost7038suus.net> wrote in
> message news:83jno-vjm.ln1@lexi2.athghost7038suus.net...
>> No problem, the C compiler would have caught it. :-)
> 
> Not necessarily! Most C compilers will compile the following code without
> warning, although actually calling this version of funcname is bound to
> cause trouble.
> 
> /**************************************/
> #include <stdio.h>
> 
> void funcname (FILE file)
> {
>    fprintf( &file, "Hello, World!\n" );
> }
> 

Ewww.  Buffer loss, memory leak.  Not good.  :-)

-- 
#191, ewill3@earthlink.net
It's still legal to go .sigless.