1. Introduction
  2. [READ ME] Concept Prerequisites
  3. [READ ME TOO] General Rust Pathway
  4. Chapters
  5. 1. Git Prelude
  6. 2. Bitcoin Mining Intro
  7. A Kafkaesque nightmare
  8. 3. The Domain of Communication and Storage
  9. 4. Storage paradigms
  10. 5. Looking at Kafka from the perspective of storing data
  11. 6. Communication patterns and Kafka
  12. 7. Kafka, RabbitMQ, Redis
  13. 8. Braiins Kafka
  14. 9. Appendix: Kafka setup
  15. gRPC & Protocol Buffers
  16. 10. Modes of communication continued
  17. 11. Evolution of interfaces
  18. 12. Interceptors
  19. 13. Streams
  20. 14. Error Handling
  21. 15. gRPC & Tower & Layers
  22. 16. Tools by buf.build
  23. Rust
  24. 17. Choosing Rust
  25. 18. Ownership and string slices
  26. 19. Traits 1: Our own traits
  27. 20. Traits 2: Foreign traits
  28. 21. Advanced Rust traits
  29. 22. Rust's Many Pointers
  30. 23. Common Rust std Traits
  31. 24. Rust's Async Story
  32. 25. Async and Concurrent: Tokio Drift
  33. 26. Closures
  34. 27. Iterators and laziness
  35. 28. Protobuf and gRPC
  36. 29. Resulting options, optional results
  37. 30. Testing and benchmarking
  38. 31. Error handling's bizarre adventure: Battle Tendency
  39. 32. Concurrent and Parallel
  40. 33. Metrics with Prometheus and Grafana
  41. 34. Idiomatic Rust
  42. 35. Using the Braiins crates registry
  43. Rust Course
  44. 36. Introduction
  45. 37. Lesson 1: Why choose Rust?
  46. 38. Lesson 2: Rust Basics: Syntax and Variables, Compiling programs with Cargo
  47. 39. Lesson 3: Control Flow and Functions, Modules
  48. 40. Lesson 4: Structs, Enums, and Pattern Matching
  49. 41. Lesson 5: Error Handling and Result
  50. 42. Lesson 6: Collections - Vectors, Strings and HashMaps
  51. 43. Lesson 7: Concurrency and Multithreading
  52. 44. Lesson 8: Standard I/course/O, File I/O and Error Handling
  53. 45. Lesson 9: Network I/course/O
  54. 46. Lesson 10: Generics and Traits
  55. 47. Lesson 11: Rust Ecosystem, Community Resources, and Tooling
  56. 48. Lesson 12: Lifetimes and References
  57. 49. Lesson 13: Error Handling - Custom Error Types
  58. 50. Lesson 14: Async Programming with Futures and Async/course/Await
  59. 51. Lesson 15: Async Programming - Tokio
  60. 52. Lesson 16: Testing and Documentation
  61. 53. Lesson 17: Rust and Web Development
  62. 54. Lesson 18: Metrics in Rust
  63. 55. Lesson 19: Miscellaneous
  64. 56. Lesson 20: Project review & Rust at Braiins
  65. 57. Additional resources
  66. 58. Links
  67. Nix
  68. 59. Introduction
  69. 60. Flakes
  70. 61. CI/CD - BOS Tooling and single projects
  71. 62. Nix patterns
  72. 63. Resources
  73. Workshops
  74. 64. Tooling in Rust
  75. 65. Tokio console & RR debugger
  76. 66. Tracing
  77. Talks in text
  78. 67. Illegal tricks with generics
  79. Syntax reference tidbits
  80. Closures
  81. Declarative macros
  82. Dot and colon syntax
  83. Enums
  84. Functions
  85. If-let and match
  86. Lifetimes
  87. Lööps
  88. Ownership
  89. Patterns
  90. Panics and fallible code
  91. Struct literals
  92. Struct methods
  93. Ranges
  94. Traits
  95. Variable bindings and tuples

Braiins University

Lesson 9: Network I/course/O