Go and Rust are compiled languages, both are open source, and both are designed for modern, microservices-oriented, parallel computing environments.<a href="https://www.rust-lang.org/" rel="noopener noreferrer" target="_blank">Rust</a> and <a href="https://golang.org/" rel="noopener noreferrer" target="_blank">Go</a> are two of the industry’s biggest successes when it comes to modern programming language development. Both languages compete in terms of backend <a href="https://qvault.io/2020/11/04/top-web-development-programming-languages-a-comparison/" rel="noopener noreferrer" target="_blank">web development</a> and it’s a fierce competition. Go and Rust are new, have growing communities, and are fast and efficient. When it comes to microservice architectures, frameworks, and apps, Rust and Go are household backend names.<h2> </h2><h2>The Go programming language</h2>Introduced to the public in 2009, Go (which is also known as Golang) was designed by Google engineers (including Ken Thompson, of Unix fame). There were various motivations behind the creation of Go, but the developers’ goals can perhaps be summed up by saying simply that they wanted a language that offered the efficiency of C++ but that was easier to write, read and deploy in an optimized way on multi-core CPUs. Toward that end, one of Go’s distinguishing features is the goroutine, which makes it easy to define functions that run as distinct subprocesses. By taking advantage of goroutines, developers can easily build applications in Go that take full advantage of concurrency by deploying workloads across multiple CPU cores at the same time. Concurrency and optimization are powerful features. They’re part of the reason why we chose to develop Twistlock using Go. <h2>The Rust programming language</h2>The history of Rust parallels that of Go in many ways. Rust was born as a personal project of a Mozilla engineer that started in the mid-2000s. The language became publicly available in 2010. Like Go, Rust was motivated in part by a desire to improve upon the conventions of C++, including by making it easier to implement concurrency. Doing so in a way that does not compromise security was also a primary consideration. Toward that end, Rust makes it very difficult for developers to introduce flaws into code that could lead to buffer overflows or other memory-related vulnerabilities. <h2>Similarities</h2> <h3>Rich Standard Libraries</h3>Rust and Go share many traits, especially when it comes to web development. They both have rich standard libraries, though Go tends to have more internet-focused protocols such as <a href="https://golang.org/pkg/net/http/" rel="noopener noreferrer" target="_blank">HTTP</a> supported of out the box. <h3>Open-Source</h3>Both languages are open-source, meaning no company will be yanking the source code out from under us anytime soon, though it is worth noting that Google drives the development of Go, while Rust is more of a community project. There are pros and cons of company support. Go benefits from the resources and PR of a major tech company, while Rust will never have the risk of Google-specific agendas being pushed on the project. <h3>Relatively New Languages</h3>Go and Rust are both new languages, which means they don’t come with the legacy and backward-compatibility baggage that you find with languages like Java and Javascript.Rust v1 released: May 15, 2015Go v1 released: March 28, 2012 <h2>Performance</h2>Performance metrics generally put Rust squarely ahead of Go, but not by a lot. The Rust compiler and language design allow developers to easily take advantage of optimizations that achieve speeds comparable to the likes of C. On the other hand, Go trades a small amount of speed for simplicity and elegant syntax.<img src="https://qvault.io/wp-content/uploads/2020/09/rust-vs-go-speed.png"><a href="https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/rust-go.html" rel="noopener noreferrer" target="_blank">benchmarksgame</a> <h2>Memory Management</h2>Both languages claim the title of “memory-safe” but take different approaches to achieve it. Rust catches memory errors at compile-time while Go uses a garbage collector at runtime.Rust makes use of compile-time ownership strategy through <a href="https://boats.gitlab.io/blog/post/zero-cost-abstractions/" rel="noopener noreferrer" target="_blank">zero-cost abstractions</a>. If a Rust program is not memory safe, it will fail to compile. To anyone who frequently deals with memory errors in C languages, this is recognized as an amazing feature. Instead of clever compiler optimizations, the Go compiler adds a small runtime to the completed executable that manages the allocation and release of memory.&nbsp; While both approaches have their pros and cons, generally speaking Rust’s compiler optimizations result in more performant programs. Alternatively, Go’s application code is cleaner because memory management is fully handled by the runtime.<img src="https://qvault.io/wp-content/uploads/2020/09/rust-vs-go-memory.png"><a href="https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/rust-go.html" rel="noopener noreferrer" target="_blank">benchmarksgame</a> <h2>Development Speed</h2>There are times during the development of a web application that development speed is more important than app speed. Python is a great example, it is one of the slowest languages but has some of the cleanest syntax. While Go is generally faster and uses less memory than languages like Java, C#, JavaScript, Python, and Ruby, it makes a performance trade-off to allow for fast and simple development.It’s also worth noting that Go and Rust are both growing in popularity. If you want to read more on that, take a look this related article, <a href="https://qvault.io/2020/05/06/rust-vs-go-which-is-more-popular/" rel="noopener noreferrer" target="_blank">“Rust vs Go – Which is More Popular?”</a>. <h2>Code Comparison</h2>Now that we’ve compared and contrasted Rust and Go conceptually, let’s take a look at what a simple HTTP server would look like in both languages. <h4>Rust HTTP Backend Server Example</h4><pre class="ql-syntax" spellcheck="false">// example taken from https://gist.github.com/mjohnsullivan/e5182707caf0a9dbdf2d

use std::net::{TcpStream, TcpListener};
use std::io::{Read, Write};
use std::thread;


fn handle_read(mut stream: &amp;TcpStream) {
 let mut buf = [0u8 ;4096];
 match stream.read(&amp;mut buf) {
 Ok(_) =&gt; {
 let req_str = String::from_utf8_lossy(&amp;buf);
 println!("{}", req_str);
 },
 Err(e) =&gt; println!("Unable to read stream: {}", e),
 }
}

fn handle_write(mut stream: TcpStream) {
 let response = b"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=UTF-8\r\n\r\n&lt;html&gt;&lt;body&gt;Hello world&lt;/body&gt;&lt;/html&gt;\r\n";
 match stream.write(response) {
 Ok(_) =&gt; println!("Response sent"),
 Err(e) =&gt; println!("Failed sending response: {}", e),
 }
}

fn handle_client(stream: TcpStream) {
 handle_read(&amp;stream);
 handle_write(stream);
}

fn main() {
 let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
 println!("Listening for connections on port {}", 8080);

 for stream in listener.incoming() {
 match stream {
 Ok(stream) =&gt; {
 thread::spawn(|| {
 handle_client(stream)
 });
 }
 Err(e) =&gt; {
 println!("Unable to connect: {}", e);
 }
 }
 }
}
</pre>As you’ll notice in the code above, we can spin up a fairly simple HTTP server without anything more than the standard library, though we have to implement some of the HTTP protocol ourselves. Notice that we include the HTTP/1.1 200 OK response directly in the data stream we are responding with. This isn’t to say there aren’t other crates that would make our lives easier, but out-of-the-box Rust forces us to do more of the heavy lifting ourselves. If you take a look at the standard HTTP create, you’ll see that it’s an intentional choice not to standardize an implementation. You will notably not find an implementation of sending requests or spinning up a server in this crate. It’s intended that this crate is the “standard library” for HTTP clients and servers without dictating any particular implementation. Note that this crate is still early on in its lifecycle so the support libraries that integrate with the http crate are a work in progress! Stay tuned and we’ll be sure to highlight crates here in the future. Golang HTTP Backend Server Example<pre class="ql-syntax" spellcheck="false">package main

import (
	"encoding/json"
	"net/http"
)

func hello(w http.ResponseWriter, req *http.Request) {
	type response struct {
		Message string `json:"message"`
	}
	resp := response{
		Message: "hello world",
	}
	respBytes, _ := json.Marshal(resp)
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	w.Write(respBytes)
}

func main() {
	http.HandleFunc("/hello", hello)
	http.ListenAndServe(":8080", nil)
}
</pre>With Go, on the other hand, it’s extremely easy to spin up a production web server, we even get support for JSON, headers, and status codes right from the standard library. <h2>Concurrency</h2>Concurrency is a necessity in backend applications. Some languages run in single-threaded environments which means they use some clever tricks to simulate concurrency without achieving true parallelism. Both Rust and Go have elegant solutions to build <a href="https://qvault.io/2020/05/11/concurrency-in-rust-can-it-stack-up-against-gos-goroutines/" rel="noopener noreferrer" target="_blank">fully parallel applications</a>, but Go takes the cake again in terms of simplicity, with the go keyword being the only syntax necessary to spin up a new thread:<pre class="ql-syntax" spellcheck="false">go someFunc()
</pre><h2> </h2><h2>The Winner</h2>As usual, there is no outright winner, the results are more nuanced than that. It's in the hand of developers who are contributing daily to these languages. The more the community will grow the more will the language grow.The companies using these language as their stack matters. <h4>Rust is Favored For:</h4><ul><li>Computation Speed</li><li>Memory usage</li><li>Fine-tuning and control over the final executable</li></ul> <h4>Go is Favored For:</h4><ul><li>Simple syntax</li><li>Beginner-friendly</li><li>Developer speed</li><li>Concurrency mechanisms</li></ul> Rust is somewhat harder to work with, and is more oriented toward building applications with a narrow scope where security is the only thing that really matters. In contrast, Go is ideal for building applications where you are concerned not only about security, but also a variety of other factors — which is probably your goal if you are a DevOps team that aims to build a flexible, extensible application or framework. Happy Coding ...

Rust vs Go as Backend in Web Development

Related blogs

About us: