Skip to content

Core Concepts

Alnoms is a Performance Intelligence Engine — a system that measures, verifies, and governs the performance behavior of Python functions through automated scaling tests and empirical analysis. This page introduces the foundational concepts that make Alnoms reliable, deterministic, and production‑ready.

1. Performance Intelligence

Performance Intelligence is the discipline of turning raw execution behavior into actionable, empirical truth. Traditional profiling answers: "Where is the time spent?" Performance Intelligence answers: "How does performance scale, and is it acceptable?"

While profilers measure snapshots, Alnoms measures behavior over growth. This shift allows for: * Asymptotic Validation: Proving a function is \(O(N)\) and not \(O(N^2)\). * Regression Detection: Catching performance drift before it hits production. * Cost Control: Predicting compute requirements as data volume scales.

Alnoms does this by:

  • running controlled scaling experiments
  • measuring execution time across increasing input sizes
  • modeling the growth pattern
  • validating the behavior against expected performance classes
  • producing a governance verdict

This transforms performance from a guess into a measurable, enforceable property of your codebase by bridging the gap between Static Intent (code structure) and Dynamic Execution (scaling behavior).

2. Scaling Tests

Scaling tests are the core mechanism of Alnoms.

A scaling test answers one question:

How does this function behave as the input grows?

Alnoms automatically:

  • generates multiple input sizes
  • executes the function repeatedly
  • records timing distributions
  • detects noise and instability
  • fits the observed behavior to a performance model

This produces a performance signature for every function.

3. Performance Models

Alnoms uses empirical modeling to classify performance behavior.
These models represent real‑world scaling patterns, such as:

  • constant
  • logarithmic
  • linear
  • linearithmic
  • quadratic
  • cubic
  • exponential (flagged as dangerous)

The Analyzer compares observed behavior against these models to determine the closest match.

This is not theoretical complexity — it is measured performance.

4. The Analyzer

The Analyzer is the heart of Alnoms.

It performs:

  • controlled execution
  • noise‑aware timing
  • model fitting
  • statistical validation
  • governance verdict generation

The Analyzer produces a structured report containing:

  • the detected performance class
  • the confidence score
  • the fitted model parameters
  • the raw timing data
  • the governance verdict
  • recommendations (if enabled)

This report is deterministic and reproducible.

5. Governance Verdicts

Governance is what elevates Alnoms from a profiler to a performance standard.

A governance verdict answers:

Is this function’s performance acceptable for production?

Verdicts include:

  • PASS — behavior matches an approved performance class
  • WARN — behavior is borderline or unstable
  • FAIL — behavior is too slow, too costly, or regressing

Governance ensures performance does not drift silently as the codebase evolves.

6. Performance Contracts

A performance contract is a declarative expectation you attach to a function.

Example:

@alnoms.expect("linear")
def process(data):
    ...
The Analyzer verifies the contract during scaling tests.

If the function regresses, the contract fails — preventing performance surprises in production.

7. Data Generators

Scaling tests require inputs that grow predictably.

Alnoms uses data generators to create structured input sequences, including:

  • lists
  • arrays
  • strings
  • graphs
  • custom objects

You can also define your own generator to match domain‑specific workloads.

Generators ensure that scaling tests are realistic, controlled, and reproducible.

8. Profiling vs. Performance Intelligence

Traditional profiling answers:

“Where is the time spent?”

Alnoms answers:

“How does performance scale, and is it acceptable?”

Profilers measure snapshots.
Alnoms measures behavior over growth.

This makes Alnoms suitable for:

  • performance governance
  • cost control
  • regression detection
  • architectural validation
  • performance‑class selection
  • production readiness checks

9. Deterministic Execution

Performance testing is notoriously noisy.
Alnoms reduces noise through:

  • warmup cycles
  • repeated trials
  • statistical smoothing
  • outlier rejection
  • stable timing backends
  • controlled scaling

This produces deterministic, trustworthy results.

10. The Performance Intelligence Workflow

A typical workflow looks like this:

  1. Write or import a function
  2. Attach a performance expectation (optional)
  3. Run the Analyzer
  4. Review the performance report
  5. Enforce governance in CI/CD
  6. Prevent regressions before they reach production

This workflow integrates seamlessly into development, testing, and release pipelines.

Additional Concepts

Static Intent vs. Dynamic Execution (The Hybrid Audit)

Alnoms combines two complementary analyses:

  • Static Intent: AST‑based detection of structural patterns (e.g., nested loops, membership tests inside loops).
  • Dynamic Execution: Empirical scaling tests that measure real behavior.

This hybrid approach increases confidence and reduces false positives.

The Doubling Test & Scaling Ratios

Alnoms models performance using the Doubling Test:
run the function at size N and 2N, then compute the Scaling Ratio:

Ratio Complexity Behavior
~1.0 Constant No meaningful growth.
~2.0 Linear Execution time doubles.
~4.0 Quadratic Execution time quadruples.
~8.0 Cubic Execution time octuples.

This makes performance modeling transparent, empirical, and deterministic.

Visual Anchors for Performance Models

To make scaling behavior scannable, Alnoms uses simple curve visualizations in reports:

  • constant → flat line
  • linear → straight rising line
  • quadratic → curved upward
  • cubic → steep curve

These anchors help developers interpret performance classes instantly.

Summary

Alnoms provides:

  • automated scaling tests
  • empirical performance modeling
  • deterministic analysis
  • governance verdicts
  • performance contracts
  • compute‑cost awareness
  • static + dynamic hybrid auditing
  • ratio‑based performance classification

Together, these form the foundation of the Performance Intelligence Engine — a new standard for building fast, reliable, and cost‑efficient software.