HDTenEightyP/NetNews huggingface dataset:
From: obry@flash.bellcore.com (Pascal Obry)
Subject: Re: Ada's (in)visibility in the engineering community
Organization: /u/obry/.organization
Date: 14 Sep 92 09:40:32


I like very much Ada. And I tried to convince in 2 differents researh center to
use it, but I failled ...

Why ? 

because they don't want to learn a new language, 

because they don't or can't afford an Ada compiler,

because they don't see any reason to buy an (expensive) Ada compiler whereas
they have a free C compiler in any of their computer, here GNAT will do
something very good.

because they think Ada is a too complex language and too big. Here they make
the big mistake to mix up language and compiler. My point is that it is not
because the compiler is hard to make that the language is difficult. And in
this case to make a compiler is difficult because the language is *powerfull*
not because it is complex to use ..

because they don't like to think a lot about the conception of their projects.
they want to make it without conception (OO or others ...) and C for this is
very good because you can do every thing you want, there is alway (a bad) way
to reach your goal.

because they didn't know Ada at all so they chose C++ (yes, they think it's the
good old C plus something so it should be good too ... bad mistake no !)

------------------------

Also all these guys sometime use a kind of *meta* language to describe an 
algorithm ... And you know what : this meta language is something very
close from Ada ...

So I tried and I failled ... But I can't even understand why !!
They have no good reasons to don't use Ada, they have no good reason to choose
C++ but they chose it ...

-------------------------

I learn Ada by myself. I like very much to learn and compare different 
languages, today I know C, C++, Eiffel, Ada, (plus a lot of other languages
like Basic, Fortran, Cobol). But after all, I definitly like very much Ada ...

Like Edmond Schonberg said in is comparison Ada 9x and C++ :

" Although the C++ community would never state it so baldly, it appears clear
to us that C++ is to some extent a reaction to Ada. By extending C with some
of the best ideas of Ada, C++ did in some measure catch up to Ada "

I would like to add that I know some guys that didn't like Ada and its
strong typing and the nested procedures, but now they enjoy this into C++.
So why waiting for C++ V3.9 beta version alpha testing 3.4 ... Use Ada
rigth now, it's a normed and validated language with all these features and
a lot of more ...


Pascal.
--

-------------------------------------------------------------------------------
--  Pascal OBRY								     --
--  Room 2D-337				e_mail : obry@bellcore.com  	     --
--  Bellcore								     --
--  445 South Street			voice : 1 - 201 829 4039	     --
--  Post Office Box 1910						     --
--  Morristown, New Jersey 07962-1910					     --
-------------------------------------------------------------------------------

  `` inheritance is surely a good answer, but who knows the question ? ''
From: dik@cwi.nl (Dik T. Winter)
Newsgroups: comp.lang.ada
Subject: Re: tgrindef for ada? --- SUMMARY
Date: 8 Sep 92 14:15:40 GMT
Organization: CWI, Amsterdam

In article <1992Sep08.112138.18146@rz.uni-jena.de> mwj@rz.uni-jena.de (Johannes Waldmann) writes:
 > which works prefectly well. Furthermore, Alex Blakemore (alex@cs.umd.edu) said:
 > 
Sorry, it works, but not perfectly well.  It does not distinguish between
the attribute 'digits' and the reserved word 'digits'.  (It puts reserved
words in bold, attributes not.  But it will put the attribute 'digits in
bold.)
-- 
dik t. winter, cwi, kruislaan 413, 1098 sj  amsterdam, nederland
home: bovenover 215, 1025 jn  amsterdam, nederland
dik@cwi.nl
Newsgroups: comp.lang.ada
From: eachus@Dr_No.mitre.org (Robert I. Eachus)
Subject: Re: MI - clutching at straws
Organization: The Mitre Corp., Bedford, MA.
Date: Tue, 8 Sep 1992 18:50:21 GMT

In article <1992Sep5.065504.18997@sei.cmu.edu> goodsenj@ajpo.sei.cmu.edu (John Goodsen) writes:

   >>A program which has objects which are simultanously in lists and trees, 
   >>and uses MI to manage both structures is a mess.  Such a program can be 
   >>created and made to work, but the list primitives will have to be aware 
   >>of the tree primitives and vice-versa.

   > It's not very persuading to point out a poor design and then state 
   > that the technology was the fault.

   I think you are agreeing with me, but the quote out of context
seems to say something I didn't intend...

   A design which contains objects which are simultaneously in lists
and trees is not inherently a bad design.  But if you need to do it,
the programmer needs either to develop a set of higher level
abstractions or pay attention to details when an object is say removed
from a list.  (If the object is also an interior node in the tree, do
you have to delete it from the tree first, or just remember its
children and reinsert them? Is it legal to have objects that are in a
list but not in a tree, or vice-versa? And so on.)  It can be done,
BUT if list and tree primitives are separately inherited the
programmer has to do most of the work.  A much better approach would
be to use single inheritance from a tree type, and extend it with list
primitives which are sensitive to the tree structure.  The progammer
must still answer the same questions, but only in one place--the
definition of the list type.

     So what I was really trying to say was that in this example it is
dificult to compare relative advantages and disadvantages of different
MI approaches, since any SI approach is so much cleaner.
--

					Robert I. Eachus

with STANDARD_DISCLAIMER;
use  STANDARD_DISCLAIMER;
function MESSAGE (TEXT: in CLEVER_IDEAS) return BETTER_IDEAS is...
From: mgeorgy@vmsclst1.sc.csupomona.edu
Newsgroups: comp.lang.ada
Subject: test
Date: 7 Sep 92 05:13:05 GMT
Organization: Computer Science Computational Systems
Nntp-Posting-User: cvadrshe

sorry just testing
Newsgroups: comp.lang.ada
From: agnew@ast.saic.com (Robert Allen Agnew)
Subject: Re: Lex and Yacc for Ada
Organization: SAIC
Date: Fri, 4 Sep 1992 21:08:24 GMT

dymm@cards.com (David Dymm) writes:

>Does anyone know where I can get versions of lex and yacc for
>Ada?  I have versions for C, but in my organization, I am
>requried to write code in Ada, not C.
 
 Yes, the machine is leige.ics.uci.edu at 128.195.1.5  
 The directory is pub/irus. Change mode to binary and download 
 aflex-ayacc_1.1c.tar.Z


Newsgroups: comp.lang.ada
From: willett@cbnewsl.cb.att.com (david.c.willett)
Subject: Re: Play 20K expressions again, Sam
Organization: AT&T Bell Laboratories
Date: Wed, 9 Sep 1992 20:24:58 GMT

From article <1992Sep9.180517.20788@inmet.camb.inmet.com>, by arra@orb.camb.inmet.com (Arra Avakian):
> In article <1992Sep9.161353.5418@seas.gwu.edu> mfeldman@seas.gwu.edu (Michael Feldman) writes:
> 
>>A nice consequence of compiler houses writing their stuff in Ada is that
>>the developers really have to know Ada! I believe that will help them
>>better to understand the kinds of programs their customers will write.
>>...
> 
> Perhaps even more significant, if the developers bootstrap (compile their
> compiler using their compiler), then you know that their compiler has
> successfully compiled a fairly large and complex application program,
> increasing the liklihood YOUR program will compile and execute without problems.
> (As has been mentioned here before, the ACVC does not serve this purpose!)
> 
> Real world test suites are critical to compiler quality, no matter the 
> language it compiles or the its implementation language.
> Boostrapping puts a real world test case in the hands of the compiler developer,
> with a very desirable impact on its quality.

The second paragraph isn't necessarily true.  While a compiler is clearly a
"large & complex" program, it is doing a simple, straightforward job.  It
may or may not use the features that you are trying to use.  I'll concede
that "bootstraping" is impressive, but not as much so as compiling a
varied suite of "typical" application programs.  Defining "typical" is 
what targets the compiler.  A vendor trying to service the avionics market
should put together a suite of "typical" avionics programs.  One going after
financial markets should use a suite of financial programs, etc.


-- 
Dave Willett          AT&T Federal Systems Advanced Technologies
attmail!dwillett      (AT&T FSAT)

A dog is a dog until he is facing you.  Then he is *MISTER* dog!
From: mgeorgy@vmsclst1.sc.csupomona.edu
Newsgroups: comp.lang.ada
Subject: Re: Detecting EOL with SEQUENTIAL_IO!!!!!!!
Date: 7 Sep 92 05:10:59 GMT
Organization: Computer Science Computational Systems
Nntp-Posting-User: cvadrshe

I appologize, I did not make my self clear enough.  Basiclly I am trying to
read an image file that can very in size.  Because of the type of the
information in the file I am using SEQUENTIAL_IO.  The problem is that I need
to write the file again hopefully in the same format as the original (ie I read
a 512 X 512 file I write a 512 x 512 file not, 262144 byte line).  So far when
I write a dummy read program (read one byte write one byte) the system has been
recognizing the LF at the end of the 512 stream and transfers it to the new
file.  The other problem is that I don't want to limit my program by always
having the max array size defined (512 X 512), I would like it to very with
each image read!!!

Sorry about the confusion,
Any additional help greatly appreciated!!!
Matt Georgy
California State Polytechnic State University, Pomona  -- Computer Science
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+When It Absolutely, Positively, Has To Be Taken Out Overnight!!!+
+                                                                +
+                                           -- Team Stealth      +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Newsgroups: comp.lang.ada
From: jldh@sei.cmu.edu (Jorge Luis Diaz-Herrera)
Subject: Re: AI and Ada (Was: Multiple Inheritance -- the last post?)
Organization: The Software Engineering Institute
Date: Tue, 8 Sep 1992 19:56:50 GMT


In article <59851@mimsy.umd.edu>, holmes@cs.umd.edu (Holmes S. Liao) writes:
|> 
|> Oh, speaking of knowledge representation, I heard some (industrial
|> and academic) folks talked about using Ada9X as an AI language.
|> What do you think? (Don't ask me what AI is, though.)
|> 
|> //hs

For six years I've run a small, high-quality conference on AI and Ada (AIDA)
and recently formed a WG for AI under SIGAda.  
You could obtain copies of the past six AIDA conference proceedings from:
	Attn: Mary Lou Kiell
	George Mason University
	Dept. of Computer Science
	Fairfax VA 22030-4444
	(703) 993-1530

Results from a survey conducted last year and a report from the AIWG summer'92
workshop in Seatle will appear in Ada Letters. I also wrote an extended
article on the subject for the encyclopedia of computer science (in print).

Briefly, Ada83 satisfies most "special" AI programming requirements, and
although a complete solution to the problems is still lacking, Ada9X promises
to be an excellent software engineering (concurrent) language strongly
supporting many typical AI programming paradigms (such as, functional
programming, logic programming, frames, and, of course, "programs as data",
not to mention object-oriented technology).

Designers of these systems face similar problems than traditional
real-time engineers. Simply put: not to engineer embedded intelligent systems
in Ada would be more costly, unreliable, would render systems which are less
maintainable, and perhaps a mistake. The technology is there, but we need to  
spread the word (I hope some AI developers are reading).


For additional information, please do not hesitate to contact me.

jld-h
--..--
p.s.: by the way, studies have shown that Ada is several times more efficient
than traditional interpreted AI languages (just in case you are worried about
efficiency considerations).
From: bortz@CNAM.CNAM.FR
Newsgroups: comp.lang.ada
Subject: Re: Play 20K expressions again, Sam
Date: 8 Sep 92 07:07:58 GMT
Organization: cnam

In article <9192@verdix.verdix.com>, brucej@verdix.com (Bruce Jones) writes:
... 
> This is to announce to our patient customers that the "damn Verdix bug"
> has been fixed.  The limit of "20K expressions" (actually "22000 `logical
> registers') has been changed to a limit of 0x40000000.  A nice round number,
                                             ^^^^^^^^^^
                                             You mean 16#40000000# ?

Sorry, could'nt resist :-)

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

					
	

-------------

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: obry@flash.bellcore.com (Pascal Obry)
Subject: Re: Ada's (in)visibility in the engineering community
Organization: /u/obry/.organization
	<OBRY.92Sep14094032@cheesesteak.flash.bellcore.com>
	<1992Sep14.151346.5563@lth.se>
Date: 14 Sep 92 13:34:19


>>Like Edmond Schonberg said in is comparison Ada 9x and C++ :
>>
>>" Although the C++ community would never state it so baldly, it appears clear
>>to us that C++ is to some extent a reaction to Ada. By extending C with some
>>of the best ideas of Ada, C++ did in some measure catch up to Ada "

>Ed Schonberg also said in public that he thinks C++ is a more powerful
>language than current Ada, and less powerful than Ada 9X.  (Stockholm,
>earlier this year).

Yes, I agree too. This was said about Ada 9x and C++ .

--

-------------------------------------------------------------------------------
--  Pascal OBRY								     --
--  Room 2D-337				e_mail : obry@bellcore.com  	     --
--  Bellcore								     --
--  445 South Street			voice : 1 - 201 829 4039	     --
--  Post Office Box 1910						     --
--  Morristown, New Jersey 07962-1910					     --
-------------------------------------------------------------------------------

  `` inheritance is surely a good answer, but who knows the question ? ''

Newsgroups: comp.lang.ada
From: brandon@evb.com (Brandon Goldfedder)
Subject: Re: GRACE information wanted
Organization: EVB Software Engineering, Inc.
Date: Tue, 15 Sep 1992 15:42:54 GMT

GRACE is a library of production-ready reusable Ada software components,
provided in source code form.  These components were developed by EVB
Software Engineering.  GRACE stands for Generic Reusable Ada Components
for Engineering.  These components consist of 23 families of abstractions (such
as Stack, Doubly-Linked-List, B-Tree, Binary_Search_Tree, etc.) in multiple
forms.  The forms address time and space issues.  For example, switching from
a Bounded_Stack designed to run in a sequential environment (no tasking) to
an Unbounded_Stack designed to run in a multi-processor tasking environment can
be done by changing a few lines of code.  This allows an implementation to 
choose the proper form of the abstraction to address current needs allowing
future requirements to be met.

For more information on GRACE, contact jenny@evb.com 
-- 
The basic idea behind malls is that they are more convenient than
cities.  Cities contain streets, which are dangerous and crowded and
difficult to park in.  Malls, on the other hand, have parking lots,
which are also dangerous and crowded and difficult to park in, but --
From: cobarruvias@asd2.jsc.nasa.gov
Newsgroups: comp.lang.ada
Subject: GRACE information wanted
Date: 14 Sep 1992 21:04:46 GMT
Distribution: usa
Organization: NASA/JSC

Does anyone have any information on a product called GRACE? I believe it stands
for Graphical Reuasable Ada Components E?????.

Any info would be appreciated!


*************************************************************************
John R. Cobarruvias	                      Oiler Fan
NASA/JSC 	                              Aggie '78
(713)-483-9357	                          Boxing Fanatic!
	
Newsgroups: comp.lang.ada
From: spray@convex.com (Rob Spray)
Subject: Re: Ada for Small Processors
Organization: CONVEX Computer Corporation, Richardson, Tx., USA
Date: Tue, 8 Sep 1992 18:31:37 GMT
X-Disclaimer: This message was written by a user at CONVEX Computer
              Corp. The opinions expressed are those of the user and
              not necessarily those of CONVEX.

In <EACHUS.92Sep8121403@Dr_No.mitre.org> eachus@Dr_No.mitre.org (Robert I. Eachus) writes:

>In article <spray.715537475@convex.convex.com> spray@convex.com (Rob Spray) writes:

>   > A project I am familiar with got a waiver to write a few hundred
>   > line C program for an Intel 8031.

>   Was this an Air Force program? If so, what you got was almost
>certainly an exception not a waiver, but that's a different issue.

Well, I saw a piece of paper with the requisite emblems on it
and I thought it said waiver, but it's been a while since I was
in that game.  Now you've brought it up, Bob, what is the difference?

>    But in reality, no one is really pushing for the use of Ada on
>small processors.  If the processor, and the code, are really small,
>then hardware availability down the road is a much more important
>issue than software maintenance costs.

Agreed.  The 8031 ran a control panel and talked to a 
much larger machine that did use Ada.  The cost of switching to
an Ada-capable processor with all the attendant support chips etc, 
would have blown the cost (and size and power and weight!) of the box 
through the roof.  And that was without adding the cost for
all the support software (cross-compilers, etc) since that was
al ready available.

Sanity prevailed.

--Rob  spray@convex.com
From: gt1827a@prism.gatech.EDU (david daniell)
Newsgroups: comp.lang.ada
Subject: Debugging tools for tasking
Date: 9 Sep 92 20:30:59 GMT
Followup-To: gt1827a@hydra.gatech.edu
Organization: Georgia Institute of Technology

Does anyone out there know of any good symbolic/interactive dubugging tools
that can properly represent tasking?  In other words, a debugger that can
actually show simultaneous tasks and allow debugging in separate tasks of 
the same program, all at once.  This is asking alot, I know. 

I've used AdaProbe, the debugging tool that comes with Alsys Ada, and I'm
fairly pleased with it, except for its ability to debug multiple tasks.  If
anyone knows how I could better use AdaProbe for tasks, that would be great,
also.

-- David

-- 
David Daniell
Georgia Institute of Technology, Atlanta Georgia, 30332
uucp:	  ...!{decvax,hplabs,ncar,purdue,rutgers}!gatech!prism!gt1827a
Internet: gt1827a@prism.gatech.edu
From: hannahp@topaz.ucq.edu.au
Newsgroups: comp.lang.ada
Subject: Ada software sites.
Date: 9 Sep 92 21:47:02 AET
Organization: University of Central Queensland, Australia


I was wondering if anyone could point me to any ftp sites (or anything else)
where there are Ada packages ready to grab and use?

I would be very grateful for any information.


Thanks!
Paul Hannah
Newsgroups: comp.lang.ada
From: rob@saturn.cs.swin.OZ.AU (Rob Allen)
Newsgroups: comp.lang.ada
Subject: Re: Generics?
Date: 9 Sep 92 01:34:35 GMT

tp923021@jarrah.canberra.edu.au (Ben Elliston) writes:
>I've since moved onto making an array a generic type (such as this):
>GENERIC
>Type Index IS (<>);
>[..]
>Type Stack_Array IS Array(Index) of Character;

>Type Stack_Type IS RECORD
>  Data_Store: Stack_Array;
>  Pointer: Natural;
>END RECORD;

>As it stands now, it seems that since the "pointer" variable (which
>indicates the current "highwater" mark of the array) is a natural, that
>Ada won't allow a natural to access an array indexed by some unknown
>(generic) type.
>For example, if the array was instantiated using a subtype of naturals
>(0 .. 100), allowing a natural to access elements of the array could
>lead to errors (of course, stack.data_store(103) would cause problems).
>Basically, I need to be able to "look at" any element in the array
>regardless of how large an array is defined in the given procedure using
>this package.
>I'm not too familiar with generics, and if someone could shed some light
>on this, I would really appreciate it.
>------------------------------------------------------------------------------
Why not declare Pointer to be of type Index ?  You can use it directly as
a subscript, initiallize it to  Index'first  and check for full against
Index'last.  However if the store is allowed to be logically empty then
there is a classic problem: it is illegal to initiallise Pointer to the 
item before the first [Index'pred(Index'first)].  The easiest solution is
to waste the first array element.
If however you decide to keep Pointer as a Natural where 1 corresponds to
the first element then always use it as 
  X.Data_Store(Index'val(X.Pointer - 1 + Pos_1st))
where
  Pos_1st : constant := Index'pos(Index'first);
is to account for the likelihood that the actual Index is an arbitrary
subtype of a discrete type.  Using this approach the 'full' test is
X.Pointer = Index'length
Though none of the above code has been checked, I hope that helps.  rob
-- 
+---------------------------------------------------------------------+
| Robert K Allen                     email: rob@saturn.cs.swin.oz.au  |
| Computer Science,                  snail: PO Box 218, Hawthorn,     |
| Swinburne University of Technology,       VIC 3122 Australia        |
Newsgroups: comp.lang.ada
From: mwj@rz.uni-jena.de (Johannes Waldmann)
Subject: tgrindef for ada?
Organization: University Jena, Germany
Date: Sun, 06 Sep 1992 16:08:38 GMT

Is there a tgrindef for Ada?
Please e-mail, since I'm not reading this list regularily.

Thanks, Johannes Waldmann.

mwj@hpux.rz.uni-jena.de -- currently: jw24@tower.york.ac.uk
From: arra@orb.camb.inmet.com (Arra Avakian)
Newsgroups: comp.lang.ada
Subject: Re: Play 20K expressions again, Sam
Date: 9 Sep 92 18:05:17 GMT
Organization: Intermetrics, Inc.

In article <1992Sep9.161353.5418@seas.gwu.edu> mfeldman@seas.gwu.edu (Michael Feldman) writes:

>A nice consequence of compiler houses writing their stuff in Ada is that
>the developers really have to know Ada! I believe that will help them
>better to understand the kinds of programs their customers will write.
>...

Perhaps even more significant, if the developers bootstrap (compile their
compiler using their compiler), then you know that their compiler has
successfully compiled a fairly large and complex application program,
increasing the liklihood YOUR program will compile and execute without problems.
(As has been mentioned here before, the ACVC does not serve this purpose!)

Real world test suites are critical to compiler quality, no matter the 
language it compiles or the its implementation language.
Boostrapping puts a real world test case in the hands of the compiler developer,
with a very desirable impact on its quality.
Newsgroups: comp.lang.ada