/Learning-RustLang

A repository for learning the RustLang for systems and blockchain engineering

Primary LanguageRust

Grinding Through The Rust Programming Language Book

The book can be found on here

======================================================================

Progress Metrics

  • day 1: getting started
    • installation
    • hello, world
    • hello, cargo
  • day 2: programming a guessing game
  • day 3: common programming concepts
    • variables and mutability
    • data types
    • functions
    • comments
    • control flow
  • day 4: understanding ownership
    • what is ownership
    • references and borrowing
    • the slice type
  • day 5: using structs to structure related data
    • defining and instantiating structs
    • an example program using structs
    • method syntax
  • day 6: enums and pattern matching
    • defining an enum
    • the match control flow construct
    • concise control flow with if let
  • day 7: managing growing projects
    • packages and crates
    • defining modules for scope and privacy
    • paths for referring to an item in the module tree
    • bringing paths into scope with use
    • separating modules into different files
  • day 8: common collections
    • Storing Lists of Values with Vectors
    • Storing UTF-8 Encoded Text with Strings
    • Storing Keys with Associated Values in Hash Maps

  1. Error Handling

    9.1. Unrecoverable Errors with panic! 9.2. Recoverable Errors with Result 9.3. To panic! or Not to panic!

  2. Generic Types, Traits, and Lifetimes

    10.1. Generic Data Types 10.2. Traits: Defining Shared Behavior 10.3. Validating References with Lifetimes

  3. Writing Automated Tests

    11.1. How to Write Tests 11.2. Controlling How Tests Are Run 11.3. Test Organization

  4. An I/O Project: Building a Command Line Program

    12.1. Accepting Command Line Arguments 12.2. Reading a File 12.3. Refactoring to Improve Modularity and Error Handling 12.4. Developing the Library’s Functionality with Test Driven Development 12.5. Working with Environment Variables 12.6. Writing Error Messages to Standard Error Instead of Standard Output

  5. Functional Language Features: Iterators and Closures

    13.1. Closures: Anonymous Functions that Capture Their Environment 13.2. Processing a Series of Items with Iterators 13.3. Improving Our I/O Project 13.4. Comparing Performance: Loops vs. Iterators

  6. More about Cargo and Crates.io

    14.1. Customizing Builds with Release Profiles 14.2. Publishing a Crate to Crates.io 14.3. Cargo Workspaces 14.4. Installing Binaries from Crates.io with cargo install 14.5. Extending Cargo with Custom Commands

  7. Smart Pointers

    15.1. Using Box to Point to Data on the Heap 15.2. Treating Smart Pointers Like Regular References with the Deref Trait 15.3. Running Code on Cleanup with the Drop Trait 15.4. Rc, the Reference Counted Smart Pointer 15.5. RefCell and the Interior Mutability Pattern 15.6. Reference Cycles Can Leak Memory

  8. Fearless Concurrency

    16.1. Using Threads to Run Code Simultaneously 16.2. Using Message Passing to Transfer Data Between Threads 16.3. Shared-State Concurrency 16.4. Extensible Concurrency with the Sync and Send Traits

  9. Object Oriented Programming Features of Rust

    17.1. Characteristics of Object-Oriented Languages 17.2. Using Trait Objects That Allow for Values of Different Types 17.3. Implementing an Object-Oriented Design Pattern

  10. Patterns and Matching

    18.1. All the Places Patterns Can Be Used 18.2. Refutability: Whether a Pattern Might Fail to Match 18.3. Pattern Syntax

  11. Advanced Features

    19.1. Unsafe Rust 19.2. Advanced Traits 19.3. Advanced Types 19.4. Advanced Functions and Closures 19.5. Macros

  12. Final Project: Building a Multithreaded Web Server

    20.1. Building a Single-Threaded Web Server 20.2. Turning Our Single-Threaded Server into a Multithreaded Server 20.3. Graceful Shutdown and Cleanup

  13. Appendix

    21.1. A - Keywords 21.2. B - Operators and Symbols 21.3. C - Derivable Traits 21.4. D - Useful Development Tools 21.5. E - Editions 21.6. F - Translations of the Book 21.7. G - How Rust is Made and “Nightly Rust”