There’s a saying: “Jack of all trades, master of none, but oftentimes better than master of one.”

In programming, it feels like half of us have forgotten that. Scroll through forums, developer chats, or Twitter threads, and you’ll see it everywhere:

• “Why isn’t this written in Rust?!”
• “Python is garbage for real work.”
• “Go is too boring to bother with.”

Yes, people argue like this. And yes, it’s exhausting.

Saws, Screwdrivers, and Hammers

Let’s start simple: you wouldn’t grab a saw to unscrew a screw. Sure, you could, if you wanted to destroy the furniture and feel frustrated in the process, but why? Programming languages are the same: tools designed for specific tasks.

• Rust is a coping saw: precise, intricate, surgical. Perfect for memory-safe systems, high-performance engines, or anything where a tiny mistake is catastrophic.
• Go is a hacksaw: straightforward, powerful, reliable. Perfect for cutting through the bulk of backend work quickly.
• Python is a Swiss Army knife: versatile, readable, and packed with convenient features. Great for automation, scripts, ML, and data analysis.
• JavaScript / TypeScript is the omnipresent generalist: messy, everywhere, but necessary to get the web done.

Holy wars over languages often sound like this: “Python is garbage! Rust is the only way!”

Now imagine replacing it with tools: “Screwdrivers are garbage! Saws are the only way!” You’d think: “What planet are these people on?” That’s exactly the absurdity of language wars. They’re yelling about completely different tools being “better” in contexts where each tool has its own purpose.

The Hammer Fallacy

Even more ridiculous is the “hammer fallacy.” Some developers act like:

My hammer is the best! It can do everything! Everyone else should throw out their other tools and just use a hammer for everything!

Imagine a carpenter saying this. Every nail, every screw, every delicate cut would be done with a hammer. You’d shake your head, maybe laugh, and definitely avoid hiring them.

Yet in programming, this happens all the time. Rust, Python, Go, JavaScript, pick your hammer. Arguments stop being about problem-solving and become about identity. Misusing the hammer works… sometimes… but it’s clumsy, inefficient, and often destructive, just like misusing a language outside its domain.

The Law of the Instrument

Abraham Maslow put it plainly:

I suppose it is tempting, if the only tool you have is a hammer, to treat everything as if it were a nail.

This is exactly what we see in programming holy wars. Over-identifying with a language turns it into a hammer, and suddenly every problem, no matter how different, is treated like it must be solved with that one tool.

The antidote? Awareness. Recognize that languages are tools, not identities. No matter how much you love your hammer, there are jobs that require screwdrivers, saws, or coping saws.

Similar Tools, Different Focus

Even languages with overlapping domains have different strengths. Rust vs Go is a perfect example: both build high-performance backends, but the trade-offs differ.

• Rust (coping saw): surgical, precise, prevents mistakes before they happen. Perfect for complex systems and performance-critical applications.
• Go (hacksaw): fast, reliable, easy to learn, built for getting through the bulk of work without drama. Not as precise, but extremely effective for its intended tasks.

They’re both saws. They’re both metal cutters. But they’re not interchangeable. Choosing one over the other isn’t a moral statement, it’s using the right saw for the cut you need.

The Career Factor

Let’s be honest: the job market encourages single-language mastery. Learn one language well, get good at it, and you can make a living. That’s great! But it reinforces the “hammer-only” mindset. Suddenly, language discussions aren’t about efficiency or problem-solving, they’re about ego and identity.

And that’s why we have holy wars.

Stop the Wars, Pick the Right Tool

The healthiest developers I know are polyglots. They don’t worship a single language, they pick the right tool for the job:

• Safety + performance? Rust.
• Rapid prototyping or data analysis? Python.
• Scalable backend? Go.
• Web apps that actually run in browsers? JavaScript/TypeScript.

Languages aren’t religions. They’re tools. If one language were “perfect” for everything, it wouldn’t be perfect anywhere. Trade-offs are what make each language shine in its own lane.

So next time someone starts a Rust vs Python, or Rust vs Go, holy war, picture them yelling about saws and screwdrivers… or hammers. It’s absurd. And that absurdity is the best reminder of why using the right tool for the right job matters more than winning any argument.