Preface
I started this language module as a way to keep track of my notes while learning Rust. As I progressed I found myself circling back to clarify concepts I thought I understood and add elements I didn’t pick up initially. As a result, my notes have evolved into a much larger project that sits somewhere between a narrative-based reference and a way to practice my letters.
I started writing this for me and unless I’m given reason to change course I am still my target audience. That is to say that this material is written by a novice autodidact, and written for someone at a similar place in their programming journey. The content assumes some familiarity with basic programming concepts so if you’ve never written a line of code you may find yourself playing a bit of catch up.
One of the biggest challenges in organizing this material is that many of the concepts are circularly dependent. This makes presenting a linear, progressive disclosure of discrete topics incredibly difficult. On a conceptual level this language module breaks the material into the following top-level categories:
- Introduction
- The Type System
- Data & Memory Management
- Project Design & Development
- Cookbook
Each of the categories contain a set of sub-topics that cover progressively more complex or interdependent concepts. The result is that covering the material categorically may present the reader with frustrating gaps. To provide some semblance of linear progression to an otherwise circular knowledge dependency I propose the following pedagogical sequence. Writing non-trivial applications and structures likely requires some knowledge of all of the topics covered here save perhaps the cookbook. So put a kettle on, make yourself comfortable, and enjoy.
- Introduction
- Preface
- Design Philosophies Where Rust sits in the modern programming landscape
- The Rust Toolchain Install and configure development tooling
- Resources Don't just listen to me
- Cargo From your first project to advanced publishing features
- Core Language Concepts An introduction to the language itself
- The Type System I
- Core Data Types Scalars, compound types, and an intro to reference types
- Custom Types Structs, tuple structs, and enums)
- Data & Memory I
- Project Development
- The Type System II
- Data & Memory II
- Cookbook
- Functional Idioms
- Networking
- Passwords
- Serialization
- JSON
- Concurrency
- Basic IO