HDTenEightyP/NetNews huggingface dataset:
From: emery@Dr_No.mitre.org (David Emery)
Subject: Re: non-blocking I/O on Unix workstations
Organization: The Mitre Corp., Bedford, MA.
Date: Mon, 13 Apr 1992 14:20:16 GMT

>	1) compilers that run on mainstream Unix systems that
>	just flat out provide non-blocking I/O for standard Ada
>	I/O calls.

This is an operating system problem, not a compiler problem.  Why
do you expect a compiler to fix shortcomings in the operating
system????

Non-blocking I/O on Unix is certainly a FAQ in these parts.  There are
techniques in various flavers of Unix to support non-blocking IO (e.g.
the select() call.)  But, these extensions are not portable, and it's
my understanding that they often require support from device drivers
that isn't always there.  

POSIX (P1003.1/ISO 9945-1) provides no facilities that guarantee
non-blocking IO. 

The general view of a program (Ada or C) to Unix is a single process.
The default behavior during a system call is that a process blocks
during the system call.  This hasn't been a problem for C, because
C programs (on Unix) are not multi-threaded.  The introduction of
threads/lightweight process/etc. for C has raised this issue for C,
too.  In these cases, the implementation of a specific threads package
on a specific system can take advantage of support in that system
(often added to support C threads) for non-blocking I/O.  When such
systems are available (e.g.  POSIX P1003.4a), then Ada can take
advantage of them.  

				dave

Newsgroups: comp.lang.ada
From: smithd@software.org (Doug Smith)
Subject: Ada 9X plans for Generic Formal Packages
Organization: Software Productivity Consortium, Herndon, Virginia
Date: Tue, 7 Apr 1992 19:29:22 GMT

A quick look at the March 92 Draft Ada 9X Project Report revealed
a new item:

    S.12.1.4 Generic Formal Packages [new]

However, the accompanying description and example leaves out a
lot of detail:

    o   How does the generic instantiate the formal package
        (named associations, etc.?)

    o   How are the profiles of the actual packages mapped
        to the profiles of the generic formal packages?

    o   How will defaults work?

Can anyone point me to further information concerning this
feature.  I have suggested something similar to several
people and see a great deal of power behind it--if it
really is what it appears to be:  Providing generic
packages as formal parameters to generic packages!

    Doug
From: g_harrison@vger.nsu.edu (George C. Harrison, Norfolk State University)
Newsgroups: comp.lang.ada
Subject: Re: Open comment to Ted Holden
Date: 15 Apr 92 21:18:26 EDT

In article <1992Apr14.202708.18771@u.washington.edu>, mfeldman@milton.u.washington.edu (Michael Feldman) writes:
> Meridian, Alsys, and RR are, in my opinion, guilty of a terribly myopic
> view of Ada, shared by much of the Ada industry. Ada does not have a large
> customer base because - several years ago when there was plenty of DoD
> and venture money flowing, the Ada companies failed to hire marketing
..............
> 
> The engineers in these companies believe they have a better mousetrap
> (at least I think they do), but the world can't beat a path to their
> door because they don't know the door is there.
> 
.............
> Why are Borland and Microsoft compilers sold in every software store in
> town, but nobody's heard of Meridian? The Ada companies will either learn
> that they have to spend money to make money, hire some decent marketeers,
> take some risks, and go for it, or they will simply shrivel up and die.
> Ada is a much better invention than its own proponents allow it to be.
> 
> Spare me the flames about how expensive validation is. I know that, and
> know that all the validation in the world will not sell a product its
> own manufacturers refuse to market aggressively.

Mike, I am glad someone finally said this on here who is [reasonably] well 
known [and not INfamous].  

But it's not only straight marketing that is the key.  DoD isn't going to try
to wow the world anymore on the joys of Ada.  That's the job of R&R, ALSYS, and
Meridian (and some mini/mainframe) Ada vendors.  Virtually all of them have
solid products as far as the standard goes, but they are unwilling to venture
into competitive markets.  
 
AJPO, some software vendors, and some other organizations were willing to
donate individual compilers to universities in hopes of WOWing the world. 
Well, what or who is going to make the universities break open the shrink
wrap?  (I still have my Oberon compiler on a disk somewhere.  It hasn't made 
any noise on its own to make me figure out how to use it or why I should ever
care to use it.)

I'm frankly sick of my students and some faculty telling me what a great 
thing C++ is when they don't know the difference between a polynomial and 
a polymorphism.  It's all ads, religion, and ingrained academic prejudice.

If Ada does die an early death, blame can be placed on many sources; however,
even thought Ada is not the best thing since the flush toilet, the downfall
can't be placed on the language.


George C. Harrison, Professor of Computer Science
Norfolk State University, 2401 Corprew Avenue, Norfolk VA 23504
PHONE 804-683-8654   FAX 804-683-9229   g_harrison@vger.nsu.edu
From: sampson@cod.nosc.mil (Charles H. Sampson)
Newsgroups: comp.lang.ada
Subject: Library Package Initialization
Date: 16 Apr 92 22:41:22 GMT
Organization: Computer Sciences Corporation
     The initialization code for a library package gets executed exactly

smart Ada system could take advantage of this by making the memory occu-
pied by that code and the associated data available, say in the heap,
during program execution.  Does anyone know what existing compilers do?

     This is not just an academic interest to me.  I'm considering some
initialization code that might be prettly large and might have to run on
a machine with limited memory.

				Charlie
Newsgroups: comp.lang.ada
Subject: Mistake on earlier posting
From: mtabacch@eve.wright.edu (Marci Tabacchi)
Date: 6 Apr 92 15:19:01 EST
Organization: Wright State University





Ada Software Development Position


Science Applications International Corporation has
a need for a Software Engineer to do Ada/X/Object Oriented
design and development for a large scale project.


Aspects of this position:

	1. Permanent position.
	2. Object-Oriented design.
	3. Ada & X Window System.
	4. Good growth potential in well established company.

 
Please call Larry Janning @ 
		513-429-6500 

or fax your resume to
		513-429-6505 <<---- here was the mistake

or send your resume to 

		Larry Janning
		1321 Research Park Drive
		Dayton, Oh  45432
From: hayes%bh_ddemo3@hac2arpa.hac.com
Newsgroups: comp.lang.ada
Subject: Naming conventions
Date: 17 Apr 92 17:06:55 GMT
Distribution: na
Organization: Hughes Aircraft Company; El Segundo, CA
Originator: hayes@ddemo3


I've always been a proponent of naming conventions in software
development, especially with team and or multi-module projects.

What kinds of naming conventions have you used with Ada?  Or,
is it necessary?

On my previous team projects (non-Ada) I/we have used the following 
naming conventions: 
1.  the file name for a module/task is an acronym for the module.
For example, the "Workstation Executive" module's primary source
file might be, for C code, we.c or wse.c and the corresponding 
include files we.h or wse.h.  If the source was distributed over 
multiple files (which I usually avoid doing so as to declare 
most of the module's globally scoped variables local (static)).

2.  procedure, function, and variables not local to a procedure or
function get named module-acronym_variable-name.

A couple of benifits of this convention are:
1.  It is very easy to determine where an object is declared which 
is extremely helpful in debugging.
2.  Sorted symbolic maps.

It seems that with Ada, I could still use my naming convention; but,
I would dropy the module acronym portion win naming objects.  To 
make references clear in the code, I could avoid use of the USE 
clause requiring me to explicity reference the package when 
using an object.




-- 
<<<<<<<<<< Brian Hayes hayes%bh_ddemo3@hac2arpa (310) 616-5129 >>>>>>>>>>>>
From: hearne@henson.cc.wwu.edu (Jim Hearne)
Newsgroups: comp.lang.ada
Subject: Re: Open comment to Ted Holden
Date: 14 Apr 92 17:44:47 GMT
Article-I.D.: henson.1992Apr14.174447.29413
Organization: Western Washington University

jonesm@nic.cerf.net (Matthew Jones) writes:

>And for my 2 cents.

>I think that comparing carrying commercial GPS equipment into the desert

                  . . .

>To me that largest problem with Ada is that it doesn't have a large
>customer base. So the Ada Compiler/development systems are not checked
>out as well as its commerial counterparts. How many beta test sites
       
                  . . .

>Matthew Jones
>jonesm@cerf.net

There is an obvious implicate to this view: the DOD should simply
buy Ada compilers for universities to increase the volume of tests
the compilers are subjected to.   This would be much cheaper than
paying defense industry rates for the same thing and would serve
a useful educational purpose also.


				James Hearne
				Computer Science Department
				Western Washington University
				Bellingham, WA  98225
From: young@cs.purdue.EDU (Michal Young)
Newsgroups: comp.lang.ada
Subject: Re: how pure are functions?
Date: 7 Apr 92 19:05:13 GMT
	<1992Apr7.171335.13631@wdl.loral.com>
Organization: Department of Computer Science, Purdue University


In reply to: 

>    Are they free from internal state?
>No.

Mark Biggar says: 
> More then likely that variable is only visible in the body of the package
> that defines the function and so is invisible to the user of the function,
> but strictly the function itself has no "internal" state. 

This is true, strictly speaking, but from the viewpoint of a user,
verifier, or compiler, Ada functions do not appear to be stateless.
For instance, one cannot generally substitute 2*f(x) for f(x) + f(x).
There are good practical reasons for not insisting that every
"function" be a pure function, but it would be quite helpful if the
language provided some way to indicate that certain "functions" were
actually functions in the mathematical sense.

--Michal Young
-- 
Michal Young
From: willett@cbnewsl.cb.att.com (david.c.willett)
Newsgroups: comp.lang.ada
Subject: Re: Open comment to Ted Holden
Date: 9 Apr 92 16:58:33 GMT
Article-I.D.: cbnewsl.1992Apr9.165833.2674
Organization: AT&T Bell Laboratories

From article <1992Apr9.155334.20536@schaefer.math.wisc.edu>, by nedervol@schaefer.math.wisc.edu (Eric Nedervold):
> SAHARBAUGH@ROO.FIT.EDU writes:
>>  No matter what Army software costs it is cheaper than the
>>alternative.  Imagine an enemy with Apache helicopter
>>equivalents in your home town for an hour. The national
>>debt may be huge but it is not as huge as the cost of
>>rebuilding Wash DC or New Yoork after a nuclear attack.
>>And, as an extra added benefit, we are alive and well
>>and our infrastructure is intact and we can work to
>>pay off that debt.
> 
> Does this argument extend to hardware too?  Like $500 toilet seats?
> 
> --Eric Nedervold
>

Oh, I *had* to jump in here on this one.  The issue in the original post
as well as the two follow-ups I've read seems to be:

	Are MIL-SPECs worth the cost?  They sure don't seem to be, but
we haven't had to re-fight WWII yet.  I have worked with 40-year old 
MIL-SPEC hardware that wouldn't have been available to me if it hadn't 
been built so ruggedly.  Greg pointed out that commercial GPS receivers
served well in the Gulf.  I would point out that the ground war there 
lasted approx. 100 hours and the entire military campaign less than
3 months.  In my opinion, that is not a fair test.  

Remember that military equipment must be able to function in spite of battle 
damage.  In a system heavily dependent on software (most are nowdays), 
survivability has a lot to do with the software being modular as well as being
able to respond to exceptions (i.e. that channel is down -- use another).  It
seems to me that Ada was designed to facilitate production of that sort of 
software.

With regard to Ada not being cost effective, I would submit that the
"commercial" world has not yet reached the degree of dependence on software that
our high-tech military "enjoys".  It is getting there fast though.  I think
Ada's advantages will become apparent in the commercial world in the next 
decade.  Of course, just because the advantages of software engineering 
methodology become well known, doesn't mean that Ada itself will be successful.
There could very well be newer languages that will do what Ada does "better".
When these languages arrive, DoD would do well to encourage their use.

Dave
Newsgroups: comp.lang.ada
From: eachus@Dr_No.mitre.org (Robert I. Eachus)
Subject: Re: associate functions to objects
Organization: The Mitre Corp., Bedford, MA.
Date: Tue, 14 Apr 1992 22:53:48 GMT


   Julian Insan Kamil (consp10@bingsunb.cc.binghamton.edu)says:

 > I'm working on a project for a Software Engineering class, and
 > we're using Ada to develop a simple database management
 > application. My part is on building the user interface for the app.
 > One of the data type that we're using is called an EntryBoard which
 > is supposed to manage a list of other objects like Fields, Buttons,
 > Titles, etc. Each of those objects should be attached to a function
 > that will be called whenever that object is selected (sort of like
 > callback functions). Now, how do you attach functions to objects? I
 > consulted my Ada references and it seems that Ada doesn't allow
 > passing functions as a parameter to a procedure (the way I did it
 > in C++ to implement the same behavior). I need hints and advice and
 > examples on how to do this kind of things. Will anybody help me
 > with some light?

   Three answers, one simple, one more complex, and one which is just
hard work... 

   The "canonical" way to do this in Ada is to make the objects
instances of a task type.  Task objects and/or objects containing
tasks can be passed as parameters, and calls made to entries of these
tasks.  Problem is that with most current Ada implementations, this is
SLOW.

   The "clever" way to do this, which works on all Ada compilers which
I've tried it on is to pass addresses as parameters and use them in
address clauses for procedures:

    procedure App(X: Something; Callback: System.Address) is

      function Local_Callback return Status;
      pragma INTERFACE(Ada, Callback);
      for Local_Callback'Address use Callback;

    begin
     
      if Local_Callback = Busy then....


    The language to use in the pragma INTERFACE varies from
implementation to implementation, and if the parameter and result
profile of the function whose address is passed doesn't match the
local declaration, expect fireworks at run-time.  But otherwise this
is an implementation dependant but fairly standard way of doing
callbacks.  (The pragma INTERFACE has to be there for legality
reasons, since no body is provided for Local_Callback.  The address in
the address clause need not be static, and in this case it probably
will change from call to call.)

    The third approach is to use generics.  Define your object types
as generic packages.  Each object is then an instance one of these
packages.  (However, the interaction of abstract types can lead to a
LOT of generic formal parameters.  See my previous message.)  The
callbacks can then be passed as generic actual subprogram parameters.
It is hard to learn this style of programming but it is very powerful.
It can be mixed with abstract types as tasks when some objects need a
separate thread of control, and so forth.

    So choose whichever approach is right for this application.  Good
luck.

--

					Robert I. Eachus

with STANDARD_DISCLAIMER;
use  STANDARD_DISCLAIMER;
function MESSAGE (TEXT: in CLEVER_IDEAS) return BETTER_IDEAS is...
From: sampson@cod.NOSC.MIL (Charles H. Sampson)
Newsgroups: comp.lang.ada
Subject: Reentrancy in Ada (Was: Ada / X / Motif multi-tasking issues)
Date: 16 Apr 92 15:33:39 GMT
Article-I.D.: cod.3776
Organization: Computer Sciences Corporation


     Check the LRM 6.1(10): "All subprograms can be called recursively and
are reentrant."

     Reentrant means that more than one invocation of a subprogram can be
active at the same time and each will perform its stated function and re-
turn to its invoker.  (Very roughly.)  It does not mean that the subprogram
will automatically be correct.  In particular, if the subprogram accesses
external data the programmer must treat that data as a shared resource.  It
is only peripherally related to tasking, in that reentrancy is needed when
two tasks "simultaneously" invoke an external subprogram.  Task code itself
does not need to be reeentrant, although it usually is as an implementation
decision.

				Charlie
Newsgroups: comp.lang.ada
From: srctran@world.std.com (Gregory Aharonian)
Subject: Ada waiver for RCAS
Organization: The World
Distribution: comp.lang.ada
Date: Wed, 15 Apr 1992 15:04:45 GMT

    Does anyone know the language that RCAS is or will be programmed in, now
that the Army has a waiver not to use Ada?  How many lines of code will RCAS
encompass.
    Also, a few years ago someone (I think SAIC) was awarded a billion dollars
for the CHCS Comprehensive Health Care System project, which as I remember,
is to be written in MUMPS (because "it is a portable, rapid-prototyping,
software engineering language").  Is CHCS still being developed in MUMPS,
and how many lines of code there?  And did a waiver have to be obtained not
to use Ada?

Greg Aharonian
Source Translation & Optimization
Newsgroups: comp.lang.ada
From: kummer@possum.den.mmc.com (Jim Kummer)
Subject: Re: Ada LRM
Keywords: LRM
Organization: Martin Marietta Astronautics Group, Denver
Distribution: na
Date: Thu, 9 Apr 1992 13:28:33 GMT

In article <6963@amsaa-cleo.brl.mil> ledwick@amsaa-cleo.brl.mil (Bill Ledwick) writes:
>Is the Ada LRM available in electronic form (i.e. ftp site)?
>				Thanks,
>				Bill

I believe that the LRM in electronic form can be found on 
ajpo.sei.cmu.edu (128.237.2.253) in directory 'public/lrm'.


-- 
 
-- Regards ----- James Kummer --- Martin Marietta Corporation --
----- kummer@pogo.den.mmc.com --- Astronautics Group ----------- 
(standard disclaimer applies)
From: sampson@cod.nosc.mil (Charles H. Sampson)
Newsgroups: comp.lang.ada
Subject: Library Package Initialization (2nd try)
Date: 16 Apr 92 22:49:46 GMT
Article-I.D.: cod.3778
Organization: Computer Sciences Corporation


     Sorry about that.  Apparently my news poster has an undocumented
requirement for a blank line in a certain position.  What I intended to
post was:

     The initialization code for a library package gets executed exactly
once, when the package is elaborated before program execution begins.  A
smart Ada system could take advantage of this by making the memory occu-
pied by that code and the associated data available, say in the heap,
during program execution.  Does anyone know what existing compilers do?

     This is not just an academic interest to me.  I'm considering some
initialization code that might be prettly large and might have to run on
a machine with limited memory.

				Charlie
From: mfeldman@milton.u.washington.edu (Michael Feldman)
Newsgroups: comp.lang.ada
Subject: Re: Ada LRM
Keywords: LRM
Date: 9 Apr 92 05:12:42 GMT
Article-I.D.: u.1992Apr9.051242.4901
Distribution: na
Organization: University of Washington, Seattle

In article <6963@amsaa-cleo.brl.mil> ledwick@amsaa-cleo.brl.mil (Bill Ledwick) writes:
>Is the Ada LRM available in electronic form (i.e. ftp site)?

Yes indeed. Get it from ajpo.sei.cmu.edu.

Mike Feldman
From: dappel@grafted.UUCP (Dave Appel)
Newsgroups: comp.lang.ada
Subject: Re: Open comment to Ted Holden
Date: 17 Apr 92 18:50:40 GMT
Organization: GRAFTED, Central Indiana's Usenet BBS 317-881-4369

wicklund@intellistor.com (Tom Wicklund) writes:

> In <TD79iB1w161w@grafted.UUCP> dappel@grafted.UUCP (Dave Appel) writes:
> 
> >Also, there is no "Standard C".   Ansi C and K&R C are *NOT*
> >"standards" that are adhered to.  Talk to the people at
> >Aldus corporation, the people who wrote PageMaker.  They
> >have PageMaker on the Mac and PageMaker on the PC.  Only 
> >about 80% of the code is identical between the two systems.
> > 
> >Graphic handling and system calls are still too different.
> 
> But Standard C doesn't define a graphical interface.  An Ada version
> of the PageMaker would also only have about 80% of the code common
> because the system calls would still differ.  Smart design can isolate
> these differences and make them easy to maintain.
> 
> The only way to make code 100% portable will be to combine the
> operating system and language into one standard.  Ada sometimes tries
> to do this but so far other than tasking / distributed systems
> features seems to be remaining a programming language.

My point was not to say that Ada had those particular things
that C is missing.  My point was to counter Ted's point aobut
C being some sort of North American Standard that "everyone"
knows and programs in.  "C" is not "C" all around the country
let alone the whole world.  Even for the same operating
system, there are incompatibilities between one C compiler
and another, even when both claim to be ANSI compatible.
I'm not saying there are aren't incompatibilities between
flavors of Ada, either.  I'm saying that C is not the panacea
that Mr. Holden claims.
    There is still a lot of momentum with other languages.
And I'm talking about NEW development, not just old code
still in production.  Just about all supercomputers have
C compilers now, but most of the NEW development is still
in Fortran for the supers.  Mini's and mainframes have C
compilers too, but most NEW development of *business*
applications is still in Cobol.

--
Dave Appel
The Grafted Branch BBS
317-881-4369
internet: dappel@grafted.UUCP
uucp: ..!uunet!grafted.UUCP!dappel
 = = Grafted Branch BBS (317) 889-6997 2 Gig on-line = =
From: boo@array.com (K)
Newsgroups: comp.lang.ada
Subject: PD ADA for IBM PC?
Keywords: ADA for a PC
Date: 3 Apr 92 03:23:37 GMT
Organization: Array Microsystems, Colorado Springs, CO. USA

I am looking for ADA that will run on a PC.  It does not have
to be Public Domain actually, but, able to run on a PC would
be nice.  Are there any good packages out there that run on a PC?

Thanks in advance!  

boo@array.com
From: steven@monu6.cc.monash.edu.au (Steve Stergakis)
Newsgroups: comp.lang.ada
Subject: INFO NEEDED on OOA Methodologies
Date: 8 Apr 92 09:45:30 GMT
Organization: Monash University, Caulfield Campus


NOTE: this message has been posted for persons that either use, teach 
or have some opinion regarding current OOA methodologies being 
used...

THIS MESSAGE HAS BEEN CROSS POSTED TO MANY NEWS GROUPS.  PLEASE 
DISREGARD IT IF HAS BEEN POSTED TO AN INCORRECT AREA.

i am a postgraduate student who is currently studying OOA and 
would greatly appreciate any information regarding experience
you have had with object oriented methodologies

as i am about to write a critical review of the current OO methodologies i 
would appreciate if you could tell me which approach you prefer.. or if
you know of any article that have compared current OOA methods, that would
also be greatly appreciated...

i am especially interested in persons who use such methodologies 
in practice.. their extent of their use in your work area.. 
the type of work you do.... and your opinion!

PLEASE feel free to comment on any of the above questions.. if you do
not wish to relate specific information pertaining to your work /
work environment, then leave it out

NOTE: if possible please reply directly to me 

thanks in advance

+------------------------------------------------------------+
| Steven Stergakis      steven@monu6.monash.cc.edu.au        |
|                                                            |
|                       (Post Graduate)                      |
|                       Faculty of Computing and Information |
|                       Technology                           |
|                                                            |
|                       Monash University - Australia        | 
+------------------------------------------------------------+