Ada Programming Language - The Complete Guide

Master Ada basics with a hello world example, variable declarations, and core control flow constructs. Learn how semicolons, if statements, for and while loops, and case statements drive output.

Explore Ada's strong typing, explicit type declarations, and the use of subtypes and enumerations to enforce runtime range checks and print values.

Declare constants in Ada with an initialization, then use them like variables but prevent mutation. Examples include pi, max score, and composite constants in packages.

Explore Ada functions as pure, strongly typed subprograms that return a single value, with by-value/by-reference parameters, explicit return types, and support for nesting, overloading, and non-scalar returns via records.

Explore Ada procedures as subprograms that perform actions without returning values, enabling encapsulation, abstraction, and modularity with in, out, and in out parameters, including nested and overloaded forms.

Explore Ada scope rules: static lexical scoping determines visibility by where names are declared, inner scopes shadow outer ones, and lifetime ends across declarations, loops, and inner procedures.

Learn how Ada record types group related data, nest records, and access fields with dot notation while discriminated records use a discriminant to shape their structure.

Ada exception handling uses begin, exception, and when blocks to catch errors like division by zero and constraint or data errors, with support for custom exceptions.

Explore unit testing in Ada using the assert keyword to raise assertion errors, with a math ops package for add and subtract and tests run first via test-driven development.

Explore how Ada uses enumerations for readable, type-safe value sets like days of the week, and how arrays use n-based indexing and enum indices.

Explore Ada access types for dynamic allocation of strings and arrays using new, enabling runtime-sized structures and safer, strongly typed pointers.

Explore Ada overloading for functions and procedures, using the same name with different types and returns, with compiler inference for integers, strings, and floats, plus default parameters.

Explore how Ada packages group related types, constants, and subprograms into a specification and a body, with ads interface and adb implementation, illustrated by a simple math example.

Ads defines the package interface, declaring services, types, constants, and procedures, while ADB provides the actual implementation. Ada enforces a clear separation between interface and implementation, improving modularity and maintainability.

Explore contract based programming in Ada, using preconditions and postconditions for early error detection, formal verification via Spark subset, and self-documenting, safe interfaces.

Demonstrate how Ada parameter modes govern data flow for subprograms: in for input, out for output, and inout for in-place modification; the lecture uses a process procedure to illustrate modes.

Explain Ada visibility rules and how local declarations, with clause and use clauses, control identifiers. Show how the with clause makes a package available, not its contents, requiring use.

Master Ada string handling, from built-in and bounded strings to unbounded dynamic strings, using concatenation, substrings, length, and equals operator comparisons.

Explore Ada unbounded strings that grow at runtime to handle unknown input sizes beyond fixed-length arrays, using heap storage and memory management with length, append, and conversion to normal strings.

Master file IO in Ada by creating and writing to files, reading lines, and deleting files using file handles and the Ada.Directories module.

Learn how Ada calls C functions and uses C data types with pragma import, then implement a simple C add function and call it from Ada to verify interoperation.

Derived types create a new distinct type from an existing one, inheriting range and operations while requiring explicit conversions. Private types hide internal implementation to support encapsulation.

Learn how Ada tagged types enable object-oriented features like type extension, dynamic dispatch, and runtime polymorphism. Extend base shapes into circle with radius and override draw to demonstrate polymorphic behavior.

Demonstrate dynamic dispatch in Ada by using class-wide types and overriding to resolve draw procedures at runtime for shapes and derived rectangles, via pointers and access all.

Explore Ada class wide types and interfaces, using root class polymorphism and tag types for dynamic dispatch and heterogeneous collections.

Explore Ada generics, enabling reusable code with generic procedures, functions, and packages that operate on diverse types, demonstrated by print item and print float item.

Develop an Ada object-oriented vehicle system featuring an abstract vehicle class and concrete car and truck types, implementing create, start, and info methods with attributes year, doors, and payload.

Explore Ada select statements, including selective accept, timed entry calls, conditional entry calls, and asynchronous select, with a server example managing start and stop and timeouts.

Discover how Ada uses tasks and rendezvous to enable concurrency, synchronization, and communication, including a simple task example and a server pattern with request service and polite shutdown.

Explore protected objects in Ada for automatic mutual exclusion and safe concurrent access to shared data. Implement a shared counter with increment and value across multiple tasks.

Ada provides tasking features for concurrent real-time applications, including priority-based scheduling and deterministic timing, with delay statements such as delay X and delay until T, using Ravenscar for predictable execution.

Explore timing events in Ada, including delay and delay until, the real time module, and periodic and one shot timers, illustrated with a protected object and cross-task notification method.