Merge branch 'slides/116-update-slides-to-remove-some-ada-2012-references' into 'master'

Resolve "Update slides to remove some Ada 2012 references"

Closes #116

See merge request feng/training/material!210

Author: frank-at-adacore

courses/fundamentals_of_ada/020_declarations.rst

@@ -834,12 +834,12 @@ Aspect Clause Example: Objects
 
    .. code:: Ada
 
+      -- using aspects
       CR1 : Control_Register with
          Size    => 8,
          Address => To_Address (16#DEAD_BEEF#);
 
-      -- Prior to Ada 2012
-      -- using *representation clauses*
+      -- using representation clauses
       CR2 : Control_Register;
       for CR2'Size use 8;
       for CR2'Address use To_Address (16#DEAD_BEEF#);

courses/fundamentals_of_ada/040_statements.rst

@@ -601,10 +601,6 @@ Basic Loops and Syntax
         Rinse (Hair);
       end loop Wash_Hair;
 
-.. container:: speakernote
-
-    Loop Iterator Specification available in Ada2012 and later
-
 --------------------
 Loop Exit Statements
 --------------------
@@ -698,7 +694,6 @@ For-loop Statements
 
 * Two high-level forms
 
-   - Ada 2012
    - Focused on objects
    - Seen later with Arrays
 

courses/fundamentals_of_ada/050_array_types.rst

@@ -36,7 +36,7 @@ Array Types
 .. include:: 050_array_types/03-unconstrained_array_types.rst
 .. include:: 050_array_types/04-attributes.rst
 .. include:: 050_array_types/05-operations.rst
-.. include:: 050_array_types/06-operations_added_for_ada2012.rst
+.. include:: 050_array_types/06-looping_over_objects.rst
 .. include:: 050_array_types/07-aggregates.rst
 .. include:: 050_array_types/08-detour_image_for_complex_types.rst
 .. include:: 050_array_types/09-anonymous_array_types.rst

courses/fundamentals_of_ada/050_array_types/06-operations_added_for_ada2012.rst renamed to courses/fundamentals_of_ada/050_array_types/06-looping_over_objects.rst

@@ -1,15 +1,16 @@
 ==============================
-Operations Added for Ada2012
+Looping Over Array Components
 ==============================
 
-----------------------------------------
-Default Initialization for Array Types
-----------------------------------------
+------------------------------------------------
+Note on Default Initialization for Array Types
+------------------------------------------------
 
-* Supports constrained and unconstrained array types
-* Supports arrays of any dimensionality
+* In Ada, objects are not initialized by default
+* To initialize an array, you can initialize each element
 
-   - No matter how many dimensions, there is only one component type
+   * But if the array type is used in multiple places, it would be better to initialize at the type level
+   * No matter how many dimensions, there is only one component type
 
 * Uses aspect `Default_Component_Value`
 

courses/fundamentals_of_ada/070_subprograms.rst

@@ -962,8 +962,11 @@ Parameter Aliasing
 
    procedure Update (Doubled, Tripled : in out Integer);
    ...
-   Update (Doubled => A,
-           Tripled => A);  -- illegal in Ada 2012
+   Update (Doubled => A, Tripled => A);
+
+.. container:: latex_environment footnotesize
+
+   :command:`error: writable actual for "Doubled" overlaps with actual for "Tripled"`
 
 ----------------------------
 Functions' Parameter Modes
@@ -975,7 +978,7 @@ Functions' Parameter Modes
    - Including those you overload
    - Keeps readers sane
 
-* Justification for only mode :ada:`in` prior to Ada 2012
+* Justification for only mode :ada:`in` in earlier versions of the language
 
    - No side effects: should be like mathematical functions
    - But side effects are still possible via globals
@@ -1045,13 +1048,6 @@ Tic-Tac-Toe Winners Example (Spec)
         - :subscript:`8` N
         - :subscript:`9` N
 
-.. container:: speakernote
-
-   Prior to Ada2012 use:
-   type Game is record
-     Board : Moves := (others ``=>`` Nobody);
-   end record;
-
 ------------------------------------
 Tic-Tac-Toe Winners Example (Body)
 ------------------------------------

courses/fundamentals_of_ada/090_overloading/05-composition_of_equality.rst

@@ -91,8 +91,8 @@ User-Defined Equality Composition
 
 * No issue for all language-defined types in all versions of Ada
 * An issue for user-defined types
-* Only automatic for :ada:`record` types in Ada 2012
-* Only automatic for :ada:`tagged record` types in Ada 2005
+* Became automatic for :ada:`record` types in Ada 2012
+* Became automatic for :ada:`tagged record` types in Ada 2005
 
    - Otherwise need explicit equality function for enclosing type
 

courses/fundamentals_of_ada/130_program_structure.rst

@@ -980,7 +980,7 @@ Summary
 
    - Direct support for subsystems
    - Extension without recompilation
-   - Separation of concerns with controlled sharing of visibility (Ada 2012)
+   - Separation of concerns with controlled sharing of visibility
 
 * Parents should document assumptions for children
 

courses/fundamentals_of_ada/135_visibility.rst

@@ -294,12 +294,10 @@ No Ambiguity Introduction
 
       use all type subtype_mark {, subtype_mark};
 
-* More specific alternative to :ada:`use` clauses
+* More specific alternatives to :ada:`use` clauses
 
    - Especially useful when multiple :ada:`use` clauses introduce ambiguity
 
-*Note that* :ada:`use all type` *was introduced in Ada 2012*
-
 --------------
 Example Code
 --------------
@@ -496,8 +494,6 @@ Summary
 
 * :ada:`use all type` clauses are more likely in practice than :ada:`use type` clauses
 
-   - Only available in Ada 2012 and later
-
 * :ada:`Renames` allow us to alias entities to make code easier to read
 
    - Subprogram renaming has many other uses, such as adding / removing default parameter values

courses/fundamentals_of_ada/230_interfacing_with_c.rst

@@ -56,49 +56,50 @@ Introduction
 Import / Export
 =================
 
-------------------------------
-Pragma Import / Export (1/2)
-------------------------------
+-------------------------------
+Import / Export Aspects (1/2)
+-------------------------------
 
-* :ada:`pragma Import` allows a C implementation to complete an Ada specification
+* Aspects :ada:`Import` and :ada:`Export` allow Ada and C to interact
 
-   - Ada view
+   * :ada:`Import` indicates a subprogram imported into Ada
+   * :ada:`Export` indicates a subprogram exported from Ada
 
-      .. code:: Ada
+* Need aspects definining calling convention and external name
 
-         procedure C_Proc;
-         pragma Import (C, C_Proc, "SomeProcedure");
+  * :ada:`Convention => C` tells linker to use C-style calling convention
+  * :ada:`External_Name => "<name>"` defines object name for linker
 
-   - C implementation
+* Ada implementation
 
-       .. code:: C
-
-          void SomeProcedure (void) {
-             // some code
-          }
+   .. code:: Ada
 
-* :ada:`pragma Export` allows an Ada implementation to complete a C specification
+      procedure Imported_From_C with
+         Import,
+         Convention    => C, 
+         External_Name => "SomeProcedureInC";
 
-   - Ada implementation
+      procedure Exported_To_C with
+         Export,
+         Convention    => C, 
+         External_Name => "some_ada_procedure;
 
-       .. code:: Ada
+* C implementation
 
-          procedure Some_Procedure;
-          pragma Export (C, Some_Procedure, "ada_some_procedure");
-          procedure Some_Procedure is
-          begin
-           -- some code
-          end Some_Procedure;
+    .. code:: C
 
-   - C view
+       void SomeProcedureInC (void) {
+          // some code
+       }
 
-       .. code:: C
+       extern void ada_some_procedure (void);
 
-          extern void ada_some_procedure (void);
+..
+  language_version 2012
 
-------------------------------
-Pragma Import / Export (2/2)
-------------------------------
+-------------------------------
+Import / Export Aspects (2/2)
+-------------------------------
 
 * You can also import/export variables
 
@@ -107,7 +108,10 @@ Pragma Import / Export (2/2)
 
       .. code:: Ada
 
-         My_Var : integer_type;
+         My_Var : Integer_Type with 
+            Import,
+            Convention    => C,
+            External_Name => "my_var";
          Pragma Import (C, My_Var, "my_var");
 
    - C implementation
@@ -116,21 +120,22 @@ Pragma Import / Export (2/2)
 
          int my_var;
 
------------------------------
-Import / Export in Ada 2012
------------------------------
+..
+  language_version 2012
+
+------------------------------
+Import / Export with Pragmas
+------------------------------
 
-* In Ada 2012, :ada:`Import` and :ada:`Export` can also be done using aspects:
+* You can also use :ada:`pragma` to import/export entities
 
    .. code:: Ada
 
-      procedure C_Proc
-        with Import,
-             Convention    => C,
-             External_Name => "c_proc";
+      procedure C_Some_Procedure;
+      pragma Import (C, C_Some_Procedure, "SomeProcedure");
 
-..
-  language_version 2012
+      procedure Some_Procedure;
+      pragma Export (C, Some_Procedure, "ada_some_procedure");
 
 ===================
 Parameter Passing
@@ -198,24 +203,26 @@ Passing Structures As Parameters
 * Ada View
 
    .. code:: Ada
-
-     type Enum is (E1, E2, E3);
-     Pragma Convention (C, Enum);
+     type Enum is (E1, E2, E3) with Convention => C;
      type Rec is record
        A, B : int;
        C : Enum;
-     end record;
-     Pragma Convention (C, Rec);
+     end record with Convention => C;
 
-* Using Ada 2012 aspects
+* This can also be done with pragmas
 
    .. code:: Ada
 
-     type Enum is (E1, E2, E3) with Convention => C;
+     type Enum is (E1, E2, E3);
+     Pragma Convention (C, Enum);
      type Rec is record
        A, B : int;
        C : Enum;
-     end record with Convention => C;
+     end record;
+     Pragma Convention (C, Rec);
+
+..
+  language_version 2012
 
 -----------------
 Parameter Modes

courses/fundamentals_of_ada/270_introduction_to_contracts.rst

@@ -64,15 +64,15 @@ Ada Contracts
    - At compile-time: specific constructs, features, and rules
    - At run-time: language-defined and user-defined exceptions
 
-* Facilities prior to Ada 2012
+* Facilities as part of the language definition
 
    - Range specifications
    - Parameter modes
    - Generic contracts
-   - OOP :ada:`interface` types (Ada 2005)
+   - OOP :ada:`interface` types
    - Work well, but on a restricted set of use-cases
 
-* Contracts aspects are explicitly added in **Ada 2012**
+* Contract aspects to be more expressive
 
    - Carried by subprograms
    - ... or by types (seen later)
@@ -145,7 +145,7 @@ Quiz
 
 Which of the following statements is (are) correct?
 
-    A. Contract principles apply only to Ada 2012
+    A. Contract principles apply only to newer versions of the language
     B. :answer:`Contract should hold even for unique conditions and corner cases`
     C. Contract principles were first implemented in Ada
     D. You cannot be both supplier and client
@@ -154,7 +154,7 @@ Which of the following statements is (are) correct?
 
     Explanations
 
-    A. No, but design-by-contract **aspects** are fully integrated to Ada 2012 design
+    A. No, but design-by-contract **aspects** were fully integrated into Ada 2012
     B. Yes, special case should be included in the contract
     C. No, in eiffel, in 1986!
     D. No, in fact you are always **both**, even the :ada:`Main` has a caller!