Introduction

Welcome to Rust for TS/JS Developers! This section introduces the guide and helps you get oriented.

---

What’s in This Section

• Target Audience - Who this guide is for
• How to Read This Guide - Learning strategies and navigation
• Prerequisites - What you need to know before starting

---

About This Guide

This is a thorough, book-style guide designed specifically for TypeScript and JavaScript developers who want to learn Rust. Unlike general Rust tutorials, this guide:

Leverages Your Existing Knowledge

We assume you already know TypeScript/JavaScript well. Instead of explaining programming from scratch, we:

• Show familiar code first - Start with TypeScript/JavaScript you already understand
• Compare side-by-side - See the Rust equivalent next to familiar code
• Explain the differences - Focus on what’s new, not what you already know
• Flag gotchas - Point out common mistakes TS/JS developers make

Example: Variables

Instead of just teaching Rust variables, we compare:

TypeScript:

let x = 5; // mutable
const y = 10; // immutable
x = 6; // allowed
// y = 11;        // error

Rust:

let x = 5;        // immutable by default!
let mut y = 10;   // explicitly mutable
// x = 6;         // error - x is immutable
y = 11;           // allowed - y is mut

Key Difference: Rust is immutable by default (opposite of JavaScript!)

---

What You’ll Learn

Core Rust Concepts

1. The Ownership System - Rust’s secret sauce for memory safety without garbage collection
2. Borrowing & Lifetimes - How Rust prevents data races at compile time
3. Type System - Stronger than TypeScript’s, but for good reasons
4. Error Handling - No exceptions, use Result and Option instead
5. Pattern Matching - Like switch statements on steroids
6. Traits - Similar to interfaces but more capable
7. Async/Await - Different syntax, same concepts
8. Macros - Compile-time code transforms (closer to Babel plugins than to decorators)

Practical Skills

• Building REST APIs (Axum vs Express)
• Working with databases (SQLx, Diesel)
• Creating CLI tools (better performance than Node.js CLIs)
• WebAssembly (run Rust in the browser)
• Systems programming
• Performance optimization
• Production deployment

---

Why Learn Rust?

For TypeScript/JavaScript Developers

You should learn Rust if you want to:

• Build high-performance backends (no GC pauses; far lower p99 latency and memory use than Node.js)
• Create CLI tools that start instantly (no Node.js startup time)
• Eliminate entire classes of bugs at compile time
• Work on systems programming (OS, embedded, game engines)
• Add Rust to JavaScript via WebAssembly or native addons
• Learn a language that makes you a better programmer

Rust might NOT be for you if:

• You only build simple web frontends (stick with TypeScript)
• You need extremely fast development iteration (Node.js is faster to prototype)
• Your team isn’t ready for the learning curve
• You’re building CRUD apps where performance isn’t critical

Real-World Use Cases

Companies using Rust:

• Discord - Rewrote its Read States service from Go to Rust, eliminating GC latency spikes
• AWS - Building Firecracker, Lambda runtime
• Microsoft - Windows components, Azure services
• Meta - Source control system (Sapling)
• Cloudflare - Edge computing platform
• Dropbox - File sync engine
• npm - Registry authorization service

Common Rust Projects:

• Web servers (faster than Node.js)
• CLI tools (replace Node.js CLIs)
• Game engines
• Blockchain/crypto
• Embedded systems
• Operating systems
• Database engines
• Network tools

---

Guide Philosophy

1. Side-by-Side Comparisons

We always show TypeScript/JavaScript first, then Rust. This helps you:

• Connect new concepts to existing knowledge
• Understand why Rust does things differently
• Spot patterns and differences quickly

2. Real-World Examples

No toy examples or contrived code. Every example:

• Uses realistic scenarios
• Includes proper error handling
• Follows best practices
• Could be used in production

3. Honest About Trade-offs

We don’t pretend Rust is perfect. We’ll tell you:

• When Rust is harder than TypeScript
• When Node.js might be a better choice
• Where the learning curve gets steep
• How to overcome common struggles

4. Progressive Learning

Content is carefully sequenced:

• Foundation → Core Language → Practical Skills → Advanced Topics → Production
• Each section builds on previous ones
• Dependencies are clearly marked
• You can skip ahead, but we don’t recommend it

---

How This Guide Is Different

vs. The Rust Book

• The Rust Book: Thorough, assumes no prior programming knowledge
• This Guide: Assumes strong TS/JS knowledge, focuses on differences

vs. Rust by Example

• Rust by Example: Brief examples with minimal explanation
• This Guide: Detailed explanations with side-by-side comparisons

vs. YouTube Tutorials

• YouTube: Sequential watching, hard to reference
• This Guide: Written format, easy to search, return to, and reference

vs. Rustlings

• Rustlings: Small exercises to learn by doing
• This Guide: Full explanations + exercises

Best approach: Use this guide as your primary resource, supplement with The Rust Book and Rustlings for practice.

---

The Journey Ahead

The guide moves through four phases: Foundation (sections 00-05, where ownership lives — take your time here), Core Language (06-10: data structures, collections, error handling, traits — you’ll start feeling productive), Practical Skills (11-19: web APIs, CLI tools, WASM — where Rust becomes fun), and Advanced Topics (20-30: production readiness and complete projects).

Time estimates and suggested reading paths live in How to Read This Guide.

---

Overcoming the Learning Curve

Common Struggles

Week 1: “Why won’t the compiler let me do this simple thing?”

• Normal! The borrow checker is strict
• Your code is probably not wrong, just needs restructuring
• This teaches you to write better code

Week 2-3: “I’m fighting with lifetimes!”

• Also normal! Lifetimes are the hardest part
• Most code doesn’t need explicit lifetime annotations
• It gets easier with practice

Week 4+: “Oh, I get it now!”

• The “aha!” moment
• Everything starts to make sense
• You begin appreciating Rust’s design

Tips for Success

1. Don’t fight the compiler - It’s trying to help you
2. Read error messages carefully - They’re very helpful
3. Practice daily - Even 30 minutes helps
4. Join the community - Discord, Reddit, forums
5. Build projects - Theory only goes so far
6. Be patient - Everyone struggles at first
7. Celebrate small wins - You’re learning a hard language!

---

Next Steps

Ready to begin? Here’s your roadmap:

1. You’re here! - Introduction
2. Target Audience - Make sure this guide is right for you
3. How to Read - Learn navigation strategies
4. Prerequisites - Verify you’re ready
5. Section 01: Getting Started - Install Rust and write your first program!

---

Questions?

• “Should I learn Rust or Go?” - Different use cases. Rust for systems/performance, Go for simplicity/concurrency
• “Will this replace JavaScript?” - No, different domains. But you might build backends in Rust
• “How long until I’m productive?” - 3-4 weeks for basic projects, 2-3 months for production code
• “Is Rust dying?” - No! It has topped Stack Overflow’s “most loved/admired language” ranking every year since 2016
• “Should I learn Rust in 2026?” - Yes! Adoption is growing, especially in backend/systems

---

Let’s Begin!

You’re about to learn one of the most capable programming languages in existence. It will be challenging, but rewarding.

Continue to Target Audience