* Re: Direct Quote from the RM
2007-11-17 21:22 Direct Quote from the RM anon
@ 2007-11-18 7:07 ` Simon Wright
2007-11-18 9:43 ` anon
2007-11-19 21:48 ` Randy Brukardt
` (2 subsequent siblings)
3 siblings, 1 reply; 24+ messages in thread
From: Simon Wright @ 2007-11-18 7:07 UTC (permalink / raw)
anon@anon.org (anon) writes:
> 10 No language can avoid the problem of efficiency. Languages
> that require over-elaborate compilers, or that lead to the
> inefficient use of storage or execution time, force these
> inefficiencies on all machines and on all programs.
This is the only part of the text you quote that addresses the
compilation environment. And what it says is, the design of the Ada
language is such that it does not require over-elaborate compilers,
and that (once compiled) a program doesn't have to be inefficient.
But there's nothing there that says the compiler itself has to be
efficient! of course inefficient compilers will be unpopular, but
that's quite a different matter.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-18 7:07 ` Simon Wright
@ 2007-11-18 9:43 ` anon
2007-11-18 12:57 ` Markus E L
2007-11-19 0:16 ` Georg Bauhaus
0 siblings, 2 replies; 24+ messages in thread
From: anon @ 2007-11-18 9:43 UTC (permalink / raw)
Paragraph of 10 from Design Goal.
10 No language can avoid the problem of efficiency. Languages that
require over-elaborate compilers, or that lead to the inefficient use
of storage or execution time, force these inefficiencies on all
machines and on all programs. Every construct of the language was
examined in the light of present implementation techniques. Any
proposed construct whose implementation was unclear or that
required excessive machine resources was rejected.
"Any proposed construct whose implementation was unclear or that required
excessive machine resources was rejected." That statement suggest that
"gnatmake" in using requires 5 complete programs to be loaded at one time
just to compile a single routine or package when 3 to 3 will do should be
rejected!
gnatmake => use in core 5 program.
gnat compile => uses 4 program 3 in core.
gcc -c => uses 3 in core program (gcc which calls gnat1 then calls as).
So using "gcc -c" is the best and is worst "gnatmake". Of course, this
can become excessive in execution time if the GNAT system is compiled
with "-fstack-check".
Defaulting the "-fstack-check" which can not at the movement be remove
by the "pragma Suppress (Storage_Check);". Leads "to the inefficient use
of storage or execution time, force these inefficiencies on all machines
and on all programs." So it too must be rejected!
And there are more places in the RM then just this part. But most people
I think had skip reading the Intro section.
And as for parallel. The way I write code allows me to compile in parallel
even though that development design is not support in the RM. But I have
learned a few trick alone the way that allows this.
Note: Parallel => I mean the number of complete compilers loaded and
running in core (no swapper file usage) at the same time. That is on the
old single-cpu system it was called Concurrency, but with two/four/+
cpus that is called Parallel. For example on a system with 4G with 1G
given to the OS/(user interface), that leave 3G or about 3_000 in core
compilers if the gcc, gnat1, as, and file/package take less than 1MB in
size or 1_500 in core compilers if they require 2MB.
And "gnatmake" does not use the Ada Task and to insure "Safety and
Security" of the code will only allow the compiling of one package at a
time because of the design of Ada structure. (As someone pointed out).
This is defined also in the RM if you look.
Note: The "make -jN" or "gnatmake -jN" does not allow multiple
compilers to be loaded in core at the same time.
In <m2k5ogvxo4.fsf@mac.com>, Simon Wright <simon.j.wright@mac.com> writes:
>anon@anon.org (anon) writes:
>
>> 10 No language can avoid the problem of efficiency. Languages
>> that require over-elaborate compilers, or that lead to the
>> inefficient use of storage or execution time, force these
>> inefficiencies on all machines and on all programs.
>
>This is the only part of the text you quote that addresses the
>compilation environment. And what it says is, the design of the Ada
>language is such that it does not require over-elaborate compilers,
>and that (once compiled) a program doesn't have to be inefficient.
>
>But there's nothing there that says the compiler itself has to be
>efficient! of course inefficient compilers will be unpopular, but
>that's quite a different matter.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-18 9:43 ` anon
@ 2007-11-18 12:57 ` Markus E L
2007-11-19 0:16 ` Georg Bauhaus
1 sibling, 0 replies; 24+ messages in thread
From: Markus E L @ 2007-11-18 12:57 UTC (permalink / raw)
'anon AT anon DOT org (anon)' wrote:
> Paragraph of 10 from Design Goal.
>
> 10 No language can avoid the problem of efficiency. Languages that
> require over-elaborate compilers, or that lead to the inefficient use
> of storage or execution time, force these inefficiencies on all
> machines and on all programs. Every construct of the language was
> examined in the light of present implementation techniques. Any
> proposed construct whose implementation was unclear or that
> required excessive machine resources was rejected.
>
> "Any proposed construct whose implementation was unclear or that required
> excessive machine resources was rejected." That statement suggest that
> "gnatmake" in using requires 5 complete programs to be loaded at one time
> just to compile a single routine or package when 3 to 3 will do should be
> rejected!
Since when is gnatmake a "construct of the language"? Furthermore the
text describes the (past) design process of Ada language and does (as
I understand it) not impose requirements on the compiler/tool
implementation. That would be the difference between "was rejected"
and "shall rejected" AFAI understand.
- M
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-18 9:43 ` anon
2007-11-18 12:57 ` Markus E L
@ 2007-11-19 0:16 ` Georg Bauhaus
2007-11-20 13:43 ` anon
1 sibling, 1 reply; 24+ messages in thread
From: Georg Bauhaus @ 2007-11-19 0:16 UTC (permalink / raw)
anon wrote:
> "Any proposed construct whose implementation was unclear or that required
> excessive machine resources was rejected." That statement suggest that
> "gnatmake" in using requires 5 complete programs to be loaded at one time
> just to compile a single routine or package when 3 to 3 will do should be
> rejected!
I had been under the impression that Ada was designed for software
systems of more than one compilation unit...
> Note: Parallel => I mean the number of complete compilers loaded and
> running in core (no swapper file usage) at the same time.
I'm curious about the elaboration rules when a compilation system
of 3_000 complete compilers is working on the same source at the
same time (not using gnatmake).
How many compilation units would be under the control of the
3_000 compilers in this example? How do they get organized?
> Note: The "make -jN" or "gnatmake -jN" does not allow multiple
> compilers to be loaded in core at the same time.
Ehr, why is that?
"`-jn'
Use n processes to carry out the (re)compilations. On a
multiprocessor machine compilations will occur in parallel."
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-19 0:16 ` Georg Bauhaus
@ 2007-11-20 13:43 ` anon
2007-11-20 15:10 ` parallel translation (was: Direct Quote from the RM) Georg Bauhaus
2007-11-20 17:07 ` Direct Quote from the RM Vadim Godunko
0 siblings, 2 replies; 24+ messages in thread
From: anon @ 2007-11-20 13:43 UTC (permalink / raw)
For Georg Bauhaus
As for parallel, I was talking about compiling up to 3_000 packages or
files used in a partition for a computer system with 4GB. Not all parallel
operations are about threads or a thread hopping onto different
processor's job schedulers. In this parallel design the system can contain
up to 3_000 copies of "gcc", "gnat1" and "as" in memory and excuting
in parallel design with each other to utilize the cpu and memory to the
fullest! In other words,
Task 1 in memmory -> (copy #1 of gnat compiler system) + (package 1)
Task 2 in memmory -> (copy #2 of gnat compiler system) + (package 2)
Task 3 in memmory -> (copy #3 of gnat compiler system) + (package 3)
...
Task N in memmory -> (copy #4 of gnat compiler system) + (package N)
Note: "gnat compiler system" is "gcc" and "gnat1" and as", which is
done by the "gnat compile" command or "gcc -c".
In this design it does not matter the number of processors or the number
of threads. This can be done by creating a script file like (linux version):
#script
#
gnat compile <name1>.adb &
gnat compile <name2>.adb &
gnat compile <name3>.adb &
..
gnat compile <nameN>.adb &
#
#end script
Usage of the Swapper file must be turn off. Swapping defeat the purpose.
And you may have to up the priority of the background tasks but that not
a problem either. Also I could of used "gcc -c" but that too much like C
programming. so I choose not too use it.
Note: "gnatmake" or "make" can not be setup in this way to preform is
type of parallel processing.
Now as for "gnatmake" try this "gnatmake *". It does not work in
Linux/FreeBSD. So, to compile packages before you create the main
program you must use "gnat compile" or better yet "gcc -c". Also, If you
have more than a couple of packages you normally build a script file to
compile the code, which can easily be turn into loading multiple copies of
the compiler and fully use the system resources aka parallel compiling.
Then when you build the main procedure out of habit you will again use
the "gcc -c" or "gnat compile" instead of "gnatmake" and then
"gnatbind" and then "gnatlink".
So, teaching or using "gnatmake" is a waste of the newbee time!
Because most project require more than one or two extra packages!
For "Elaboration rule"! Well try this:
1. create a temporary dir
2. cd to that temporary dir
3. copy system.ads to this temporary dir.
4. copy s-stoele.ad* to this temporary dir
-- System.Storage_Elements package for example.
5. edit system.ads and remove the comment at the top of the file.
Note: Any child package should, by the "Elaboration rules" force the
operator to recompile system.ads first.
6. gnat compile s-stoele.adb -gnatpg -nostdinc
This file is a child of system. But where is the error?
7. gnat compile system.ads -gnatpg -nostdinc
Note: Only if you "bind" a program that uses the
System.Storage_Elements will you see the Error based
on the "Elaboration rule" in this example.
Plus, not all project require Elaboration to be used.
In <4740d5f0$0$27131$9b4e6d93@newsspool1.arcor-online.net>, Georg Bauhaus <rm.tsoh+bauhaus@maps.futureapps.de> writes:
>anon wrote:
>
>> "Any proposed construct whose implementation was unclear or that required
>> excessive machine resources was rejected." That statement suggest that
>> "gnatmake" in using requires 5 complete programs to be loaded at one time
>> just to compile a single routine or package when 3 to 3 will do should be
>> rejected!
>
>I had been under the impression that Ada was designed for software
>systems of more than one compilation unit...
>
>
>> Note: Parallel => I mean the number of complete compilers loaded and
>> running in core (no swapper file usage) at the same time.
>
>I'm curious about the elaboration rules when a compilation system
>of 3_000 complete compilers is working on the same source at the
>same time (not using gnatmake).
>How many compilation units would be under the control of the
>3_000 compilers in this example? How do they get organized?
>
> > Note: The "make -jN" or "gnatmake -jN" does not allow multiple
> > compilers to be loaded in core at the same time.
>
>Ehr, why is that?
>"`-jn'
> Use n processes to carry out the (re)compilations. On a
> multiprocessor machine compilations will occur in parallel."
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: parallel translation (was: Direct Quote from the RM)
2007-11-20 13:43 ` anon
@ 2007-11-20 15:10 ` Georg Bauhaus
2007-11-20 18:47 ` parallel translation Jeffrey R. Carter
2007-11-20 17:07 ` Direct Quote from the RM Vadim Godunko
1 sibling, 1 reply; 24+ messages in thread
From: Georg Bauhaus @ 2007-11-20 15:10 UTC (permalink / raw)
On Tue, 2007-11-20 at 13:43 +0000, anon wrote:
> For Georg Bauhaus
>
> As for parallel, I was talking about compiling up to 3_000 packages or
> files used in a partition for a computer system with 4GB.
OK. This was my understanding, too.
> Task 1 in memmory -> (copy #1 of gnat compiler system) + (package 1)
> Task 2 in memmory -> (copy #2 of gnat compiler system) + (package 2)
> Task 3 in memmory -> (copy #3 of gnat compiler system) + (package 3)
> ...
> Task N in memmory -> (copy #4 of gnat compiler system) + (package N)
Right. Now,
with P2;
package P1 is
...
end P1;
P1 (in file "p1.ads", say) depends on P2 (in file "p2.ads", say).
I am assuming that Task 1 is supposed to compile P1, and task 2
is supposed to compile P2. An elaboration order will have to be
established in order to translate almost anything. Here, for
example, task 1 (compiling P1) must know what is in P2 (compiled
in task 2) because P1 depends on P2. How do the compilers etc.
communicate?
> For "Elaboration rule"! Well try this:
Why should a programmer new to Ada mess with compiler files?
And how will the GNAT specifics of System.Storage_Elements and
special processing of System affect the package dependences in an
Ada project?
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: parallel translation
2007-11-20 15:10 ` parallel translation (was: Direct Quote from the RM) Georg Bauhaus
@ 2007-11-20 18:47 ` Jeffrey R. Carter
2007-11-20 19:48 ` Samuel Tardieu
2007-11-20 20:26 ` Georg Bauhaus
0 siblings, 2 replies; 24+ messages in thread
From: Jeffrey R. Carter @ 2007-11-20 18:47 UTC (permalink / raw)
Georg Bauhaus wrote:
>
> P1 (in file "p1.ads", say) depends on P2 (in file "p2.ads", say).
> I am assuming that Task 1 is supposed to compile P1, and task 2
> is supposed to compile P2. An elaboration order will have to be
> established in order to translate almost anything. Here, for
> example, task 1 (compiling P1) must know what is in P2 (compiled
> in task 2) because P1 depends on P2. How do the compilers etc.
> communicate?
No, GNAT is source based. The compilation of P1 will read p2.ads; the
compilation of P2 will read p2.ads and p2.adb (if needed). The compilation of P1
need not wait for P2 to be compiled.
If P1 depends on the body of P2 (perhaps by calling an inlined subprogram with
-gnatn), then you have a problem similar to what you described. I'm not sure how
GNAT handles this, but perhaps the task compiling P1 can wait until appropriate
versions of p2.ali and p2.o are created.
--
Jeff Carter
"Go and boil your bottoms."
Monty Python & the Holy Grail
01
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: parallel translation
2007-11-20 18:47 ` parallel translation Jeffrey R. Carter
@ 2007-11-20 19:48 ` Samuel Tardieu
2007-11-21 0:09 ` Jeffrey R. Carter
2007-11-20 20:26 ` Georg Bauhaus
1 sibling, 1 reply; 24+ messages in thread
From: Samuel Tardieu @ 2007-11-20 19:48 UTC (permalink / raw)
>>>>> "Jeffrey" == Jeffrey R Carter <spam.jrcarter.not@acm.nospam.org> writes:
Jeffrey> If P1 depends on the body of P2 (perhaps by calling an
Jeffrey> inlined subprogram with -gnatn), then you have a problem
Jeffrey> similar to what you described. I'm not sure how GNAT handles
Jeffrey> this, but perhaps the task compiling P1 can wait until
Jeffrey> appropriate versions of p2.ali and p2.o are created.
As you wrote, GNAT is source based. If P1 depends on the body of P2,
it will use its source file (p2.adb in this case), and this is totally
independant of the compilation of P2 which may well happen in
parallel or after the compilation of P1.
Any unit can be compiled without depending on any other unit
compilation. Moreover, the compiler never reads any ali file. gnatmake
does (to determine what needs to be compiled), and gnatbind does as
well (to determine the elaboration order).
Sam
--
Samuel Tardieu -- sam@rfc1149.net -- http://www.rfc1149.net/
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: parallel translation
2007-11-20 19:48 ` Samuel Tardieu
@ 2007-11-21 0:09 ` Jeffrey R. Carter
0 siblings, 0 replies; 24+ messages in thread
From: Jeffrey R. Carter @ 2007-11-21 0:09 UTC (permalink / raw)
Samuel Tardieu wrote:
>>>>>> "Jeffrey" == Jeffrey R Carter <spam.jrcarter.not@acm.nospam.org> writes:
>
> Jeffrey> If P1 depends on the body of P2 (perhaps by calling an
> Jeffrey> inlined subprogram with -gnatn), then you have a problem
> Jeffrey> similar to what you described. I'm not sure how GNAT handles
> Jeffrey> this, but perhaps the task compiling P1 can wait until
> Jeffrey> appropriate versions of p2.ali and p2.o are created.
>
> As you wrote, GNAT is source based. If P1 depends on the body of P2,
> it will use its source file (p2.adb in this case), and this is totally
> independant of the compilation of P2 which may well happen in
> parallel or after the compilation of P1.
>
> Any unit can be compiled without depending on any other unit
> compilation. Moreover, the compiler never reads any ali file. gnatmake
> does (to determine what needs to be compiled), and gnatbind does as
> well (to determine the elaboration order).
Thanks for the clarification.
--
Jeff Carter
"Go and boil your bottoms."
Monty Python & the Holy Grail
01
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: parallel translation
2007-11-20 18:47 ` parallel translation Jeffrey R. Carter
2007-11-20 19:48 ` Samuel Tardieu
@ 2007-11-20 20:26 ` Georg Bauhaus
1 sibling, 0 replies; 24+ messages in thread
From: Georg Bauhaus @ 2007-11-20 20:26 UTC (permalink / raw)
On Tue, 2007-11-20 at 18:47 +0000, Jeffrey R. Carter wrote:
> Georg Bauhaus wrote:
> >
> > P1 (in file "p1.ads", say) depends on P2 (in file "p2.ads", say).
> > I am assuming that Task 1 is supposed to compile P1, and task 2
> > is supposed to compile P2. An elaboration order will have to be
> > established in order to translate almost anything. Here, for
> > example, task 1 (compiling P1) must know what is in P2 (compiled
> > in task 2) because P1 depends on P2. How do the compilers etc.
> > communicate?
>
> No, GNAT is source based. The compilation of P1 will read p2.ads; the
> compilation of P2 will read p2.ads and p2.adb (if needed). The compilation of P1
> need not wait for P2 to be compiled.
Yes, I had felt uneasy after posting as the comment confused translation
and elaboration. Yet, I had understood that something like a shell
script was to control starts of gccs for each file, basically. What is
the win over "gnatmake -jnnn" when none of the independent compilers
knows which file has already been processed? There will not normally
be a "p2.ali" after "gcc -c" has read and analyzed "p2.ads" (with'ed
by P1).
Time to look at the sources of gnatmake.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-20 13:43 ` anon
2007-11-20 15:10 ` parallel translation (was: Direct Quote from the RM) Georg Bauhaus
@ 2007-11-20 17:07 ` Vadim Godunko
2007-11-21 6:44 ` anon
1 sibling, 1 reply; 24+ messages in thread
From: Vadim Godunko @ 2007-11-20 17:07 UTC (permalink / raw)
On Nov 20, 4:43 pm, a...@anon.org (anon) wrote:
>
> So, teaching or using "gnatmake" is a waste of the newbee time!
> Because most project require more than one or two extra packages!
>
1) gnatmake has special -jX command line switch, where X is a number
of parallel gcc commands.
1a) you may use classic make program and its parallel modifications.
2) two dual core processors and 4Gb of RAM doesn't really many
resources even for medium size projects. Real projects may utilize up
to 3Gb of RAM per one compiler process.
> 6. gnat compile s-stoele.adb -gnatpg -nostdinc
> This file is a child of system. But where is the error?
What are you expecting? You are _exactly_ ask _compiler_ rebuild
specific file. Note, _compiler_! Compiler must prepare relevant
elaboration code, but it doesn't responsible for partition elaboration
at hole, ...
> Note: Only if you "bind" a program that uses the
> System.Storage_Elements will you see the Error based
> on the "Elaboration rule" in this example.
>
... bind program is responsible for generation of partition
elaboration code.
> Plus, not all project require Elaboration to be used.
>
Can you please provide an real example?
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-20 17:07 ` Direct Quote from the RM Vadim Godunko
@ 2007-11-21 6:44 ` anon
0 siblings, 0 replies; 24+ messages in thread
From: anon @ 2007-11-21 6:44 UTC (permalink / raw)
>> Plus, not all project require Elaboration to be used.
>>
>Can you please provide an real example?
1. Since a persion was asking about "Ada OS" the other day!
An Ada version of a Multi-Boot program simular to XP or LILO.
2. Another type can be partitions that use other language I/O and library
functions with or without the "pragma No_Run_Time;" statement. In
the GNAT examples there is a program called "use_of_import.adb"
which requires "impoerted_function.c".
In <a954e769-3822-4079-a77d-957d56be4a9e@d61g2000hsa.googlegroups.com>, Vadim Godunko <vgodunko@gmail.com> writes:
>On Nov 20, 4:43 pm, a...@anon.org (anon) wrote:
>>
>> So, teaching or using "gnatmake" is a waste of the newbee time!
>> Because most project require more than one or two extra packages!
>>
>1) gnatmake has special -jX command line switch, where X is a number
>of parallel gcc commands.
>
>1a) you may use classic make program and its parallel modifications.
>
>2) two dual core processors and 4Gb of RAM doesn't really many
>resources even for medium size projects. Real projects may utilize up
>to 3Gb of RAM per one compiler process.
>
>> 6. gnat compile s-stoele.adb -gnatpg -nostdinc
>> This file is a child of system. But where is the error?
>What are you expecting? You are _exactly_ ask _compiler_ rebuild
>specific file. Note, _compiler_! Compiler must prepare relevant
>elaboration code, but it doesn't responsible for partition elaboration
>at hole, ...
>
>> Note: Only if you "bind" a program that uses the
>> System.Storage_Elements will you see the Error based
>> on the "Elaboration rule" in this example.
>>
>.... bind program is responsible for generation of partition
>elaboration code.
>
>> Plus, not all project require Elaboration to be used.
>>
>Can you please provide an real example?
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-17 21:22 Direct Quote from the RM anon
2007-11-18 7:07 ` Simon Wright
@ 2007-11-19 21:48 ` Randy Brukardt
2007-11-19 22:41 ` Ludovic Brenta
2007-11-19 21:48 ` Randy Brukardt
2007-11-19 21:48 ` Randy Brukardt
3 siblings, 1 reply; 24+ messages in thread
From: Randy Brukardt @ 2007-11-19 21:48 UTC (permalink / raw)
"anon" <anon@anon.org> wrote in message
news:mYI%i.27882$if6.6495@bgtnsc05-news.ops.worldnet.att.net...
> Intro or section 0 between 150 .. 200 lines in the RM for Ada 95!
>
> (long quote omitted).
Ah, yes, the motherhood section. I was asking you to provide a *normative*
reference (one that is actually binding on users/implementers), which the
introduction is surely not such a section. (See the definition of
"normative" in 1.1.2.)
The introduction is just a list of "good" properties which really doesn't
mean that much and has no bearing on the requirements for implementations
and users. Pretty much every programming language has a version of these
same goals. After all, can you imagine a programming language saying that it
was designed to make unreliable programs with no regard to efficiency? Who'd
use that?
Others have explained the difference between properties of the language and
properties of the toolset, so I won't spend more time on that.
Randy.
> Quote
>
> Design Goals
>
> 6 Ada was originally designed with three overriding concerns:
> program reliability and maintenance, programming as a human
> activity, and efficiency. This revision to the language was
> designed to provide greater flexibility and extensibility,
> additional control over storage management and synchronization,
> and standardized packages oriented toward supporting important
> application areas, while at the same time retaining the original
> emphasis on reliability, maintainability, and efficiency.
>
> 7 The need for languages that promote reliability and simplify
> maintenance is well established. Hence emphasis was placed
> on program readability over ease of writing. For example, the
> rules of the language require that program variables be explicitly
> declared and that their type be specified. Since the type of a
> variable is invariant, compilers can ensure that operations on
> variables are compatible with the properties intended for objects
> of the type. Furthermore, error-prone notations have been
avoided,
> and the syntax of the language avoids the use of encoded forms in
> favor of more English-like constructs. Finally, the language
offers
> support for separate compilation of program units in a way that
> facilitates program development and maintenance, and which
> provides the same degree of checking between units as within a
> unit.
>
> 8 Concern for the human programmer was also stressed during the
> design. Above all, an attempt was made to keep to a relatively
> small number of underlying concepts integrated in a consistent
> and systematic way while continuing to avoid the pitfalls of
> excessive involution. The design especially aims to provide
> language constructs that correspond intuitively to the normal
> expectations of users.
>
> 9 Like many other human activities, the development of programs
> is becoming ever more decentralized and distributed.
Consequently,
> the ability to assemble a program from independently produced
> software components continues to be a central idea in the design.
> The concepts of packages, of private types, and of generic units
> are directly related to this idea, which has ramifications in many
> other aspects of the language. An allied concern is the
maintenance
> of programs to match changing requirements; type extension and the
> hierarchical library enable a program to be modified while
minimizing
> disturbance to existing tested and trusted components.
>
> 10 No language can avoid the problem of efficiency. Languages that
> require over-elaborate compilers, or that lead to the inefficient
use
> of storage or execution time, force these inefficiencies on all
> machines and on all programs. Every construct of the language was
> examined in the light of present implementation techniques. Any
> proposed construct whose implementation was unclear or that
> required excessive machine resources was rejected.
>
> Unquote!
>
> Which any programmer should take to mean that they should write High
> Integrity and Efficient code to maintain the Ada Design Goals. And that
> just one of many parts of the manual that address these type of concerns.
>
> Randy Brukardt may have writing one or more sections but as the list
> of authors states he was not alone. So, unless he wrote the intro he
> could of skipped that section. Just like most people who read the RM,
> they skip parts that does not deal with writing code. I personally have
> no problems that Randy Brukardt writing part(s) of the RM unless he
> wrote that intro. In that case, telling me to re-read it is just wrong.
>
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-19 21:48 ` Randy Brukardt
@ 2007-11-19 22:41 ` Ludovic Brenta
0 siblings, 0 replies; 24+ messages in thread
From: Ludovic Brenta @ 2007-11-19 22:41 UTC (permalink / raw)
Randy Brukardt writes
> The introduction is just a list of "good" properties which really doesn't
> mean that much and has no bearing on the requirements for implementations
> and users. Pretty much every programming language has a version of these
> same goals. After all, can you imagine a programming language saying that it
> was designed to make unreliable programs with no regard to efficiency? Who'd
> use that?
Malbolge and INTERCAL come to mind :)
And yes, there are people "using" these languages, for some weird
definition of "use" :)
--
Ludovic Brenta.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-17 21:22 Direct Quote from the RM anon
2007-11-18 7:07 ` Simon Wright
2007-11-19 21:48 ` Randy Brukardt
@ 2007-11-19 21:48 ` Randy Brukardt
2007-11-19 21:48 ` Randy Brukardt
3 siblings, 0 replies; 24+ messages in thread
From: Randy Brukardt @ 2007-11-19 21:48 UTC (permalink / raw)
"anon" <anon@anon.org> wrote in message
news:mYI%i.27882$if6.6495@bgtnsc05-news.ops.worldnet.att.net...
> Intro or section 0 between 150 .. 200 lines in the RM for Ada 95!
>
> (long quote omitted).
Ah, yes, the motherhood section. I was asking you to provide a *normative*
reference (one that is actually binding on users/implementers), which the
introduction is surely not such a section. (See the definition of
"normative" in 1.1.2.)
The introduction is just a list of "good" properties which really doesn't
mean that much and has no bearing on the requirements for implementations
and users. Pretty much every programming language has a version of these
same goals. After all, can you imagine a programming language saying that it
was designed to make unreliable programs with no regard to efficiency? Who'd
use that?
Others have explained the difference between properties of the language and
properties of the toolset, so I won't spend more time on that.
Randy.
> Quote
>
> Design Goals
>
> 6 Ada was originally designed with three overriding concerns:
> program reliability and maintenance, programming as a human
> activity, and efficiency. This revision to the language was
> designed to provide greater flexibility and extensibility,
> additional control over storage management and synchronization,
> and standardized packages oriented toward supporting important
> application areas, while at the same time retaining the original
> emphasis on reliability, maintainability, and efficiency.
>
> 7 The need for languages that promote reliability and simplify
> maintenance is well established. Hence emphasis was placed
> on program readability over ease of writing. For example, the
> rules of the language require that program variables be explicitly
> declared and that their type be specified. Since the type of a
> variable is invariant, compilers can ensure that operations on
> variables are compatible with the properties intended for objects
> of the type. Furthermore, error-prone notations have been
avoided,
> and the syntax of the language avoids the use of encoded forms in
> favor of more English-like constructs. Finally, the language
offers
> support for separate compilation of program units in a way that
> facilitates program development and maintenance, and which
> provides the same degree of checking between units as within a
> unit.
>
> 8 Concern for the human programmer was also stressed during the
> design. Above all, an attempt was made to keep to a relatively
> small number of underlying concepts integrated in a consistent
> and systematic way while continuing to avoid the pitfalls of
> excessive involution. The design especially aims to provide
> language constructs that correspond intuitively to the normal
> expectations of users.
>
> 9 Like many other human activities, the development of programs
> is becoming ever more decentralized and distributed.
Consequently,
> the ability to assemble a program from independently produced
> software components continues to be a central idea in the design.
> The concepts of packages, of private types, and of generic units
> are directly related to this idea, which has ramifications in many
> other aspects of the language. An allied concern is the
maintenance
> of programs to match changing requirements; type extension and the
> hierarchical library enable a program to be modified while
minimizing
> disturbance to existing tested and trusted components.
>
> 10 No language can avoid the problem of efficiency. Languages that
> require over-elaborate compilers, or that lead to the inefficient
use
> of storage or execution time, force these inefficiencies on all
> machines and on all programs. Every construct of the language was
> examined in the light of present implementation techniques. Any
> proposed construct whose implementation was unclear or that
> required excessive machine resources was rejected.
>
> Unquote!
>
> Which any programmer should take to mean that they should write High
> Integrity and Efficient code to maintain the Ada Design Goals. And that
> just one of many parts of the manual that address these type of concerns.
>
> Randy Brukardt may have writing one or more sections but as the list
> of authors states he was not alone. So, unless he wrote the intro he
> could of skipped that section. Just like most people who read the RM,
> they skip parts that does not deal with writing code. I personally have
> no problems that Randy Brukardt writing part(s) of the RM unless he
> wrote that intro. In that case, telling me to re-read it is just wrong.
>
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-17 21:22 Direct Quote from the RM anon
` (2 preceding siblings ...)
2007-11-19 21:48 ` Randy Brukardt
@ 2007-11-19 21:48 ` Randy Brukardt
2007-11-20 12:32 ` anon
3 siblings, 1 reply; 24+ messages in thread
From: Randy Brukardt @ 2007-11-19 21:48 UTC (permalink / raw)
"anon" <anon@anon.org> wrote in message
news:mYI%i.27882$if6.6495@bgtnsc05-news.ops.worldnet.att.net...
> Intro or section 0 between 150 .. 200 lines in the RM for Ada 95!
>
> (long quote omitted).
Ah, yes, the motherhood section. I was asking you to provide a *normative*
reference (one that is actually binding on users/implementers), which the
introduction is surely not such a section. (See the definition of
"normative" in 1.1.2.)
The introduction is just a list of "good" properties which really doesn't
mean that much and has no bearing on the requirements for implementations
and users. Pretty much every programming language has a version of these
same goals. After all, can you imagine a programming language saying that it
was designed to make unreliable programs with no regard to efficiency? Who'd
use that?
Others have explained the difference between properties of the language and
properties of the toolset, so I won't spend more time on that.
Randy.
> Quote
>
> Design Goals
>
> 6 Ada was originally designed with three overriding concerns:
> program reliability and maintenance, programming as a human
> activity, and efficiency. This revision to the language was
> designed to provide greater flexibility and extensibility,
> additional control over storage management and synchronization,
> and standardized packages oriented toward supporting important
> application areas, while at the same time retaining the original
> emphasis on reliability, maintainability, and efficiency.
>
> 7 The need for languages that promote reliability and simplify
> maintenance is well established. Hence emphasis was placed
> on program readability over ease of writing. For example, the
> rules of the language require that program variables be explicitly
> declared and that their type be specified. Since the type of a
> variable is invariant, compilers can ensure that operations on
> variables are compatible with the properties intended for objects
> of the type. Furthermore, error-prone notations have been
avoided,
> and the syntax of the language avoids the use of encoded forms in
> favor of more English-like constructs. Finally, the language
offers
> support for separate compilation of program units in a way that
> facilitates program development and maintenance, and which
> provides the same degree of checking between units as within a
> unit.
>
> 8 Concern for the human programmer was also stressed during the
> design. Above all, an attempt was made to keep to a relatively
> small number of underlying concepts integrated in a consistent
> and systematic way while continuing to avoid the pitfalls of
> excessive involution. The design especially aims to provide
> language constructs that correspond intuitively to the normal
> expectations of users.
>
> 9 Like many other human activities, the development of programs
> is becoming ever more decentralized and distributed.
Consequently,
> the ability to assemble a program from independently produced
> software components continues to be a central idea in the design.
> The concepts of packages, of private types, and of generic units
> are directly related to this idea, which has ramifications in many
> other aspects of the language. An allied concern is the
maintenance
> of programs to match changing requirements; type extension and the
> hierarchical library enable a program to be modified while
minimizing
> disturbance to existing tested and trusted components.
>
> 10 No language can avoid the problem of efficiency. Languages that
> require over-elaborate compilers, or that lead to the inefficient
use
> of storage or execution time, force these inefficiencies on all
> machines and on all programs. Every construct of the language was
> examined in the light of present implementation techniques. Any
> proposed construct whose implementation was unclear or that
> required excessive machine resources was rejected.
>
> Unquote!
>
> Which any programmer should take to mean that they should write High
> Integrity and Efficient code to maintain the Ada Design Goals. And that
> just one of many parts of the manual that address these type of concerns.
>
> Randy Brukardt may have writing one or more sections but as the list
> of authors states he was not alone. So, unless he wrote the intro he
> could of skipped that section. Just like most people who read the RM,
> they skip parts that does not deal with writing code. I personally have
> no problems that Randy Brukardt writing part(s) of the RM unless he
> wrote that intro. In that case, telling me to re-read it is just wrong.
>
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-19 21:48 ` Randy Brukardt
@ 2007-11-20 12:32 ` anon
2007-11-20 16:21 ` Adam Beneschan
` (2 more replies)
0 siblings, 3 replies; 24+ messages in thread
From: anon @ 2007-11-20 12:32 UTC (permalink / raw)
For Randy Brukardt.
You did not need to post three copies of you post! I read the first one.
Since, you want to sub-divide the RM that's fine. From 1.1.2 using (2
and 3) states the core starts in Section 1 .. 13. So using
"Section 1 General" paragraph 1.
Quote!
1 Ada is a programming language designed to support the
construction of long-lived, highly reliable software systems.
The language includes facilities to define packages of related
types, objects, and operations. The packages may be
parameterized and the types may be extended to support the
construction of libraries of reusable, adaptable software
components. The operations may be implemented as subprograms
using conventional sequential control structures, or as entries
that include synchronization of concurrent threads of control as
part of their invocation. The language treats modularity in the
physical sense as well, with a facility to support separate
compilation.
Unquote!
Which echoes the "Design Goals" with less detail. You step in that one.
But to extend this concept (answer) every paragraph under the Headings
"Implementation Requirements", "Implementation Permissions",
"Implementation Advice" and "NOTES" strengthen the concept of creating
"HIGH INTEGRITY and HIGH RELIABLE" software.
Note: The one and only and I do mean ONLY language that states in its
design and goal sections it was construct for high reliable and high
integrity software is Ada. Every language has a specific purpose, and Ada
purpose is for creating efficiency and integrity software. Just like COBOL
was created as a "COmmon Business-Oriented Language" and FORTRAN
was created as a "FORmula TRANslation" language.
In <fhta34$fv9$1@jacob-sparre.dk>, "Randy Brukardt" <randy@rrsoftware.com> writes:
>"anon" <anon@anon.org> wrote in message
>news:mYI%i.27882$if6.6495@bgtnsc05-news.ops.worldnet.att.net...
>> Intro or section 0 between 150 .. 200 lines in the RM for Ada 95!
>>
>> (long quote omitted).
>
>Ah, yes, the motherhood section. I was asking you to provide a *normative*
>reference (one that is actually binding on users/implementers), which the
>introduction is surely not such a section. (See the definition of
>"normative" in 1.1.2.)
>
>The introduction is just a list of "good" properties which really doesn't
>mean that much and has no bearing on the requirements for implementations
>and users. Pretty much every programming language has a version of these
>same goals. After all, can you imagine a programming language saying that it
>was designed to make unreliable programs with no regard to efficiency? Who'd
>use that?
>
>Others have explained the difference between properties of the language and
>properties of the toolset, so I won't spend more time on that.
>
> Randy.
>
>
>
>
>
>
>> Quote
>>
>> Design Goals
>>
>> 6 Ada was originally designed with three overriding concerns:
>> program reliability and maintenance, programming as a human
>> activity, and efficiency. This revision to the language was
>> designed to provide greater flexibility and extensibility,
>> additional control over storage management and synchronization,
>> and standardized packages oriented toward supporting important
>> application areas, while at the same time retaining the original
>> emphasis on reliability, maintainability, and efficiency.
>>
>> 7 The need for languages that promote reliability and simplify
>> maintenance is well established. Hence emphasis was placed
>> on program readability over ease of writing. For example, the
>> rules of the language require that program variables be explicitly
>> declared and that their type be specified. Since the type of a
>> variable is invariant, compilers can ensure that operations on
>> variables are compatible with the properties intended for objects
>> of the type. Furthermore, error-prone notations have been
>avoided,
>> and the syntax of the language avoids the use of encoded forms in
>> favor of more English-like constructs. Finally, the language
>offers
>> support for separate compilation of program units in a way that
>> facilitates program development and maintenance, and which
>> provides the same degree of checking between units as within a
>> unit.
>>
>> 8 Concern for the human programmer was also stressed during the
>> design. Above all, an attempt was made to keep to a relatively
>> small number of underlying concepts integrated in a consistent
>> and systematic way while continuing to avoid the pitfalls of
>> excessive involution. The design especially aims to provide
>> language constructs that correspond intuitively to the normal
>> expectations of users.
>>
>> 9 Like many other human activities, the development of programs
>> is becoming ever more decentralized and distributed.
>Consequently,
>> the ability to assemble a program from independently produced
>> software components continues to be a central idea in the design.
>> The concepts of packages, of private types, and of generic units
>> are directly related to this idea, which has ramifications in many
>> other aspects of the language. An allied concern is the
>maintenance
>> of programs to match changing requirements; type extension and the
>> hierarchical library enable a program to be modified while
>minimizing
>> disturbance to existing tested and trusted components.
>>
>> 10 No language can avoid the problem of efficiency. Languages that
>> require over-elaborate compilers, or that lead to the inefficient
>use
>> of storage or execution time, force these inefficiencies on all
>> machines and on all programs. Every construct of the language was
>> examined in the light of present implementation techniques. Any
>> proposed construct whose implementation was unclear or that
>> required excessive machine resources was rejected.
>>
>> Unquote!
>>
>> Which any programmer should take to mean that they should write High
>> Integrity and Efficient code to maintain the Ada Design Goals. And that
>> just one of many parts of the manual that address these type of concerns.
>>
>> Randy Brukardt may have writing one or more sections but as the list
>> of authors states he was not alone. So, unless he wrote the intro he
>> could of skipped that section. Just like most people who read the RM,
>> they skip parts that does not deal with writing code. I personally have
>> no problems that Randy Brukardt writing part(s) of the RM unless he
>> wrote that intro. In that case, telling me to re-read it is just wrong.
>>
>
>
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-20 12:32 ` anon
@ 2007-11-20 16:21 ` Adam Beneschan
2007-11-21 3:14 ` Randy Brukardt
2007-11-21 3:01 ` Randy Brukardt
2007-11-21 3:01 ` Randy Brukardt
2 siblings, 1 reply; 24+ messages in thread
From: Adam Beneschan @ 2007-11-20 16:21 UTC (permalink / raw)
On Nov 20, 4:32 am, a...@anon.org (anon) wrote:
> For Randy Brukardt.
>
> You did not need to post three copies of you post! I read the first one.
>
> Since, you want to sub-divide the RM that's fine. From 1.1.2 using (2
> and 3) states the core starts in Section 1 .. 13. So using
> "Section 1 General" paragraph 1.
Randy, I think he's got you there. Perhaps I should make a formal
request in Ada-Comment that 1.1.2(3) be changed from "Sections 1
through 13" to "Sections 1.1.3 through 13". And maybe I'm the right
person to submit this, since I seem someone who worries way too much
about the implications of taking the RM's language hyper-literally.
Maybe this should be brought up at an ARG meeting, for comic relief to
release some stress before delving into the next Baird issue. (I
notice you finally changed the !recommendation section of AI05-0051,
by the way...) :) :)
-- Adam
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-20 16:21 ` Adam Beneschan
@ 2007-11-21 3:14 ` Randy Brukardt
2007-11-21 8:03 ` anon
0 siblings, 1 reply; 24+ messages in thread
From: Randy Brukardt @ 2007-11-21 3:14 UTC (permalink / raw)
"Adam Beneschan" <adam@irvine.com> wrote in message
news:d5495389-9ee7-44f5-8a3e-864afdc7edee@s36g2000prg.googlegroups.com...
> On Nov 20, 4:32 am, a...@anon.org (anon) wrote:
> > For Randy Brukardt.
> >
> > You did not need to post three copies of you post! I read the first one.
> >
> > Since, you want to sub-divide the RM that's fine. From 1.1.2 using (2
> > and 3) states the core starts in Section 1 .. 13. So using
> > "Section 1 General" paragraph 1.
>
> Randy, I think he's got you there.
Not sure why you think so, none of the language talking about compilation
environments is echoed there. And the original discussion was about
compilation environments, not about the language itself.
> Perhaps I should make a formal
> request in Ada-Comment that 1.1.2(3) be changed from "Sections 1
> through 13" to "Sections 1.1.3 through 13". And maybe I'm the right
> person to submit this, since I seem someone who worries way too much
> about the implications of taking the RM's language hyper-literally.
<grin> I don't think there is anything wrong with 1.1 or 1.1.1. It *is*
unusual that Section 1 isn't marked as Redundant in the AARM, because it is
just the normal non-normative introductory text. (Most clauses in the RM
start with introductory text that doesn't include anything normative - it
just makes the purpose of the clause easier to understand for the reader. A
big difference between the Ada standard and many others is the attempt to
make it readable to ordinary programmers.) The real problem is that 1.12
doesn't clearly note that introductory text is non-normative - but that's
probably because there are some counter-examples.
> Maybe this should be brought up at an ARG meeting, for comic relief to
> release some stress before delving into the next Baird issue. (I
> notice you finally changed the !recommendation section of AI05-0051,
> by the way...) :) :)
Nawww, Tucker just did his homework and provided a new version, which
necessarily included a real recommendation. Of course, if you read his
e-mail that ends the !appendix of the e-mail, you'll note that the effect of
the AI hasn't changed any. :-)
Randy.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-21 3:14 ` Randy Brukardt
@ 2007-11-21 8:03 ` anon
0 siblings, 0 replies; 24+ messages in thread
From: anon @ 2007-11-21 8:03 UTC (permalink / raw)
If you read below the quote you would have read that I included all
paragraphs under the heading "Implementation Requirements",
"Implementation Permissions", "Implementation Advice" and "NOTES".
With that said, Section 1.1.5 paragraph 11, under the
"Implementation Permissions" heading states that the usages of
"compile line switch" converts the 'Standard Ada Compiler' to a
'Non-Standard Compiler' mode of operation that can reject
compilation_units that do not comply with the "Non-Standard" mode
or to halt compiling due to too many "errors/warnings".
Note: 'mode of operation' has to do with "compilation environments".
So, adding "-fstack-check" converts the standard GNAT compiler to
an "Non-standard compiler".
Also, the "-fstack-check" switch does not reject compilation_units
or halt process because of to many errors/warnings. It only halts
the process if the Storage_Error exception is not trapped and a
Storage_Error is raised, which could be apart of the algorithm.
So, it does not meet the definition of a "command line switch" in
Section 1.1.5 (11).
Also requesting that this switch becomes apart of the default
suggest that one wants all future GNAT Ada compiler to be
"Non-Standard" only Ada compile.
And does a 'Non-Standard' compiler imply "HIGH INTEGRITY and
HIGH RELIABLE" software, based on the RM? The answer is 'NO!'
In <fi07no$t2$1@jacob-sparre.dk>, "Randy Brukardt" <randy@rrsoftware.com> writes:
>"Adam Beneschan" <adam@irvine.com> wrote in message
>news:d5495389-9ee7-44f5-8a3e-864afdc7edee@s36g2000prg.googlegroups.com...
>> On Nov 20, 4:32 am, a...@anon.org (anon) wrote:
>> > For Randy Brukardt.
>> >
>> > You did not need to post three copies of you post! I read the first one.
>> >
>> > Since, you want to sub-divide the RM that's fine. From 1.1.2 using (2
>> > and 3) states the core starts in Section 1 .. 13. So using
>> > "Section 1 General" paragraph 1.
>>
>> Randy, I think he's got you there.
>
>Not sure why you think so, none of the language talking about compilation
>environments is echoed there. And the original discussion was about
>compilation environments, not about the language itself.
>
>> Perhaps I should make a formal
>> request in Ada-Comment that 1.1.2(3) be changed from "Sections 1
>> through 13" to "Sections 1.1.3 through 13". And maybe I'm the right
>> person to submit this, since I seem someone who worries way too much
>> about the implications of taking the RM's language hyper-literally.
>
><grin> I don't think there is anything wrong with 1.1 or 1.1.1. It *is*
>unusual that Section 1 isn't marked as Redundant in the AARM, because it is
>just the normal non-normative introductory text. (Most clauses in the RM
>start with introductory text that doesn't include anything normative - it
>just makes the purpose of the clause easier to understand for the reader. A
>big difference between the Ada standard and many others is the attempt to
>make it readable to ordinary programmers.) The real problem is that 1.12
>doesn't clearly note that introductory text is non-normative - but that's
>probably because there are some counter-examples.
>
>> Maybe this should be brought up at an ARG meeting, for comic relief to
>> release some stress before delving into the next Baird issue. (I
>> notice you finally changed the !recommendation section of AI05-0051,
>> by the way...) :) :)
>
>Nawww, Tucker just did his homework and provided a new version, which
>necessarily included a real recommendation. Of course, if you read his
>e-mail that ends the !appendix of the e-mail, you'll note that the effect of
>the AI hasn't changed any. :-)
>
> Randy.
>
>
>
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-20 12:32 ` anon
2007-11-20 16:21 ` Adam Beneschan
@ 2007-11-21 3:01 ` Randy Brukardt
2007-11-26 18:23 ` Adam Beneschan
2007-11-21 3:01 ` Randy Brukardt
2 siblings, 1 reply; 24+ messages in thread
From: Randy Brukardt @ 2007-11-21 3:01 UTC (permalink / raw)
"anon" <anon@anon.org> wrote in message
news:ZtA0j.33469$if6.26651@bgtnsc05-news.ops.worldnet.att.net...
...
> You did not need to post three copies of you post! I read the first one.
I didn't intend to post more than one; the first and second attempts failed
during the posting and I didn't realize that they had gotten through despite
the error. Since the newsreader sends before reading, I didn't notice the
multiple postings until later. I suppose it's what I get for feeding the
troll...
Randy.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-21 3:01 ` Randy Brukardt
@ 2007-11-26 18:23 ` Adam Beneschan
0 siblings, 0 replies; 24+ messages in thread
From: Adam Beneschan @ 2007-11-26 18:23 UTC (permalink / raw)
On Nov 20, 7:01 pm, "Randy Brukardt" <ra...@rrsoftware.com> wrote:
> "anon" <a...@anon.org> wrote in message
>
> news:ZtA0j.33469$if6.26651@bgtnsc05-news.ops.worldnet.att.net...
> ...
>
> > You did not need to post three copies of you post! I read the first one.
>
> I didn't intend to post more than one; the first and second attempts failed
> during the posting and I didn't realize that they had gotten through despite
> the error. Since the newsreader sends before reading, I didn't notice the
> multiple postings until later. I suppose it's what I get for feeding the
> troll...
Well, your explanation for why the post showed up three times only
showed up twice, so I guess that's an improvement. :)
This is a big problem with Google Groups, which I use to post. Too
often, I write my post and send it, and Google eventually comes back
with a message like "There was an error in posting, try again later",
only to find out that the post actually did make it out to Usenet and
I didn't really need to retry. It doesn't appear that you're using
Google to post, but apparently whatever method you're using suffers
from the same glitch.
-- Adam
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: Direct Quote from the RM
2007-11-20 12:32 ` anon
2007-11-20 16:21 ` Adam Beneschan
2007-11-21 3:01 ` Randy Brukardt
@ 2007-11-21 3:01 ` Randy Brukardt
2 siblings, 0 replies; 24+ messages in thread
From: Randy Brukardt @ 2007-11-21 3:01 UTC (permalink / raw)
"anon" <anon@anon.org> wrote in message
news:ZtA0j.33469$if6.26651@bgtnsc05-news.ops.worldnet.att.net...
...
> You did not need to post three copies of you post! I read the first one.
I didn't intend to post more than one; the first and second attempts failed
during the posting and I didn't realize that they had gotten through despite
the error. Since the newsreader sends before reading, I didn't notice the
multiple postings until later. I suppose it's what I get for feeding the
troll...
Randy.
^ permalink raw reply [flat|nested] 24+ messages in thread