RustLang
- Atul
- Programming
- February 2, 2025
Table of Contents
Learning Rust: A Top-Down Journey
1. Foundation and Motivation
- Primary Focus: Web3.0 and Decentralization
- Learning Approach: Top-down methodology
- End Goal: Understanding Rust for blockchain and decentralized applications
2. The Genesis of Rust
- Historical Background
- Core Philosophy
- Key Contributors and Organizations
- Problems Rust Aims to Solve
- Resource: Introductory video covering Rust’s history
3. Technical Architecture
- Compilation Process
- Computer Interaction Model
- Comparative Analysis:
- Rust vs C/C++
- Distinguishing Features
- Performance Characteristics
4. Application Domains
- Blockchain Development
- Web Development
- Decentralized Systems
- Other Potential Use Cases
5. Implementation and Practice
- Practical Applications
- Real-world Usage Scenarios
- Development Workflow
- Best Practices
6. Resource Compilation
- Learning Materials
- Documentation
- Tools and References
- Community Resources
1. Foundation and Motivation
1.1 Primary Focus: Web3.0 and Decentralization
As I’ve heard Rust in Web3.0 lectures and summits.
1.2 Learning Approach: Top-down methodolog
1.3 End Goal: Understanding Rust for blockchain and decentralized applications
2. The Genesis of Rust
Official site: https://www.rust-lang.org/
A language empowering everyone to build reliable and efficient software.
2.1 Historical Background
Here is the video which tells are good history of Rust.
2.2 Core Philosophy
It wasn’t always so clear, but the Rust programming language is fundamentally about empowerment: no matter what kind of code you are writing now, Rust empowers you to reach farther, to program with confidence in a wider variety of domains than you did before. (Forward: The Book)
Rust breaks down these barriers by eliminating the old pitfalls and providing a friendly, polished set of tools to help you along the way. Programmers who need to “dip down” into lower-level control can do so with Rust, without taking on the customary risk of crashes or security holes, and without having to learn the fine points of a fickle toolchain. Better yet, the language is designed to guide you naturally towards reliable code that is efficient in terms of speed and memory usage.
But Rust isn’t limited to low-level systems programming. It’s expressive and ergonomic enough to make CLI apps, web servers, and many other kinds of code quite pleasant to write — you’ll find simple examples of both later in the book. Working with Rust allows you to build skills that transfer from one domain to another; you can learn Rust by writing a web app, then apply those same skills to target your Raspberry Pi.
Safety First: This is the cornerstone of Rust. It aims to eliminate entire classes of errors common in other languages, like memory leaks, dangling pointers, and data races. This is achieved through its ownership system and the borrow checker, which enforce memory safety at compile time.
This site seems to provide more information.
Overall, Rust’s philosophy emphasizes safety, performance, and developer experience within the context of systems programming. It combines innovative features with a welcoming community, making it a compelling choice for building reliable and high-performance systems.
Rust was created by Mozilla Research with the aim of building a systems programming language that would address many of the security and performance challenges faced by traditional programming languages. Rust was designed to provide memory safety without needing a garbage collector, which is a common feature in languages like Java and C#. This was achieved through Rust’s ownership model and its strict compile-time checks, which help prevent many common programming errors, such as null pointer dereferences and data races.
By providing a high level of control over system resources and ensuring safety, Rust aims to be a reliable and efficient language for developing high-performance software, particularly for systems programming and web assembly. Rust has gained significant popularity due to its focus on safety and concurrency, making it an attractive choice for developers working on critical systems and applications. By Rigga AI
2.3 Key Contributors and Organizations
Mozilla
Getting started with Rust:
Installation:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustc --version
rustc 1.86.0-nightly (a730edcd6 2025-01-30)
Yes! Nightly, Polkadot made do it.
Rustup
Rust is installed and managed by the rustup tool.
rustup installs The Rust Programming Language from the official release channels, enabling you to easily switch between stable, beta, and nightly compilers and keep them updated. It makes cross-compiling simpler with binary builds of the standard library for common platforms. And it runs on all platforms Rust supports.
Hello world
mkdir projects
cd projects
mkdir hello_world
cd hello_world
fn main() {
println!("Hello World!!");
}
rustc main.rs
./main
OUTPUt!!
println! calls a Rust macro. If it had called a function instead, it would be entered as println (without the !). We’ll discuss Rust macros in more detail in Chapter 19. For now, you just need to know that using a ! means that you’re calling a macro instead of a normal function and that macros don’t always follow the same rules as functions.
Cargo
the included dependency manager and build tool, makes adding, compiling, and managing dependencies painless and consistent across the Rust ecosystem.
If you are coming from Js, this is like NPM.
cargo version
cargo 1.86.0-nightly (cecde95c1 2025-01-24)
Creating new project with Cargo:
cargo new hello_cargo
This file is in the TOML (Tom’s Obvious, Minimal Language) format, which is Cargo’s configuration format.
The first line, [package], is a section heading that indicates that the following statements are configuring a package. As we add more information to this file, we’ll add other sections.
The next three lines set the configuration information Cargo needs to compile your program: the name, the version, and the edition of Rust to use. We’ll talk about the edition key in Appendix E.
The last line, [dependencies], is the start of a section for you to list any of your project’s dependencies. In Rust, packages of code are referred to as crates.
Building project:
cargo build
This command creates an executable file in target/debug/hello_cargo (or target\debug\hello_cargo.exe on Windows) rather than in your current directory. Because the default build is a debug build, Cargo puts the binary in a directory named debug.
Running the project:
cargo run
Cargo also provides a command called cargo check. This command quickly checks your code to make sure it compiles but doesn’t produce an executable:
Let’s recap what we’ve learned so far about Cargo:
- We can create a project using cargo new.
- We can build a project using cargo build.
- We can build and run a project in one step using cargo run.
- We can build a project without producing a binary to check for errors using cargo check. Instead of saving the result of the build in the same directory as our code, Cargo stores it in the target/debug directory.
When your project is finally ready for release, you can use cargo build –release to compile it with optimizations.
