Version 1.4 of ai12s/ai12-0330-1.txt

Unformatted version of ai12s/ai12-0330-1.txt version 1.4
Other versions for file ai12s/ai12-0330-1.txt

!standard N(0)          19-05-07 AI12-0330-1/01
!class Amendment 19-04-05
!status work item 19-04-05
!status received 19-03-08
!priority Low
!difficulty Easy
!subject Add items to the Glossary
!summary
Various new and pre-existing terms are added to the glossary.
!problem
We've defined a number of new concepts in Ada 2020, among them "parallel constructs", "logical thread of control", "reduction", "default initial condition", and "stable property". At least some of these should be added to the Glossary.
!proposal
(See Summary.)
!wording
Attribute A characteristic or property of an entity that can be queried, and in some cases specified.
Container Aggregate A construct used to define the value for a type that represents a collection of elements, by explicitly specifying the elements in the collection.
Check A test made during execution to determine whether a language rule has been violated.
Default Initial Condition A property that should hold for every default-initialized object of a given type.
Iterator Filter A construct that is used to restrict the elements produced by an iteration to those for which a boolean condition evaluates to True.
Logical Thread of Control An activity within the execution of a program that can proceed in parallel with other activities of the same task, or of separate tasks.
Master The execution of a construct that includes waiting for tasks and finalization of objects associated with the master, prior to leaving the construct.
Operational Aspect An aspect that indicates a logical property of an entity, such as the precondition of a subprogram, or the procedure used to write a given type of object to a stream.
parallel Construct An executable construct that defines multiple activities of a single task that can proceed in parallel, via the execution of multiple logical threads of control.
Reduction Expression An expression that defines how to map or transform a collection of values into a new set of values, and then summarize the values by applying an operation to reduce the set to a single value.
Representation Aspect An aspect that indicates how an entity is mapped onto the underlying hardware, for example the size or alignment of an object.
Stable Property A characteristic associated with objects of a given type that is preserved by many of the primitive operations of the type.
Subunit A body of a program unit that can be compiled separately from its enclosing program unit.
Suppress To turn off a run-time check for a portion of the text of a program.
!discussion
We tried to cover the interesting new concepts, as well as some existing concepts that were not previously defined in the glossary.
We might want to verify that most of these terms also appear in the index. At the moment, "logical thread of control" is not in the index.
!ASIS
[Not sure. It seems like some new capabilities might be needed, but I didn't check - Editor.]
!ACATS test
ACATS B- and C-Tests are needed to check that the new capabilities are supported.
!appendix

From: Randy Brukardt
Sent: Friday, March 8, 2019  7:39 PM

>Annex N I would like more items, such as Attribute, Check, Master, 
>Operational Aspect, Representation Aspect, Subunit, Suppress.  But I 
>think I had Annex N to review for Ada 2012 too and my request was 
>turned down then.

Some of those terms might be valuable, but I'd guess it would be even more 
useful to add some terms around parallel constructs, like say, "parallel 
construct" :-), "logical thread of control", and "reduction".

Do we have someone volunteering to propose some additional Glossary entries 
(including the definitions, silly :-)??

P.S. I believe that Jeff is away on "holiday", so we can't talk him into it 
today.

***************************************************************

From: Jeff Cousins
Sent: Thursday, April 4, 2019  8:49 PM

> You're right, of course, but we need Glossary entries for lots of things 
and I didn't get any volunteers when I asked last month.
 
Hereís a shot at the items that I suggested.  No doubt as everyone knows a 
bit about this everyone will comment.
 
Attribute
A characteristic or property of an entity that can be queried, and in some 
cases specified.  (I darenít tackle how this overlaps with aspect!).

Check
A test made during execution that some unusual condition has not occurred.

Master
The execution of a construct that includes the finalisation of local objects 
(after completion but before leaving).

Operational Aspect
Aspects other than Representation Aspects.

Representation Aspect
An aspect that affects how an entity is mapped onto the underlying hardware, 
for example the size or alignment of an object.

Subunit
A body that can be compiled separately from its embracing library unit. (Only 
GNAT doesnít ? ).

Suppress
To turn off a run-time check.

***************************************************************

From: Randy Brukardt
Sent: Thursday, April 4, 2019  8:49 PM

Great, but that doesn't include anything NEW, which seems to be the most 
critical need.

Ed asked for "default initial condition", presumably because all of the other 
assertion contracts already have a glossary entry (and that was obvious in the 
text he was reviewing 

I had suggested at a minimum "parallel construct", "logical thread of 
control", and "reduction". There may be others.

P.S. I need to know where to place the entries as well. Glossary entries are 
actually given in as AARM notes next to the formal definition (scattered about 
the Standard); the tools make the actual annex at the end. Side thought: it's 
a bit annoying that the information about the location of the formal definition 
isn't displayed in the glossary, since that wouldn't be very hard to do, at 
least in non-ISO editions.

***************************************************************

From: Randy Brukardt
Sent: Friday, April 5, 2019  11:02 PM

...
>Hereís a shot at the items that I suggested.  No doubt as everyone 
>knows a bit about this everyone will comment.

So far this message has gotten the same response as the original call for a 
volunteer. I suppose that says something too.
	 
...
>Master
>
>The execution of a construct that includes the finalisation of local 
>objects (after completion but before leaving).

We just had a long discussion of 's' vs. 'z' in "finalization". Hope we don't 
have another one. :-)

>Operational Aspect
>Aspects other than Representation Aspects.

Not strictly true, there are a few that aren't officially classed as either. 
If they have enough rules (like "Pre"), that doesn't matter. In any event, 
this is rather circular. It should say something about properties, as in 
13.1. Maybe:

An aspect that defines properties of an entity other than representation 
properties (see Representation Aspect).
	 
>Subunit
>A body that can be compiled separately from its embracing library unit.  
>(Only GNAT doesnít ? ).

I'm pretty sure we can't put emojies into the Standard; probably can't refer 
to GNAT either. ;-)

***************************************************************

From: Jeff Cousins
Sent: Saturday, April 6, 2019  3:49 AM

>>The execution of a construct that includes the finalisation of local objects 
>>(after completion but before leaving).

>We just had a long discussion of 's' vs. 'z' in "finalization". Hope we don't 
have another one. :-)
 
Iíd deliberately typed Ďzí in deference to my American colleagues, but the 
spell-checker must have auto-corrected it.

***************************************************************

From: Jeff Cousins
Sent: Saturday, April 6, 2019  12:04 PM

> Great, but that doesn't include anything NEW, which seems to be the 
> most critical need.
 
I actually see the newer terms as being less important as they're for the more 
advanced users, whereas some of the older terms are building blocks for how 
Ada views the world, and should have been in the glossary years ago.

I would prefer the authors of the relevant AIs to state their intended 
meaning rather than me potentially second-guessing them, but I've had a go at 
a few of them.

> Glossary entries are actually given in as AARM notes next to the formal 
> definition 
 
Iím hoping that the glossary terms are more user-friendly than the sometimes 
convoluted words of the formal definition.

Attribute

A characteristic or property of an entity that can be queried, and in some 
cases specified. (First defined in 4.1.4).

 
Check
A test made during execution that some unusual condition has not occurred.
(These are mentioned all over the place, but the place to talk about them in 
general rather than specific checks looks to be 11 Exceptions).

 
Default Initial Condition
A condition that must hold true after the default initialization of an object. 
(Defined in 7.3.3 (2.a/5).

Logical Thread of Control
To paraphrase Wikipedia:
The smallest sequence of programmed instructions that can be scheduled 
independently.
(This is the successor to Task as the lowest level concurrent entity for most 
purposes, but Task wasn't defined in the Glossary either.
If we are going to define it, presumably it should go in 9 - 5.1 says see 9 
for a definition, but there isn't (yet) a definition there).

Master
The execution of a construct that includes the finalization of local objects 
(after completion but before leaving).
(Defined in 7.6.1).

Operational Aspect
An aspect that defines properties of an entity other than representation 
properties (see Representation Aspect).
(Defined in 13.1).

Parallel Construct
A parallel construct is a construct that introduces additional logical threads 
of control without creating a new task. Parallel loops and parallel block 
statements are examples of parallel constructs.
(Defined in 5.1).

Reduction Expression
A reduction expression maps or transforms a collection of values into a new 
set of values, and then summarizes the values produced by applying an 
operation to reduce the set to a single value result.
(Defined in 4.5.10).

Representation Aspect
An aspect that affects how an entity is mapped onto the underlying hardware, 
for example the size or alignment of an object.
(Defined in 13.1).

Subunit
A body that can be compiled separately from its embracing library unit.
(Defined in 10.1.3).
 
Suppress
To turn off a run-time check.
(Defined in 10.5).

***************************************************************

From: Tucker Taft
Sent: Tuesday, May 7, 2019  4:02 PM

Enjoy! [Followed by version /01 of the AI - Editor.]

***************************************************************

From: Randy Brukardt
Sent: Tuesday, May 7, 2019  4:18 PM

...
> We might want to verify that most of these terms also appear in the 
> index.
> At the moment, "logical thread of control" is not in the index.

It's not in the index because it is never defined in the Standard. It's used
a lot, but there is nothing resembling a definition in either Chapter 5 or 9.
So what would the index entry point to??

In general, it is helpful if one points out where each of these glossary items 
is defined (each entry appears in the AARM at that point, the actual glossary 
is a constructed entity).

***************************************************************

From: Jeff Cousins
Sent: Wednesday, May 7, 2019  5:49 AM

This was my list of where terms are defined:

Attribute
A characteristic or property of an entity that can be queried, and in some 
cases specified.
(First defined in 4.1.4).

Check
A test made during execution that some unusual condition has not occurred.
(These are mentioned all over the place, but the place to talk about them 
in general rather than specific checks looks to be 11 Exceptions).

Default Initial Condition
A condition that must hold true after the default initialization of an object. 
(Defined in 7.3.3 (2.a/5).

Logical Thread of Control
To paraphrase Wikipedia:
The smallest sequence of programmed instructions that can be scheduled 
independently.
(This is the successor to Task as the lowest level concurrent entity for most 
purposes, but Task wasn't defined in the Glossary either.

If we are going to define it, presumably it should go in 9 - 5.1 says see 9 
for a definition, but there isn't (yet) a definition there).

Master
The execution of a construct that includes the finalization of local objects 
(after completion but before leaving).
(Defined in 7.6.1).

Operational Aspect
An aspect that defines properties of an entity other than representation 
properties (see Representation Aspect).
(Defined in 13.1).

Parallel Construct
A parallel construct is a construct that introduces additional logical threads 
of control without creating a new task. Parallel loops and parallel block 
statements are examples of parallel constructs.
(Defined in 5.1).

Reduction Expression
A reduction expression maps or transforms a collection of values into a new 
set of values, and then summarizes the values produced by applying an 
operation to reduce the set to a single value result.
(Defined in 4.5.10).

Representation Aspect
An aspect that affects how an entity is mapped onto the underlying hardware, 
for example the size or alignment of an object.
(Defined in 13.1).

Subunit
A body that can be compiled separately from its embracing library unit.
(Defined in 10.1.3).

Suppress
To turn off a run-time check.
(Defined in 10.5).

***************************************************************

From: Tucker Taft
Sent: Wednesday, May 7, 2019  8:19 AM

> ...
>> We might want to verify that most of these terms also appear in the 
>> index.
>> At the moment, "logical thread of control" is not in the index.
> 
> It's not in the index because it is never defined in the Standard. 
> It's used a lot, but there is nothing resembling a definition in 
> either Chapter 5 or 9. So what would the index entry point to??

I think it can still be useful to index all *uses* of a term, even if it isn't 
felt necessary to have an Ada-specific definition of the term in the RM.

> In general, it is helpful if one points out where each of these 
> glossary items is defined (each entry appears in the AARM at that 
> point, the actual glossary is a constructed entity.

Sorry, I didn't know about that requirement.  I presume you figured that out.
If not, it looks like Jeff might have done the work.

***************************************************************

From: Randy Brukardt
Sent: Wednesday, May 7, 2019  2:13 PM

> > It's not in the index because it is never defined in the Standard. 
> > It's used a lot, but there is nothing resembling a definition in 
> > either Chapter 5 or 9. So what would the index entry point to??
> 
> I think it can still be useful to index all *uses* of a term, even if 
> it isn't felt necessary to have an Ada-specific definition of the term 
> in the RM.

The index, in general, does not index uses of a term. There are a few special
cases where that is done (generally where the property is important to 
users/implementers, like "implementation-defined" or "inconsistent"). And even 
in those cases, there is an actual definition that is indexed first.

There is no definition of any sort (even informal) in the RM; this glossary 
entry is the first attempt at it. I suppose the glossary entry will get 
indexed (I think that happens automatically), so perhaps that is good enough 
(unless someone wants to take another swing at revising the intro to 
Chapter 9).

***************************************************************

Questions? Ask the ACAA Technical Agent