AURA: Ada User Repository Annex¶
The Ada User Repository Annex (AURA) is a proposed specification for a native Ada source code package management system, developed in lock-step with a reference implementation. This is the official documentation for the Reference Implementation (AURA CLI).
AURA CLI was designed to function as a production-ready, integrated build system with similar capabilities to existing native packaging systems for projects like Rust (cargo), Python (pip), and NodeJS (npm).
AURA CLI has a fully parallelized design for maximum performance on modern systems, and uses all available cores to parse program text, compute dependencies, obtain subsystems, perform configuration, and build projects. Besides having a user-friendly interface, AURA CLI is also designed to work in automated CI/CD pipelines.
AURA was designed as a hypothetical new Specialized Needs Annex of the Ada Reference Manual (the Ada standard). As such it is not designed to be an exclusively stand-alone tool, but rather as a specific set of behaviors that an Ada compiler could optionally implement 1. The behavior specified by AURA is triggered when the implementation encounters a dependency that it cannot immediately locate. Dependencies are typically specified through standard Ada with clauses, though AURA also specifies a new pragma for the expression of non-Ada dependencies.
The basic idea is that when an AURA implementation encounters a with clause for a library unit of a subsystem it cannot immediately locate, it attempts to retrieve that subsystem from the first available (configured) AURA repository. The AURA reference implementation (“AURA CLI”) parses the context clause of all Ada sources in a project. It then builds a fully dependency graph, and uses this information to compute which subsystems must be obtained, and if those subsystems actually contain the required units.
As a conceptual Specialized Needs Annex, the behavior is well-defined for both compliant and non-compliant compilers. Generally, the attempt to compile an AURA project with a non-compliant compiler may fail, but will never change the meaning of the program text, or the behavior of the compiled program.
The Ada Reference Manual (ARM) is the ISO standardized formal specification for the Ada language, and formally defines how a compliant compiler is required to behave.
The ARM contains a set of Specialized Need Annexes that “define features that are needed by certain application areas”.
Subsystems are both Ada concepts, and (by extension) AURA concepts, as AURA is a conceptual Specialized Needs Annex. Subsystems are essentially any library unit hierarchies rooted by a “top-level” unit. Top-level means a direct child of
Subsystems retrieved and configured through AURA are essentially analogues to “packages” or “crates” of other package managers.
Staying true to the Ada philosophy¶
Package management is fraught with danger. Two poisons conspire: interdependency and versioning.
AURA takes a deliberate, and possibly controversial position that versioning should not be the responsibility of the package manager. Instead, AURA expects versioning and version interdependency to be handled at the level of the repository and/or subsystem. This is done to ensure that AURA’s behaviour is always predictable and that checked-out code never changes without explicit user intervention.
The reference implementation (“AURA CLI”) prominently integrates git, and encourages the use of submodules, branches, or tags to handle repository versioning. The simple subdirectory based repository structure implemented by AURA CLI encourages repository coalescing, where individual subsystems are maintained in their own git repository, allowing coalesced AURA repositories to include them as git submodules, targeting specific commits of each subsystem. Such coalesced repositories can then be versioned as a collection, where integration testing can be applied to all submodules in the repository. Ideally, a project can create its own single point of truth repository to coalesce all project dependencies. This approach, though more work, makes updating of codebases much more reliable, safe, and controlled.
Please see this blog post for a deeper philosophical discussion on the design of AURA.