Why I prefer Rust

2026-05-23T15:16:00+03:00

Having spent substantial time writing code in various environments, I've used everything from systems languages like C and C++ to modern languages like Go and TypeScript. Each has its strengths, but Rust has become my language of choice. Here are the core reasons why I prefer Rust, contrasting it with my experiences in other languages.

Expression-Based Semicolons

In C, a semicolon simply terminates a statement. In Rust, however, the presence or absence of a semicolon has a semantic meaning. Because Rust is an expression-oriented language, blocks evaluate to their last expression. By omitting the semicolon from the final line of a block or function, it implicitly returns that value. This removes the need for typing the return keyword in almost all standard function ends, making the code cleaner and emphasizing data flow:

1fn add(a: i32, b: i32) -> i32 {
2    a + b // No semicolon, implicit return!
3}

Everything is an Expression

Go lacks a ternary operator (like a ? b : c), requiring verbose, multi-line if/else statements even for simple assignments. While some languages abuse ternaries to the point of unreadability, Rust solves this beautifully: everything is an expression. In Rust, you don't need a ternary operator because if/else blocks and match statements return values directly. This keeps syntax clean and readable without the boilerplate of pre-declaring mutable variables:

1let status = if authenticated { "Welcome" } else { "Access Denied" };

Result Types and the ? Operator

C++ relies heavily on exceptions and try/catch blocks, which can make control flow hard to follow and introduce overhead. Rust takes a completely different path with its monadic Result<T, E> and Option types. Rather than throwing exceptions, errors are just normal values returned by functions. Combining this with the ? operator allows you to bubble up errors in a single character, providing error handling that is both explicit and incredibly clean, without the cognitive load of exception tracking:

1fn fetch_data() -> Result<String, Error> {
2    let response = make_request()?; //Returns an error incase of failure
3    Ok(response)
4}

Truly Statically Typed

TypeScript is a great developer experience, but it is ultimately a wrapper around JavaScript. Its types are erased at compile time, meaning they provide no runtime safety. Moreover, the ease of escaping to any or dealing with loose typing can lead to hidden runtime bugs. Rust is a truly statically typed language. Its types exist at compile time, are strictly enforced at runtime, and compiled directly to machine code (using monomorphization). When a compiler guarantees that a value is of a certain type, you can be 100% confident it holds true at runtime.

Ultimately, Rust feels like a language where the designers looked at the ergonomics of high-level languages and the control of low-level systems languages, and fused them into a coherent, safe, and expressive toolset.

Moving blog to HyperTemplate

2025-05-23T15:00:00-07:00

This incarnation of my blog uses HyperTemplates.

It really seems straight enough to understand for someone like me coming from HTLM3 and a much more simplistic time in web architecture. Yet it utilizes most of the new modern things. Learning most of it realistically takes only an evening.

Blog

Why I prefer Rust

Moving blog to HyperTemplate