HDTenEightyP/NetNews huggingface dataset:
From: sakkinen@jyu.fi (Markku Sakkinen)
Subject: Re: Ada's (in)visibility in the engineering community
Organization: University of Jyvaskyla, Finland
Date: Tue, 29 Sep 1992 13:18:15 GMT

In article <1992Sep25.210409.23219@fcom.cc.utah.edu> val@news.ccutah.edu (Val Kartchner) writes:
> ...
>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.  While it may be
> ...

Please, tell us even _one_ real-time feature of C !

----------------------------------------------------------------------
Markku Sakkinen (sakkinen@jytko.jyu.fi)
       SAKKINEN@FINJYU.bitnet (alternative network address)
Department of Computer Science and Information Systems
University of Jyvaskyla (a's with umlauts)
PL 35
SF-40351 Jyvaskyla (umlauts again)
Finland
----------------------------------------------------------------------
From: erickson@atlas.cs.nps.navy.mil (David Erickson)
Newsgroups: comp.lang.ada
Subject: Re: Ada's (in)visibility in the engineering community
Date: 6 Oct 92 15:22:12 GMT
Reply-To: erickson@taurus.cs.nps.navy.mil (David Erickson)
Organization: Naval Postgraduate School, Monterey CA

In article <EMERY.92Oct5164907@Dr_No.mitre.org> emery@Dr_No.mitre.org (David Emery) writes:

>Furthermore, the BiiN operating system (which provided a System V
>interface) was itself written in Ada, with a C binding!  

I  would be interested in more details, if anyone can point me to sources
of information.  How were the C bindings implemented?  How were server
tasks implemented?

-Dave Erickson
Xref: sparky comp.lang.ada:2874 comp.databases:7076
From: readingj@nic.cerf.net (John D. Reading)
Newsgroups: comp.lang.ada,comp.databases
Subject: Need help finding Graphael / other OODBMS
Keywords: Ada, object oriented database, graphic database
Date: 5 Oct 92 15:42:01 GMT
Followup-To: comp.lang.ada
Organization: CERFnet

Sorry to bother you all, but a few years back we were briefly
in contact with an outfit called (I think) Graphael, which
marketed an object oriented graphical database management
system.  At the time we decided we didn't need their product,
but now we are more interested.  Is anybody aware of how I
can get in touch with them?  Or, in more general terms, is
anyone familiar with an object oriented, graphical DBMS that
will interface to an Ada application?

I appreciate any and all help.  Please respond by email, and
I will summarize if there is general interest.

Thanks,

John Reading
readingj@cerf.net
(818) 902-5096
-- 
"To know me is to know me"
From: bortz@CNAM.CNAM.FR
Newsgroups: comp.lang.ada
Subject: Version 2.0 of Paradise
Keywords: Unix, Paradise, sockets, system and network programming
Date: 30 Sep 92 15:34:42 GMT

The version 2.0 of the subsystem Paradise is now ready. You can retrieve it from
 cnam.cnam.fr. The most important difference with the old version is the
 parametrization threw Ada-Param to deal with differences between systems.
 Paradise should be much more portable. Here is the README:

                    WELCOME TO PARADISE

Paradise is a subsystem (a set of packages) developped to implement
 inter-processes, inter-tasks and inter-machines communication for
 Ada programs in the Unix world. This subsystem gives the user full
 access to files, pipes, sockets (both Unix and Internet), and
 pseudo-devices.

The main features of Paradise are:
- blocking IO are no longer blocking the whole Unix process, but
 are just blocking the task requesting data transfer,
- typing is much stronger than in C,
- exceptions are raised by system calls. You don't need to test
 return codes any more.

To install Paradise on your machine, read INSTALL. If your machine
 is not in the following list, read PORTING to see how you can
 adapt it.
Currently supported systems:
- Sun/Sparc with Verdix compiler
- Sun with Alsys compiler
- DECsystem with DEC compiler
- DECsystem with Alsys/Systeam compiler
- Sony/Risc with Alsys/Systeam compiler

You need only the paradise.tar.Z file. Other files with the name of
 a system/compiler are here for special purposes. See INSTALL for
 details.

Comments, bug-reports, flames and congratulations should be 
directed to:
paradise-info@cnam.cnam.fr

Paradise is available from anonymous ftp at cnam.cnam.fr 
(192.33.159.6) in pub/Ada/Paradise.

Stephane Bortzmeyer           Conservatoire National des Arts et Metiers	
bortzmeyer@cnam.cnam.fr       Laboratoire d'Informatique
                              292, rue Saint-Martin			
tel: +33 (1) 40 27 27 31      75141 Paris Cedex 03
fax: +33 (1) 40 27 27 72      France	

"C'est la nuit qu'il est beau de croire a la lumiere." E. Rostand

					
	

Newsgroups: comp.lang.ada
From: mchen@groucho.cs.psu.edu (Michael Chen)
Subject: Ada source for compression (LZW especially)?
Organization: Penn State Computer Science
Date: Thu, 1 Oct 1992 21:15:35 GMT

Posting this for a friend...


Date:    Thu, 01 Oct 92 14:31:57 EDT
From:    jnestoriak@vnet.ibm.com
Subject: Compression stuff

We at IBM don't (yet) have full internet access so I was wondering if you
could do me a favor?  Post a note on comp.lang.ada for me requesting that
if anyone has the source code to a compression program in ADA (esp LZW
compression) to send me a note of where I could find it, or better yet
to send the code in a message (if it's not too big).  Tell them to send it
directly to me at jnestoriak@vnet.ibm.com because I can't read any netnews.

Thanks

Remember, replies via e-mail should go to John and not me (I'll just pass them
on to him).

-- Mike
_____________________________________________________________________________
| Michael Chen			| From the depths of our most lucid horrors |
|				| spring our fond hopes and pure desires... |
| mchen@groucho.cs.psu.edu	| except what comes from HELL! :-) 7/23/92  |
\_______________________________\___________________________________________|
-- 
_____________________________________________________________________________
| Michael Chen			| From the depths of our most lucid horrors |
|				| spring our fond hopes and pure desires... |
| mchen@groucho.cs.psu.edu	| except what comes from HELL! :-) 7/23/92  |
From: michael.hagerty@nitelog.com (Michael Hagerty) 
Newsgroups: comp.lang.ada
Subject: Re: Ada's (in)visibility
Date: 27 Sep 92 20:48:00 GMT
Distribution: world
Organization: Nitelog BBS - Monterey, CA - 408-655-1096
Reply-To: michael.hagerty@nitelog.com (Michael Hagerty) 

In a message to ALL, KEVIN RODGERS writes:

K.                                             Back about four years ago,
K. the word was that all of our deliverable vehicle simulations for future
K. contracts would be required to be in Ada (they are currently in
K. Fortran). Several of us forward-looking regular engineers went out,
K. learned Ada, and became reasonably proficient in it.  What happens?
K. Either the gov't decides not to specify Ada for the sim (and sometimes
K. not even the flight software) or our management weasels out of it.

I've seen a similar situation (Navy/FORTRAN shop) where a number of the
software types seem eager to learn the "A" language and have gone out of
the way to take classes, etc.  Unfortunately, management is reluctant to
move to Ada, but seems very willing to fully embrace C instead...  As I
live and learn, I am continually amazed!

K. From what I've seen, the Army is the most reluctant to move to Ada.

Well, golly...  I sat at a table for dinner with Grace Hopper the week that
"green" became Ada.  Her comment was that if she had her way, she would
"scuttle it"...  I see system after system being done by or for the Navy
in C (and FORTRAN) and never hear of approved waivers.

The most coneheaded response I've heard to the question, "Why didn't you
do it in Ada, the mandated language?" was, "We had to be compatible with
X-windows, the Navy standard, and there was no requirement for Ada."  Of
course the Navy had yet (has it since then?) to select a windowing standard
of any kind.  The more I see of this, the more disheartened I become.  It
seems that all the excuses are like a**holes; everyone has one and they all
stink...

Regards, Mikey (michael.hagerty@nitelog.com)

---
Statements and opinions are mine alone -- I have no idea what my company
thinks about these issues.
---
 . JABBER v1.3.1 #.042 . Be suspicious of all native-born Esperanto speakers.
From: young@gdfwc3 (Mark Young)
Newsgroups: comp.lang.ada
Subject: Declaring Arrays of Bits (how)?
Date: 29 Sep 92 16:11:12 GMT
Distribution: comp
Organization: General Dynamics, Fort Worth Division


I am trying to declare arrays of bits in Ada.  Here's my attempt:


type Array_Range_Type is range 1..128;

type Bit_Type is (OFF, ON);
for  Bit_Type use (OFF => 0, ON => 1);
for  Bit_Type'size use 1;

type Bit_Array_Type is array (Array_Range_Type) of Bit_Type;

Bit_Array : Bit_Array_Type;


This looks right to me.  I would expect Bit_Array to be represented
as an array of 128 bits (128 contiguous bits).  This is not the case,
however.  My compiler (XDADA) is representing Bit_Array as an array
of 128 bytes.  As an added note, I have been using representation clauses
for records without any problems.  

Am I missing something?  
Is there a special representation clause for arrays that I am overlooking? 
Is my compiler at fault?

Thanks for the INPUT,
Mark Young
From: warhaug@dhmolde.no (Geir Warhaug)
Newsgroups: comp.lang.ada
Subject: How to read a character without waiting for ENTER??
Date: 3 Oct 92 06:15:51 GMT
Organization: The Internet

I have a little problem.

I want to read a character without the user needing to hit the ENTER.
Do I have to read the buffer, and if I do, how do I do that??
Please give me an example.
Thanks in advance.

Geir Warhaug
warhaug@dhmolde.no
Newsgroups: comp.lang.ada
From: emery@Dr_No.mitre.org (David Emery)
Subject: Re: Ada's (in)visibility
Organization: The Mitre Corp., Bedford, MA.
	<1992Sep30.135444.10417@titan.tsd.arlut.utexas.edu>
	<EMERY.92Sep30113104@Dr_No.mitre.org> <1992Oct1.071757.21801@lth.se>
Date: Thu, 1 Oct 1992 14:57:32 GMT

>My _guess_ is that X will be compatible with POSIX threads, if X ever
>gets threaded.  The question then is how compatible POSIX threads and
>Ada tasks are...

Once POSIX threads are an approved standard (or at least are
"stable"), I'm sure you are correct.  Right now IEEE P1003.4a is still
in ballot, and it's my understanding that they are not very close to
completion.  In the interim, I don't know what thread/concurrency
model X11R6 is/will be based on.

IEEE P1003.20 is specifically tasked with working out how Ada tasks
and POSIX Threads interact.  There'll be a meeting of this group as
part of the POSIX meetings in Utrecht, Netherlands 19-23 October 1992.

				dave
Newsgroups: comp.lang.ada
From: rauscher@romulus.rutgers.edu (Rich Rauscher)
Newsgroups: comp.lang.ada,comp.lang.misc
Subject: Public domain Snobol and Ada compilers (for SunOS Unix?)
Date: 5 Oct 92 15:56:41 GMT
Article-I.D.: romulus.Oct.5.11.56.41.1992.1226
Followup-To: comp.lang.ada
Organization: Center for Discrete Math. and Theor. Comp. Sci.


Subject says it.  If anybody knows of any available, please
send me email.
Thanks,
Rich
-- 
Rich Rauscher, Systems Analyst, Federal Reserve Board of Governors
              "In the long run, the computers will win."
rauscher@dimacs.rutgers.edu     uunet!fed!rauscher   rauscher@NJIN.bitnet
From: ae@sei.cmu.edu (Arthur Evans)
Newsgroups: comp.lang.ada
Subject: Re: converting (limited) private types?
Date: 27 Sep 92 20:07:05 GMT
Organization: Software Engineering Institute

andrewd@cs.adelaide.edu.au (Andrew Dunstan) asks about a stack of items
of type Text_IO.File_Type, which is limited private.

It would be hard to do if you are using a stack package.  However, if
you implement the stack as an array and an index (probably reasonable in
your case), just open the file right into the stack.  Leaving out a lot,
like this:

	File_Stack: array(0..File_Stack_Max) of Text_IO.File_Type;
	Current_File: integer := 0;	-- Current item in File_Stack

	...
	-- Opening intial file
	Text_IO.Open(File_Stack(Current_File), Text_IO.In_File, ...

	-- Reading the file (can be simplified with Set_Input)
	Text_IO.Get_Line(File_Stack(Current_File), ...

	-- Processing %include (or whatever)
	Current_File := Current_File + 1;
	Text_IO.Open(File_Stack(Current_File), Text_IO.In_File, ...
	...
	-- process the file
	...
	Text_IO.Close(File_Stack(Current_File));
	Current_File := Current_File - 1;

You can easily fill in the details.

Art Evans
----------------------------------------------
Arthur Evans, Jr, PhD           Ada Consultant
461 Fairview Road
Pittsburgh PA  15238-1933
412-963-0839
ae@sei.cmu.edu
From: ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe)
Newsgroups: comp.lang.ada
Subject: Re: INFO-ADA Digest V92 #299
Date: 7 Oct 92 03:07:50 GMT
Organization: Comp Sci, RMIT, Melbourne, Australia

In article <1992Oct2.104250.21814@lth.se>, dag@control.lth.se (Dag Bruck) writes:
> In <comp.lang.ada> ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe) writes:
> >Let's keep a sense of perspective here:
> >	Ada is smaller than COBOL.
	...
> >	Ada is larger than Scheme.

> Excellent advice.  How do you measure size?

Effort required to read the defining document.  The COBOL-85 standard is
physically larger than the Ada-83 LRM and I found it harder to read.  It
also appears to define more concepts.  The Scheme standard is ~50 pages,
very much in the style of the Algol 60 report, and that includes a
formal semantics which I (ahem) skipped.

> >....  If it comes to that, I am continually surprised by how
> >little C many of the C programmers I speak to know, and it's not large.
> 
> Do you mean that C is a good language (in some sense) because it is
> small to start with and you don't even have to know much of that to
> get useful work done?

I didn't mean to say anthing at all about good/bad.  I will say that very
little of ANSI C is "bloat".  However, there _are_ rough edges to watch
out for.  I have in mind things like which arguments of what built in
functions are size_t rather than int, and why; what exactly are the
differences between pointers and arrays; why it's a bad idea to put
function declarations (not definitions, that's not legal) inside blocks
even though it's legal; what NULL is and exactly when it needs a cast;
when p[-1] is legal; how to do arithmetic on times; when you need ptrdiff_t;
I could go on and on.  I've never written down a full list, but most of
the rough edges don't exist in Ada.  (How many Ada programmers would think
of multidimensional dynamically allocated arrays as _hard_?)
Newsgroups: comp.lang.ada
From: dlc@ddsdx2.jhuapl.edu (Dave Collard x7468)
Subject: Re: Declaring Arrays of Bits (how)?
Organization: Johns Hopkins University
Distribution: comp
Date: Tue, 29 Sep 92 16:54:39 GMT

In <YOUNG.92Sep29101112@kuwait.gdfwc3> young@gdfwc3 (Mark Young) writes:


>I am trying to declare arrays of bits in Ada.  Here's my attempt:

>type Array_Range_Type is range 1..128;

>type Bit_Type is (OFF, ON);
>for  Bit_Type use (OFF => 0, ON => 1);
>for  Bit_Type'size use 1;

>type Bit_Array_Type is array (Array_Range_Type) of Bit_Type;
-- Add this line:
pragma Pack(Bit_Array_Type);
-- and you will find that Bit_Array_Type objects will be stored as 
-- you originally expected.  The compiler chose the most efficient
-- implementation of Bit_Array_Type, as it is allowed to do.  
-- However, see below for a better way to do what you are probably
-- really trying to do.

>Bit_Array : Bit_Array_Type;


-- I believe that you really want a packed array of boolean which
-- is how I often represent bits:

type Array_Range_Type is range 1..128;
type Bit_Array_Type is array(Array_Range_Type) of Boolean;
pragma pack(Bit_Array);

-- This makes it much easier to do logical bitwise operations on
-- the resulting data structure, which is usually why you want
-- arrays of bits in the first place.  Note that the packed boolean
-- array is guaranteed to take up exactly 1 bit per boolean by
-- some AI or other.


--Thor
dlc@ddsdx2.jhuapl.edu
collard@capsrv.jhuapl.edu

Newsgroups: comp.lang.ada
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: 5 Oct 92 21:54:33 GMT

In article <1992Oct5.195015.128@fcom.cc.utah.edu> val@news.ccutah.edu (Val Kartchner) writes:
>sakkinen@jyu.fi (Markku Sakkinen) writes:
>: Please, tell us even _one_ real-time feature of C !
>
[stuff deleted]
>To answer this question, we must first understand what is meant by "real-time"
>as used in the English language.
>
[Definitions of "real-time" in American Heritage Dictionary, Webster's II
 Riverside Dictionary, and Collins English Dictionary" deleted]
[more stuff deleted]
>However, contrary to common English usage, the same report says that Ada has
>a better real-time score.  This apparent contradiction can most easily be
>resolved by concluding that Ada has a definition for "real-time" which differs
>from common English usage.

Do you also rely on English dictionaries and "common English usage" for the
meanings of "object-oriented", "inheritance", and "dynamic binding"?

[lots of stuff deleted on the widespread use of C]
>We can all point to instances of inferior products being commercial successes
>and superior products dying....
>While commercial success does not always follow technical
>superiority, there is a high degree of correlation.  But remember, commercial
>success does follow the principle on which the United States of America was
>founded on: freedom of choice.

Long live COBOL and FORTRAN.  :)
Newsgroups: comp.lang.ada
From: anders@tfd.chalmers.se (Anders Karlsson)
Newsgroups: comp.lang.ada
Subject: Ada/Ed for Atari ?
Date: 7 Oct 92 00:54:15 GMT
Distribution: comp.lang.ada
Organization: Chalmers University of Technology, Gothenbourg, Sweden


In the FAQ it says that Ada/Ed is now available for the Atari.

My simple question is: Where can I find this version of Ada/Ed ?

Anders

--
---                                                                        ---
   Anders Karlsson     Thermo and Fluid Dynamics     anders@tfd.chalmers.se
---                                                                        ---
From: dburr@sbphy.physics.ucsb.edu (Donald Burr)
Newsgroups: comp.lang.ada
Subject: Where to get Ada/Ed (Unix source code)?
Date: 3 Oct 92 03:10:47 GMT

Does anyone know where I can FTP the "latest and greatest" Ada/Ed source
code for Unix systems?  I would like to take a crack at getting this
installed on my machine.

Please reply via email to dburr@sbphy.physics.ucsb.edu.  Thanks.

--
: Donald Burr, Coordinator          : dburr@sbphy.physics.ucsb.edu   INTERNET :
: Santa Barbara Area Network(SBANET): dburr@gnu.ai.mit.edu (Backup)  ======== :
: Santa Barbara, CA  USA            : DonaldBurr@aol.com (AOL gateway)        :
: uunet!dsc.com!dschub!sbanet!dburr : America OnLine: DonaldBurr              :
From: crispen@efftoo.boeing.com (crispen)
Newsgroups: comp.lang.ada
Subject: Re: Using Global Variables
Date: 28 Sep 92 20:56:25 GMT
Article-I.D.: efftoo.9209282056.AA12821
Organization: The Internet

Victor Giddings and Lee Marden share some guilty secrets about using
shared memory.  Here's one of mine.  On a multi-board VME chassis
running VxWorks/VADSWorks, we changed the boot configuration file
so that the sysMemTop function in VxWorks thought each VME board
had 64K memory less than it actually had.  This top 64K was used
to pass data back and forth between the boards:

	for Control_Block use at System.Physical_Address (xxxxx);

It worked great, especially when the system crashed, because the
ROM monitor had the ability (under most kinds of crashes) to display
memory in a hex dump even when the OS and all the application
programs were thoroughly hosed.  We knew that 0x3f0004 contained
the service request, etc.

Of course, we had a pretty firm control: one writer, one reader for
a field, and the writer interrupted the reader when it wanted the
reader to read the field.

I really enjoyed this.  It was like the old days in microprocessors,
where you knew were everything was and you treated machines like
machines.  Those were the days...
+-------------------------------+--------------------------------------+
| Bob Crispen                   |   The owls are not what they seem    |
| crispen@foxy.boeing.com       +--------------------------------------+
| (205) 461-3296                |Opinions expressed here are mine alone|
+-------------------------------+--------------------------------------+
Newsgroups: comp.lang.ada
From: dag@control.lth.se (Dag Bruck)
Subject: Re: Ada's (in)visibility in the engineering community
Organization: Department of Automatic Control, Lund, Sweden
Date: Wed, 30 Sep 1992 13:11:46 GMT

In <comp.lang.ada> mccall@mksol.dseg.ti.com (fred j mccall 575-3539) writes:
>
>I'm curious; have
>you had large numbers of people from "the C++ community" denying that
>any parts of C++ were inspired by Ada?

I think that to some extent it depends on how precise you want to be.
I usually simplify matters and tell people that exception handling in
C++ is "just like Ada."  There are of course important differences,
and I know them.  If you want to be more precise you must also mention
influences from other languages, e.g., Clu, Mesa, ML and PL/I.  In
that situation it is easy to answer "absolutely not" if someone asks
if EH in C++ is like EH in Ada.

The C++ community as I know it is not afraid to acknowledge influences
from other languages.  People sometimes make rude jokes about Ada, but
that is not relevant.

In my experience, the C++ community is not very interested in Ada,
which probably is a pity.  I don't really understand why some people
in the Ada community spend so much time comparing with C++; isn't Ada
good enough in itself?  Does it really matter much who's influenced
who?  I think it smells of envy because C++ is a greater commercial
success.

		Dag Bruck
		Member of the C++ community