why i want to learn rust: comparing rust and go for modern development

As a developer always looking to expand my toolkit, I’ve recently become interested in learning Rust. Rust has been gaining a lot of attention for its performance, safety, and growing ecosystem. Since I already have experience with Go (Golang), I wanted to reflect on why Rust appeals to me, how it compares to Go, and what the strengths and weaknesses of each language are.

why rust?

The Rust is a systems programming language focused on safety, speed and concurrency. It has its unique approach to memory management—without the garbage collector—has been considered fast and reliable; it prevents whole classes of bugs at compile time (especially those related to recall safety).

My motivation to learn Rust comes from:

Curiosity about its ownership and borrowing model.
The desire to write high-performance, safe code.
Its growing use in areas like web servers, CLI tools, and even embedded systems.
The vibrant and welcoming Rust community.

comparing rust and go

Both Rust and Go are modern languages designed to address the shortcomings of older systems languages such as C and C++, but they take very different approaches.

rust

Pros:

Memory Safety: Rust’s ownership model eliminates many common bugs (null pointers, data races) at compile time.
Performance: Comparable to C/C++ due to zero-cost abstractions and no garbage collector.
Concurrency: Advanced concurrency features with strong guarantees against data races.
Expressive Type System: Powerful generics, pattern matching, and enums.
Growing Ecosystem: Increasing adoption in systems programming, web (via WebAssembly), and more.

Cons:

Steep Learning Curve: The ownership and lifetime system can be challenging for newcomers.
Longer Compile Times: Safety checks and optimizations can slow down builds.
Ecosystem Still Maturing: While growing fast, some areas (e.g., GUI, certain libraries) are less mature than older languages.

go

Pros:

Simplicity: Minimalist syntax and design make it easy to learn and read.
Fast Compilation: Very quick build times, great for rapid development.
Concurrency Made Easy: Goroutines and channels make concurrent programming approachable.
Strong Standard Library: Excellent built-in support for networking, web servers, and more.
Great Tooling: Built-in formatting, testing, and dependency management.

Cons:

Limited Generics (until recently): Go’s type system is less expressive, though generics are now being introduced.
Garbage Collection: Can introduce unpredictable latency in performance-critical applications.
Less Control: Not ideal for low-level systems programming where fine-grained control is needed.
Error Handling: Verbose and sometimes repetitive.

go and rust: complementary tools in modern engineering

Note that the companies mentioned above—Discord, Figma, Cloudflare and npm (GitHub)—continue to use both Go and Rust in their technology stacks.Rather than fully replacing Go with Rusta, they use each language for the problems it solves best.

Go remains a top choice for rapid development, scalable network services, and cloud infrastructure due to its simplicity, fast compilation, and excellent concurrency model.
Rust is adopted for performance-critical, safety-sensitive, or low-level components where memory safety and fine-grained control are essential.

This pragmatic approach allows teams to benefit from the strengths of both languages, such as Go for productivity and ease of use; Rust for reliability and performance where it matters most; The coexistence of Go and Rusent in these organizations shows that choosing the right tool for the job is often more effective than standardizing on a single language.

go vs rust: code example

I can give an example of how to explain the differences between Go and Rust with a simple HTTP server in both languages.

http server in go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World from Go!")
}

func main() {
    http.HandleFunc("/", handler)
    fmt.Println("Starting server at :8080")
    http.ListenAndServe(":8080", nil)
}

http server in rust (using actix-web)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
use actix_web::{web, App, HttpResponse, HttpServer, Responder};

async fn greet() -> impl Responder {
    HttpResponse::Ok().body("Hello, World from Rust!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Starting server at :8080");
    HttpServer::new(|| {
        App::new().route("/", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Both examples use an easy web server that responds with a greeting. Go’s version is concise, and uses its standard library; Go–St’d edition has the popular Actix-web framework for reading (in addition to being read by itself) as well as strong type safety—and shows off async/await in Rust ‘Rusto’ while Rusent’r’l’e’ syntax is more verbose but it provides greater control and safety guarantees.

real-world: companies porting projects from go to rust

Many companies have opted to port parts of their codebase or specific projects from Go to Rust, often for performance, safety and/or reliability advantages. Here are some notable examples.

Discord: Discord migrated parts of their backend services from Go to Rust, especially for their real-time voice and audio infrastructure. They cited Rust’s memory safety and performance as key reasons for the switch, resulting in lower latency and fewer bugs.
Figma: Figma ported some performance-critical components from Go to Rust to improve speed and reduce memory usage, particularly for their multiplayer server infrastructure.
Cloudflare: Cloudflare has used both Go and Rust extensively. For certain networking and cryptography services, they ported Go code to Rust to take advantage of Rust’s safety guarantees and performance, especially in their edge infrastructure.
npm (GitHub): The npm team at GitHub rewrote their authentication service from Go to Rust, achieving better performance and reliability.

For example, Go is excellent for rapid development and simplicity but Rust can provide significant benefits for performance-critical or safety-sensitive applications; port often reflects the need for more control, speed (or reliability) in certain parts of a system.

when to choose rust or go?

Choose Rust if you need maximum performance, memory safety, and fine-grained control over system resources. It’s ideal for systems programming, performance-critical applications, and when safety is paramount.
Choose Go for rapid development, simplicity, and scalable networked services. It shines in cloud infrastructure, web servers, and microservices.

conclusion

Both Rust and Go are good languages, each with their own philosophy and strengths. I’m looking forward to learning Rusest for a better and more flexible developer as well as the knowledge of both in addition to my Go experience.