ontoref/assets/presentation/reader-script-en.md

Rustikon 2026 - Slide Text (Reader Version)

One section per real Slidev slide (parser-based count).

Slide 1

STORY: Act 1 - Hook & Promise TENSION: Low -> Medium EMPHASIS: Credibilidad y dolor real DELIVERY: Calma, pausas limpias

Why I Needed Rust Finally, Infrastructure Automation I Can Sleep On 🛡 ●●●○○ 😴 ●●●○○ 🔥 ●○○○○

Slide 2

STORY: Act 1 - Hook & Promise TENSION: Low -> Medium EMPHASIS: Credibilidad y dolor real DELIVERY: Calma, pausas limpias

Years. One Problem. 1987 → 2025 Era Tool Lesson

---

1990s Perl Power without safety is a disaster 2000s Python Pragmatism without guarantees is fragile 2010s Bash · Chef · Ansible · Terraform More tools don't solve paradigm problems 2020s Go · ??? Each time, I thought I had the answer. Each time, reality proved me wrong.

Slide 3

STORY: Act 1 - Hook & Promise TENSION: Low -> Medium EMPHASIS: Credibilidad y dolor real DELIVERY: Calma, pausas limpias

The Evolution How we got here

Slide 4

STORY: Act 2 - Escalation TENSION: Medium -> High EMPHASIS: Crecimiento de complejidad sin control DELIVERY: Ritmo creciente

Stage 1 — Local (late 80s / early 90s) Dumb terminals. Single machine. One state. Local development, long deployment cycles, low urgency One state — easy to observe, easy to control IaC: procedural scripts, logic hidden inside the application

The Perl Era: we could do anything.

We could also break anything.

Beautiful, terrifying metaprogramming.

No safety net. Silent failures at 3 AM.

Lesson: power without safety is a disaster. 🛡 ●●●●○   😴 ●●●●○   🔥 ●○○○○

Slide 5

STORY: Act 2 - Escalation TENSION: Medium -> High EMPHASIS: Crecimiento de complejidad sin control DELIVERY: Ritmo creciente

Stage 2 — Networks / Internet Systems getting farther away. More people. More coordination. Remote access, distributed teams, security becomes relevant Cost of downtime rises — processes become critical Harmonizing: package installs, config, updates across multiple machines in parallel IaC: reproducible automation, first declarative attempts

The Python Era: rapid development, great community.

But nothing stopped you from being wrong.

Type hints came late — and optional.

Runtime errors >> compile-time errors.

Lesson: pragmatism without guarantees is fragile. More pieces. More people. Getting interesting. 🛡 ●●●○○   😴 ●●●○○   🔥 ●●○○○

Slide 6

STORY: Act 2 - Escalation TENSION: Medium -> High EMPHASIS: Crecimiento de complejidad sin control DELIVERY: Ritmo creciente

Stage 3 — Containers / Cloud / CI-CD Everything. Everywhere. All at once. Monolith → distributed, 24×7×365, high availability Cloud, hybrid, multi-cloud, on-prem — simultaneously Rollback and rollforward: database transactions, but for infrastructure Scale horizontally AND vertically — and descale CI/CD continuous: new features, new deploys, permanent churn

The Cloud/IaC Era: Ansible, Terraform, Chef, Puppet.

What changed? The syntax.

What didn't? The fundamental problems.

Still fighting type safety. Still discovering errors in production.

Lesson: more tools don't solve paradigm problems. 🛡 ●●○○○   😴 ●○○○○   🔥 ●●●●○

Slide 7

STORY: Act 2 - Escalation TENSION: Medium -> High EMPHASIS: Crecimiento de complejidad sin control DELIVERY: Ritmo creciente

I could automate infrastructure. But I couldn't make it reliable. I couldn't prevent mistakes. I couldn't sleep. 🛡 ●○○○○    😴 ○○○○○    🔥 ●●●●●

Slide 8

STORY: Act 3 - Problem Anatomy TENSION: High EMPHASIS: Causa raiz y costo de fallar tarde DELIVERY: Didactico, frases cortas

Why IaC Fails The restaurant problem

Slide 9

STORY: Act 3 - Problem Anatomy TENSION: High EMPHASIS: Causa raiz y costo de fallar tarde DELIVERY: Didactico, frases cortas

The Restaurant Every restaurant has at least three actors. Restaurant Infrastructure

---

Guest declares what they want Declarative config (YAML, HCL) Waiter validates and transmits Orchestrator (K8s, Ansible) Kitchen executes and delivers Runtime / provisioning Dish arrives — or doesn't Deployment succeeds — or not What makes it work — or not: The guest declares. Doesn't implement. The waiter must know what's possible — before going to the kitchen.

"I want X" → waiter goes to kitchen → "we don't have X, why is it on the menu?" → back to the table.

Equivalent: I configured a host with port 8443 → that port isn't allowed → reconfigure from zero.

Slide 10

STORY: Act 3 - Problem Anatomy TENSION: High EMPHASIS: Causa raiz y costo de fallar tarde DELIVERY: Didactico, frases cortas

The Truth That Mutates State is not static. It can change at every step of the chain. Step Truth for this actor

---

Guest speaks What they want Waiter's notepad What was written down Kitchen markings What's done / not done Payment ticket What was actually served

Fail early = fail cheap. Fail in production = nightmare. The context problem: The waiter knows the regular customer: "always no salt." The kitchen doesn't. If the waiter changes — that context disappears. Configuration drift is the same thing: Implicit state. Not explicit. Not propagated. Lost silently. The cost of failure depends on where it happens: Fail at the table (impossible order): cheap — caught before kitchen Fail in kitchen (ingredient missing): medium — renegotiate with guest Fail at delivery (wrong dish arrives): expensive — experience destroyed

Slide 11

STORY: Act 3 - Problem Anatomy TENSION: High EMPHASIS: Causa raiz y costo de fallar tarde DELIVERY: Didactico, frases cortas

"We Don't Have Mushrooms" When an actor in the chain can't fulfill part of the order.

"Can I substitute vegetables?"

That renegotiation must be explicit. Traced. Re-authorized. Not silent. Not assumed. Configuration drift is silent renegotiation: The system changes. Nobody notified. State diverges without trace. Rust's answer — Option : [code example] The compiler is the waiter who cannot pretend an ingredient exists.

Slide 12

STORY: Act 3 - Problem Anatomy TENSION: High EMPHASIS: Causa raiz y costo de fallar tarde DELIVERY: Didactico, frases cortas

The Config Evolution How we got from code to YAML hell Hardcoded — everything inside the binary. Full control. Zero flexibility. External config (JSON) — works between machines. Unreadable for humans at scale. YAML / TOML — more readable. Fragile syntax. Implicit types. Silent errors. YAML + Serde — Serde validates the structure: Does the field exist? Is it the right type? Do we accept "elephant" as a pet? If the type is String... yes. Serde validates shape. Not meaning. Helm / Jinja templates — YAML generated from variables (in YAML). Does it validate the content of the generated YAML? No. Not at all. Like using an LLM with a markdown reference: the format is there, but is the content correct? Nobody guarantees that.

Slide 13

STORY: Act 3 - Problem Anatomy TENSION: High EMPHASIS: Causa raiz y costo de fallar tarde DELIVERY: Didactico, frases cortas

Continuous CI/CD. No semantic validation. Continuous hope. (crossing our fingers in production) 🛡 ●○○○○    😴 ○○○○○    🔥 ●●●●●

Slide 14

STORY: Act 3 - Problem Anatomy TENSION: High EMPHASIS: Causa raiz y costo de fallar tarde DELIVERY: Didactico, frases cortas

Three Questions Without Answers Question 1 — — Why do we wait for things to break? "Works on my machine" — in production, I don't know Fail late = maximum cost. We want: fail fast, fail cheap Question 2 — — Do we actually know what we want? Is the declaration sufficient and consistent with what's possible? What are the boundaries? Static or dynamic? What is the source of truth — and when does it mutate? Question 3 — Can we guarantee determinism ? CI/CD without semantic validation = continuous hope We want certainty, not randomness "Works on my machine" cannot be the production standard

We're not inventing anything new. Everything already exists. The question is whether we're managing it correctly.

Slide 15

STORY: Act 4 - Turning Point TENSION: Peak EMPHASIS: No faltan tools, falta paradigma DELIVERY: Silencios intencionales

The tools weren't the problem. The languages weren't the problem. The paradigm was the problem.

Slide 16

STORY: Act 4 - Turning Point TENSION: Peak EMPHASIS: No faltan tools, falta paradigma DELIVERY: Silencios intencionales

Systems we don't know how to control. We hope they work. When they don't — we fix them. Continuous nightmare. ( alarm state as the new normal) 🛡 ●○○○○    😴 ○○○○○    🔥 ●●●●●

Slide 17

STORY: Act 4 - Turning Point TENSION: Peak EMPHASIS: No faltan tools, falta paradigma DELIVERY: Silencios intencionales

Rust The answer to all three questions

Slide 18

STORY: Act 4 - Turning Point TENSION: Peak EMPHASIS: No faltan tools, falta paradigma DELIVERY: Silencios intencionales

The Bridge: From Serde to Types Serde loads structurally valid config. But "elephant" as pet: String compiles. Rust's answer: don't use String. Use a type. [code example] This is the shift.: Not the config format. The model of what it can contain. Serde validates shape Types validate meaning The compiler validates before the binary exists.

Slide 19

STORY: Act 5 - Resolution TENSION: High -> Medium EMPHASIS: Types y compiler como respuesta DELIVERY: Claro y tecnico

What Rust Gives Us Answer to Question 1: fail early, fail cheap [code example] Answer to Question 2: explicit contracts [code example]

Slide 20

STORY: Act 5 - Resolution TENSION: High -> Medium EMPHASIS: Types y compiler como respuesta DELIVERY: Claro y tecnico

The Compiler as Pre-Validator Answer to Question 3: guaranteed determinism [code example] The compiler validates: Before building the binary Not after hours of execution Not when a function nobody touched in months finally gets called Predictable behavior: memory, resources, workflows The compiler is the waiter who validates the order. Before it reaches the kitchen. Before the guest waits. Before any ingredient is missing. 🛡 ●●●●○   😴 ●●●●○   🔥 ●●○○○

Slide 21

STORY: Act 5 - Resolution TENSION: High -> Medium EMPHASIS: Types y compiler como respuesta DELIVERY: Claro y tecnico

The Human Impact When the system is trustworthy: ✓ Sleep comes back ✓ Confidence returns ✓ The team trusts the automation ✓ Stress decreases ✓ You can actually rest

What you can't measure: fear .

What you can measure: MTTR .

Before: > 30 minutes. Now: . 🛡 ●●●●●  😴 ●●●●●  🔥 ●○○○○

Slide 22

STORY: Act 5 - Resolution TENSION: High -> Medium EMPHASIS: Types y compiler como respuesta DELIVERY: Claro y tecnico

Continuous CI/CD. Types. Compiler. Explicit state. Continuous certainty. (to keep sleeping well) 🛡 ●●●●●    😴 ●●●●●    🔥 ●○○○○

Slide 23

STORY: Act 5 - Resolution TENSION: High -> Medium EMPHASIS: Types y compiler como respuesta DELIVERY: Claro y tecnico

In Production This is not theory

Slide 24 (name: provisioning)

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

import { ref, computed } from 'vue' const useWhite = ref(false) const bgStyle = computed(() => ({ backgroundImage: url('${useWhite.value ? "/w-arch-diag-v2.svg" : "/arch-diag-v2.svg"}'), backgroundSize: 'contain', backgroundRepeat: 'no-repeat', backgroundPosition: 'center', position: 'absolute', inset: '0', cursor: 'pointer', })) 🌗

Slide 25

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

Nickel YAML rejected. TOML rejected. Reason: no type safety. YAML wrote what we wanted. It couldn't say what was possible. Nickel closes that gap — at config time, not at 3 AM. [code example] Typed Source of Truth Result (ADR-003): zero configuration type errors in production. Config hierarchy: defaults → workspace → profile → environment → runtime Each layer merges. Type system catches conflicts. At config time — not deployment time. The guest wrote an impossible order. Nickel makes impossible orders unwritable.

Serde validates shape.

Nickel validates meaning.

The compiler validates before deployment.

Slide 26

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

Traits as Provider The kitchen can change. AWS ≠ UpCloud ≠ bare metal. Same menu. [code example] Explicit state — no drift: [code example] Contracts Checkpoint every 5 minutes No implicit state.

No "the waiter remembers the customer doesn't want salt." It's in the order. Always. Explicit.

Slide 27

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

Dependency Graph Failfast: bool is not a config option. It's a principle encoded as a type. Typed DAG — dependency resolution enforced at workflow compile time: The kitchen doesn't serve the main course before the starter is done. DependencyType::Hard is that rule. In the type system, not in a runbook. [code example] Fail Fast, Fail Cheap DependencyType::Hard - failure stops the chain. Always. DependencyType::Soft - continues, explicitly degraded. DependencyType::Optional - missing is expected and fine.

The compiler catches the install order. Not the on-call engineer at 2 AM. 🛡 ●●●●●   😴 ●●●●●   🔥 ●○○○○

Slide 28

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

Real Applications

Kubernetes

The orchestrator provisions cluster components as a typed workflow: [code example] Each dependency is a DependencyType. The compiler catches: installing Cilium without Kubernetes. Not the on-call engineer at 2 AM.

"In my machine it works" has a price here.

This is the highest-stakes infrastructure in the deck.

Blockchain Validators

Validators require brutal uptime. A validator that fails loses funds — not your infrastructure's money. Your customer's. Post-quantum cryptography: CRYSTALS-Kyber + Falcon + AES-256-GCM hybrid. Validator keys protected against quantum computers. SLOs with real error budgets: 99.99% = 52.6 min downtime/year. Prometheus blocks deploys when burn rate exceeds budget. Deterministic config: validator parameters are types. A bondamount that isn't a valid u128 doesn't compile.

Slide 29

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

Disaster Recovery Rollback as a type, not a procedure 3 AM. Something broke. You need to rollback. Without types: you improvise. With types: you choose a strategy — or it doesn't compile. [code example] Multi-backend backup: restic, borg, tar, rsync — all as enum variants. Production backup and DR restore use the same type, the same schema.

The runbook exists.

Nobody reads it clearly at 3 AM under pressure.

The type forces the decision before the crisis.

The state is the same in prod and in DR. Always.

Slide 30

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

Self-Healing

When something breaks at 3 AM — the system responds, not you. [code example] — Typed Remediation What happens at 3 AM: Alert fires → RemediationEngine matches condition → runs RestartService Works: silent. Nobody woken up. Fails 3×: page sent — with full state, checkpoint, and execution history. You wake up to information. Not to chaos. 🛡 ●●●●●   😴 ●●●●●   🔥 ●○○○○

Slide 31

STORY: Act 6 - Proof in Production TENSION: Medium -> High EMPHASIS: Casos reales e impacto operativo DELIVERY: Energetico y concreto

Without types. Without compiler. Without explicit state. MTTR > 30 minutes. ──────────────────────── Rust. Types. Explicit state. Automated response. MTTR (at 3 AM. without you.) 🛡 ●●●●●    😴 ●●●●●    🔥 ●○○○○

Slide 32

STORY: Act 7 - Close & CTA TENSION: Medium -> Low EMPHASIS: Cierre emocional con accion DELIVERY: Lento y memorable

Why This Matters For everyone in this room

Slide 33

STORY: Act 7 - Close & CTA TENSION: Medium -> Low EMPHASIS: Cierre emocional con accion DELIVERY: Lento y memorable

For You If you've been frustrated like me Rust solves problems you already have. This is not hype. It is operational relief. Start here: Model your infrastructure as types Let the compiler pre-validate before deployment If you're earlier in your career Start with type safety from day one. Build for reliability, not only speed. The shortest path: Types for config. Traits for providers. Determinism for operations.

Slide 34

STORY: Act 7 - Close & CTA TENSION: Medium -> Low EMPHASIS: Cierre emocional con accion DELIVERY: Lento y memorable

I have perspective from long production experience. I have seen technologies come and go. Rust is not hype. Rust is relief with evidence. It solves real operational problems I had for decades. More years is not a liability. It is an advantage.

Slide 35 (name: end)

STORY: Act 7 - Close & CTA TENSION: Medium -> Low EMPHASIS: Cierre emocional con accion DELIVERY: Lento y memorable

Why I Needed Rust 🛡 ●●●●● 😴 ●●●●● 🔥 ●○○○○ Three Closing Lines I have lived this problem for decades. Rust gave me deterministic systems and better sleep. Start small: model infrastructure as types. Thank you. Questions? More info: · jesusperez.pro · provisioning.systems · vapora.dev · rustelo.dev