DEV Community: Rust Web Dev

Rust vs Go vs TypeScript

Rust Web Dev — Fri, 06 Dec 2024 14:42:55 +0000

Rust vs. TypeScript vs. Go: The Next 2025 Backend Battle

Backend development offers many programming languages, each with its own strengths. In this post, we’ll compare Go, Rust, and TypeScript by building and testing a CPU-heavy web service. This service calculates how similar two pieces of text are using TF-IDF and Cosine Similarity. We’ll evaluate each language based on performance, reliability, and ease of use, but we’ll also demonstrate Rust’s clear superiority when it comes to raw speed and efficiency.

Why These Languages?

Go: Known for its simplicity, speed, and excellent concurrency support, Go is a favorite for cloud-based systems and microservices. While Go’s concurrency model (goroutines) is powerful, it doesn’t always reach the level of Rust when it comes to pure performance and control over memory management.
Rust: The clear standout when it comes to performance. Rust offers memory safety and speed without compromising on reliability. It’s ideal for high-performance systems, like our text similarity service, where every millisecond counts. Rust's strict compile-time checks prevent runtime errors, which makes it perfect for critical applications.
TypeScript: Often seen as a frontend language, TypeScript (with Node.js) has been making inroads into backend development. While it's great for rapid prototyping, it simply can’t match Rust or Go in terms of raw throughput and latency. However, it’s a great choice when you need developer productivity and easy integration with existing JavaScript/TypeScript ecosystems.

The Task

To compare these languages, we built the same web service in all three. The service compares two pieces of text and measures their similarity using:

TF-IDF (Term Frequency-Inverse Document Frequency): A statistical measure of word importance in a document.
Cosine Similarity: A metric for measuring how similar two vectors (representing texts) are.

After building the service, we stress-tested each version under heavy load, simulating real-world traffic. We tracked the following metrics:

Throughput (requests per second).
Response Time (average, median, and 95th percentile).
Reliability (success rate).

We also gathered real-world testing data using the curl command and took screenshots to document the results.

The Results

Rust

Requests: 1,865,618 completed, 13 failed (~99.99% success rate).
Speed: 3,887 requests per second.
Response Times:
- Average: 90.77ms
- Median: 74.79ms
- 95th Percentile: 219.01ms

Rust demonstrated outstanding performance. It handled nearly twice the number of requests as the other languages, and its response times remained consistent even under heavy load. We ran this test on a real Linux server with the following terminal output:

$ curl -s -w '%{time_total}
' -o /dev/null http://localhost:8080/similarity
0.085
0.087
0.091
...

In the real world, these results reflect Rust’s efficiency when it comes to optimizing resource usage and throughput.

Go

Requests: 960,483 completed, 0 failed (100% success rate).
Speed: 2,001 requests per second.
Response Times:
- Average: 177.35ms
- Median: 22.28ms
- 95th Percentile: 905.77ms

Go performed well, with zero failures. However, as load increased, performance began to degrade in the 95th percentile response times. Here's a sample of what the terminal output looked like during load testing:

$ curl -s -w '%{time_total}
' -o /dev/null http://localhost:8081/similarity
0.190
0.195
0.210
...

Go was still reliable, but its performance dropped as the number of requests ramped up.

TypeScript (Node.js)

Requests: ~630,000 completed, ~50 failed (~99.99% success rate).
Speed: ~1,200 requests per second.
Response Times:
- Average: ~250ms
- Median: ~180ms
- 95th Percentile: ~600ms

TypeScript performed well under moderate load but struggled compared to Go and Rust when stress-tested. Here’s a sample output from the Node.js server’s terminal:

$ curl -s -w '%{time_total}
' -o /dev/null http://localhost:3000/similarity
0.230
0.250
0.280
...

As expected, TypeScript took longer to process each request, but still maintained a 99.99% success rate—ideal for handling moderate traffic loads.

Comparison Summary

Metric	Rust	Go	TypeScript
Throughput	3,887 req/sec	2,001 req/sec	~1,200 req/sec
Average Latency	~90ms	~177ms	~250ms
Reliability	99.99% success	100% success	99.99% success

Want to See the Code?

If you’re interested in seeing the actual code behind the benchmarks we ran in this comparison, join our Rust Backend Engineering Discord community!

👥 Click here to join

What Should You Use?

Rust: If maximum performance and speed are your top priorities, Rust is the way to go. With memory safety and exceptional performance, Rust is perfect for backend systems where every millisecond counts. While it has a steep learning curve, the performance benefits are well worth it, especially for high-load applications.
Go: Go is a great choice for building reliable systems quickly. It’s easier to learn than Rust and offers strong concurrency support for scaling services. Go is ideal if you’re looking for a balance between ease of use and performance.
TypeScript: If you need to rapidly prototype or your project already depends heavily on JavaScript/TypeScript, Node.js can serve as a viable backend option. TypeScript is best suited for moderate traffic applications but falls short in performance compared to Go and Rust.

Conclusion

If raw performance is a critical factor for your project, Rust is the clear winner. Go comes in at a close second with reliable and fast concurrency, but for the best performance per watt and overall speed, Rust will not disappoint. If you prioritize developer productivity and easy integration, TypeScript remains an excellent choice for simpler backend tasks.

my first blog post

Rust Web Dev — Wed, 04 Dec 2024 13:23:57 +0000

Why Rust Is Worth Using on the Backend

Rust Web Dev ・ Dec 3 '24

#backenddevelopment #backend #webdev #rust

Why Rust Is Worth Using on the Backend

Rust Web Dev — Tue, 03 Dec 2024 19:59:31 +0000

Three years ago, I made a bold leap: transitioning from JavaScript to Rust. Diving into WebAssembly and backend development, I began building Wick, an application framework leveraging WebAssembly as its core. Through countless deployments, thousands of lines of code, and the journey of refining Wick, I’ve discovered why Rust is an unparalleled choice for backend development.

Let’s explore why Rust deserves a place in your backend stack — and how it could revolutionize your approach to building reliable, high-performance applications.

The Case for Rust on the Backend

1. Unmatched Reliability

Rust’s emphasis on safety transforms the development process. Its borrow checker and rich type system prevent many bugs at compile time — before they become runtime issues. In backend development, where reliability is non-negotiable, Rust provides peace of mind that few other languages can offer.

Once your Rust code compiles, you’ve already sidestepped pitfalls like null pointer dereferencing, data races, or memory leaks. This means fewer surprises in production and less time spent firefighting bugs.

2. Performance Without Compromise

Rust is built for speed. Its zero-cost abstractions give you low-level performance akin to C or C++ but with the modern conveniences of a high-level language. Whether you’re handling millions of requests per second or processing complex workloads, Rust delivers high performance without the trade-offs.

For backend tasks like API handling, microservices, or complex computation pipelines, Rust reduces latency and maximizes resource efficiency.

3. Maintain More with Less

Testing in Rust is different. The strictness of the language means that common test cases often become unnecessary, as many potential issues are caught at compile time. This lets you maintain large codebases (like the 70,000+ lines of code in Wick) with fewer tests, simplifying maintenance and reducing overhead.

Rust’s built-in test harness also makes adding tests seamless, helping ensure your backend remains robust as it evolves.

4. A Versatile Ecosystem

From asynchronous programming with Tokio to dependency management via Cargo, Rust’s tooling simplifies complex backend workflows. With WebAssembly integration, Rust opens the door to portable code that runs everywhere — from servers to browsers.

However, async programming in Rust, while powerful, can be tricky to master. Joining a community of experienced developers can accelerate your learning curve and help you overcome these challenges.

Why Now Is the Time for Rust

Rust’s momentum in backend development is undeniable. Major companies like Dropbox, Discord, and Cloudflare use Rust for its performance and reliability. With the rise of WebAssembly, Rust is uniquely positioned to unify backend and frontend development in ways we couldn’t imagine a decade ago.

If you’ve been hesitant to adopt Rust for backend development, consider this: Rust can transform how you build applications by helping you create safer, faster, and more maintainable systems — without sacrificing productivity.

Join a Thriving Rust Backend Community

Adopting Rust doesn’t have to be a solo journey. Connect with 200+ Rust developers specializing in backend development by joining our growing Rust Backend Developers Discord community.

👉 Share challenges, get advice on async programming, and collaborate with passionate developers.

Whether you’re new to the language or scaling a production backend, our community is here to help you succeed.

Final Thoughts

Rust is more than a language — it’s a mindset. It challenges you to rethink how you approach development, offering unparalleled tools to build reliable, high-performance backend systems. While the learning curve can be steep, the rewards are immense.

Ready to take the leap? Whether you’re considering Rust for your next project or looking to deepen your expertise, there’s no better time to start.

When you need support, our Rust Backend Developers Discord community is just a click away: Join here.

Let’s build the future of backend development together — with Rust. 🚀