Rust for Pythonistas: Why I Dropped the Snake and Picked Up an Axe

David Beale

— 3 min read

I’ve written code in a lot of languages.

ColdFusion, back when I didn’t know better. PHP when I needed a job. Ruby when I wanted to feel something. Go when I wanted things to work. A little Elixir for the poetry. Java when I had no choice. Python? Python was the comfort language. The hoodie and sweatpants of my stack. I loved it — until I didn’t.

This is the story of how I went all in on Rust. Not because I needed to. Because I wanted to. Because for the first time in years, a language made me feel like both a craftsman and a sorcerer. Because the world doesn’t need more lazy abstractions. It needs sharp tools and sharper minds.

🛠️ From Scripting to Systems: The Vibe Shift

Python is great. Until it isn’t.

If you’re doing data work, scripting, automation, or gluing together services with some REST endpoints and a Kafka topic or two, Python sings. Tools like Airflow, pandas, and scikit-learn have made it indispensable in the data world. I wouldn’t dare build a DAG or a messy ETL stack without it.

But let’s call a spade a spade: Python is not built for modern web applications. Not if you care about performance, predictability, or memory safety. You can scale Python with enough duct tape, C extensions, and clever async event loops. But why should you have to?

Rust flipped the script. It gave me:

  • Speed like Go, but with actual nuance
  • Tooling that feels like it was made by obsessive geniuses who care about developer joy (Cargo, Clippy, rust-analyzer — I see you)
  • Syntax that can be expressive or minimal, depending on your taste
  • A Community that’s shockingly helpful and not yet ruined by LinkedIn grifters
  • And most importantly: Control without chaos

🧠 The Learning Curve Is a Feature, Not a Bug

Yes, Rust has a learning curve. So does real craftsmanship.

If you’ve spent your career duct-taping microservices together with Python and YAML, Rust is going to feel like bootcamp. But that pain? That’s your brain growing calluses in the right places. You start caring about lifetimes, borrowing, memory layout. You stop writing code like a script and start building machines.

The compiler isn’t your enemy — it’s your battle buddy.

📊 Type Systems That Actually Prevent Bullshit

Python’s type hints are like pretending to care about safety while juggling knives drunk.

Rust’s type system means it. Enums with tagged unions, pattern matching that actually makes your brain work, and compile-time guarantees that’ll save you from 3am Slack pings. No more undefined NoneType errors or brittle runtime ductwork.

Rust doesn’t just catch bugs — it builds walls around them.

📝 Python vs. Rust: Side-by-Side Patterns

Let’s talk syntax. Here are a few simple patterns, side by side:

Reading a File

Python:

with open('file.txt', 'r') as f:
    contents = f.read()

Rust:

use std::fs;

let contents = fs::read_to_string("file.txt")?;

Async HTTP Server

Python (FastAPI):

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

Rust (Axum):

use axum::{routing::get, Router};
use std::net::SocketAddr;

async fn root() -> &'static str {
    "Hello, World!"
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root));
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr).serve(app.into_make_service()).await.unwrap();
}

Deserializing JSON

Python:

import json

raw = '{"name": "David", "age": 39}'
data = json.loads(raw)

Rust (Serde):

use serde::Deserialize;

#[derive(Deserialize)]
struct Person {
    name: String,
    age: u8,
}

let raw = "{\"name\": \"David\", \"age\": 39}";
let person: Person = serde_json::from_str(raw)?;

🪜 My Rust Stack

Here’s what I run day-to-day:

  • Editor: Neovim with LazyVim setup — tuned to my needs, built for speed
  • Language: Rust, obviously
  • Async runtime: tokio — battle-tested and gorgeous to work with
  • Web framework: axum — composable, async-native, no fluff
  • Serialization/Deserialization: serde — the GOAT
  • Linting & Dev Tools: clippy, cargo-watch, rust-analyzer, taplo for TOML

This is the most ergonomic, productive, and joyful stack I’ve touched since the early Rails days.

🌶️ Python Still Has a Place

Don’t get it twisted. I’m not here to bury Python. It’s still the king of quick-and-dirty scripting, data science, ML prototyping, and anything that benefits from an ecosystem that’s 90% Stack Overflow paste-ready.

If you're doing work in Airflow, Spark, pandas, or Jupyter, Python is still the move. No data engineer or ML scientist could live without it.

But if you’re building something you want to last, something that needs to run lean and mean, something you want to be proud of ten years from now?

Rust.

It’s not about hype. It’s not about purity. It’s about taste. It’s about tools that let you feel the work again.

And for me, Rust is the only language that gives me the joy of building something hard and making it beautiful.

Drop the snake. Pick up the axe.

Read more