HDTenEightyP/NetNews huggingface dataset:
From: mfeldman@seas.gwu.edu (Michael Feldman)
Subject: Cooked cost-effectiveness
Organization: George Washington University
Date: Sun, 13 Dec 1992 20:35:46 GMT

In article <921212103914.20203764@OTTAWA.DSEG.TI.COM> PETCHER@OTTAWA.dseg.ti.com (What? Me Ada?) writes:
>
>On the life cycle cost controversy:  While, as somebody recently pointed out,
>statistics can be cooked up any way you want them, even a good cook can't
>cook without ingredients.  The typical life cycle of a military system is
>about 20 years, probably to grow a bit as time goes on.  I'm not sure what
>the oldest fielded Ada based system is right now, but it couldn't be over
>four or five years old.  Anybody who attempts to compare life cycle cost can
>only do so based on speculation.
>
Which is exactly why the DoD Ada nay-sayers should quit wasting their time
saying nay, relax, admit they are stuck with the mandate -- which carries
with it a _presumption_ that a safe and standard language will be cost-
effective in the long term -- and get on with the business at hand.
High time for a little good faith and giving it your best shot, IMHO.

For the non-DoD world, those of us who choose Ada have done so with no 
mandate -- we were open-minded enough not to need one.

Mike Feldman
From: jeffe@hathor.CSS.GOV (Jeff Etrick)
Newsgroups: comp.lang.ada
Subject: I/O and the LRM
Keywords: I/O NAME OPEN
Date: 17 Dec 92 13:25:00 GMT
Organization: ENSCO, Inc., Melbourne, FL



 The following is taken from the LRM:

>>function NAME(FILE : in FILE_TYPE) return STRING;

>>Returns a string which uniquely identifies the external file currently
>>associated with the given file (and may thus be used in an OPEN
>>operation).  If an environment allows alternative specifications of the
>>name (for example, abbreviations), the string returned by the function
>>should correspond to a full specification of the name.

>>The exception STATUS_ERROR is raised if the given file is not open.


 I have used the function successfully many times to get the external
name of a currently opened file but what I don't understand is the
comment about it being used in an open statement. Why would I want to use
this statement in an open since the file must already be opened or
STATUS_ERROR will be raised.

Thanks for the help,

Jeff
From: jhalper@access.digex.com (John Halper)
Newsgroups: comp.lang.ada
Subject: Re: Language pitfalls (was Re: FORTRAN bug)
Date: 17 Dec 1992 18:48:17 GMT
Organization: Express Access Online Communications, Greenbelt, MD USA
NNTP-Posting-Host: access.digex.com

In article <EMERY.92Dec15095542@dr_no.mitre.org> emery@dr_no.mitre.org (David Emery) writes:
>Maybe we should follow up Bob K's 5 rules and construct a "The Net":
>Ada Traps and Pitfalls.  At least this will be a technically oriented
>discussion on Ada, rather than Comp.Lang.Jihad.
>
>I'll think about it and send in some of my rules.
>
>				dave

Good idea, how about a moderated group.  I sure would like to be able to
read technically oriented discussions without having to wade through all
the crud.  Mind you I would never suggest suppressing the ever witty Fred
and Ted show. I just want to be able to turn to another channel.
J. Halper
Newsgroups: comp.lang.ada
From: willson@seas.gwu.edu (Stephen R. Willson)
Subject: What a lame thread.
Organization: George Washington University
Distribution: usa
Date: Wed, 16 Dec 1992 16:40:14 GMT

In article <1992Dec16.154129.28443@aio.jsc.nasa.gov> cobarruvias@asd2.jsc.nasa.gov writes:
>I AGREE! How about a group called: comp.lang.Ada.Argue or
>comp.lang.Ada.Waste_of_time or comp.lang.Ada.get_back_to_work.
>
>If you are still compelled to post about Ada .vs. whatever, think twice, and
>dont! 

How about comp.lang.religion.  Where everyone can preach the blessings if
[insert favorite language].  
-- 
-----------------------+-------------------------------------------------------
 Stephen R. Willson    | A fitting end to a screwy campaign year...
 willson@seas.gwu.edu  | Here to swear in the President of the United States,
 (202) 395-4922        | Larry King!                         -The Miami Herald
Newsgroups: comp.lang.ada
From: pattis@cs.washington.edu (Richard Pattis)
Subject: Re: Language pitfalls (was Re: FORTRAN bug)
Summary: Here is one in Ada
Organization: Computer Science & Engineering, U. of Washington, Seattle
Date: Tue, 15 Dec 92 18:08:21 GMT

Since Dave has volunteered to keep track....

When I introduce recursion in my CS1/CS2 class, this one never fails to show
up. It is truly a C-like error (excuse the pejorative term) in that the
distinction between a statement and value is clouded to reduce the number of
reserved words.

Often the base case of a recursive function to manipulate a list looks like:

  IF mumble = NULL THEN
    RETURN NULL;
  ELSE ...

What my students sometimes write is

  IF mumble = NULL THEN
    NULL;
  ELSE ...

Here the statement NULL replaces the returning of a NULL value (which might be
better to denote as NIL, at the expense of another reserved word). Of course,
this is all syntactically legal and the error shows up only at execution time:
often as a PROGRAM_ERROR (so at least Ada catches it at some time) if there
are no other statements after the IF in the function. Of course, some compilers
will give a warning based on the functions data flow information.

Rich Pattis
-- 
------------------------------------------------------------------------------
  Richard E. Pattis                     "Programming languages are like
  Department of Computer Science         pizzas - they come in only "too"
    and Engineering                      sizes: too big and too small."
Newsgroups: comp.lang.ada
From: kdm@puppy (Kent Mitchell)
Subject: Re: IBM - Air Traffic Control - GAO Rpt - FYI
Organization: Rational
X-Newsreader: TIN [version 1.1 PL8]
Date: Mon, 14 Dec 1992 17:32:00 GMT

Jim M. Bowden (at507@cleveland.Freenet.Edu) wrote:

: All typos are my error.   The first project - is being done by
: IBM and CSC in Rockville, MD using Rational development machines (
: about 20 I believe) using the Ada programming language.

They also use MVS in IBM mainframes and RS/6000's for software development.
Not all portions of the software are developed on the Rational Environment.
This is just a simple correction of information and not intended to be 
anything other than that (so no flame wars now).

Kent Mitchell
Technical Consultant
Rational

My opinions are my own

Newsgroups: comp.lang.ada
From: lonjers@prc.unisys.com (Jim Lonjers)
Subject: Re: Ada & PDL (ick !)
Organization: Paoli Research Center - Paoli, PA
Distribution: usa
Date: Tue, 15 Dec 1992 06:08:57 GMT

In article <EACHUS.92Dec10165132@oddjob.mitre.org> eachus@oddjob.mitre.org (Robert I. Eachus) writes:
>
>                            Detailed design is 90% concerned with the
>package specificatations.  Coding is 90% concerned with package bodies
>and subunits.  With a little bit of effort it is possible to have a
>complete compilable design in Ada without writing a line of what would
>be considered executable code in other languages.
>
>     But...the problem that you mention does exist.  It is hard to
>have a hard and fast rule as to what is design and what is coding, and
>use this to keep people from riding off the deep end.  My attitude has
>been that it is better to depend on good faith efforts by the
>programming staff.  If their goals are yours, the project will
>succeed, if they consistantly try to subvert the project, no standards
>or rules will help.  The only case where you have to use judgement
>with Ada is in determining when a "superprogrammer" is creating more
>work than he is accomplishing, rather than flat out telling him to
>stop coding or get off the project.

Bob has stated my views rather accurately.  This "completion criteria"
problem is the same problem that one must consider in the transition from
preliminary to detailed design, and to some extent, in trying to keep
design material out of requirements analysis.  There is no substitute for
good engineering judgement.

Jim Lonjers
Newsgroups: comp.lang.ada
From: mfeldman@seas.gwu.edu (Michael Feldman)
Subject: Re: Language pitfalls (was Re: FORTRAN bug)
Organization: George Washington University
Date: Tue, 15 Dec 1992 15:47:51 GMT

In article <252@visicom.com> rlk@VisiCom.COM (Bob Kitzberger) writes:

[good stuff deleted]
>
>(*) Of course, Ada programmers spend more time with compile-time syntax
>    errors than anyone else ;-)

I think this is _almost_ right. In my experience, the difficulty is
not with _syntax_ (are the structures formed correctly?) but with
_semantic checking_ (do the types match?). Both are compile-time
issues. In my experience with everyone from freshmen to experienced
industry folks, the pure syntax problems go away after a few weeks of
coding; the semantic ones never do. Ada's type system is complicated,
powerful, and designed to be _very_ safe, and therefore the type
checking is a pain in the neck to get through the compiler.

It should come as no surprise to regular readers of my junk that I think
it's worth it.

Mike Feldman

PS - the semantic checking is harder to write into the compiler, too!
From: rlk@VisiCom.COM (Bob Kitzberger)
Newsgroups: comp.lang.ada
Subject: Re: Language pitfalls (was Re: FORTRAN bug)
Date: 16 Dec 92 17:38:07 GMT

eachus@oddjob.mitre.org (Robert I. Eachus) writes:

>    (What Robert Dewar and I objected to was that certain functions
>whose only intended effect is to raise an exception must still contain
>a return statement.  This results in junk return statements in stubbed
>out code, and makes a stubber much harder to write.)

Robert, I can't think of a reason to have a function that does nothing
but raise an exception... can you provide an example?  (I'm not
questioning the need for it -- just curious)

	.Bob.
----------------
Bob Kitzberger          VisiCom Laboratories, Inc.
rlk@visicom.com         10052 Mesa Ridge Court, San Diego CA 92121 USA
                        +1 619 457 2111    FAX +1 619 457 0888
Newsgroups: comp.lang.ada
From: rsd@sei.cmu.edu (Richard S D'Ippolito)
Subject: Re: ?
Keywords: ?
Organization: The Software Engineering Institute
Date: Thu, 17 Dec 1992 11:23:42 EST


In article <1992Dec10.171508.15588@mcc.com>, Mark Breland writes:
> In article <maheal.723966279@hawk> Martin Heal writes:
> >?
> 
> Sometimes I read this group and feel the same way.
> 
> Mark A. Breland - Microelectronics and Computer Technology Corporation (MCC)
> Ada Fault Tolerance                               | voice:    (512) 338-3509
> 3500 West Balcones Center Drive                   | FAX:      (512) 338-3900
> Austin, Texas 78759-6509   USA                    | internet: breland@mcc.com

Geez, Mark, I read your response and laughed so hard I got tears in my eyes!

Rich
From: emery@dr_no.mitre.org (David Emery)
Newsgroups: comp.lang.ada
Subject: Re: Open Systems closed to Ada?
Date: 16 Dec 92 15:10:16 GMT
	<1992Dec11.212550.23767@seas.gwu.edu>
	<1992Dec13.151515.27646@sei.cmu.edu> <BzBG7L.G3A@puffin.uucp>
Organization: The Mitre Corporation, Bedford, MA

>Ada is certainly not a bad language; it wasn't nearly as well supported
>as C for its first 5 or more years, but that is finally getting better.

Huh?  How many C compilers were there during the first 5 years of C,
back around 1972 or so...
				dave
Newsgroups: comp.lang.ada
From: emery@dr_no.mitre.org (David Emery)
Subject: Re: Language pitfalls (was Re: FORTRAN bug)
Organization: The Mitre Corp., Bedford, MA.
	<1992Dec8.172551.16780@newshost.lanl.gov>
	<1992Dec9.060218.23940@seas.gwu.edu>
	<1992Dec11.132942.24054@mksol.dseg.ti.com>
	<1992Dec11.163811@lglsun.epfl.ch> <1992Dec14.165537.18275@mks
	<1992Dec15.135539.7245@lth.se>
Date: Tue, 15 Dec 1992 14:55:42 GMT

Maybe we should follow up Bob K's 5 rules and construct a "The Net":
Ada Traps and Pitfalls.  At least this will be a technically oriented
discussion on Ada, rather than Comp.Lang.Jihad.

I'll think about it and send in some of my rules.

				dave
Newsgroups: comp.lang.ada
From: garym@telesoft.com (Gary Morris @pulsar)
Subject: Re: Novice Question on Record Representation
Organization: Alsys Group, San Diego, CA, USA
Date: Thu, 17 Dec 1992 18:24:03 GMT

In <dnsurber.724602575@node_26400> dnsurber@lescsse.jsc.nasa.gov (Douglas N. Surber) writes:
>    package P1 is
>	type T is private;
>	T_Size : constant := 32;
>    private
>	type T is new Integer;
>	subtype Assertion is boolean range true .. true;
>	a1 : constant Assertion := T_Size = T'Size;
>    end P1;

>By using the Assertion, you assure that T_Size has the right value.  Yes,
>you may have to tweak its value when you port, but you can't get a clean
>compile with the wrong value so it is safe. 

Unfortunately, you can't rely on assertion like this.  The constant a1 is
not used anywhere and an optimizing compiler could remove a1 and the
expression used for its initial value (TSize = T'Size).  So the range check
never occurs and no exception or compile time warning is generated.  This
optimization is allowed by 11.6(7), when the only effect of a predefined
operation is to raise an exception. 

--GaryM
-- 
Gary Morris                      Internet: garym@telesoft.com
Ada Software Development         UUCP:     uunet!telesoft!garym
Alsys West (TeleSoft)            Phone:    +1 619-457-2700
San Diego, CA, USA               Fax:      +1 619-452-2117
Newsgroups: comp.lang.ada
From: mfeldman@seas.gwu.edu (Michael Feldman)
Subject: Re: FORTRAN bug(was Re: C++ vs. Ada -- Is Ada loosing?)
Organization: George Washington University
Date: Tue, 15 Dec 1992 02:43:40 GMT

In article <1992Dec14.170421.18709@mksol.dseg.ti.com> mccall@mksol.dseg.ti.com (fred j mccall 575-3539) writes:
>
>I agree.  I feel the same way about Ada, by the way.  There's simply
>too much there to be teaching it to people as a first language.
Well, you're certainly entitled to your opinion. Those of us who are
actually _doing_ it, and (most of) our students, like what they see.

We don't tell the students what a verbose, hairy, big, risky dinosaur
Ada is, so they somehow get the impression they can learn it. And they do.

We teach our infant children a subset of English (or German, or whatever),
and we teach our freshmen a subset of Ada. They learn the rest as they
grow up. It's a language you can grow into.
>
>Pascal tends to be a somewhat more appropriate choice for a first
>language.  It's a nice protected environment with a limited set of
>features. 
The downside is that vanilla Pascal (the ISO standard version) is much
too underpowered for the software engineering stuff (like separate
compilation) we want to do, even with first-years. So many teachers go
with Turbo. Only trouble is, Philippe has decided that Turbo for Unix
isn't worth his trouble, so yanking the kids off their PC's onto the
Unix boxes in the lab is impossible unless they switch to C...or Ada.

Mike Feldman
Newsgroups: comp.lang.ada
From: eachus@oddjob.mitre.org (Robert I. Eachus)
Subject: Re: Language pitfalls (was Re: FORTRAN bug)
Organization: The Mitre Corp., Bedford, MA.
	<1992Dec15.180821.17817@beaver.cs.washington.edu>
	<1992Dec15.203558.18211@inmet.camb.inmet.com>
Date: Wed, 16 Dec 1992 01:22:49 GMT

In article <1992Dec15.203558.18211@inmet.camb.inmet.com> stt@spock.camb.inmet.com (Tucker Taft) writes:

   Oh boy.  That is a nasty one.  This argues for a "friendly" 
   Ada compiler giving a warning about any use of "null;" other
   than the idiomatic ones like "when others => null;" or "begin null; end;"
   (especially in a function that returns an access type ;-).

   In retrospect, one could argue that it would have been better
   to have no "null" statement at all (other than simply ";") than
   to create a situation allowing this kind of one word error.

    Actually, there is an Ada rule which normally catches this, and
which Robert Dewar and I have argued should be removed in Ada 9X.  (A
function must contain a return statement RM 6.5(1).)  If it belongs on
the top ten list, then the rule should stay.

    (What Robert Dewar and I objected to was that certain functions
whose only intended effect is to raise an exception must still contain
a return statement.  This results in junk return statements in stubbed
out code, and makes a stubber much harder to write.)

--

					Robert I. Eachus

with Standard_Disclaimer;
use  Standard_Disclaimer;
function Message (Text: in Clever_Ideas) return Better_Ideas is...
Newsgroups: comp.lang.ada
From: tom@hpncmo.rose.hp.com (Thomas Vachuska)
Subject: Re: Lets split comp.lang.ada into multiple groups to confine flames
Date: Thu, 17 Dec 1992 19:33:15 GMT
Organization: HP Networked Computer Mfg. Operation
X-Newsreader: TIN [version 1.1.8 PL6]

Alex Blakemore (alex@cs.umd.edu) wrote:
: make comp.lang.ada obsolete and create a small set of groups instead.
: 
:   some suggestions
: 
:     comp.lang.advocacy   - for the flame wars
:     comp.lang.programmer - for discussions of design/development Ada language issues
:                            (or comp.lang.technical or better name?)
:     comp.lang.announce   - moderated, low volume important announcements
:                            of meetings, products, standards, new mandates :) etc
:     comp.lang.misc       - catch all
: 

Am I wrong if I assume that you really meant to write 'comp.lang.ada.*'
instead of 'comp.lang.*'?  At least for the *programmer, *announce, and *misc
groups anyway.  IMHO, there should really be only one 'comp.lang.*.advocacy'
group.  Kind of a /dev/null... huh?  ;-)

I'll vote YES on comp.lang.advocacy, comp.lang.ada.[programmer, announce, misc].

Thomas Vachuska
------------------------------------------------------------------------------
tom@mothra.rose.hp.com                   (916)-785-4983  (Telnet & Voice Mail)
------------------------------------------------------------------------------
Newsgroups: comp.lang.ada
From: LJ10891@LMSC5.IS.LMSC.LOCKHEED.COM
Subject: Re: Open Systems closed to Ada?
Organization: Lockheed Missiles & Space Company, Inc.
Date: Fri, 11 Dec 92 21:04:44 GMT

   Fred, I lost count of the number of times you used the word "mandate" in
your last post, but I gather that this is a pet peeve of yours.

   In all seriousness, your implication that no one would use a non-validated
Ada compiler, and therefore such a compiler has no value, seems suspect to me.
If you would briefly grant me the assumption that the mandate was being
successfully enforced, would you agree with the statement that "No one can use
any 'C' compiler, therefore 'C' compilers are useless"?  I doubt it.

   I disagree with the Ada mandate; however, when all is said and done, the DoD
is just one software customer.  I doubt there's a large market for Macintosh
software at IBM.  It hasn't kept Mac programmers from peddling their wares
elsewhere.  If the DoD chooses to freeze THEIR technology for eleven
years at a pop, IT'S THEIR CHOICE (and, IMHO, one whose wisdom has yet to be
established).
Newsgroups: comp.lang.ada
From: pattis@cs.washington.edu (Richard Pattis)
Subject: IBM & Air Traffic Control
Summary: Anyone know more?
Keywords: Big Screwup
Organization: Computer Science & Engineering, U. of Washington, Seattle
Date: Sat, 12 Dec 92 00:25:23 GMT


In today's NYT business section, there was an article about the government
threatening to cancel a $3.8 billion contract with IBM to overhaul the
air traffic control system. It says

  "Because of a software foul-up, the contract with the FAA has already
   suffered an 18 month delay...The problems involve testing and integrating
   software in what is called the initial sector suite system..."

This seems like a very large and embarasing screwup.

Anyone know more about the project. I thought the air traffic control stuff was
being done "mostly" in Ada; if not, anyone know what language was used. Even
better, anyone know what is "really" behind the delay.

Rich Pattis


-- 
------------------------------------------------------------------------------
  Richard E. Pattis                     "Programming languages are like
  Department of Computer Science         pizzas - they come in only "too"
    and Engineering                      sizes: too big and too small."
Newsgroups: comp.lang.ada
From: dnsurber@lescsse.jsc.nasa.gov (Douglas N. Surber)
Subject: Re: Novice Question on Record Representation
Organization: Lockheed Engineering and Sciences
Date: 17 Dec 92 14:29:35 GMT

In <1992Dec16.225712.23791@saifr00.cfsat.honeywell.com> lam@saifr00.cfsat.honeywell.com (Josh Lam) writes:

>There is a type in another package I need to use in a record in my package.
>Unfortunately, that type is private and I need to use record representation
>for my record.

> for My_Rec use record
>    A      at 0 range 0..15;
>    B      at 0 range 16..31;
>    C      at 1 range 0..31;     -- of course there is an error here!
>    Choice at 2 range 0..31;
>    D      at 0 range 0..15;
> end record;

Try the following small kludge:

    package P1 is
	type T is private;
	T_Size : constant := 32;
    private
	type T is new Integer;
	subtype Assertion is boolean range true .. true;
	a1 : constant Assertion := T_Size = T'Size;
    end P1;

    with P1;
    package P2 is
	type T is 
	    record
		F : P1.T;
	    end record;
	for T use record
	    F at 0 range 0 .. P1.T_Size - 1;
	end record;
    end P2;

You can't use P1.T'Size directly since it isn't static outside of the
private part (at least according to the Alsys compiler).  By using the
Assertion, you assure that T_Size has the right value.  Yes, you may have
to tweak its value when you port, but you can't get a clean compile with
the wrong value so it is safe.


--
Douglas Surber             "Would you rather debug at
Lockheed                    compile time or run time?"
Houston, TX                      --Michael B. Feldman
From: jnestoriak@vnet.ibm.com (John Nestoriak III)
Date: Fri, 11 Dec 92 17:24:26 EST
Newsgroups: comp.lang.ada
Subject: Re: FORTRAN bug(was Re: C++ vs. Ada -- Is Ada loosing?)
Disclaimer: These views are mine, mine, mine.  IBM can't have 'em.
News-Software: UReply 3.0
            <1992Dec11.210404.2480@inmet.camb.inmet.com>

In <1992Dec11.210404.2480@inmet.camb.inmet.com> Tucker Taft writes:
>One of our goals for Ada 9X has been to give system programmers
>back this feeling of satisfaction, so that you can do "code generation
>in your head" for most Ada constructs.  In other words,
>you can predict about how many machine instructions (and
>generally which ones ;-) will be generated for each
>construct in your program.  For a real-time embedded language,
>this seems particulary important.

Are there plans to add bitwise operations to Ada 9X?  Lack of
built in shift operators was a disappointing discovery for me.
I know that Ada is a high order language and therefor less suitable
for manipulating bits than say C, but there are high level functions
that need to manipulate bits.  I'm thinking in particular of
compression routines.  The project I work on is Ada but we had to
implement compression using C.
Newsgroups: comp.lang.ada