Rust-X-CPE--Internship

My Journey of learning Rust in Rust Foundation x Department of Computer Engineering Internship, UNIBEN

A structured 50-day Rust learning and project challenge starting Hacktober 1st. This plan balances learning core concepts and building practical Rust projects.

Week 1: Rust Basics & Syntax

Day 1-5:

• Install Rust and set up the development environment.
• Learn basic syntax: variables, data types, functions, conditionals, loops.
• Project: Create a simple CLI calculator to practice basic operations and user input.

Day 6-7:

• Dive into ownership, borrowing, and lifetimes.
• Project: Extend your calculator to handle complex operations and introduce error handling.

Week 2: Structs, Enums, and Error Handling

Day 8-9:

• Learn about structs and enums.
• Project: Build a small inventory management system using structs and enums.

Day 10-11:

• Understand pattern matching and control flow.
• Project: Add pattern matching to the inventory system, allowing for item categorization.

Day 12-14:

• Deep dive into Rust's error handling with Result and Option.
• Project: Add error handling to the inventory, making it more robust.

Week 3: Collections and Iterators

Day 15-17:

• Learn about vectors, hash maps, and strings.
• Project: Build a contact book app, allowing for the addition, removal, and search of contacts.

Day 18-19:

• Master iterators and closures.
• Project: Add sorting and filtering options to the contact book using iterators.

Day 20-21:

• Study traits and generics in Rust.
• Project: Refactor the contact book to make it more generic and reusable.

Week 4: Async Programming and Concurrency

Day 22-25:

• Learn async programming with tokio.
• Project: Build an asynchronous web scraper that fetches and processes data from multiple websites concurrently.

Day 26-28:

• Study concurrency using threads.
• Project: Modify the web scraper to handle multiple scraping tasks concurrently.

Week 5: Working with Files, Crates, and Modules

Day 29-31:

• Learn file I/O in Rust and how to use crates.
• Project: Build a log parser that reads logs from a file and generates a report.

Day 32-34:

• Learn about Rust modules and crate structures.
• Project: Refactor the log parser to be modular and scalable.

Week 6: Web Development with Actix or Warp

Day 35-38:

• Study basic web development in Rust using actix-web or warp.
• Project: Create a simple REST API for a TODO app.

Day 39-41:

• Add database integration with SQLx or Diesel.
• Project: Extend the TODO app to store tasks in a Postgres or SQLite database.

Week 7: Advanced Topics (FFI, Unsafe, Macros)

Day 42-44:

• Learn about Foreign Function Interface (FFI) and using C libraries in Rust.
• Project: Build a small Rust application that uses a C library for some functionality.

Day 45-47:

• Dive into unsafe Rust.
• Project: Build a memory-efficient data structure using unsafe code for performance optimization.

Day 48-50:

• Study Rust macros and how to create your own.
• Project: Create a custom derive macro to automatically generate code for common tasks in one of your previous projects.

Don't forget to drop a star to the repository

Throughout the challenge, contribute to Hacktoberfest by submitting pull requests to open-source Rust projects or libraries.