💻

1

Years. One Problem.

1988 → today

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.

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.

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.

"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<T>:

// The waiter cannot silently skip a missing ingredient
let mushrooms: Option<Ingredient> = order.mushrooms;
match mushrooms {
    Some(m) => add_to_dish(m),
    None    => renegotiate_with_guest(&guest)?, // explicit. always.
}
// drift = treating None as Some. Rust makes that impossible.

The compiler is the waiter who cannot pretend an ingredient exists.

The Config Evolution

How we got from code to YAML hell

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.

// Before: String — anything goes
pet: String  // "elephant" compiles. "unicorn" compiles. 🤷

// After: closed domain — impossible values don't exist
enum Pet { Dog, Cat, Rabbit }  // "elephant" doesn't compile

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.

What Rust Gives Us

// Immutability by default — invariants are invariants
let config = load_config()?;  // cannot change silently
// Option<T> — no nulls, no assumptions
let mushrooms: Option<Ingredient> = order.mushrooms;
match mushrooms {
    Some(m) => add_to_dish(m),
    None    => notify_kitchen_to_skip(),  // explicit. always.
}
// Enums as closed domains
enum CloudProvider { Hetzner, UpCloud, AWS, GCP, Azure, OnPrem }
enum Port { Valid(u16) }  // not any integer — a valid port

// Traits define what every actor in the chain must fulfill
#[async_trait]
pub trait TaskStorage: Send + Sync {
    async fn create_task(&self, task: WorkflowTask) -> StorageResult<WorkflowTask>;
    async fn update_task(&self, id: &str, status: TaskStatus) -> StorageResult<()>;
    // Add a new provider: implement this trait or it doesn't compile
}