2026 · active
Learn Rust
Rebuilding systems knowledge through ownership, algorithms, concurrency, and hands-on Rust projects.
Rust as a different lens
Learn Rust documents a path from ownership and borrowing to data structures, concurrency, async systems, and applications. Rust is useful not only as another language, but as a way to make memory, lifetime, and correctness decisions visible.
The repository is not an attempt to replace .NET work with a new identity. It creates a second environment for studying representation, resource lifetime, error modeling, and the cost of abstraction.
Learning architecture
Ownership appears early because later topics depend on it. Data structures make representation concrete; concurrency makes shared responsibility unavoidable; projects force several models to coexist.
Learn, code, write, apply, build
The repository follows a deliberate loop: learn a concept, isolate it in code, explain it, apply it to problems, and use it in a project. Comparisons with C# connect unfamiliar mechanics to existing experience without pretending the models are identical.
Paired comparisons
| Rust concept | C# comparison question |
|---|---|
| ownership and moves | where is resource responsibility expressed? |
Option<T> | how is absence represented and checked? |
Result<T, E> | which failures belong in the type? |
| traits | which behavior is static, dynamic, or constrained? |
Drop | when is deterministic cleanup guaranteed? |
The goal is not to declare a winner. It is to identify which guarantees come from the compiler, runtime, API design, convention, or tests.
Competitive programming as a laboratory
Algorithm problems provide small constraints for practicing correctness, complexity, and representation. Rust adds friction around ownership and indexing that can reveal assumptions hidden by a quick implementation.
Contest and production code remain separate standards. Accepted output does not prove maintainability, robust error handling, or safe operation. A useful second pass renames intent, records invariants, and tests boundary cases.
Boundaries and evidence
Learn Rust is an evolving study path. It does not claim production deployment or benchmark superiority. Examples should compile under the recorded toolchain, and performance claims require reproducible measurement. The public repository is the evidence for completed modules; the roadmap is not evidence that later topics are already mastered.
Current direction
The longer path leads through DSA and competitive programming toward CLI tools, backend services, and small system components where performance and control matter. Success is measured by clearer questions about ownership, concurrency, data layout, and failure in any engineering environment.