HDTenEightyP/NetNews huggingface dataset:
From: emery@Dr_No.mitre.org (David Emery)
Subject: Re: Review of "Ada & C++: A Business Case Analysis
Organization: The Mitre Corp., Bedford, MA.
	<1992Jul29.074434.21817@lmpsbbs.comm.mot.com> <2408@nic.cerf.net>
	<1992Jul30.084243.1137@lmpsbbs.comm.mot.com>
	<1992Jul30.155950.10725@mksol.dseg.ti.com>
Distribution: usa
Date: Thu, 30 Jul 1992 19:37:58 GMT

Some people have found that the Ada tasking model does not match their
needs based on their way of doing real-time concurrent programming.
For many distributed systems (with and without stringent real-time
coordination), the Ada tasking model works just fine.

Ada 9X will provide additional data oriented synchronization alternatives
to rendezvous (which is procedural-oriented).  But, Ada83's rendezvous
is a classic RPC paradigm, and RPC's are very widely used in
distributed systems (if not real-time systems).  

The problem that many people seem to have with Ada tasking is that it
doesn't match their view of the their problem.  I'm not convinced that
they're trying to force their particular approach to their problem
onto the language as a whole.  

In retrospect, some parts of Ada tasking proved to be less useful than
expected.  The Ada mapping of interrupt to task entries, and the
associated syntax for this, is one example of a language mechanism
that hasn't been real useful.  Another part of tasking that cost both
implementation time and runtime, with limited utility, is task
termination.  

But, the basic notion of tasking, that of concurrent units of work, is
a very close mapping to other similar abstractions, most notably the
threads work now ongoing for C in POSIX.  POSIX Threads provides
different synchronization facilities than the rendezvous (and they
look a lot more like 9X protected objects), but the basic model is the
same.  

As I've said before, Ada tasking provides a very useful model for
distributed/parallel computation.  It's been a lot of fun watching the
C community discover things like deadlocks, race conditions, etc.
Part of the fun comes in listening to them try to describe something
in C/Threads/Mutexes/Condition Variables/etc that you can describe to
the average Ada programmer with 5 lines of Ada.  (e.g.  "A Deadlock
occurs when a task indirectly tries to call one of its own entries."
Try describing a similar condition using Mutexes and Condition
Variables!) 

				dave
From: spray@convex.com (Rob Spray)
Newsgroups: comp.lang.ada
Subject: Re: Style Guide "Enforcers: (was Re: Question of style)
Date: 23 Jul 92 21:07:18 GMT
Organization: CONVEX Computer Corporation, Richardson, Tx., USA
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 <3070001@mothra.rose.hp.com> tom@mothra.rose.hp.com (Thomas Vachuska) writes:

>Hmmm.... pretty printers are fine and dandy, but I would tend to think that
>interactive (or incremental) formating, would be the thing to go after -
>as in GNU Emacs Ada mode.  What do you think?

Well, I think pretty printers have their place.  When you check 
a file out of the CM system, it can be piped through  the pretty 
printer with _your_ style preferences.

When something gets checked back in, it's reconverted to the 
"standard" style in the CM system, which could be the style
as delivered or maybe a semi-compressed form, e.g. all left
justified, with no indentation - the compilers don't care.

This scheme obviates the "Style Wars" that waste a lot of time.

--Rob   spray@convex.com

Disclaimer: I work for a company that sells hardware!  B-)
Newsgroups: comp.lang.ada
From: dn1l@.ist.ucf.edu (Dale Newfield)
Subject: Re: Object Oriented Ada Preprocessors
Organization: VSL, IST, UCF, Orlando
Date: Thu, 30 Jul 1992 16:24:13 GMT

In article <1992Jul30.123114.4907@news.uni-stuttgart.de> ucaa2385@ruscvx.rus.uni-stuttgart.de (Peter Hermann) writes:
>Ada9x will provide saturated features to fully support
>good programing practices.
>Ada9x even provides single inheritance for those,
>who still believe that object oriented programing would need it.
>
>Peter Hermann


This doesn't help.
Ada9x wont be around untijl Fall 93 at least.
We need Obj. Oriented Ada now.
The only elegant possibility right now is the use of a preprocessor.
I have done lots of research on them, but most of what I found are written by
the authors of the preprocessors, so I have no objective numbers to go by.
From what I have been able to tell, DRAGOON seems the most ideal.
What I'm looking for includes 2 things.
--I am looking for people that have used these products before.
--I am looking for the products.
(I haven't been able to track these people down in Italy, France, London, ...)

Dale Newfield
dn1l@ist.ucf.edu
(P.S.  Sorry for the double post before... (I hate this interface.) )
From: bruniau@cenatls.cena.dgac.fr (Christophe Bruniau)
Newsgroups: comp.lang.ada
Subject: Re: Ada tasking rules and AST's...
Date: 27 Jul 92 09:12:19 GMT
Organization: Centre d'Etudes de la Navigation Aerienne
Originator: bruniau@piano


In article <1992Jul22.194130.10544@europa.asd.contel.com>, king@ssvax.gte.com (Larry King) writes:
|> 	We are issueing VMS system calls from Ada.  These system calls
|> have associated AST's which I have defined and have gotten to work
|> correctly.  My question is how can I get Ada to do a rescheduling of the
|> tasks to get this new entry to run.  There is one process that takes
|> some amount of time but if the system call has finished we would like
|> the AST entry to run before this task normally finishes.  Currently we 
|> issue a delay statement for the time
|> DURATION'SMALL but this causes us to lose 10 milliseconds of time just
|> to do the delay.  It does cause VAX Ada to run the AST entry but we would like
|> to avoid losing the 10 milliseconds if possible.  Does VAX Ada (or any
|> Ada for that matter) allow you to force an execution of the next entry on 
|> the queue before the current task has completely finished?  I know the
|> question is vague but I hope I am giving enough for someone to give me a
|> reply.  Thanks in advance...
|> 
|> --
|> Larry King
|> GTE Government Systems, Needham, MA    		(617) 455-3384 
|> E-Mail : king%ssvax.dnet@get.com

I think the best way to do this is to assign a higher priority to the
task which handles the AST (this is coherent in that case because the task
handles system interrupts). When the AST is issued, the executive should
do a rescheduling, so the AST handling task would execute before the previous
"current" one.
This mechanism is valid only in the case of a preemptive executive (If my memory
doesn't fail, this is the case of DEC-Ada, and it is enforced by Ada rules).
This will prevent you from time wasting using delays, or CPU consuming using
busy waiting (select ... else ...).
Another way to help this mechanism work is to enable time-slicing, but it
involves overhead and may cause you some tuning problems.


Christophe BRUNIAU   CENA Toulouse
(+33) 62 25 95 56.   bruniau@cenatls.cena.dgac.fr
Newsgroups: comp.lang.ada
Subject: REQUEST FOR ADA COMPILER CODE
Supersedes: <92211.114343U53474@uicvm.uic.edu>
Organization: University of Illinois at Chicago
Date: Wednesday, 29 Jul 1992 13:46:35 CDT
From: <U53474@uicvm.uic.edu>

   Hi!! I'm interested in obtaining the source code for an ada compiler
 in 'C'  and the ftp site locations for ada compilers.

Anyone with information please mail to :
                      U53474@uicvm.uic.edu
orjakka@uicbert.uic.edu
Newsgroups: comp.lang.ada
From: mfeldman@seas.gwu.edu (Michael Feldman)
Subject: Re: AdaNet and ADA - copyright problems?
Organization: George Washington University
Date: Mon, 27 Jul 1992 03:31:11 GMT

You can tell everyone you know that Ada has NOT been a trademark
since 1988. Ada was never a "copyright" - the Language Reference Manual
was a copyrighted document. Ada was in fact a trademark of the US DoD
but that trademark lapsed around the beginning of 1988. If you or your
pals would like an online copy of the document explaining the 
disappearance of the trademark, let me know by private e-mail.

However: you MAY have a copyright problem with AdaNet, which actually
exists as a NASA-sponsored, privately administered Ada-related archive
and database operating out of West Virginia. I assume your Fido-based
AdaNet is unrelated to this, and therefore suggest that you find a
different name. Even if AdaNet is not a traemarked term (I don't know
whether it is or not), you'd best find another name just to avoid
confusion.

All my papers are on a moving van at the moment, so I can't look up
AdaNet info for you to use to check this out. If any other AdaNet users
are reading this, you might want to respond with more info.

I like your idea, by the way.

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

Professor, Dept. of Electrical Engineering and Computer Science
School of Engineering and Aplied Science
The George Washington University
Washington, DC 20052 USA
(202) 994-5253 (voice)
(202) 994-5296 (fax)
mfeldman@seas.gwu.edu (Internet)
Newsgroups: comp.lang.ada
From: wellerd@ajpo.sei.cmu.edu (David Weller)
Subject: FORTRAN to Ada Translators...
Summary: Another impassioned plea...
Organization: Software Engineering Institute
Date: Mon, 27 Jul 1992 00:40:42 GMT

First, let me apologize.  I usually hit the 'j'unk key when I 
see a request for info on translators.  Mostly because I don't
philosophically support the usage of them.  Well, now I'M the
one asking for information.

I quickly looked through the Translators.txt file on the AJPO
host and found a decent enough listing of available translators.
Unfortunately, that listing gave no indication of the health
or robustness of said products.  I am looking for "lessons learned"
using a source translator.  I am also curious as to what the
"flavor" of FORTRAN was supported by the tool.  We are about to
embark on a major translation of software for the Space Transportation
System (Shuttle).  Some of this software is in FORTRAN 66! (Did 
I happen to mention GOTO's? :-)

Please, for those of you that want to send flames, do NOT use the
above internet address.  Instead, send them to flames@slant.dev.slant.null

P.S. -- To any vendors that might reply:  I'm only interested in
TOOLS.  I will not respond to solicitations for translation services.
From: alex@cs.umd.edu (Alex Blakemore)
Newsgroups: comp.lang.ada
Subject: Correction regarding delay 0.0 semantics
Date: 23 Jul 92 20:40:53 GMT
Organization: U of Maryland, Dept. of Computer Science, Coll. Pk., MD 20742

Dave Emery was kind enough to point out an error in my previous posting:

  It is not a _requirement_ of the language that DELAY 0.0 will generate
  a synchronization.  The URG and current practice recommend that DELAY
  0.0 be treated as a synchronization point, to support exactly this
  kind of thing.  

I am pretty sure VAX Ada implements delay 0.0 in the manner suggested
by the URG.


-- 
-------------------------------
Alex Blakemore alex@cs.umd.edu
From: SAHARBAUGH@ROO.FIT.EDU
Newsgroups: comp.lang.ada
Subject: generates itself?
Date: 20 Jul 92 18:27:00 GMT
Organization: The Internet

Sorry for the post but:
Server replied: "550 <simonson@beaver.cs.washington.edu>... User unknown"

Does "generates itself" mean prints an image of its source code on the output device?
sam harbaugh saharbaugh@ROO.FIT.EDU        
-----------
From: srw@geode.UUCP (Sandy Wilbourn)
Newsgroups: comp.lang.ada
Subject: Re: Ada for OS/2
Date: 25 Jul 92 02:11:22 GMT
Distribution: world
Organization: The Internet



    Date: 24 Jul 92 12:14:54 GMT
    From: prism!np4@gatech.edu  (Nick Pomponio)
    Subject: Ada for OS/2
    Message-ID: <64242@hydra.gatech.EDU>

    I have recently switched to the OS/2 operating system (as have many others
    in my laboratory) on an IBM PC compatible. I had been using Meridian
    OpenAda 386 under DOS, but it won't run in a DOS window under OS/2 because,
    apparently, it uses a VCPI extender to access the protected mode of the 386
    while compiling. I called Meridian, and was told that they have no plans
    to upgrade to a DPMI compliant extender (which does run under OS/2), but
    that they are considering possibly developing an OS/2 native version.

Meridian certainly has plans to upgrade to a DPMI compliant extender in
the very near future. I should keep our sales force from spreading such 
rumors. 

    Does anyone know of any other protected mode Ada compiler (for large programs)
    that will run under OS/2?

    -- 
    POMPONIO,NICHOLAS A
    Georgia Institute of Technology, Atlanta Georgia, 30332
    uucp:	  ...!{decvax,hplabs,ncar,purdue,rutgers}!gatech!prism!np4
    Internet: np4@prism.gatech.edu

Sandy Wilbourn
Director of Engineering
Meridian Software
From: cliveg@cix.compulink.co.uk (Clive Grace)
Newsgroups: comp.lang.ada
Subject: Books For Sale
Date: 24 Jul 92 17:29:00 GMT
Reply-To: cliveg@cix.compulink.co.uk



I'm clearing out my entire collection of about 200 computer books -
many of which are either language-based, OS based or PC based... if
you would like a list, then email me on: cliveg@compulink.co.uk, and
I shll mail you a list with a contact number. Most books are around
#10 each I'd prefer selling them to people in the UK and Eire as US
postal charges can be prohibitive, but obviously I can sell to anyone
wanting a particular book.

These are all virtually unused. I have a job that involves buying
certain books, studying them and approving them for specific
companies and then doing a write-up - as a result, these books are
pristine in all cases - not scribbled in or dog-eared (i'm nice like
that).

Bulk orders are particularly welcome...

Clive Grace

cliveg@compulink.co.uk
cliveg@compulink.uucp
Newsgroups: comp.lang.ada
From: jeff@ryhope.del.dec.com (Jeff Finkelstein)
Subject: Re: C to Ada conversion
Organization: Digital Equipment Corporation
Distribution: usa
Date: Tue, 21 Jul 1992 19:05:00 GMT

In article <l6mim9INNs5g@exodus.Eng.Sun.COM> menges@Eng.Sun.COM writes:
>
>Can anyone recommend a shop or consultants that convert C code to Ada?
>
>The package is about 35-40K (LOC) C code and is highly graphics oriented. I 
>believe that it runs on PCs.
>

I can't recommend anyone, but I'm in the process of going through it
also. I have a program that is ~18K LOC of C and need to convert it to
Ada. Much of it is fairly straight forward until you get into some of
the quirks (read: features) of C, i.e. pointer arithmetic and casting.

Bottom line is it depends on how well written (and documented) the C
code is. I originally estimated that my conversion would take 6-9 months
and it looks more like 9-12 months. One thing I have discovered is that
as I go through the process I become more and more of an Ada fan. I am
find many bugs in the original code that Ada will not let me get away
with. 

My $0.02.

jeff
----
jeff finkelstein                | disclaimer:
digital equipment corporation   |   A horse is a horse, of course, of course.
jeff@ryhope.del.dec.com         |   
-- 
jeff finkelstein                | disclaimer:
digital equipment corporation   |   A horse is a horse, of course, of course.
jeff@ryhope.del.dec.com         |
From: elsworthef@aston.ac.uk (Ted Elsworth)
Newsgroups: comp.lang.ada
Subject: Re: Shortest Self-Generating Ada Program
Date: 22 Jul 92 11:09:01 GMT
Followup-To: comp.lang.ada
Organization: Computer Science, Aston University

This was my *must-be-as-one-line* Ada self-replicating program:

with text_io;use text_io;procedure r is s:string(1..115):=
"with text_io;use text_io;procedure r is s:string(1..115):="";
begin put(s(1..59)&s(1..59)&s(59..115)&s(59..115));end;";
begin put(s(1..59)&s(1..59)&s(59..115)&s(59..115));end;

If you or your compiler don't like the above, here is another (57-line)
self-replicating program with maximum line length 78 chars 
and using (hopefully) reasonably clear layout and identifiers.
Also, it doesn't need the programmer to do any character counting.

Ted Elsworth.

===================================================================

with text_io; use text_io;
procedure rep is
  s : constant string :=
"with text_io; use text_io;\"&
"procedure rep is\"&
"  s : constant string :=\"&
"""\"&
"  procedure put_s(pass : integer) is\"&
"    skipping_part1 : boolean := pass=3 or pass=4;\"&
"  begin\"&
"    for i in 1..s'last loop\"&
"      if s(i) = ascii.quotation then skipping_part1 := false; end if;\"&
"      if not skipping_part1 then\"&
"        if s(i) = ascii.back_slash then\"&
"          if pass=2 or pass=3 then\"& 
"         
put(ascii.back_slash);put(ascii.quotation);put(ascii.ampersand);\"& 
"          end if;\"&
"          new_line;\"&
"          if pass=2 or pass=3 then put(ascii.quotation); end if;\"&
"        else\"&
"          put(s(i));\"&
"        end if;\"&
"        if s(i)=ascii.quotation and (pass=1 or pass=2) then exit; end
if;\"&
"      end if;\"&
"    end loop;\"&
"  end;\"&
"begin\"&
"  put_s(1);\"&
"  put_s(2);\"&
"  put_s(3);\"&
"  put_s(4);\"&
"end;";
  procedure put_s(pass : integer) is
    skipping_part1 : boolean := pass=3 or pass=4;
  begin
    for i in 1..s'last loop
      if s(i) = ascii.quotation then skipping_part1 := false; end if;
      if not skipping_part1 then
        if s(i) = ascii.back_slash then
          if pass=2 or pass=3 then 
          put(ascii.back_slash);put(ascii.quotation);put(ascii.ampersand); 
          end if;
          new_line;
          if pass=2 or pass=3 then put(ascii.quotation); end if;
        else
          put(s(i));
        end if;
        if s(i)=ascii.quotation and (pass=1 or pass=2) then exit; end if;
      end if;
    end loop;
  end;
begin
  put_s(1);
  put_s(2);
  put_s(3);
  put_s(4);
end;

=============================================================================
From: fortran@giac1.oscs.montana.edu (Lou Glassy)
Newsgroups: comp.lang.ada
Subject: Ada questions:  ungetting input, and cmd-line args
Summary: are there standard, portable ways to do these things?
Date: 26 Jul 92 03:33:49 GMT
Article-I.D.: coe.1992Jul26.033349.22498
Organization: Montana State University, Bozeman Montana USA

Two small Ada 'how-to' questions:

[1]   How would you go about un-getting a character of input
      (basically, backing up the input stream by one character, 
      like C's ungetc() routine does) ?

I have before me a copy of ANSI/MIL-STD-1815A.  In 14.2.4 (Direct
Input-Output), a procedure called SET_INDEX is described, that could do
what I think I'd need to do, in a pinch.  The cheap-and-dirty solution
I've got in mind (save the current INDEX, do the GET, then SET_INDEX to
current INDEX minus one, to back up) is unpleasant at best.

I'm building pieces of a compiler for a small language.  The ability to
unget input would be very handy for the lexical analyzer. 

What is the portable, standard way to do this?

Next question:

[2]   None of the Ada books I've seen in the school library (nor -1815A)
      mention the environment in which an Ada program is expected to run
      (except minimally).  Hence, there are no routines mentioned in the
      standard trio of IO packages (SEQUENTIAL_IO, DIRECT_IO, TEXT_IO) 
      that retrieve "command-line arguments."  Is there a portable, 
      standard-conforming way to do this?  or is the idea of "command-line
      arguments" outside of the scope of the Ada definition, or outside
      of the ability of standard Ada?  (...I hope not, but it's non-fatal
      if it is.  I'll just have to adjust the compiler's user interface
      to suit...)

----------------
One last small question:  (maybe a silly one.)  Will programs written 
in Ada-83 (or whatever the specific name is of the language defined in
-1815A) continue to compile and run without modification in the next
version of Ada (Ada-9X)?  In other words, is it anticipated that Ada-9X
will break some standard-conforming Ada-83 programs?  or will -9X be a
strict superset of -83?  (Specifically, for 'Sequential-Ada', i.e., the
subset of Ada without tasking, will -9X break anything?  If so, what?)


Thanks in advance,

Lou Glassy

-- 
Lou Glassy                     <> Watch the field behind the plow
Student in Earth Sciences      <> Turn to straight, dark rows..
Montana State University       <> Put another season's promise in the ground.
fortran@giac1.oscs.montana.edu <>                          --Stan Rogers 
Newsgroups: comp.lang.ada
From: srctran@world.std.com (Gregory Aharonian)
Subject: Re: FORTRAN to Ada Translators...
Organization: The World
Date: Thu, 30 Jul 1992 05:32:43 GMT

    Having spent many years studying this problem, my two cents of advice is
this.  If you must use translators, you should have one developed that is
specific to the types of Fortran codes being translated.  I have seen this
be helpful for Fortran to Ada and Jovial to Ada conversions.  There are a
variety of text transformation tools available over the Internet which can
handle Fortran and Ada grammars. Choose one, adapt it to the languages you
are using, and hard code in stuf to handle the stuff that is difficult to
translate.
    This is not a very classy approach to this problem, but it works.

Greg Aharonian
Source Translation & Optimization
From: rpwhite@taurus.cs.nps.navy.mil (rpwhite)
Newsgroups: comp.lang.ada
Subject: Re: ADA implementation for Unix PC / generic System V box
Date: 27 Jul 92 15:59:57 GMT
Reply-To: rpwhite@cs.nps.navy.mil (rpwhite)
Followup-To: talk.bizarre,misc.test
Distribution: usa
Organization: Naval Postgraduate School, Monterey CA

Craig Carpenter writes:
>Thomas J. Pusateri writes:

>> The majority of people using ADA these days are government contractors and
>> even that number is decreasing.

>The number can't do anything but grow. Since Congress has made it a LAW that

Just like they made 55 MPH a law?

Har har.
From: emery@Dr_No.mitre.org (David Emery)
Newsgroups: comp.lang.ada
Subject: Re: initialization of vars when declared.
Date: 21 Jul 92 14:35:21 GMT
Organization: The Mitre Corp., Bedford, MA.

a_variable : array (1..3) of integer := (1,2,3);
				dave
(p.s.  many people consider this declaration, which is an anonymous
 array type, to be bad style.  One problem is that the following
 declarations are of two different types:
	X : array (1..3) of integer;
	Y : array (1..3) of integer;
 and therefore you can't say "X := Y;")
Newsgroups: comp.lang.ada
From: eachus@Dr_No.mitre.org (Robert I. Eachus)
Subject: Re: 1 millisecond tasking on a Mips
Organization: The Mitre Corp., Bedford, MA.
Date: Tue, 21 Jul 1992 19:22:28 GMT


In article <ELLIOTTM.92Jul17225954@beach.csulb.edu> elliottm@beach.csulb.edu (Elliot Michael) writes:

   We are considering an embedded application in Ada, running on a Mips
   chip (speed yet unspecified) which will require at least one task to 
   be run at 1 KHz.  Is this reasonable?  I've heard lots of rumors about
   how much overhead is involved in Ada tasking.

   Is it possible? Yes, but the issue is the design of the underlying
hardware and run-time environment.--I assume you are not going to use
Unix.  Some run-times (and processor designs) do allow task switches
in about 20 microseconds.

   Is it a good idea?  Probably not.  If you really do have a
requirement to do some (simple) operation every millisecond, put it in
an interrupt handler.  If the task is more complex, dedicate a
processor.  With modern chip architectures caching and data
consistency overheads can kill you outside the actual task switch
times.  For example, if an interrupt handler needs to flush the cache,
the distributed cost of reloading the cache--incurred by all running
tasks--may overwhelm any other cost associated with the interrupt
processing.

    Of course, none of this is really specific to Ada, and that is
really my point.  Current Ada compilers add little unnecessary
overhead to the services provided by the hardware and run-time
environment.  (The necessary overhead occurs when exiting a scope
which has dependent tasks, but that should never happen in real-time
code ohter than during system shutdown.)

--

					Robert I. Eachus

with STANDARD_DISCLAIMER;
use  STANDARD_DISCLAIMER;
function MESSAGE (TEXT: in CLEVER_IDEAS) return BETTER_IDEAS is...