How Rust got to the top.

Music to listen to while reading this.

When I started programming in 2013, I didn't have a clue where to begin. As a result, I did what a lot of people did: pick the easiest option.

Of course, in 2013, there weren't too many options for me.

iOS development was off the table, as I didn't have a Mac back then, and so was Windows development (I took one look at the C# docs, and I've literally never looked back).

However, web development looked to be a pretty cool field to go into: I could do it on my laptop, and build products that were cross-compatible. But most importantly, it was easy.

<!doctype html>
<html>
    <p>Hello World</p>
</html>

It was this simple to get started.

However, as time progressed, the web world became very different. Times change, and now I regularly see fights break out at hackathons over which framework is the best (by the way, it's Angular). JavaScript has become a self-created monster, lacking nearly any tools for structured, consistent programming and techniques.

As a result, I burned out. I didn't get the same rewarding feeling building something that I had when I was just starting out. I started to dread working with the tech stack that I had chosen; there were always too many things to keep track of, and not enough people to help out.

In hindsight, it wasn't the easiness that brought me to web development, it was the human connection. In 2013, there were very few frameworks and library (that were viable for production code), and so everyone focused on a couple of things, and there was clear, consistent, human-centric design. This idea was echoed all throughout the ecosystem, from the languages to the library design and docs.

We've all but lost this humanity in web development, which is why I needed a refresher.

I quenched my thirst for this humanity in tech with mathematics and natural languages. Instead of studying code, I studied the dynamics that humans used to communicate, be it through English, French, or function notation.

Most of that studying was devoted to working on Philang with Andrew Gao from Hack Club, but I got something else out of it: Rust.

Rust is one of the fastest languages out there, just hovering near C and quite a far way away from C++. However, what makes it stand out is the fact that it has type safety, embedded systems compatibility, and a whole host of other factors.

However, what made Rust stand out for me was the language itself. Like I said before, I was focusing on human-focused design at the time. Because of this, Rust struck me quite hard.

You see, Rust did what the web had done in the old days: crafted a well-knit community and put its developers first. But more importantly, its language was, quite frankly, beautiful.

Rust's syntax is incredibly human-centric, and variables are the smallest example of this.

// Mutable variable definition
let mut x = 5;

// Immutable variable definition
let y = 6;

// Constant
const z = 7;

The total amount of variable/constant keywords in Rust.

You only really need 2 keywords, both of which are pretty self-explanatory. This type of design brought me back to when I was messing around with JS in elementary school, and I realized that this was what I was looking for.

Rust has some of the most thoughtful syntax that I've come across in a long time, from implying that all variables should be immutable by default, to the way that garbage collection works.

Its success proves one thing: we've been working on optimizing our languages for computers so much that we've forgotten to optimize it for ourselves.