Logo
  • About

Courses

  • Introduction to Ada
    • Introduction
      • History
      • Ada today
      • Philosophy
      • SPARK
    • Imperative Language
      • Hello world
      • Imperative language - If/Then/Else
      • Imperative language - Loops
        • For loops
        • Bare loops
        • While loops
      • Imperative language - Case statement
      • Imperative language - Declarative regions
      • Imperative language - conditional expressions
        • If expressions
        • Case expressions
    • Subprograms
      • Subprograms
        • Subprogram calls
        • Nested subprograms
        • Function calls
      • Parameter modes
      • Subprogram calls
        • In parameters
        • In out parameters
        • Out parameters
        • Forward declaration of subprograms
      • Renaming
    • Modular Programming
      • Packages
      • Using a package
      • Package body
      • Child packages
        • Child of a child package
        • Multiple children
        • Visibility
      • Renaming
    • Strongly Typed Language
      • What is a type?
      • Integers
        • Operational semantics
      • Unsigned types
      • Enumerations
      • Floating-point types
        • Basic properties
        • Precision of floating-point types
        • Range of floating-point types
      • Strong typing
      • Derived types
      • Subtypes
        • Subtypes as type aliases
    • Records
      • Record type declaration
      • Aggregates
      • Component selection
      • Renaming
    • Arrays
      • Array type declaration
      • Indexing
      • Simpler array declarations
      • Range attribute
      • Unconstrained arrays
      • Predefined array type: String
      • Restrictions
      • Returning unconstrained arrays
      • Declaring arrays (2)
      • Array slices
      • Renaming
    • More About Types
      • Aggregates: A primer
      • Overloading and qualified expressions
      • Character types
    • Access Types
      • Overview
      • Allocation (by type)
      • Dereferencing
      • Other features
      • Mutually recursive types
    • More About Records
      • Dynamically sized record types
      • Records with discriminant
      • Variant records
    • Fixed-Point Types
      • Decimal fixed-point types
      • Ordinary fixed-point types
    • Privacy
      • Basic encapsulation
      • Abstract data types
      • Limited types
      • Child packages & privacy
    • Generics
      • Introduction
      • Formal type declaration
      • Formal object declaration
      • Generic body definition
      • Generic instantiation
      • Generic packages
      • Formal subprograms
      • Example: I/O instances
      • Example: ADTs
      • Example: Swap
      • Example: Reversing
      • Example: Test application
    • Exceptions
      • Exception declaration
      • Raising an exception
      • Handling an exception
      • Predefined exceptions
    • Tasking
      • Tasks
        • Simple task
        • Simple synchronization
        • Delay
        • Synchronization: rendezvous
        • Select loop
        • Cycling tasks
      • Protected objects
        • Simple object
        • Entries
      • Task and protected types
        • Task types
        • Protected types
    • Design by contracts
      • Pre- and postconditions
      • Predicates
      • Type invariants
    • Interfacing With C
      • Multi-language project
      • Type convention
      • Foreign subprograms
        • Calling C subprograms in Ada
        • Calling Ada subprograms in C
      • Foreign variables
        • Using C global variables in Ada
        • Using Ada variables in C
      • Generating bindings
        • Adapting bindings
    • Object Oriented Programming
      • Derived types
      • Tagged types
      • Classwide types
      • Dispatching operations
      • Dot notation
      • Private & Limited
      • Classwide access types
    • Standard Library: Containers
      • Vectors
        • Instantiation
        • Initialization
        • Appending and prepending elements
        • Accessing first and last elements
        • Iterating
        • Finding and changing elements
        • Inserting elements
        • Removing elements
        • Other Operations
      • Sets
        • Initialization and iteration
        • Operations on elements
        • Other Operations
      • Indefinite maps
        • Hashed maps
        • Ordered maps
        • Complexity
    • Standard Library: Dates & Times
      • Date and time handling
        • Delaying using date
      • Real-time
        • Benchmarking
    • Standard Library: Strings
      • String operations
      • Limitation of fixed-length strings
      • Bounded strings
      • Unbounded strings
    • Standard Library: Files & Streams
      • Text I/O
      • Sequential I/O
      • Direct I/O
      • Stream I/O
    • Standard Library: Numerics
      • Elementary Functions
      • Random Number Generation
      • Complex Types
      • Vector and Matrix Manipulation
    • Appendices
      • Appendix A: Generic Formal Types
        • Indefinite version
      • Appendix B: Containers
  • Advanced Journey With Ada
    • Data types
      • Types
        • Names
        • Objects
        • Scalar Types
        • Enumerations
        • Universal and Root Types
        • Definite and Indefinite Subtypes
        • Incomplete types
        • Type view
        • Type conversion
        • Qualified Expressions
        • Default initial values
        • Deferred Constants
        • User-defined literals
      • Types and Representation
        • Enumeration Representation Clauses
        • Data Representation
        • Sizes
        • Alignment
        • Overlapping Storage
        • Packed Representation
        • Record Representation and storage clauses
        • Changing Data Representation
        • Valid Attribute
        • Unchecked Union
        • Addresses
        • Discarding names
      • Shared variable control
        • Volatile
        • Independent
        • Atomic
        • Full-access only
        • Atomic operations
      • Records
        • Default Initialization
        • Mutually dependent types
        • Null records
        • Record discriminants
        • Discriminant constraints and operations
        • Unknown discriminants
        • Unconstrained subtypes
        • Variant parts
        • Per-Object Expressions
      • Aggregates
        • Container Aggregates
        • Record aggregates
        • Full coverage rules for Aggregates
        • Array aggregates
        • Extension Aggregates
        • Delta Aggregates
      • Arrays
        • Array constraints
        • Multidimensional Arrays
        • Derived array types and array subtypes
      • Strings
        • Character and String Literals
        • Wide and Wide-Wide Strings
        • String Encoding
        • UTF-8 applications
        • Image attribute
        • Put_Image aspect
        • Universal text buffer
      • Numerics
        • Numeric Literals
        • Modular Types
        • Floating-Point Types
        • Fixed-Point Types
        • Big Numbers
    • Control Flow
      • Expressions
        • Expressions: Definition
        • Conditional Expressions
        • Quantified Expressions
        • Declare Expressions
        • Reduction Expressions
      • Statements
        • Simple and Compound Statements
        • Labels
        • Exit loop statement
        • If, case and loop statements
        • Block Statements
        • Extended return statement
      • Subprograms
        • Parameter Modes and Associations
        • Operators
        • Expression functions
        • Overloading
        • Operator Overloading
        • Operator Overriding
        • Nonreturning procedures
        • Inline subprograms
        • Null Procedures
      • Exceptions
        • Classification of Errors
        • Asserts
        • Assertion policies
        • Checks and exceptions
        • Ada.Exceptions package
        • Exception renaming
        • Out and Uninitialized
        • Suppressing checks
    • Modular programming
      • Packages
        • Package renaming
        • Private packages
        • Private with clauses
        • Limited Visibility
        • Visibility
        • Use type clause
        • Use clauses and naming conflicts
      • Subprograms and Modularity
        • Private subprograms
    • Resource Management
      • Access Types
        • Access types: Terminology
        • Access types: Allocation
        • Discriminants as Access Values
        • Parameters as Access Values
        • Self-reference
        • Mutually dependent types using access types
        • Dereferencing
        • Ragged arrays
        • Aliasing
        • Accessibility Levels and Rules: An Introduction
        • Unchecked Access
        • Unchecked Deallocation
        • Null & Not Null Access
        • Design strategies for access types
        • Access to subprograms
        • Accessibility Rules and Access-To-Subprograms
        • Access and Address
      • Anonymous Access Types
        • Named and Anonymous Access Types
        • Anonymous Access-To-Object Types
        • Access discriminants
        • Self-reference
        • Mutually dependent types using anonymous access types
        • Access parameters
        • User-Defined References
        • Anonymous Access Types and Accessibility Rules
        • Anonymous Access-To-Subprograms
        • Accessibility Rules and Anonymous Access-To-Subprograms
      • Limited Types
        • Assignment and equality
        • Limited private types
        • Explicitly limited types
        • Subtypes of Limited Types
        • Deriving from limited types
        • Immutably Limited Types
        • Limited Types with Discriminants
        • Record components of limited type
        • Limited types and aggregates
        • Constructor functions for limited types
        • Return objects
        • Building objects from constructors
        • Limited types as parameter
      • Controlled Types
        • Overview
        • Initialization
        • Assignment
        • Finalization
        • Controlled Types and Exception Handling
        • Applications of Controlled Types
  • Ada In Practice
    • Introduction
      • Assumptions
      • Definitions
        • Suppliers and Clients
        • Compile-time Visibility
        • Views
        • Partial and Full Views
    • Essential Design Idioms for Packages
      • Motivation
      • Implementation(s)
        • Named Collection of Declarations
        • Groups of Related Program Units
      • Notes
    • Abstract Data Types
      • Motivation
      • Implementation(s)
      • Pros
      • Cons
      • Relationship With Other Idioms
      • Notes
    • Abstract Data Machines
      • Motivation
      • Implementation(s)
      • Pros
      • Cons
    • Programming by Extension
      • Motivation
      • Implementation(s)
      • Pros
      • Cons
      • Relationship With Other Idioms
      • Notes
    • Constructor Functions For Abstract Data Types
      • Motivation
      • Implementation(s)
      • Pros
      • Cons
      • Relationship With Other Idioms
      • Notes
    • Controlling Object Initialization and Creation
      • Motivation
      • Implementation(s)
        • Compile-Time Legality
        • Run-Time Checks
        • Preventing Object Creation by Clients
      • Pros
      • Cons
      • Relationship With Other Idioms
      • Notes
    • Type Punning
      • Motivation
      • Implementation(s)
        • Overlays
        • Unchecked Conversions on Address Values
      • Pros
      • Cons
      • Relationship With Other Idioms
      • Notes
    • Expressing Inheritance Idioms
      • Motivation
        • Building Blocks
      • Implementation(s)
        • Subtype Inheritance
        • Implementation Inheritance
      • Pros
      • Cons
      • Relationship With Other Idioms
    • Providing Component Access to Enclosing Record Objects
      • Motivation
      • Implementation(s)
      • Real-World Example
      • Pros
      • Cons
      • Relationship With Other Idioms
      • Notes
      • Full Source Code for Selected Units
    • Interrupt Handling
      • Motivation
      • Implementation(s)
        • First Level Handler Alone
        • Task Notification Introduction
        • Task Notification With Communication
        • Task Notification Without Communication
      • Pros
      • Cons
      • Relationship With Other Idioms
      • What About Priorities?
      • Notes
    • Reducing Object Code from Generic Package Instantiations
      • Motivation
      • Implementation(s)
      • Pros
      • Cons
      • Relationship With Other Idioms
      • Notes
  • Introduction to SPARK
    • Overview
      • What is it?
      • What do the tools do?
      • Key Tools
      • A trivial example
      • The Programming Language
      • Limitations
        • No side-effects in expressions
        • No aliasing of names
      • Designating SPARK Code
      • Code Examples / Pitfalls
        • Example #1
        • Example #2
        • Example #3
        • Example #4
        • Example #5
        • Example #6
        • Example #7
        • Example #8
        • Example #9
        • Example #10
    • Flow Analysis
      • What does flow analysis do?
      • Errors Detected
        • Uninitialized Variables
        • Ineffective Statements
        • Incorrect Parameter Mode
      • Additional Verifications
        • Global Contracts
        • Depends Contracts
      • Shortcomings
        • Modularity
        • Composite Types
        • Value Dependency
        • Contract Computation
      • Code Examples / Pitfalls
        • Example #1
        • Example #2
        • Example #3
        • Example #4
        • Example #5
        • Example #6
        • Example #7
        • Example #8
        • Example #9
        • Example #10
    • Proof of Program Integrity
      • Runtime Errors
      • Modularity
        • Exceptions
      • Contracts
        • Executable Semantics
        • Additional Assertions and Contracts
      • Debugging Failed Proof Attempts
        • Debugging Errors in Code or Specification
        • Debugging Cases where more Information is Required
        • Debugging Prover Limitations
      • Code Examples / Pitfalls
        • Example #1
        • Example #2
        • Example #3
        • Example #4
        • Example #5
        • Example #6
        • Example #7
        • Example #8
        • Example #9
        • Example #10
    • State Abstraction
      • What's an Abstraction?
      • Why is Abstraction Useful?
      • Abstraction of a Package's State
      • Declaring a State Abstraction
      • Refining an Abstract State
      • Representing Private Variables
      • Additional State
        • Nested Packages
        • Constants that Depend on Variables
      • Subprogram Contracts
        • Global and Depends
        • Preconditions and Postconditions
      • Initialization of Local Variables
      • Code Examples / Pitfalls
        • Example #1
        • Example #2
        • Example #3
        • Example #4
        • Example #5
        • Example #6
        • Example #7
        • Example #8
        • Example #9
        • Example #10
    • Proof of Functional Correctness
      • Beyond Program Integrity
      • Advanced Contracts
        • Ghost Code
        • Ghost Functions
        • Global Ghost Variables
      • Guide Proof
        • Local Ghost Variables
        • Ghost Procedures
        • Handling of Loops
        • Loop Invariants
      • Code Examples / Pitfalls
        • Example #1
        • Example #2
        • Example #3
        • Example #4
        • Example #5
        • Example #6
        • Example #7
        • Example #8
        • Example #9
        • Example #10
  • Introduction to Embedded Systems Programming
    • Introduction
      • So, what will we actually cover?
      • Definitions
      • Down To The Bare Metal
      • The Ada Drivers Library
    • Low Level Programming
      • Separation Principle
      • Guaranteed Level of Support
      • Querying Implementation Limits and Characteristics
      • Querying Representation Choices
      • Specifying Representation
      • Unchecked Programming
      • Data Validity
    • Multi-Language Development
      • General Interfacing
        • Aspect/Pragma Convention
        • Aspect/Pragma Import and Export
        • Aspect/Pragma External_Name and Link_Name
        • Package Interfaces
      • Language-Specific Interfacing
        • Package Interfaces.C
        • Package Interfaces.C.Strings
        • Package Interfaces.C.Pointers
        • Package Interfaces.Fortran
        • Machine Code Insertions (MCI)
      • When Ada Is Not the Main Language
    • Interacting with Devices
      • Non-Memory-Mapped Devices
      • Memory-Mapped Devices
      • Dynamic Address Conversion
      • Address Arithmetic
    • General-Purpose Code Generators
      • Aspect Independent
      • Aspect Volatile
      • Aspect Atomic
      • Aspect Full_Access_Only
    • Handling Interrupts
      • Background
      • Language-Defined Interrupt Model
      • Interrupt Handlers
      • Interrupt Management
      • Associating Handlers With Interrupts
      • Interrupt Priorities
      • Common Design Idioms
        • Parameterizing Handlers
        • Multi-Level Handlers
      • Final Points
    • Conclusion
  • What's New in Ada 2022
    • Introduction
      • References
    • 'Image attribute for any type
      • 'Image attribute for a value
      • 'Image attribute for any type
      • References
    • Redefining the 'Image attribute
      • What's the Root_Buffer_Type?
      • Outdated draft implementation
      • References
    • User-Defined Literals
      • Turn Ada into JavaScript
      • References
    • Advanced Array Aggregates
      • Square brackets
      • Iterated Component Association
      • References
    • Container Aggregates
      • References
    • Delta Aggregates
      • Delta aggregate for records
      • Delta aggregate for arrays
      • References
    • Target Name Symbol (@)
      • Alternatives
      • References
    • Enumeration representation
      • Literal positions
      • Representation values
      • Before Ada 2022
      • References
    • Big Numbers
      • Big Integers
      • Tiny RSA implementation
      • Big Reals
      • References
    • Interfacing C variadic functions
      • References
  • Ada for the C++ or Java Developer
    • Preface
    • Basics
    • Compilation Unit Structure
    • Statements, Declarations, and Control Structures
      • Statements and Declarations
      • Conditions
      • Loops
    • Type System
      • Strong Typing
      • Language-Defined Types
      • Application-Defined Types
      • Type Ranges
      • Generalized Type Contracts: Subtype Predicates
      • Attributes
      • Arrays and Strings
      • Heterogeneous Data Structures
      • Pointers
    • Functions and Procedures
      • General Form
      • Overloading
      • Subprogram Contracts
    • Packages
      • Declaration Protection
      • Hierarchical Packages
      • Using Entities from Packages
    • Classes and Object Oriented Programming
      • Primitive Subprograms
      • Derivation and Dynamic Dispatch
      • Constructors and Destructors
      • Encapsulation
      • Abstract Types and Interfaces
      • Invariants
    • Generics
      • Generic Subprograms
      • Generic Packages
      • Generic Parameters
    • Exceptions
      • Standard Exceptions
      • Custom Exceptions
    • Concurrency
      • Tasks
      • Rendezvous
      • Selective Rendezvous
      • Protected Objects
    • Low Level Programming
      • Representation Clauses
      • Embedded Assembly Code
      • Interfacing with C
    • Conclusion
    • References
  • Ada for the Embedded C Developer
    • Introduction
      • So, what is this Ada thing anyway?
      • Ada — The Technical Details
    • The C Developer's Perspective
      • What we mean by Embedded Software
      • The GNAT Toolchain
      • The GNAT Toolchain for Embedded Targets
      • Hello World in Ada
      • The Ada Syntax
      • Compilation Unit Structure
      • Packages
        • Declaration Protection
        • Hierarchical Packages
        • Using Entities from Packages
      • Statements and Declarations
      • Conditions
      • Loops
      • Type System
        • Strong Typing
        • Language-Defined Types
        • Application-Defined Types
        • Type Ranges
        • Unsigned And Modular Types
        • Attributes
        • Arrays and Strings
        • Heterogeneous Data Structures
        • Pointers
      • Functions and Procedures
        • General Form
        • Overloading
        • Aspects
    • Concurrency and Real-Time
      • Understanding the various options
      • Tasks
      • Rendezvous
      • Selective Rendezvous
      • Protected Objects
      • Ravenscar
    • Writing Ada on Embedded Systems
      • Understanding the Ada Run-Time
      • Low Level Programming
        • Representation Clauses
        • Embedded Assembly Code
      • Interrupt Handling
      • Dealing with Absence of FPU with Fixed Point
      • Volatile and Atomic data
        • Volatile
        • Atomic
      • Interfacing with Devices
        • Size aspect and attribute
        • Register overlays
        • Data streams
      • ARM and svd2ada
    • Enhancing Verification with SPARK and Ada
      • Understanding Exceptions and Dynamic Checks
      • Understanding Dynamic Checks versus Formal Proof
      • Initialization and Correct Data Flow
      • Contract-Based Programming
      • Replacing Defensive Code
      • Proving Absence of Run-Time Errors
      • Proving Abstract Properties
      • Final Comments
    • C to Ada Translation Patterns
      • Naming conventions and casing considerations
      • Manually interfacing C and Ada
      • Building and Debugging mixed language code
      • Automatic interfacing
      • Using Arrays in C interfaces
      • By-value vs. by-reference types
      • Naming and prefixes
      • Pointers
      • Bitwise Operations
      • Mapping Structures to Bit-Fields
        • Overlays vs. Unchecked Conversions
    • Handling Variability and Re-usability
      • Understanding static and dynamic variability
      • Handling variability & reusability statically
        • Genericity
        • Simple derivation
        • Configuration pragma files
        • Configuration packages
      • Handling variability & reusability dynamically
        • Records with discriminants
        • Variant records
        • Object orientation
        • Pointer to subprograms
      • Design by components using dynamic libraries
    • Performance Considerations
      • Overall expectations
      • Switches and optimizations
        • Optimizations levels
        • Inlining
      • Checks and assertions
        • Checks
        • Assertions
      • Dynamic vs. static structures
      • Pointers vs. data copies
        • Function returns
    • Argumentation and Business Perspectives
      • What's the expected ROI of a C to Ada transition?
      • Who is using Ada today?
      • What is the future of the Ada technology?
      • Is the Ada toolset complete?
      • Where can I find Ada or SPARK developers?
      • How to introduce Ada and SPARK in an existing code base?
    • Conclusion
    • Hands-On: Object-Oriented Programming
      • System Overview
      • Non Object-Oriented Approach
        • Starting point in C
        • Initial translation to Ada
        • Improved Ada implementation
      • First Object-Oriented Approach
        • Interfaces
        • Base type
        • Derived types
        • Subprograms from parent
        • Type AB
        • Updated source-code
      • Further Improvements
        • Dispatching calls
        • Dynamic allocation
        • Limited controlled types
        • Updated source-code
  • SPARK Ada for the MISRA C Developer
    • Preface
    • Enforcing Basic Program Consistency
      • Taming Text-Based Inclusion
      • Hardening Link-Time Checking
      • Going Towards Encapsulation
    • Enforcing Basic Syntactic Guarantees
      • Distinguishing Code and Comments
      • Specially Handling Function Parameters and Result
        • Handling the Result of Function Calls
        • Handling Function Parameters
      • Ensuring Control Structures Are Not Abused
        • Preventing the Semicolon Mistake
        • Avoiding Complex Switch Statements
        • Avoiding Complex Loops
        • Avoiding the Dangling Else Issue
    • Enforcing Strong Typing
      • Enforcing Strong Typing for Pointers
        • Pointers Are Not Addresses
        • Pointers Are Not References
        • Pointers Are Not Arrays
        • Pointers Should Be Typed
      • Enforcing Strong Typing for Scalars
        • Restricting Operations on Types
        • Restricting Explicit Conversions
        • Restricting Implicit Conversions
    • Initializing Data Before Use
      • Detecting Reads of Uninitialized Data
      • Detecting Partial or Redundant Initialization of Arrays and Structures
    • Controlling Side Effects
      • Preventing Undefined Behavior
      • Reducing Programmer Confusion
      • Side Effects and SPARK
    • Detecting Undefined Behavior
      • Preventing Undefined Behavior in SPARK
      • Proof of Absence of Run-Time Errors in SPARK
    • Detecting Unreachable Code and Dead Code
    • Conclusion
    • References
      • About MISRA C
      • About SPARK
      • About MISRA C and SPARK
  • Introduction to the GNAT Toolchain
    • GNAT Toolchain Basics
      • Basic commands
      • Compiler warnings
        • -gnatwa switch and warning suppression
        • Style checking
    • GPRbuild
      • Basic commands
      • Project files
        • Basic structure
        • Customization
      • Project dependencies
        • Simple dependency
        • Dependencies to dynamic libraries
      • Configuration pragma files
      • Configuration packages
    • GNAT Studio
      • Start-up
        • Windows
        • Linux
      • Creating projects
      • Building
      • Debugging
        • Debug information
        • Improving main application
        • Debugging the application
      • Formal verification
    • GNAT Tools
      • gnatchop
      • gnatprep
      • gnatmem
      • gnatdoc
      • gnatpp
      • gnatstub
  • Guidelines for Safe and Secure Ada/SPARK
    • Introduction
      • Scope
      • Structure
      • Enforcement
      • About the Rules
        • Mapping to Other Standards
    • Definitions
      • Level
      • Remediation
    • Dynamic Storage Management
      • Common High Integrity Restrictions (DYN01)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Traditional Static Allocation Policy (DYN02)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Access Types Without Allocators Policy (DYN03)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Minimal Dynamic Allocation Policy (DYN04)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • User-Defined Storage Pools Policy (DYN05)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Statically Determine Maximum Stack Requirements (DYN06)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
    • Safe Reclamation
      • No Multiple Reclamations (RCL01)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Only Reclaim Allocated Storage (RCL02)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Only Reclaim To The Same Pool (RCL03)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
    • Concurrency
      • Use the Ravenscar Profile (CON01)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Use the Jorvik Profile (CON02)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Avoid Shared Variables for Inter-task Communication (CON03)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
    • Robust Programming Practice
      • No Use of "others" in Case Constructs (RPP01)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • No Enumeration Ranges in Case Constructs (RPP02)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Limited Use of "others" In Aggregates (RPP03)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • No Unassigned Mode-Out Procedure Parameters (RPP04)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • No Use of "others" in Exception Handlers (RPP05)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Avoid Function Side-Effects (RPP06)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Functions Only Have Mode "in" (RPP07)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Limit Parameter Aliasing (RPP08)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Use Precondition and Postcondition Contracts (RPP09)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Do Not Re-Verify Preconditions In Subprogram Bodies (RPP10)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Always Use the Result of Function Calls (RPP11)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • No Recursion (RPP12)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • No Reuse of Standard Typemarks (RPP13)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Use Symbolic Constants For Literal Values (RPP14)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
    • Exception Usage
      • Do Not Raise Language-Defined Exceptions (EXU01)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • No Unhandled Application-Defined Exceptions (EXU02)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • No Exception Propagation Beyond Name Visibility (EXU03)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Prove Absence of Run-time Exceptions (EXU04)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
    • Object-Oriented Programming
      • No Class-wide Constructs Policy (OOP01)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Static Dispatching Only Policy (OOP02)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Limit Inheritance Hierarchy Depth (OOP03)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Limit Statically-Dispatched Calls To Primitive Operations (OOP04)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Use Explicit Overriding Annotations (OOP05)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Use Class-wide Pre/Post Contracts (OOP06)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Ensure Local Type Consistency (OOP07)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
    • Software Engineering
      • Use SPARK Extensively (SWE01)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Enable Optional Warnings and Treat As Errors (SWE02)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Use A Static Analysis Tool Extensively (SWE03)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
      • Hide Implementation Artifacts (SWE04)
        • Reference
        • Description
        • Applicable Vulnerability within ISO TR 24772-2
        • Applicable Common Weakness Enumeration
        • Noncompliant Code Example
        • Compliant Code Example
        • Notes
    • References

Labs

  • Introduction to Ada: Laboratories
    • Imperative Language
      • Hello World
      • Greetings
      • Positive Or Negative
      • Numbers
    • Subprograms
      • Subtract procedure
      • Subtract function
      • Equality function
      • States
      • States #2
      • States #3
      • States #4
    • Modular Programming
      • Months
      • Operations
    • Strongly Typed Language
      • Colors
      • Integers
      • Temperatures
    • Records
      • Directions
      • Colors
      • Inventory
    • Arrays
      • Constrained Array
      • Colors: Lookup-Table
      • Unconstrained Array
      • Product info
      • String_10
      • List of Names
    • More About Types
      • Aggregate Initialization
      • Versioning
      • Simple todo list
      • Price list
    • Privacy
      • Directions
      • Limited Strings
      • Bonus exercise
        • Colors
        • List of Names
        • Price List
    • Generics
      • Display Array
      • Average of Array of Float
      • Average of Array of Any Type
      • Generic list
    • Exceptions
      • Uninitialized Value
      • Numerical Exception
      • Re-raising Exceptions
    • Tasking
      • Display Service
      • Event Manager
      • Generic Protected Queue
    • Design by contracts
      • Price Range
      • Pythagorean Theorem: Predicate
      • Pythagorean Theorem: Precondition
      • Pythagorean Theorem: Postcondition
      • Pythagorean Theorem: Type Invariant
      • Primary Color
    • Object Oriented Programming
      • Simple type extension
      • Online Store
    • Standard Library: Containers
      • Simple todo list
      • List of unique integers
    • Standard Library: Dates & Times
      • Holocene calendar
      • List of events
    • Standard Library: Strings
      • Concatenation
      • List of events
    • Standard Library: Numerics
      • Decibel Factor
      • Root-Mean-Square
      • Rotation
    • Solutions
      • Imperative Language
        • Hello World
        • Greetings
        • Positive Or Negative
        • Numbers
      • Subprograms
        • Subtract Procedure
        • Subtract Function
        • Equality function
        • States
        • States #2
        • States #3
        • States #4
      • Modular Programming
        • Months
        • Operations
      • Strongly typed language
        • Colors
        • Integers
        • Temperatures
      • Records
        • Directions
        • Colors
        • Inventory
      • Arrays
        • Constrained Array
        • Colors: Lookup-Table
        • Unconstrained Array
        • Product info
        • String_10
        • List of Names
      • More About Types
        • Aggregate Initialization
        • Versioning
        • Simple todo list
        • Price list
      • Privacy
        • Directions
        • Limited Strings
      • Generics
        • Display Array
        • Average of Array of Float
        • Average of Array of Any Type
        • Generic list
      • Exceptions
        • Uninitialized Value
        • Numerical Exception
        • Re-raising Exceptions
      • Tasking
        • Display Service
        • Event Manager
        • Generic Protected Queue
      • Design by contracts
        • Price Range
        • Pythagorean Theorem: Predicate
        • Pythagorean Theorem: Precondition
        • Pythagorean Theorem: Postcondition
        • Pythagorean Theorem: Type Invariant
        • Primary Colors
      • Object-oriented programming
        • Simple type extension
        • Online Store
      • Standard library: Containers
        • Simple todo list
        • List of unique integers
      • Standard library: Dates & Times
        • Holocene calendar
        • List of events
      • Standard library: Strings
        • Concatenation
        • List of events
      • Standard library: Numerics
        • Decibel Factor
        • Root-Mean-Square
        • Rotation
  • Bug Free Coding
    • Let's Build a Stack
      • Background
      • Input Format
      • Constraints
      • Output Format
      • Sample Input
      • Sample Output
learn.adacore.com
  • What's New in Ada 2022

What's New in Ada 2022

This course presents an overview of the new features of the latest Ada 2022 standard.

This document was written by Maxim Reznik and reviewed by Richard Kenner.

Note

The code examples in this course use an 80-column limit, which is a typical limit for Ada code. Note that, on devices with a small screen size, some code examples might be difficult to read.

Download PDF Download EPUB

Contents:

  • Introduction
    • References
  • 'Image attribute for any type
    • 'Image attribute for a value
    • 'Image attribute for any type
    • References
  • Redefining the 'Image attribute
    • What's the Root_Buffer_Type?
    • Outdated draft implementation
    • References
  • User-Defined Literals
    • Turn Ada into JavaScript
    • References
  • Advanced Array Aggregates
    • Square brackets
    • Iterated Component Association
    • References
  • Container Aggregates
    • References
  • Delta Aggregates
    • Delta aggregate for records
    • Delta aggregate for arrays
    • References
  • Target Name Symbol (@)
    • Alternatives
    • References
  • Enumeration representation
    • Literal positions
    • Representation values
    • Before Ada 2022
    • References
  • Big Numbers
    • Big Integers
    • Tiny RSA implementation
    • Big Reals
    • References
  • Interfacing C variadic functions
    • References
Previous Next

© Copyright 2018 – 2025, AdaCore. All rights reserved.    Creative Commons License
Legal   |   Privacy Policy   |   Report an Issue