Rust for Pythonistas: A Gentle Introduction to Systems Programming

December 18, 2024

Disclosure: This post may contain affiliate links, meaning Chikara Houses get a commission if you decide to make a purchase through our links, at no cost to you. Please read our disclosure for more info.

Content Disclaimer: The following content has been generated by a combination of human and an AI language model. Content is images, text and video (if any). Please note that while we strive to provide accurate and up-to-date information, the content generated by the AI may not always reflect the most current news, events, or developments.

Rust for Pythonistas: A Gentle Introduction to Systems Programming

Are you a Python developer curious about the world of systems programming? Rust is a powerful and increasingly popular language that offers speed, safety, and a unique approach to memory management. This beginner-friendly tutorial provides a taste of Rust, drawing parallels with Python to ease your learning curve.

From installation to modules, we'll cover the basics and get you comfortable writing your first Rust programs. Let's dive in!

Setting Up Your Rust Environment

The journey begins with installing Rust. The video demonstrates a straightforward installation process using the command install rust and cargo in your terminal. Cargo, Rust's build system and package manager, is crucial for managing dependencies and compiling your code.

Rust's Building Blocks: Data Types

Just like Python, Rust has various data types to represent different kinds of information. The video introduces key data types, comparing them to familiar Python equivalents:

Numbers: Integers (signed and unsigned), floating-point numbers.
Booleans: True and False values.
Strings: Mutable and immutable strings.
Collections: Vectors (similar to Python lists) and hash maps (like Python dictionaries).

Your First Rust Program: Hello World!

Using Cargo, we can quickly set up a new Rust project using the command cargo init. This generates a basic project structure, including a Cargo.toml file for configuration and a main.rs file where your code will reside.

The video walks through a "Hello World" program, highlighting Rust's syntax and the role of the main function as the entry point for execution.

Functions in Rust: Structure and Reusability

Rust encourages code organization through functions. The tutorial explains how to define functions, pass parameters, and specify return types. You'll learn how the fn keyword introduces function definitions, and the arrow (->) indicates the return type.

Taming Complexity with Modules

As your projects grow, modules help to manage code and maintain readability. The video shows how to create separate module files (with the .rs extension) to house functions and then import them into your main program using the mod keyword. You'll see how Rust leverages the double colon (::) for accessing functions within modules, similar to the dot notation in Python.

This introductory tutorial offers a glimpse into Rust's elegance and power. As you progress, you'll explore more advanced features like ownership and borrowing, which form the heart of Rust's memory safety guarantees.

Short Answer Quiz

Instructions: Answer the following questions in 2-3 sentences each.

What two tools are installed when you run the command curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh?
How do you declare a mutable variable in Rust?
Explain the difference between String and &str in Rust.
What is the purpose of the cargo add command?
What is the entry point for a Rust program?
What is the significance of semicolons in Rust?
What are the two ways to write comments in Rust code?
How do you define a function in Rust?
What is the purpose of the pub keyword?
How do you import a module in Rust?

Answer Key

The command curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh installs Rust, the programming language, and Cargo, the Rust package manager.
By default, variables in Rust are immutable. To declare a mutable variable, use the mut keyword before the variable name during declaration (e.g. let mut my_variable = 10;).
String is a growable, heap-allocated string type, while &str (pronounced "string slice") is an immutable reference to a string slice, which can be stored on either the stack or the heap.
The cargo add command is used to add dependencies to your Rust project. These dependencies are libraries or packages that provide additional functionality.
The entry point for a Rust program is the main function. This is where the execution of your program begins.
Semicolons in Rust are used to terminate expressions and statements. They are usually required at the end of each line, except for the last expression in a code block.
Rust supports two types of comments: single-line comments using // and multi-line comments enclosed between /* and */.
To define a function in Rust, use the fn keyword, followed by the function name, parentheses for arguments, and curly braces for the function body (e.g. fn my_function(arg1: i32, arg2: &str) { /* function body */ }).
The pub keyword is used to make an item public, meaning it can be accessed from outside its module. By default, items in Rust are private and only accessible within their own module.
To import a module in Rust, use the mod keyword followed by the module name and a semicolon (e.g. mod my_module;). You can then access items from the module using the :: operator (e.g. my_module::my_function()).

Glossary of Key Terms

Term & Definition

Cargo: The Rust package manager used for building, managing dependencies, and running Rust projects.
Compiler: A program that translates source code written in a high-level language like Rust into low-level machine code that a computer can understand and execute.
Crate: A package of Rust code, which can be a library or an executable program.
Expression: A piece of code that evaluates to a value.
Function: A reusable block of code that performs a specific task.
Immutable: A value that cannot be changed after it is created.
Module: A way to organize code into logical units, which can be imported and used in other parts of the program.
Mutable: A value that can be modified after it is created.
Ownership: A core concept in Rust that governs memory management and ensures memory safety by defining clear rules about how data is owned and borrowed.
Statement: A piece of code that performs an action, but does not necessarily return a value.
Type System: A set of rules that define the types of data that can be used in a program and how they can be manipulated.
Variable: A named storage location that holds a value.
&str: A string slice, which is an immutable reference to a string.
String: A heap-allocated, growable string type in Rust.

Watch the Youtube video, make sure your terminal is ready and follow along: Rust Tutorial For Beginners Coming From Python

Chikara Houses have some other articles about AI and IT in general, some are a collab with @Creditizens Youtube channel and have videos and example code snippets to get an idea. Continue Reading