Version 1.3 of ai12s/ai12-0313-1.txt

ai12s/ai12-0313-1.txt version 1.3

Other versions for file ai12s/ai12-0313-1.txt Unformatted version ofOther versions for file

!standard 0.3(57.21/3) 19-03-09 AI12-0313-1/02

!class presentation 19-02-07

!status work item 19-02-07

!status received 19-02-07

!priority Low

!difficulty Easy

!subject Introduction for Ada 2020

!summary

A Language Changes section for Ada 2020 is added, and the Design Goals and Language Summary are updated for Ada 2020.

!question

The Language Changes section in the Introduction is for Ada 2012. It needs to be replaced, right? (Yes.)

Similarly, the Design Goals and Language Summary in the Introduction should be updated, right? (Yes.)

!response

(See Summary.)

!wording

In Design Goals:

Modify paragraph Intro(6/3):

Ada was originally designed with three overriding concerns: program reliability and maintenance, programming as a human activity, and efficiency. The 1995 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. [This third edition provides] {Subsequent editions, including this 2020 edition, have provided} further flexibility and add[s]{ed} more standardized packages within the framework provided by the 1995 revision.

Modify paragraph Intro(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. {Parallel constructs were introduced to simplify making safe and efficient use of modern multicore architectures.}

In Language Summary, Other Facilities:

Add after paragraph Intro(41/2):

Aspect clauses can also be used to specify more abstract properties of program entities, such as the pre- and postconditions of a subprogram, or the invariant for a private type. Additional aspects are specifiable to allow user-defined types to use constructs of the language, such as literals, aggregates, or indexing, normally reserved for particular language-defined categories of types, such as numeric types, record types, or array types.

In Language Changes:

Replace the whole "Language Changes" section with the following:

This International Standard replaces the third edition of 2012. It modifies the previous edition by making changes and additions that improve the capability of the language and the reliability of programs written in the language.

Significant changes in this edition are:

- Improved support for parallel execution is provided via the

introduction of parallel loops, parallel blocks, parallel container iteration, and parallel reduction.

- More precise specification of subprogram interfaces is supported via

the new aspects Global, Global'Class, and Nonblocking. The Global aspects, in particular, help to determine whether two constructs can safely execute in parallel.

- Pre and Post aspects may now be specified for access to subprogram

types and for generic formal subprograms; a postcondition for a type's default initialization may be specified using the new Default_Initial_Condition aspect.

- The behavior of many predefined container operations is now more

precisely specified by using pre- and postcondition specifications instead of English descriptions; a stable view for most containers is introduced to support more efficient iteration.

- More flexible uses of static expressions are supported via the

introduction of static expression functions along with fewer restrictions on static strings.

- The Image attribute is supported for non-scalar types, and a

user-specifiable attribute Put_Image is provided, which determines the value of the Image attribute for a user-defined type.

- The use of numeric and string literals is generalized to support

other sorts of types, via the new Integer_Literal, Real_Literal, and String_Literal aspects.

- Array and record aggregates are made more flexible: index parameters

are allowed in an array aggregate to define the components as a function of their array index; discriminants can be defined more flexibly within an aggregate for a variant record type.

- New types of aggregates are provided: delta aggregates to allow

the construction of a new object by incremental updates to an existing object; container aggregates to allow construction of an object of a container type by directly specifying its elements.

- A short-hand is provided, using the token '@', to refer to the

target of an assignment statement in the expression defining its new value.

- "Declare" expressions are provided which permit the definition and

use of local constants or renamings, to allow an expression used within an aspect specification to be more concise and readable.

- Support for lightweight iteration is added via the introduction of

procedural iterators.

- Support for the map-reduce programming strategy is added via the

introduction of reduction expressions.

- Predefined packages supporting arbitrary-precision integer and real

arithmetic are provided.

- The Jorvik profile is introduced to support hard real-time

applications that need to go beyond the restrictions of the Ravenscar profile.

!discussion

Areas that probably ought to be covered (some things are in multiple categories):

* Parallel constructs (loops, blocks, reductions)

* Improved aggregates (delta aggregates, container aggregates, iterators in aggregates)

* Increased abstraction (user-defined literals, user-defined image, static expression functions, reductions)

* Additional contracts (default-initial-condition, nonblocking, global, stable-properties)

* Additional static error detection (conflict check policies, nonblocking, global)

* Additional expressiveness for expressions (declare expression, reductions)

* Improved readability (target symbol, null/single element aggregate notation [brackets!], simplified object renames)

* Real-time improvements (aspect Yield, new EDF, queue length control, profile Yorvik)

* other (object_size, Enum_Rep/Enum_Val)

!ASIS

None needed.

!ACATS test

No ACATS tests needed.

!appendix

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

Questions? Ask the ACAA Technical Agent

