# README
## ๐ฆ **30 Days of Rust**
โจ *Learn Rust step by step in just 30 days! Each topic builds upon the last to take you from beginner to Rustacean pro!*
| ๐ **Day** | ๐ **Topics** |
| ---------- | :-------------------------------------------------------------------------------------------------------------------------------------------------: |
| **01** | [๐ฆ **Introduction to Rust**](#-day-1---introduction-to-rust) |
| **02** | [๐ข **Variables, Data Types**](/30-days-of-rust/02_variables-datatypes/02_variables_data_types.md) |
| **03** | [๐ **Control Flow**](/30-days-of-rust/03_control-flow/03_control_flow.md) |
| **04** | [๐ ๏ธ **Functions**](/30-days-of-rust/04_functions/04_functions.md) |
| **05** | [โ๏ธ **Ownership and Borrowing**](/30-days-of-rust/05_ownership-and-borrowing/05_ownership_and_borrowing.md) |
| **06** | [๐๏ธ **Structs**](/30-days-of-rust/06_structs/06_structs.md) |
| **07** | [๐ **Enums**](/30-days-of-rust/07_enums/07_enums.md) |
| **08** | [๐งณ **Collections**](/30-days-of-rust/08_collections/08_collections.md) |
| **09** | [๐ฅ **Error Handling**](/30-days-of-rust/09_error-handling/09_error_handling.md) |
| **10** | [๐งฉ **Generics**](/30-days-of-rust/10_generics/10_generics.md) |
| **11** | [๐ง **Traits**](/30-days-of-rust/11_traits/11_traits.md) |
| **12** | [๐ฆ **Modules and Crates**](/30-days-of-rust/12_modules-and-crates/12_modules_and_crates.md) |
| **13** | [๐ **Testing**](/30-days-of-rust/13_testing/13_testing.md) |
| **14** | [๐ฆ **Cargo and Package Management**](/30-days-of-rust/14_cargo-and-package-management/14_cargo_and_package_management.md) |
| **15** | [โก **Macros**](/30-days-of-rust/15_macros/15_macros.md) |
| **16** | [๐ **File Handling**](/30-days-of-rust/16_file-handling/16_file_handling.md) |
| **17** | [๐ **Concurrency**](/30-days-of-rust/17_concurrency/17_concurrency.md) |
| **18** | [โก **Asynchronous Programming**](/30-days-of-rust/18_asynchronous-programming/18_asynchronous_programming.md) |
| **19** | [๐ **Networking**](/30-days-of-rust/19_networking/19_networking.md) |
| **20** | [๐ **Unsafe Rust**](/30-days-of-rust/20_unsafe-rust/20_unsafe_rust.md) |
| **21** | [โณ **Rust Lifetimes**](/30-days-of-rust/21_rust-lifetimes/21_rust_lifetimes.md) |
| **22** | [๐ฅ๏ธ **Building CLI Applications**](/30-days-of-rust/22_building-cli-applications/22_building_cli_applications.md) |
| **23** | [๐ **Web Development with Rust**](/30-days-of-rust/23_web-development/23_web_development.md) |
| **24** | [๐ **Integrating with C/C++**](/30-days-of-rust/24_integrating_with_c_c++/24_integrating_with_c_c++.md) |
| **25** | [โ๏ธ **Rust on Embedded Systems**](/30-days-of-rust/25_rust-on-embedded-systems/25_rust_on_embedded_systems.md) |
| **26** | [๐ **Rust and WebAssembly**](/30-days-of-rust/26_rust-and-webassembly/26_rust_and_webassembly.md) |
| **27** | [๐จ **Graphics Programming with Rust**](/30-days-of-rust/27_graphics-programming-with-rust/27_graphics_programming_with_rust.md) |
| **28** | [๐ฎ **Game Development with Rust**](/30-days-of-rust/28_game-development-with-rust/28_game_development_with_rust.md) |
| **29** | [๐ค **Rust and Machine Learning**](/30-days-of-rust/29_rust-and-machine-learning/29_rust_and_machine_learning.md) |
| **30** | [๐ **Project Wrap-Up & Advanced Concepts**](/30-days-of-rust/30_project-wrap-up-and-advanced-concepts/30_project_wrap_up_and_advanced_concepts.md) |
๐ **Happy Coding in Rust!** ๐ฆ
## Github Stats:
| ๐ Stars | ๐ด Forks | ๐ Issues | ๐ Repo Size | ๐ Open PRs | ๐ Closed PRs |
| ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
|  |  |  |  |  |  |
Support the **author** to create more educational materials\
[](https://buymeacoffee.com/het81857)
## ๐ฆ 30 Days Of Rust: Day 1 - Introduction ๐
[ ](https://www.linkedin.com/in/het-patel-8b110525a/?utm_source=share\&utm_campaign=share_via\&utm_content=profile\&utm_medium=android_app)[](https://github.com/Hunterdii)
***Author:*** [***Het Patel***](https://www.linkedin.com/in/het-patel-8b110525a/?utm_source=share\&utm_campaign=share_via\&utm_content=profile\&utm_medium=android_app)
October, 2024
[Day 2 >>](/30-days-of-rust/02_variables-datatypes/02_variables_data_types.md)
* [๐ฆ 30 Days of Rust](#-30-days-of-rust)
* [๐ Day 1 - Introduction to Rust](#-day-1---introduction-to-rust)
* [๐ Welcome](#-welcome)
* [๐ Introduction](#-introduction)
* [๐ก Why Rust?](#-why-rust)
* [๐ Environment Setup](#-environment-setup)
* [๐ฅ Installing Rust](#-installing-rust)
* [๐ป Installing Visual Studio Code](#-installing-visual-studio-code)
* [๐ Setting Up Your First Rust Project](#-setting-up-your-first-rust-project)
* [๐ฏ Hands-On Challenge](#-hands-on-challenge)
* [๐ฅ Helpful Video References](#-helpful-video-references)
* [๐ Understanding Rust Basics](#-understanding-rust-basics)
* [๐ค Rust Syntax](#-rust-syntax)
* [๐ฌ Comments](#-comments)
* [๐ป Exercises - Day 1](#-exercises---day-1)
* [โ
Exercise: Level 1](#-exercise-level-1)
* [โ
Exercise: Level 2](#-exercise-level-2)
* [โ
Exercise: Level 3 (OPTIONAL)](#-exercise-level-3-optional)
* [๐ Day 1 Summary](#-day-1-summary)
## ๐ Day 1 - Introduction to Rust
### ๐ Welcome
Welcome to **Day 1** of your exciting journey through Rust programming! ๐ Today, weโll dive into setting up Rust, exploring its unique features, and writing your very first Rust program. Get ready to embark on a fun and engaging adventure! ๐ฏ
**Congratulations!** ๐ You've taken the first step in your journey to master the *30 Days of Rust* programming challenge. In this challenge, you will learn the fundamentals of Rust and how to harness its power to write efficient, fast, and safe code. By the end of this journey, you'll have gained a solid understanding of Rust's core concepts and best practices, helping you become a confident Rustacean. ๐ฆ
Feel free to join the [30 Days of Rust](https://discord.gg/dy4gAhng) community on Discord, where you can interact with others, ask questions, and share your progress!
### ๐ Introduction
Rust is a systems programming language focused on safety, speed, and concurrency. Itโs known for its memory safety features and its ability to build fast and efficient software. Whether you're building web applications, embedded software, or system-level programs, Rust is your go-to language. ๐ฆพ
Rust is a modern, systems programming language that aims to combine safety, speed, and concurrency. Developed by Mozilla, itโs designed to be a safe alternative to languages like C and C++, without compromising on performance. Rust has quickly gained popularity due to its unique ownership model, which helps prevent common bugs like null pointer dereferencing and data races at compile time.
Throughout this challenge, youโll learn the latest version of Rust, step-by-step, with easy-to-understand explanations, real-world examples, and hands-on exercises. Whether youโre a beginner or a professional looking to enhance your skills, this challenge will guide you in understanding the core aspects of Rust in a fun, engaging, and motivating way.
### ๐ก Why Rust?
Rust is a powerful, yet beginner-friendly language that can be used for various applications such as:
* **Concurrency**: Makes it easier to write concurrent programs.
* **Community**: A growing and welcoming community ready to help you learn.
* **Data science and machine learning**: Rust's speed and safety are attracting developers who are building data-intensive applications.
* **Game development**: Thanks to its high performance, Rust is also suitable for game development.
* **System programming**: Rustโs low-level control over system resources makes it ideal for building operating systems, embedded software, and more.
* **Safety**: Prevents common bugs like null pointer dereferencing and data races.
* **Speed**: Compiles to native code, ensuring faster execution.
* **Web development**: Rust can be used to build both back-end and front-end (with frameworks like Yew).
๐ *If youโre looking for a language that blends performance with reliability, Rust is the way to go!*
These are just a few of the many use cases that make Rust a versatile and in-demand language. ๐ Ready to start coding in Rust?
### ๐ Environment Setup
#### ๐ฅ Installing Rust
To run Rust code, you need to have Rust installed on your system. Letโs get started by [downloading Rust](https://www.rust-lang.org/tools/install). Follow the installation guide to set up Rust:
For Windows users, run this command in the terminal:
```rs
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
For macOS and Linux users, use the same command in your terminal.
Once you have Rust installed, you can verify it by checking the version:
```rs
rustc --version
```
If the command outputs a version number, youโre good to go! ๐
#### ๐ป Installing Visual Studio Code
While Rust can be coded in any text editor, we'll use [Visual Studio Code](https://code.visualstudio.com/) for this challenge. Itโs a powerful, customizable, and widely used code editor. If you havenโt already, [download Visual Studio Code](https://code.visualstudio.com/Download) and set it up.
Make sure to install the **Rust extension** on Visual Studio Code for syntax highlighting, code formatting, and error checking:
1. Open Visual Studio Code.
2. Go to **Extensions** (or press `Ctrl+Shift+X`).
3. Search for `rust-analyzer` and install it.
Now, you're ready to start coding! โจ
#### ๐ Setting Up Your First Rust Project
Letโs create our first Rust project using Cargo, Rust's package manager. Open your terminal and run:
```rs
cargo new hello-rust
```
This command will create a new directory named `hello-rust` with the necessary files. Change to the project directory:
```rs
cd hello-rust
```
Inside, you'll find `Cargo.toml` (a manifest file for Rust projects) and a `src` directory containing `main.rs`. Let's explore whatโs inside.
```rs
fn main() {
println!("Hello, Rust!");
}
```
To run your first Rust program, type:
```rs
cargo run
```
You should see the output:
```rs
Hello, Rust!
```
Congratulations! ๐ Youโve successfully set up your Rust development environment and run your first Rust program.
๐ก๏ธ *Boom! Youโve successfully written and executed your first Rust program!*
### ๐ฏ Hands-On Challenge
Create a Rust program that prints your name and the reason you're excited to learn Rust. Hereโs a template to get you started:
```rs
fn main() {
let name = "Your Name";
let reason = "I'm excited to learn Rust because it's fast and reliable!";
println!("Hello, my name is {} and {}.", name, reason);
}
```
โ
**Share your solution on GitHub and tag `#30DaysOfRust` on social media!** Let the world know youโve begun your Rust journey! ๐
### ๐ฅ Helpful Video References
Get a better understanding of Rust and how it works by checking out these great resources:
1. [**Rust for Beginners - Complete Guide**](https://www.youtube.com/watch?v=8O0Nt9qY_vo)\
\&#xNAN;*A comprehensive guide that walks you through the basics of Rust.*
2. [**Why Rust? - A Love Letter to Rust**](https://www.youtube.com/watch?v=pW4yuT2Gk54)\
\&#xNAN;*Learn why Rust has become so popular in recent years.*
3. [**Build Your First Rust Project**](https://www.youtube.com/watch?v=pGh-0cMvH5g)\
\&#xNAN;*Create a complete project from scratch with this hands-on video.*
### ๐ Understanding Rust Basics
#### ๐ค Rust Syntax
Rust syntax is clear and concise, making it easy to write and understand. Letโs explore some of the essential elements youโll need to get started.
#### ๐ฌ Comments
In Rust, comments are crucial for explaining your code and making it more understandable. They can be categorized into non-doc comments and doc comments.
* Non-doc Comments
* Single-Line Comments
* MultiLine Comments
* Doc Comments
* Outer doc comments
* Inner doc comments
#### Non-Doc Comments
Non-doc comments are used to annotate your code without being part of the documentation generated by tools like `rustdoc`. They are primarily for developers working directly with the code.
**Single-Line Comments**
Single-line comments start with `//` and continue to the end of the line. They are useful for short explanations.
**Example:**
```rs
fn main() {
let x = 5; // This is a single-line comment
println!("Value of x: {}", x);
}
```
*Output:*
```
Value of x: 5
```
**Multi-Line Comments**
Multi-line comments start with `/*` and end with `*/`. They can span multiple lines, making them suitable for longer explanations.
**Example:**
```rs
fn main() {
/* This is a multi-line comment.
It can span multiple lines.
The next line will print the value of x. */
let x = 10;
println!("Value of x: {}", x);
}
```
*Output:*
```
Value of x: 10
```
#### Doc Comments
Doc comments are used to document public APIs and generate documentation using tools like `rustdoc`. They start with `///` for outer doc comments and `//!` for inner doc comments.
**Outer Doc Comments**
Outer doc comments are placed before functions, structs, or modules and are used to describe them in the generated documentation.
**Example:**
```rs
/// This function adds two numbers and returns the result.
fn add(a: i32, b: i32) -> i32 {
a + b
}
```
In this example, `///` provides a description of what the `add` function does. This comment will appear in the documentation generated by `rustdoc`.
**Inner Doc Comments**
Inner doc comments are placed within the context of a module, function, or struct, usually to provide more details about the implementation.
**Example:**
````rs
/// A structure representing a point in 2D space.
struct Point {
x: f64,
y: f64,
}
impl Point {
/// Creates a new Point at the given coordinates.
///
/// # Examples
///
/// ```
/// let p = Point::new(1.0, 2.0);
/// ```
fn new(x: f64, y: f64) -> Self {
Point { x, y }
}
}
````
In this example, `///` describes the `Point` struct and the `new` method. The `///` before the `new` method serves as a doc comment that explains what the method does and provides an example.
### ๐ป Exercises - Day 1
#### โ
Exercise: Level 1
1. Create a new Rust project using Cargo.
2. Write a program that prints `Hello, World!` to the console.
3. Verify that Rust is installed correctly by checking its version.
#### โ
Exercise: Level 2
1. Modify the `main.rs` file to declare an immutable variable `x` with the value of `5`.
2. Change `x` to be mutable and update its value to `10`.
#### โ
Exercise: Level 3 (OPTIONAL)
1. Write a Rust program that declares different data types (integer, float, boolean, string) and prints them.
2. Experiment with different control flow structures (`if`, `else`, `for`, `while`).
### ๐ Day 1 Summary
* We covered the **installation of Rust**.
* You wrote your **first Rust program**.
* You explored **helpful video resources** to dive deeper into Rust.
* You completed your first **hands-on challenge**.
๐ *Well done on making it through Day 1! Pat yourself on the back and get ready for the next step!*
๐ Great job! You have completed Day 1 of the *30 Days of Rust* challenge! Keep practicing, and get ready for Day 2 where you'll dive deeper into Rust basics.
Thank you for joining **Day 1** of the 30 Days of Rust challenge! If you found this helpful, donโt forget to  star this repository, share it with your friends, and stay tuned for more exciting lessons ahead!
**Stay Connected**\
๐ง **Email**: [Hunterdii](mailto:hunterdii9879@gmail.com)\
๐ฆ **Twitter**: [@HetPate94938685](https://twitter.com/HetPate94938685)\
๐ **Website**: [Working On It(Temporary)](https://hunterdii.github.io/Portfolio-Temporary/)
[Day 2 >>](/30-days-of-rust/02_variables-datatypes/02_variables_data_types.md)
***
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://hunterdii.gitbook.io/30-days-of-rust/readme.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
