HDTenEightyP/NetNews huggingface dataset:
From: englehar@src.honeywell.com (Matt Englehart)
Subject: Namelist package
To: comp.lang.ada
Posted-Date: Mon, 12 Oct 92 10: 18:30 CDT
Organization: Honeywell Systems & Research Center
Date: Mon, 12 Oct 1992 15:18:30 GMT
Received-Date: Mon, 12 Oct 92 10: 18:21 CDT

If anyone has implemented the (semi or exact) equivalent of the Fortran
namelist mechanism in Ada, I'd be extremely greatful for the code.  Please
respond via email to englehar@src.honeywell.com

Thanks, Matt
From: michael.hagerty@nitelog.com (Michael Hagerty)
Newsgroups: comp.lang.ada
Subject: PC & SUN ENVIRONMENTS
Date: 9 Oct 92 09:08:00 GMT
Reply-To: michael.hagerty@nitelog.com (Michael Hagerty)
Organization: Nitelog BBS - Monterey, CA - 408-655-1096

I attempted to respond to an earlier message from RCALIARI at the email
address "rcaliari@su5v.ess.harris.com" regarding PC & Sun Environments.

Unfortunately, this address seems to be off-line...  If you are out
there and have a better email address, please send me a private post
so I can provide some of the information you were asking about.

Regards, Mikey  (michael.hagerty@nitelog.com)
                                                                                                                       
Newsgroups: comp.lang.ada
From: jclander@texas.mitre.org (Julian C. Lander)
Subject: Re: Booch Components
Reply-To: jclander@texas.mitre.org (Julian C. Lander)
Organization: The MITRE Corporation, McLean, Va
Distribution: na
Date: Tue, 13 Oct 1992 12:37:41 GMT

The Boch Components are distributed in source form (at least the ones
I worked with were).  I've used them before, and they're a great time-
saver.  

The way to think about whether they're worth it for you are to 
figure out how many of the packages described in Booch's book
(Software Components in Ada, or something like that, I don't have
a copy here) you would use.  The distributed components are
just the code in the book, in all varieties (there's a list in
an appendix.)  You could code them up yourself if you needed to. 
So is it cheaper to code or buy?

The Booch components are also pretty much bug-free (I don't 
remember problems, but I might have forgotten or missed some.)

Another good thing about them is that you find yourself 
choosing the components that best suit the problem, not
just trying to re-use the ones you already wrote.  (This
assumes, of course, that there are Booch components that
match your problem.)
 
Julian C. Lander
jclander@mitre.org
(Standard disclaimer goes here.)
Newsgroups: comp.lang.ada
From: bwallet@apssgi.nswc.navy.mil (Brad Wallet)
Subject: Re: Ada and real-time
Organization: Naval Surface Warfare Center
Date: Fri, 16 Oct 1992 13:11:57 GMT

In article <1992Oct15.163026.7899@saifr00.cfsat.honeywell.com>, walls@saifr00.cfsat.honeywell.com (Gerald Walls) writes:
|> In article <1992Oct15.144135.24045@sei.cmu.edu> jbg@sei.cmu.edu (John Goodenough) writes:
|> >
|> >By "non-deterministic tasking" do you mean the fact that it can be difficult
|> >or impossible to write down a timeline for a set of Ada tasks, given
|> >variations in execution times and the effect of preemption?  If so, this is
|> >not, in itself, sufficient reason to conclude that Ada tasking is unsuitable
|> >for embedded real-time systems.  
|> >
|> 
|> the FAA requires this in avionics software.  Ada tasking is not
|> suitable for real-time avionics software.

But, the FAA is requiring the use of Ada.  Ada tasking is deterministic
given a set of circumstances.  The external inputs to the Ada program are
not deterministic.  Ada running under Unix will not be deterministic.  This
is because of the external effects of the operating system, but, then 
again, Unix is not a suitable real-time operating system.

Brad
From: simonson@cs.washington.edu (Kevin Simonson)
Newsgroups: comp.lang.ada
Subject: Does the LRM permit parameter passing by reference?
Date: 9 Oct 92 02:38:07 GMT
Article-I.D.: beaver.1992Oct9.023807.20641
Organization: Computer Science & Engineering, U. of Washington, Seattle


     I was under the impression that Ada made local copies of parameter
values when a procedure was called.  However my Verdix compiler apparently
does calls by reference when the call is for a string value, as demonstrat-
ed by the script file below.  Notice how the parameter "COPY" (which Ada
won't allow code to alter inside the procedure) changes its value from the
first "put_line" to the second.

     Is it legal for Ada to allow this parameter to change in the middle of
the procedure, or have I found a bug?

                                     ---Kevin

ph^guru} cat reference_demo_p.a
with text_io;

procedure REFERENCE_DEMO_P
is

   ORIGINAL : string(1..3);

   procedure DEMO_P (COPY : string)
   is

   begin

      text_io.put_line (COPY);
      ORIGINAL(1..COPY'length) := COPY;
      text_io.put_line (COPY);

   end DEMO_P;

begin

   ORIGINAL := "abc";
   DEMO_P (ORIGINAL(2..3));

end REFERENCE_DEMO_P;
ph^guru} reference_demo_p
bc
cc
ph^guru} exit
ph^guru} 
script done on Thu Oct  8 08:53:41 1992
From: byrley@NTSC-RD.NAVY.MIL ("Paul Byrley")
Newsgroups: comp.lang.ada
Subject: Assy/Ada SLOC ratio;What's an  Ada SLOC?
Date: 9 Oct 92 21:30:00 GMT
Distribution: world
Organization: The Internet

Two questions:
First, what do you experts count for Ada SLOC?  I thought total
semicolons but now am hearing "semicolons EXCEPT for ...".  I
would appreciate opinions from lots of people who have Ada
experience.  I will send summary out to net when results are in.

Second, what ratio do you experts use when estimating the no.
of assembly lines of code to make an Ada SLOC (as you defiined
it in answering my first question).  I would hope to get data
on the "group" of assembly code which performed a certain 
operation or function vs the SLOC for the Ada to perform the
same operation or function.  I don't think line for line assy to
Ada translation would help much.  Please try to tell me the domain
you work in and the number of lines of code (not just the ratio).

I can use the answer for the first question without the second, but
not the reverse.

Thank you very much

Paul Byrley
BYRLEY@NTSC-RD.NAVY.MIL

Newsgroups: comp.lang.ada
From: af241@yfn.ysu.edu (Borja Toron Antons)
Subject: Interface between Ada and XWindows?
Reply-To: af241@yfn.ysu.edu (Borja Toron Antons)
Organization: St. Elizabeth Hospital, Youngstown, OH
Date: Wed, 7 Oct 1992 12:26:08 GMT


-- 
------------------------------------
Borja TORON                        I My name is Borja,
toron @ ccucvx.unican.es           I and I am an IRC-adict... :)
af241 @ yfn.ysu.edu                I
From: hawk@hpavla.avo.hp.com (Dave Hawk)
Date: Wed, 14 Oct 1992 13:32:52 GMT
Subject: Meridian Ada for MS Windows
Organization: Hewlett-Packard Avondale Division
Newsgroups: comp.lang.ada

In comp.os.ms-windows.misc, mfeldman@seas.gwu.edu (Michael Feldman) writes:

> Meridian has a compiler now available with Windows libraries.
> (Don't ask me what the price is; I don't know.) Call 1-800-221-2522.

> Mike Feldman

I have purchased a copy of this and haven't played around with it much yet,
but I am at least initially a bit disappointed in the way Meridian has
implemented it.  I had been hopeing for a well thought out Ada style 
package which somehow encapsulated (and buried) all of the C-style hacking
that is required currently to produce a Windows program.  I realize that
designing such a package (and doing it right) is non-trivial, but it would 
have been a major contribution to Windows programming.  I was hopeing for
a contribution on the order of what Borland's OWL class hierarchies have
done for their Pascal and C++ languages.  It seems Ada should have even
more potential.

Instead Meridian implemented what they call an "intentionally thin" interface
in which the C-style Windows functions are called more or less directly and
the Ada programmer still has to hack up the C-style parameters.  They had
some good reasons for going this way (they can ski off of all of the existing
Windows documentation such as Petzold, someone that already knows Windows
can learn things faster, and they don't need to produce as much documentation), 
but the net effect is that we can now write our programs in Ada - but they
are still C programs.  Very little of Ada's type-checking capabilities come
into play.  I am not sure Meridan's offering provides any reason to switch
to Ada development for Windows from any of the other languages that are
now available.

I would agree that even if they did provide such a package that I would
want what they did provide as an escape hatch for which I need to do
something unusual.  Borland provides a complete interface to all of the
Windows API in addition to OWL.  A typical program is 90% OWL and 10%
direct API calls. 

David Hawk
Hewlett-Packard Co.
Avondale, PA.
Newsgroups: comp.lang.ada
From: gg10@prism.gatech.EDU (GALLOWAY)
Newsgroups: comp.lang.ada,comp.sys.sun.wanted
Subject: Looking for Ada Compilers for Sun
Date: 13 Oct 92 15:29:06 GMT
Followup-To: poster
Organization: Georgia Institute of Technology

Does anyone have a list of available Ada compilers for Sun SPARC systems
besides Sun's offering?

Please respond by email, I will post summary on request.

Greg Galloway
gg10@prism.gatech.edu
Newsgroups: comp.lang.ada
From: tlai@cs.toronto.edu (Tony Wen Hsun Lai)
Subject: Re: Ada's (in)visibility in the engineering community
Organization: Department of Computer Science, University of Toronto
Date: 13 Oct 92 02:45:27 GMT

In article <1992Oct12.193624.26845@fcom.cc.utah.edu> val@news.ccutah.edu (Val Kartchner) writes:
>This is a summary of this subthread, which could be called "What is
>'real-time'?":
[stuff deleted]
>But my reply was (summarized):
>: In article <1992Sep25.210409.23219@fcom.cc.utah.edu> val@news.ccutah.edu
>:...
>:A major superiority claim can be made on behalf of C's real-time ability
>:over Ada's real-time ability in that families of commerically viable
>:(meaning actually FAST) operating systems have been written using C.
>:...
>
[stuff deleted]
>1 - emery@Dr_No.mitre.org (David Emery) wrote:
>: The "conventional" meaning of real-time is a system that must respond
>: to external events within (usually restrictive) timing constraints.
>: My workstation and text editor are not real-time in this sense,
>: because the only thing that happens when I don't get an adequate
>: response is that I get mad.  Nothing goes boom or falls out of the sky.
>
>This still does equate to "speed".  This was the point that I was trying to
>make by siting operating systems and such.  While (mostly) no physical damage
>will be done, the operating system MUST get that character out of the input
>register before the next one comes or that character will be lost.  And it
>must consistently do this for EVERY person who is logged in, or the system
>will be judged "flakey" or worse.

If you want to see the conventional meaning of "real-time" in computer
science, try looking at some books on operating systems or comparative
programming languages.

Consider the following example.  Suppose you are writing software for a
missile system.  Suppose you have a timing constraint where you must use
a backup sensor if the main sensor does not respond every 25 msec.  You
cannot express such a constraint in C without using an OS call or an
external routine.  The C language has no real-time facilities per se.
From: grover@brahmand.Eng.Sun.COM (Vinod Grover)
Newsgroups: comp.lang.ada
Subject: Re: What is "real-time"?
Date: 15 Oct 1992 16:36:21 GMT
Organization: Sun Microsystems, Mt. View, Ca.
NNTP-Posting-Host: brahmand

There is another definition of real-time that was popular at some time.  If
the time required by an operation was bounded by a constant, then the
operation was termed as a real-time operation. This is not particularly
useful for hard-real-time systems.

Vinod Grover

Newsgroups: comp.lang.ada
From: tne@world.std.com (Thomas N Erickson)
Subject: Re: Good Ada development tools on Sparc?
Organization: The World Public Access UNIX, Brookline, MA
Distribution: comp
Date: Fri, 9 Oct 1992 18:49:41 GMT

ulf@julius.c3consult.comm.se (Ulf Lagerstedt) writes:



>Since I have been unable to locate a FAQ, I'd be grateful for any advice
>or pointers to information about good SPARC-based Ada development tools. 
>(So far, I only know about the Rational Environment.) 


>Thanks!

>--
>Ulf Lagerstedt                  "When the grammar checker identifies an error,
>Communicator C3Consult           it suggests a correction and can even makes
>Stockholm, Sweden                some changes for you."
>ulf@c3consult.comm.se           Microsoft Word for Windows 2.0 User's Guide.


Ulf,

We at Alsys have support for the Sun SPARC with the features you are
looking for, including a new GUI interface for our tools.

In Sweden, you should contact:

Alsys AB
Patron Pehrs Vag 10, Box 1085
141 22 Huddinge, Stockholm

(087)46-09-20  Voice
(087)74-52-13  Fax


Tom Erickson


-- 
Tom Erickson
Alsys
tne@world.std.com
Newsgroups: comp.lang.ada
From: erwin@cvtserv1.verfahrenstechnik.uni-stuttgart.de (Erwin Dieterich)
Subject: ADA for OS/2 ??
Reply-To: erwin@cvtserv1.verfahrenstechnik.uni-stuttgart.de
Organization: ICVT Uni Stuttgart
Date: Wed, 7 Oct 1992 10:36:20 GMT

Subject says it.

I'm looking for an ADA-Compiler under OS/2, available in Germany.
Is there such a beast or am I two years to early ?

Thanks, 
 -- Erwin

---
Erwin (Bamse) Dieterich               erwin@cvt12.verfahrenstechnik.uni-stuttgart.de
University of Stuttgart (Germany)     This mail-adress is too long  !@*&%$##!   :-)
Chemical Engineering Department

Newsgroups: comp.lang.ada
From: hudson@cs.umass.edu (Rick Hudson)
Subject: Re: Ada and real-time
Reply-To: hudson@cs.umass.edu
Organization: Dept of Comp and Info Sci, Univ of Mass (Amherst)
	<1992Oct12.193624.26845@fcom.cc.utah.edu>
	<1992Oct13.153217.9754@alliant.com>
Date: Tue, 13 Oct 1992 20:51:50 GMT

>>>>> On 13 Oct 92 15:32:17 GMT, russ@alliant.com (Russell McFatter) said:

Russ> (3)  No self-imposed nondeterminism:

Russ>      Can a language be nondeterministic?  Sure it can.  Take LISP, for
Russ>      example...

Russ> 	"Whoa!  That missile flew right over our heads and this thing
Russ> 	 didn't even try to intercept it!"

Russ> 	"Bummer of a time to do a garbage collection.  Sorry 'bout your
Russ> 	 city, man."


Actually, there have been techniques for doing real time GC around since the
seventies. Most Lisp systems do not utilize these techniques due to the total
overhead required (a bounded number of extra instruction on each memory read).
The fact that all Ada systems fail to offer GC is an implementation decision.
There is nothing in the Ada language definition that would prevent implementation
of a full blown generational copy collector and I suspect this was not by
accident. There is nothing in the Lisp language definition that prevents
real time garbage collection either.

Other than this we have considerable common ground when it comes to describing
what real time means.
--

                Richard L. Hudson, Research Associate
                University Computing Services
                Lederle Graduate Research Center
                University of Massachusetts
                Amherst, MA  01003
                (413) 545-1220; Hudson@cs.umass.edu
Newsgroups: comp.lang.ada,comp.os.ms-windows.misc,comp.os.ms-windows.programmers.misc
From: root@udcps3.cps.udayton.edu
Subject: Ada Interface to Windows
Organization: The University of Dayton, Computer Science Dept., Dayton, OH
Date: Fri, 9 Oct 1992 15:17:54 GMT

I am thinking about writing a set of Ada packages that will allow
a user to create and manipulate MS Windows through Ada routine calls.

What I have in mind is to use a set of windows routines written in C and
generalize them into a set of Ada calls.

I'm looking for any information on MS Windows programming in Ada.
Can anyone direct me to any information on this topic?

Request replies posted here and mailed to:

                 bohlerml%avlab.dnet@aa.wpafb.af.mil  

Thanks,
Michael Bohler
From: griest@ajpo.sei.cmu.edu (Tom Griest)
Newsgroups: comp.lang.ada
Subject: Re: Ada and real-time
Date: 16 Oct 92 20:45:20 GMT
Organization: Ada Joint Program Office

In article <1992Oct15.163026.7899@saifr00.cfsat.honeywell.com> walls@saifr00.cfsat.honeywell.com (Gerald Walls) writes:
>In article <1992Oct15.144135.24045@sei.cmu.edu> jbg@sei.cmu.edu (John Goodenough) writes:
>>
>>By "non-deterministic tasking" do you mean the fact that it can be difficult
>>or impossible to write down a timeline for a set of Ada tasks, given
>>variations in execution times and the effect of preemption?  If so, this is
>>not, in itself, sufficient reason to conclude that Ada tasking is unsuitable
>>for embedded real-time systems.  
>>
>
>the FAA requires this in avionics software.  Ada tasking is not
>suitable for real-time avionics software.


Show me the regulation that prohibits "this".  I know of commercial
avionics software that does not have purely deterministic scheduling.
(Any software that has asynchonous interrupts probably fits into
this category.)

   Tom Griest
Newsgroups: comp.lang.ada
From: jbg@sei.cmu.edu (John Goodenough)
Subject: Re: Ada and real-time
Organization: The Software Engineering Institute
Date: Thu, 15 Oct 1992 14:41:35 GMT


In article <1992Oct14.143733.842@saifr00.cfsat.honeywell.com>,
walls@saifr00.cfsat.honeywell.com (Gerald Walls) writes: 

|> determinism is very important.  we've ditched Ada's nondeterministic
|> task and have instead implemented our own, deterministic tasking.
|> 
|> Ada's tasking is not suitable for embedded real-time systems.

By "non-deterministic tasking" do you mean the fact that it can be difficult
or impossible to write down a timeline for a set of Ada tasks, given
variations in execution times and the effect of preemption?  If so, this is
not, in itself, sufficient reason to conclude that Ada tasking is unsuitable
for embedded real-time systems.  

These issues are discussed in the paper "Real-time Scheduling and Ada" in the
April 1990 issue of COMPUTER magazine.  In essence, the paper shows how rate
monotonic theory allows you to ignore the "non-determinism" of Ada tasking by
showing whether each task will get enough compute time to meet its deadline.
The theory has been used on delivered embedded systems, so it is actually
applicable to real systems, and it is being used on real-time systems that are
using Ada tasking in its "non-deterministic" sense.

John B. Goodenough					Goodenough@sei.cmu.edu
Software Engineering Institute				412-268-6391
Newsgroups: comp.lang.ada
From: mfeldman@seas.gwu.edu (Michael Feldman)
Subject: Re: Does the LRM permit parameter passing by reference?
Organization: George Washington University
Date: Fri, 9 Oct 1992 18:12:21 GMT

In article <1992Oct9.023807.20641@beaver.cs.washington.edu> simonson@cs.washington.edu (Kevin Simonson) writes:
>
>     I was under the impression that Ada made local copies of parameter
>values when a procedure was called.  However my Verdix compiler apparently
>does calls by reference when the call is for a string value, as demonstrat-
>ed by the script file below.  Notice how the parameter "COPY" (which Ada
>won't allow code to alter inside the procedure) changes its value from the
>first "put_line" to the second.
>
>     Is it legal for Ada to allow this parameter to change in the middle of
>the procedure, or have I found a bug?
>
You've found a feature. The LRM explicitly allows _structured_ parameters
to be passed either by copy (value/result) or by reference. Scalars must
be copied.

Most compilers indeed pass arrays and records by reference; generally this
is thought to be more efficient, though there is reason to think that
the extra indirection could be more expensive than the time to copy.
Some compilers pass _small_ structures by copy and _large_ ones by
reference. Copying large structures consumes both time and space.

I recall a post a few years ago stating that this flexibility was needed
in order to allow reference passing on single processor machines, but
copying on distributed system, through task entry parameters.

IMHO, Ada has found a nice engineering compromise on the matter of
parameter passing: the abstraction (IN/OUT/IN OUT) is de-coupled from
the implementation (copy vs. reference). This is a clean break from
Pascal, which requires that non-VAR parameters be copied, no matter
how large. This means we had to teach our first-years to pass big
arrays as VAR parametrers, giving the danger of accidental modification,
in order to avoid endless copying.

Rich Pattis did a study once of Pascal texts' code for binary search,
in which much fuss was made over the log N search time, ignoring the
fact that copying the array into the search function was O(N).

Ada doesn't have this problem - we can be pretty confident that realistic
compilers will pass arrays by reference, even if they are IN parameters. 

Nice.

Mike Feldman

------------------------------------------------------------------------
Michael B. Feldman
co-chair, SIGAda Education Committee

Professor, Dept. of Electrical Engineering and Computer Science
School of Engineering and Applied Science
The George Washington University
Washington, DC 20052 USA
(202) 994-5253 (voice)
(202) 994-5296 (fax)
mfeldman@seas.gwu.edu (Internet)

"Americans wants the fruits of patience -- and they want them now."
------------------------------------------------------------------------
From: michael.hagerty@nitelog.com (Michael Hagerty) 
Newsgroups: comp.lang.ada
Subject: Public domain Snobol and Ada compilers (for SunOS Unix?)
Date: 6 Oct 92 22:50:00 GMT
Distribution: world
Organization: Nitelog BBS - Monterey, CA - 408-655-1096
Reply-To: michael.hagerty@nitelog.com (Michael Hagerty) 

to: rauscher@romulus.rutgers.edu

Yo, Rich...  You might want to contact the people at the University
of Arizona who have been working with ICON.  This is the upgrade of
SNOBOL and is, I believe, available for your system.

Regards, Mikey (michael.hagerty@nitelog.com)
 * JABBER v1.3B1 #B042 * If Shakespeare had used "vi", we'd have no plays.
From: sjs@sbphy.physics.ucsb.edu (Steve J. Schmidhauser)
Newsgroups: comp.lang.ada
Subject: NEED HELP with compiling Ada/Ed on UNIX PC
Date: 8 Oct 92 02:11:43 GMT


Greetings, brave souls with Development Sets.

I am having a bear of a time trying to get the New York University
Ada/Ed public domain Ada interpreter system to compile on my UNIX PC.
I do not have enough disk space to recompile it, and do not have enough
money to buy a hard disk upgrade, etc.  Nor can I clear off any of the
files (they are important to me; I am involved in several development
projects and such.)  Also I had MAJOR problems getting the last version
to compile, and don't know if my "hacks" can be duplicated with the new
code.

Anyway, if someone who has the resources and the disk space, would be
willing to help me with this little problem, I would be ETERNALLY
grateful.  Not only that, but I will happily release the compiled
binaries of Ada/Ed to the net in general (OSU archives, etc.) so that
others don't have to go through the hardships I (and you) did.

The code is FTP-able from the FTP server at cs.nyu.edu, in /pub/adaed
(I think).  I also have a copy of the stuff on UNIX PC floppies (in
CPIO format).  If you would like the floppies instead (both the floppies
and the shipping are "on the house"), get back to me with your postal
address.
Anyway, THANKS for the help!  Please reply to me at sjs@ucsbuxa.ucsb.edu
or sjs@sbphy.physics.ucsb.edu.
--
Steve Schmidhauser               |  INTERNET: sjs@sbphy.physics.ucsb.edu
LTA Santa Barbara City College   |  Backup: 2209schm@ucsbuxa.ucsb.edu
721 Cliff Dr, S.B.,CA 93109      |  PHONE: (805)965-0581 x2401