---
theme: default
title: Why I Needed Rust
titleTemplate: '%s - Rustikon 2026'
layout: 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.

<style>
h1 { font-size: 3rem; }
p { font-size: 1.5rem; color: var(--color-text-secondary); margin: 0.5em 0; }
</style>

---
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**

<div class="box-highlight">
<strong>The Promise:</strong> We could do anything

<strong>The Reality:</strong> We could break anything
</div>

- 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**

<div class="box-highlight">
<strong>The Appeal:</strong> Rapid development, great community

<strong>The Problem:</strong> Nothing stopped you from being wrong
</div>

- 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**

<div class="box-highlight">
<strong>What changed?</strong> The syntax

<strong>What didn't?</strong> The fundamental problems
</div>

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

---

# The Breaking Point

<div style="text-align: center; margin: 3em 0;">

**I could automate infrastructure**

**But I couldn't make it reliable**

**I couldn't prevent mistakes**

**I couldn't sleep**

</div>

---
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

<div class="box-highlight">
It's not about <strong>deployment</strong>.

It's about <strong>reliable deployment</strong> that doesn't cause panic.
</div>

---

# 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

<div class="box-highlight">
<strong>"Type safety?"</strong>

<strong>"Memory safety?"</strong>

<strong>"Do I really need this?"</strong>

This looks... complicated.
</div>

Initial reaction: skepticism mixed with curiosity

---

# The Shift: Type System as Defense

<div style="text-align: center; margin: 2em 0;">

**Wait.**

**The compiler could prevent my mistakes?**

**Before they reach production?**

**Before I even run the code?**

</div>

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

<div class="box-highlight">
I could define constraints in code.

Compiler enforced them everywhere.

Changes forced adaptation everywhere.

No silent failures.
</div>

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

<div class="box-highlight">
<strong>Type System</strong>
Prevents entire categories of errors before execution

<strong>Performance</strong>
No overhead, can be truly reactive

<strong>Ecosystem</strong>
Coherent tools (Nickel, Nushell, KCL) not disparate solutions

<strong>Single Binary</strong>
Deploy anywhere, no dependency hell

<strong>Community</strong>
People who care about correctness
</div>

---
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

<div class="box-highlight">
At 63, I have perspective.

I've seen technologies come and go.

<strong>Rust isn't hype. It solves real problems I've had for decades.</strong>

Being older isn't a liability.

It's an advantage.
</div>

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

<div style="text-align: center; margin: 3em 0;">

**Think differently about infrastructure.**

Type safety isn't luxury.

It's foundation.

You deserve better than 3 AM panic.

</div>

---
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

<style>
a { color: var(--rust-orange); }
</style>

---

# 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)
