CVS difference for ais/ai-00437.txt

Differences between 1.5 and version 1.6
Log of other versions for file ais/ai-00437.txt

--- ais/ai-00437.txt	2006/03/07 01:30:48	1.5
+++ ais/ai-00437.txt	2006/04/20 05:31:57	1.6
@@ -1,4 +1,4 @@
-!standard N         (01)                               06-02-23  AI95-00437/04
+!standard N         (01)                               06-04-19  AI95-00437/05
 !standard N         (03)
 !standard N         (04)
 !standard N         (06)
@@ -107,12 +107,12 @@
 is an array. A discriminant for a task type can be used to pass
 data to a task of the type upon creation.
 
-Elaboration. The process by which a declaration has its run-time effect
+Elaboration. The process by which a declaration achieves its run-time effect
 is called elaboration. Elaboration is one of the forms of execution.
 
 Add after N(17):
 
-Evaluation. The process by which an expression has its run-time effect
+Evaluation. The process by which an expression achieves its run-time effect
 is called evaluation. Evaluation is one of the forms of execution.
 
 Add after N(19):
@@ -163,7 +163,7 @@
 Private type. A private type gives a view of a type that reveals only some of
 its properties. The remaining properties are provided by the full view given
 elsewhere. Private types can be used for defining abstractions that hide
-unnecessary details from its clients.
+unnecessary details from their clients.
 
 Procedure. A procedure is a form of subprogram that does not return a result
 and can only be called by a statement.
@@ -186,7 +186,7 @@
 
 Add after N(37):
 
-Subprogram. A subprogram is a section of program that can be executed in
+Subprogram. A subprogram is a section of a program that can be executed in
 various contexts. It is invoked by a subprogram call that may qualify the
 effect of the subprogram through the passing of parameters. There are two forms
 of subprograms: functions, which return values, and procedures, which do not.
@@ -329,7 +329,7 @@
 is an array. A discriminant for a task type can be used to pass
 data to a task of the type upon creation.
 
-@b<Elaboration.> The process by which a declaration has its run-time effect
+@b<Elaboration.> The process by which a declaration achieves its run-time effect
 is called elaboration. Elaboration is one of the forms of execution.
 
 !corrigendum N(17)
@@ -338,7 +338,7 @@
 @b<Enumeration type.> An enumeration type is defined by an enumeration of its
 values, which may be named by identifiers or character literals.
 @dinst
-@b<Evaluation.> The process by which an expression has its run-time effect
+@b<Evaluation.> The process by which an expression achieves its run-time effect
 is called evaluation. Evaluation is one of the forms of execution.
 
 !corrigendum N(19)
@@ -440,7 +440,7 @@
 @b<Private type.> A private type gives a view of a type that reveals only some
 of its properties. The remaining properties are provided by the full view given
 elsewhere. Private types can be used for defining abstractions that hide
-unnecessary details from its clients.
+unnecessary details from their clients.
 
 @b<Procedure.> A procedure is a form of subprogram that does not return a
 result and can only be called by a @fa<statement>.
@@ -474,7 +474,7 @@
 @dinsa
 @b<Scalar type.> A scalar type is either a discrete type or a real type.
 @dinst
-@b<Subprogram.> A subprogram is a section of program that can be executed in
+@b<Subprogram.> A subprogram is a section of a program that can be executed in
 various contexts. It is invoked by a subprogram call that may qualify the
 effect of the subprogram through the passing of parameters. There are two forms
 of subprograms: functions, which return values, and procedures, which do not.
@@ -688,6 +688,107 @@
 refer to syntax items, it seems a bit silly to put them in the Glossary.
 
 Jeff's last list seems redundant with things that are defined already.
+
+****************************************************************
+
+From: Tucker Taft
+Sent: Friday, April 14, 2006  10:00 PM
+
+Here are some funnies that I noticed in the glossary:
+
+    Elaboration. The process by which a declaration has its run-time
+    effect is called elaboration. Elaboration is one of the forms of
+    execution.
+
+    Evaluation. The process by which an expression has its run-time
+    effect is called evaluation. Evaluation is one of the forms of
+    execution.
+
+    Execution. The process by which a construct achieves its run-time
+    effect is called execution. Execution of a declaration is also
+    called elaboration. Execution of an expression is also called
+    evaluation.
+
+  It is weird that two of these say "has its run-time effect"
+  and the other says "achieves its run-time effect."  Since
+  "Execution" was already in the glossary, it seems like the
+  other two should conform to that and also say "achieves" rather
+  than "has."
+
+---
+
+    Private type. A private type gives a view of a type that reveals
+    only some of its properties. The remaining properties are provided
+    by the full view given elsewhere. Private types can be used for
+    defining abstractions that hide unnecessary details from its clients.
+
+  This should either be "... from their clients" or:
+
+    ... A private type can be used to define an abstraction that hides
+    unnecessary details from its clients.
+
+---
+
+    Subprogram. A subprogram is a section of program that can be executed
+    in various contexts. ...
+
+  A "section of program"?  That sounds like a "slice of salami."  I would
+  suggest either a "section of a program" or better, a "program unit"
+  since that is the term we use when defining a "package" earlier in
+  the glossary.
+
+****************************************************************
+
+From: Randy Brukardt
+Sent: Wednesday, April 19, 2006  9:20 PM
+
+...
+>   It is weird that two of these say "has its run-time effect"
+>   and the other says "achieves its run-time effect."  Since
+>   "Execution" was already in the glossary, it seems like the
+>   other two should conform to that and also say "achieves" rather
+>   than "has."
+
+It's just wrong, actually. The definition uses "achieve". I'll change it. (Note
+that this is a *very* marginal change at this point, but as it's only a single
+word and not a significant meaning change, I'll do it.)
+
+...
+>     Private type. A private type gives a view of a type that reveals
+>     only some of its properties. The remaining properties are provided
+>     by the full view given elsewhere. Private types can be used for
+>     defining abstractions that hide unnecessary details from its clients.
+>
+>   This should either be "... from their clients" or:
+>
+>     ... A private type can be used to define an abstraction that hides
+>     unnecessary details from its clients.
+
+At this point, we're making minimum changes to fix typos; "its" to "their"
+qualifies; the rewording doesn't.
+
+...
+>     Subprogram. A subprogram is a section of program that can be executed
+>     in various contexts. ...
+>
+>   A "section of program"?  That sounds like a "slice of salami."  I would
+>   suggest either a "section of a program" or better, a "program unit"
+>   since that is the term we use when defining a "package" earlier in
+>   the glossary.
+
+"slice of program" sounds fine to me. :-0
+
+Anyway, consistent with the above, I'll add "a".
+
+In any case, defining "subprogram" in terms of "program unit" and then defining
+"program unit" in terms of "subprogram" is a no-no.
+
+You have pointed out that "package" is wrong in this way, but it's too late to
+fix it. "A package is a program unit..." "A program unit is either a package,
+..."!! Yuck!
+
+[If someone objects, the changes would be removed and presented to the ARG as
+part of AI05-0004 for future fixing. But hopefully no one will object.]
 
 ****************************************************************
 

Questions? Ask the ACAA Technical Agent