Welcome to my rigorous journey through Rust, Data Structures, Algorithms, Systems Programming, and Advanced Engineering concepts. This challenge is designed cover a vast spectrum of topics from basic programming to cutting-edge system architectures.
- Basic Rust Syntax: Familiarity with Rust's syntax, ownership model, and basic programming constructs.
- Cargo: Comfortable with creating and managing Rust projects.
- Data Structures: Understanding of arrays, vectors, strings, and basic algorithms.
- Programming Fundamentals: Strong grasp of programming concepts.
- Command Line & Git: Basic proficiency in using command line tools and version control.
- Distributed Systems: Preliminary knowledge of distributed system principles.
This challenge merges two educational paths:
- Rust and Data Structures & Algorithms (DSA) - Mastery of Rust-specific features, memory safety, and algorithm implementation.
- Advanced Engineering - Dive into modern backend, distributed systems, blockchain, and performance optimization.
- Daily Challenges: Each day includes 7-10 tasks of increasing complexity.
- Focus Areas
- Rust-specific optimizations
- Systems programming
- Concurrency and parallelism
- Backend architecture
- Distributed systems and blockchain
Day 1 to Day 30: Each day's tasks are listed in a dedicated file, DAY_X/README.md, where X represents the day number. These files detail:
- Basic Data Structures
- Advanced Data Structures
- Graph Algorithms
- String and Bit Manipulation
- Network and System Programming
- Database Systems
- Blockchain and Consensus Mechanisms
- Concurrency and Parallelism
- Security and Performance Optimization
To help participants gauge their progress and set achievable goals during the 30-day Rust challenge, we’ve categorized the challenge into four difficulty levels. Each level corresponds to a specific number of tasks to complete within the challenge duration:
-
Easy
- Goal: Complete 3 tasks.
- Description: Perfect for beginners or those with limited time.
-
Intermediate
- Goal: Complete 6 tasks.
- Description: Suitable for participants with some Rust experience.
-
Hard
- Goal: Complete 10 tasks.
- Description: Designed for those ready to take their Rust knowledge to the next level.
-
Extreme
- Goal: Complete 15 tasks.
- Description: For the ambitious and highly motivated.
Choose your level based on your current expertise and the amount of time you can dedicate to learning Rust.
Clone this repository to your local machine or fork it to your own GitHub account for modifications:
git clone https://github.com/donjne/rusty_repo.gitInstall Rust: If you haven't installed Rust yet, use the following command:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shUpdate the Rust Toolchain: Ensure you have the latest version:
rustup updateRead the Instructions: Open the DAY_X.md file to review the tasks for the day.
Implement the Tasks: Create a new Rust project or add tasks to an existing project using Cargo:
cargo new task_namecd task_nameFollow best practices while writing Rust code.
Test Your Code: Write unit tests for your implementations. Run tests using:
cargo testDocument Your Code: Add comments to explain complex parts or optimizations. Use /// for documentation comments and generate docs using:
cargo doc --openPush to Your Fork: Save your work to your GitHub repository:
git add .
git commit -m "Day X: Implemented tasks"
git push origin masterUse Branches for Each Day: Keep your repository organized by using branches:
git checkout -b day_X
git add .
git commit -m "Day X: Implemented tasks"
git push origin day_XCompare your implementation with reference solutions (if provided). Engage in discussions with the Rust community or your learning group to get feedback. Reflect on what you’ve learned and identify areas for improvement.
Issues: Report bugs, suggest improvements, or discuss ideas in the Issues section.
Pull Requests: Propose changes or submit new challenges. Ensure they align with the challenge's goals.
Follow Rust's standards. Use rustfmt for consistent formatting:
cargo fmtThis project is licensed under the MIT License. See the LICENSE file for details.
Rust Community: For providing an exceptional ecosystem and learning resources. Contributors: For shaping this challenge and adding value to the learning journey.
On the last day, integrate your learning into a comprehensive project. The final project should demonstrate:
Documentation: Detailed architecture and design decisions. Performance: Benchmarks and optimization reports. Security: A security audit checklist. Scalability: Evidence of scalability testing. Recovery: Strategies for failure recovery. Monitoring: Implementation of observability tools. Embark on this journey to not just learn Rust, but master the art of engineering with it! 🚀
The project is organized as follows:
30-day-rust-challenge/
│
├── day_one/
│ ├── task_01_stack/
│ │ ├── src/
│ │ │ ├── main.rs
│ │ ├── Cargo.toml
│ ├── task_02_queue/
│ │ ├── src/
│ │ │ ├── main.rs
│ │ ├── Cargo.toml
│ └── README.md
│
├── day_two/
│ ├── task_01_circular_buffer/
│ │ ├── src/
│ │ │ ├── main.rs
│ │ ├── Cargo.toml
│ └── README.md
│
└── README.mdIn this structure, day_one, day_two, etc., are folders for each day's tasks. Inside each day's folder, you will find subfolders for individual tasks (e.g., task_01_stack, task_02_queue). Each task has its own Rust project with Cargo.toml and src/main.rs. A README.md file for each day to guide you through the tasks.