RSG: Reliable Software Guild: Manifesto and Rubric 0.6

Copyright © 2026 Michael Herman (Bindloss, Alberta, Canada) – Creative Commons Attribution-ShareAlike 4.0 International Public License

Abstract

This short paper introduces a quantitative model for reliable software quality defined as Q = (CPR)^2 × G, where CPR represents structural engineering strength and G represents governance strength. The model formalizes the nonlinear contribution of engineering integrity and the linear moderating role of governance. By separating structural properties from governance mechanisms and applying geometric aggregation to prevent compensatory inflation, the framework (in the form of a rubric) establishes a mathematically grounded theory of structural primacy in reliable software systems. The foundation of the RSG model is an orthogonal spanning set of reliable software principles.

Intended Audience

The intended audience for this paper is a broad range of professionals interested in furthering their understanding of reliable software quality as it related to software apps, agents, and services. This includes software architects, application developers, and user experience (UX) specialists, as well as people involved in software endeavors related to artificial intelligence; including:

• Operating System Masons
• Framework Masons
• Services Masons
• Data Masons (including the developement of LLMs)
• Network Effects Masons
• Protocol Masons
• User-face App Masons
• Tools Masons
• Codegen Tools Masons
• Verification Masons
• Veritically Integreated Master Masons

“The #crafting of #software is no different from the #craft of making a fine #Irish #single #malt. Like great whiskey, great software needs to be tended to multiple times: poteen, malting, milling, mashing, fermentation, multiple distillations, maturation, tasting, release to bottling, and bottling. These steps can be #human, #mechanical, or #digital. Learn to work constructively with your #digital #counterparts … as #partners – not as tools or challenges to be conquered.” Michael Herman, February 28, 2026.

Reliable Software Guild Manifesto

Overall reliable software quality grows quadratically with structural engineering strength and only linearly with governance quality.

• Governance cannot compensate for structural weakness.
• Structural excellence amplifies governance effectiveness.
• Imbalance within any structural pair (C, P, or R) degrades total quality multiplicatively.
• Sustainable software is governed engineering — but engineered first.

Formally:

Software Quality ∝ (Engineering)^2 × Governance

Strategic Interpretation

• If CPR is low: Even perfect governance yields low Q.
• If CPR is high but G is low: The system is powerful but dangerous or unstable long-term.
• If both are high: You get durable, scalable, trustworthy systems.

Reliable Software Quality Principles

The Reliable Software Quality Principles represent a linear list of orthogonal spanning set of reliable software quality metrics:

1. Correctness: Software produces outputs that correspond to reality and specification.
2. Composable: Can be safely combined with other systems through clean interfaces.
3. Performant: How efficiently does the system use time and resources to achieve its function.
4. Privacy-First: Minimizes unnecessary data exposure and maximizes user control over data.
5. Reliable: Produces expected results consistently over time.
6. Resilient: Maintains function under stress, degradation, or partial failure.
7. Evolvable: Designed to adapt over time without collapse.
8. Secure: Resists unauthorized access, misuse, and adversarial compromise.
9. Transparent: Observable, auditable, and understandable.
10. User-Centered: Optimized for human goals, comprehension, and agency.

Orthogonal Major and Minor Axes

The following categorization is presented for explanatory purposes. It represents a two-level orthogonal spanning set of the SSQ Quality Principles.

Spatial

• Composable
• User-Centered

Temporal

• Evolvable
• Reliable
• Resilient

Integrity

• Correctness
• Secure
• Privacy-First

Efficiency

• Performant

Observability

• Transparent

Structural Core

The Structural Core of a reliable software system is the set of fundamental engineering dimensions that ensure its integrity, stability, and robustness. It encompasses the interrelated principles of correctness, composability, performance, privacy, reliability, and resilience—forming the foundational “skeleton” upon which all other governance and user-facing features depend.

The structural core is the backbone of a system, combining correctness, composability, performance, privacy, reliability, and resilience to create a stable, robust foundation for all other features and governance mechanisms.

Structural Core Score (CPR)

The Structural Core Score (CPR) consists of three geometric pairings:

• C = √(Correctness × Composable)
• P = √(Performant × Privacy-First)
• R = √(Reliable × Resilient)

The aggregate structural core quality is computed as the geometric mean of C, P, and R:

CPR = ³√(C × P × R)

The use of geometric means penalizes imbalance and prevents compensatory scoring. Structural core quality is then squared to reflect compounding architectural leverage: (CPR)^2.

Structural Core Principles (CPR) Relationships and Interactions

C = Correctness + Composable → Logical & Structural Integrity

• Correctness – Software does what it is supposed to do.
• Composable – Software can safely integrate with other systems.
  Metaphor: “A brick must be solid and fit with others to build a stable wall.”
  Reasoning: A system is only structurally sound if it is both right and integrable.

P = Performant + Privacy-First→ Practical Operational Quality

• Performant – Efficient, fast, and resource-conscious.
• Privacy-First – Protects sensitive data and respects boundaries.
  Metaphor: “A car must move fast and lock its doors; speed without safety or safety without speed is useless.”
  Reasoning: A system is only usable in real life if it is both efficient and safe.

R = Reliable + Resilient → Temporal Robustness

• Reliable – Works consistently under normal conditions.
• Resilient – Survives and recovers from stress, failures, or unexpected events.
  Metaphor: “A bridge must stand every day and survive storms to be truly dependable.”
  Reasoning: Robustness requires both steady performance and the ability to handle disruption.

Governance (G)

Governance refers to the set of guiding mechanisms that ensure a reliable software system evolves responsibly, remains secure, operates transparently, and serves real user needs. In this context, governance does not create structural strength; rather, it moderates and scales the impact of the structural core over time.

Governance is the institutional layer that guides how a system adapts, secures itself, exposes accountability, and remains user-centered—multiplying the value of structural strength without substituting for it.

Software Governance Quality Score

Governance is modeled as the arithmetic mean of four moderating dimensions:

G = (E + S + T + U) / 4

Where E = Evolvable, S = Secure, T = Transparent, and U = User-Centered. Governance acts as a multiplier rather than an exponent, reflecting its role in scaling engineering outcomes rather than creating them.

Software Governance Principles

E = Evolvable → Adaptation over Time

• Can change, improve, or scale without collapsing.
  Metaphor: “A building designed for future expansion is more valuable than one that cannot adapt.”

S = Secure → Protection Against Threats

• Guards against unauthorized access or exploitation.
  Metaphor: “A fortress is only valuable if the gates are locked against intruders.”

T = Transparent → Observability & Accountability

• Understandable, auditable, and explainable.
  Metaphor: “A window in the wall lets people see what’s happening inside; without it, trust is impossible.”

U = User-Centered → Human Alignment

• Designed with human needs, goals, and comprehension in mind.
  Metaphor: “A tool is only useful if people can actually use it.”

Reliable Software Quality Total Score (Q)

The complete quality equation is defined as:

Q = (CPR)^2 × G

Taking partial derivatives demonstrates structural dominance:

∂Q/∂CPR = 2CPR × G

∂Q/∂G = (CPR)^2

For sufficiently strong systems, marginal improvements in structural strength produce greater gains in quality than equivalent improvements in governance.

Organizational Implications

1. Architectural investment yields nonlinear returns.
2. Governance without structure produces superficial quality.
3. High-maturity systems institutionalize structural discipline.
4. Structural shortcuts square long-term risk.

Future Work

Future empirical validation may include retrospective scoring across systems, incident correlation studies, and longitudinal tracking of structural improvements versus governance enhancements.

Conclusion

Reliable software quality behaves quadratically with structural engineering integrity and linearly with governance integrity. This establishes the foundation of the Reliable Software Quality Rubric:

Quality equals the square of engineering strength multiplied by governance strength ((CPR)^2 ESTU).

Appendix A: Reliable Software Quality Rubic

Structural Core (CPR)² × Governance (ESTU)

Scoring scale (per principle):

Score	Meaning
0	Absent / actively harmful
1	Minimal / inconsistent
2	Adequate but fragile
3	Strong and reliable
4	Excellent / exemplary
5	Industry-leading / best-in-class

Structural Core (CPR)

These are multiplicative: weakness in one materially degrades overall quality.

C — Correctness

• Produces accurate results
• Meets specification
• Deterministic where required
• Comprehensive test coverage
• Clear validation of edge cases

C — Composable

• Modular components
• Clear interfaces
• Low coupling, high cohesion
• Reusable abstractions
• Integrates cleanly with other systems

P — Performant

• Meets latency/throughput targets
• Efficient resource usage
• Scales predictably
• No unnecessary bottlenecks
• Measured and monitored performance

P — Privacy-first

• Minimizes data collection
• Data use aligned with purpose
• Proper access controls
• Data lifecycle management
• Encryption and isolation practices

R — Reliable

• Consistent uptime
• Predictable behavior
• Low defect rate
• Effective monitoring
• Fast mean time to recovery

R — Resilient

• Graceful degradation
• Fault tolerance
• Redundancy where appropriate
• Handles partial failures safely
• Recovery mechanisms tested

Governance (ESTU)

These modulate long-term sustainability and trust.

E — Evolvable

• Easy to extend or modify
• Backward compatibility strategy
• Clear versioning practices
• Refactor-friendly design
• Maintains architectural integrity over time

S — Secure

• Threat modeling performed
• Least privilege enforced
• Strong authentication
• Regular audits and patching
• Defense-in-depth strategy

T — Transparent

• Observable and auditable
• Clear documentation
• Traceable decision logic
• Honest communication about limitations
• Accessible logs and metrics

U — User-Centered

• Solves real user problems
• Usability tested
• Clear UX flows
• Accessibility considered
• Feedback loops incorporated

Scoring Model

Structural Core Score (CPR)

C = √(Correctness × Composable)

P = √(Performant × Privacy-First)

R = √(Reliable × Resilient)

CPR = ³√(C × P × R)

Governance Score (G)

$$G = \frac{E + S + T + U}{4}$$

Total Quality Score (Q)

Q = (CPR)^2 × G

This preserves the insight:

• Weaknesses in the structural core compound.
• Governance moderates sustainability.
• High performance without security (or correctness without reliability) cannot yield high Q.

Appendix B – Crafting Traditional Irish Single Malt Whiskey

Here are the standard production steps for Irish single malt whiskey, with commonly used Irish (Gaeilge) terms where they exist.

Well-supported: The production sequence below aligns with modern Irish whiskey regulations (e.g., distilled in Ireland, malted barley base, pot still distillation, aged ≥3 years in wooden casks).
Note: There is no single ancient Gaelic set of named “ritual steps.” Modern distilling vocabulary is often English, with Irish equivalents used descriptively rather than as fixed technical terms.

---

1. Malting

English: Malting
Irish: Braichlín a dhéanamh (to malt)
Barley is soaked, allowed to germinate, then dried (kilned).

---

2. Milling

English: Milling / Grinding
Irish: Meilt
The malted barley is ground into grist.

---

3. Mashing

English: Mashing
Irish: Maisiú
Hot water extracts fermentable sugars from the grist.

---

4. Fermentation

English: Fermentation
Irish: Coipeadh
Yeast converts sugars into alcohol, producing “wash.”

---

5. Distillation (Pot Still)

English: Distillation
Irish: Driogadh
Single malt is distilled in copper pot stills, usually twice (sometimes three times in Ireland).

Famous distilleries using traditional pot stills include:

• (Scottish example for comparison)

---

6. Maturation

English: Aging / Maturation
Irish: Aibiú
The spirit matures in wooden casks for at least 3 years in Ireland.

Common cask types:

• Ex-bourbon barrels
• Sherry casks

Examples of Irish single malts:

• The Irishman
• West Cork Distillers

---

7. Bottling

English: Bottling
Irish: Buidéalú
The whiskey is diluted (if needed), filtered, and bottled.

---

Summary Flow

Poteen → Malting → Milling → Mashing → Fermentation → Distillation → Maturation → Bottling