ontoref/assets/presentation/org_slides.md

theme, title, titleTemplate, layout

theme	title	titleTemplate	layout
default	Why I Needed Rust	%s - Rustikon 2026	cover

Why I Needed Rust

Finally Infrastructure Automation I Can Sleep On

Jesús Pérez Lorenzo Las Palmas, Spain Rustikon 2026

---

The Problem Statement

After decades in infrastructure, I was exhausted.

Not by the work.

By the failures.

---

layout: two-cols

38 Years of Infrastructure

1987 — 2025

::left::

• Perl (1990s)
• Python (2000s)
• Bash (2000s)
• Chef (2010s)
• Ansible (2010s)
• Terraform (2010s)
• Go (2010s-2020s)
• ???

::right::

"I've tried everything to solve the provisioning problem."

Each time, I thought I had the answer.

Each time, reality proved me wrong.

---

The Perl Era (1990s)

Power and Chaos

The Promise: We could do anything

The Reality: We could break anything

• Metaprogramming that was beautiful and terrifying
• No safety net
• Silent failures at 3 AM
• Lesson: Power without safety is a disaster

---

The Python Pragmatism (2000s)

Flexible, Rapid, Trusted

The Appeal: Rapid development, great community

The Problem: Nothing stopped you from being wrong

• Type hints came late (and optional)
• Runtime errors > compile-time errors
• Scripts that "worked on my machine"
• Lesson: Pragmatism without guarantees is fragile

---

The Cloud Scale (2010s)

More Tools, Same Problems

Tools arrived: Ansible • Terraform • Chef • Puppet

What changed? The syntax

What didn't? The fundamental problems

• Still fighting type safety
• Still discovering errors in production
• Still maintaining undocumented scripts
• Lesson: More tools don't solve paradigm problems

---

The Breaking Point

I could automate infrastructure

But I couldn't make it reliable

I couldn't prevent mistakes

I couldn't sleep

---

layout: section

The Real Problems

What Actually Fails

---

What Actually Fails

• Typos discovered at 3 AM in production configs
• Scripts that "worked on my machine" fail everywhere else
• Nobody understands the code even 6 months later
• Changes that break other things silently
• Secrets scattered everywhere without audit trails

It's not about deployment.

It's about reliable deployment that doesn't cause panic.

---

The Cost

Not just technical:

• Hours debugging cryptic errors
• Sleep lost to on-call incidents
• Team stress and burnout
• Lack of confidence in deployments
• Technical debt that compounds
• The thing you can't measure: fear

---

The Realization

The tools weren't the problem.

The languages weren't the problem.

The paradigm was the problem.

I needed something that:

• Forced clarity (not enabled chaos)
• Prevented errors (before production)
• Made assumptions explicit (not hidden)
• Gave confidence (not anxiety)

---

layout: section

Rust Enters the Picture

The Shift

---

First Encounter with Rust

"Type safety?"

"Memory safety?"

"Do I really need this?"

This looks... complicated.

Initial reaction: skepticism mixed with curiosity

---

The Shift: Type System as Defense

Wait.

The compiler could prevent my mistakes?

Before they reach production?

Before I even run the code?

This changed everything.

---

What Changed For Me

Problem	Old Way	Rust Way
Typos in config	3 AM incident	Compile error
"Works on my machine"	Hope and prayers	Guaranteed same output
Secrets leaking	Runtime discovery	Type system prevents it
Undocumented constraints	Institutional knowledge	Compiler enforces it
Silent failures	Debug for hours	Explicit error handling

---

The Infrastructure Insight

I could define constraints in code.

Compiler enforced them everywhere.

Changes forced adaptation everywhere.

No silent failures.

This is not a small thing.

---

The Human Impact

When the system is trustworthy:

• ✓ Sleep comes back
• ✓ Confidence returns
• ✓ Team trusts the automation
• ✓ Stress decreases
• ✓ You can actually rest

---

layout: section

What I Built

The Implementation

---

Current Projects

Building in Rust:

• project-provisioning — Infrastructure provisioning orchestrator
• secretumvault — Secrets management with PQC
• typedialog — Interactive configuration forms
• daemon-cli — Unified service abstraction

Not selling products.

Demonstrating that it works.

---

The Key Patterns

Type-safe declarations

• Schema defines constraints at compile-time

Schema-driven generation

• Forms, validation, templates all derived from one source

Distributed orchestration

• Control, not chaos. Semaphore-based coordination

Unified governance

• Auth, audit, compliance as first-class concerns

Each pattern prevents specific failures.

---

Why Rust Specifically

Type System Prevents entire categories of errors before execution

Performance No overhead, can be truly reactive

Ecosystem Coherent tools (Nickel, Nushell, KCL) not disparate solutions

Single Binary Deploy anywhere, no dependency hell

Community People who care about correctness

---

layout: section

What I Learned

The Philosophy

---

Three Key Insights

1. Infrastructure is your core, not an afterthought

It's not a support function. It's the foundation your business runs on.

2. Reliability requires preventing errors, not handling them

You can't code around a broken paradigm.

3. Engineers deserve better than anxiety

We shouldn't be woken at 3 AM by infrastructure failures.

---

The Age Advantage

At 63, I have perspective.

I've seen technologies come and go.

Rust isn't hype. It solves real problems I've had for decades.

Being older isn't a liability.

It's an advantage.

I can tell you: this matters.

---

What Infrastructure Actually Is

• Core of your business — not a cost center
• Must evolve with business needs
• Can't be fragile — customers depend on it
• Can't cause panic — engineers can't be on-call all the time
• Engineers deserve to rest — this is non-negotiable

---

layout: section

The Ask

For Everyone Here

---

For Infrastructure Veterans

If you've been frustrated like me:

• ✓ Listen up
• ✓ Rust solves the problems you know
• ✓ Not problems you've never had
• ✓ Give it a real chance
• ✓ Your sleep will thank you

---

For Younger Engineers

Learn from someone who tried everything:

• ✓ Don't waste 30 years on fragile infrastructure
• ✓ Start with type safety
• ✓ Build for reliability from- day one
• ✓ You'll thank yourself later

---

The Simple Ask

Think differently about infrastructure.

Type safety isn't luxury.

It's foundation.

You deserve better than 3 AM panic.

---

layout: cover

Why I Needed Rust, Finally

Because I Wanted to Sleep

Questions?

---

Resources & Contact

Projects:

• github.com/jesusperez/provisioning
• github.com/jesusperez/secretumvault
• github.com/jesusperez/typedialog

Community:

• Rust Las Palmas — rust-laspalmas.dev

Contact:

• jesusperez.pro

---

Speaker Notes

Delivery Tips

• Opening: Vulnerable, honest. Show the struggle before the solution.
• Tone shift: Around slide "The Shift" — move from struggling to architect who figured it out.
• Key moments: Pause after emotional beats. Let them sink in.
• Age: Not an apology, not bragging. Just perspective.
• Closing: Hopeful, inclusive. This is for everyone.

Audience Engagement

• Opening question: "Who's been woken up at 3 AM by infrastructure failure?" (show of hands)
• Pause points: After problem slides, let silence sit
• Expression: Show relief when talking about Rust solution
• Ending: Direct eye contact, slow delivery

Timing

• 2 min: Opening (slides 1-2)
• 5 min: Journey (slides 3-8)
• 5 min: Problems (slides 9-12)
• 6 min: Rust discovery (slides 13-17)
• 5 min: Implementation (slides 18-20)
• 4 min: Philosophy (slides 21-23)
• 2 min: Call to action (slides 24-26)
• 1 min: Closing (slide 27)
• Total: 30 minutes + Q&A

If Extending to 40 min

Add stories:

• Specific 3 AM incident (2 min)
• First Rust project struggles (2 min)
• Team adoption journey (2 min)
• Measurable improvements (2 min)