Oreilly – Idiomatic Rust, Video Edition 2024-9

Description

Idiomatic Rust course, Video Edition. This course will make you a better Rust developer, whether you’re a beginner or a pro. This course introduces the essential design patterns for Rust software with detailed explanations and code examples that encourage you to practice. In Idiomatic Rust you will learn how to apply important design patterns including:

• Fluent interfaces to create pleasant APIs
• Constructor pattern for data encapsulation and initialization
• Immutable data structures that help you avoid hard-to-debug data race conditions
• Functional programming patterns
• Anti-patterns and what not to do in Rust

Idiomatic Rust lists, documents, and describes both how classic design patterns work with Rust, as well as Rust-specific patterns that help you master the language. Each pattern or best practice helps solve common programming problems and ensures that your code is easy for others to understand. You’ll learn when to use each pattern – and when to break it! Soon you will be producing higher quality Rust code and higher quality Rust software.

What you will learn

• Creating pleasant APIs
• Apply classic constructor patterns and other patterns
• Functional programming patterns
• Rust anti-patterns

This course is suitable for people who

• Rust developers who want to improve their skills
• People looking to learn Rust design patterns
• Those who want to write higher quality Rust code

Idiomatic Rust, Video Edition course specifications

• Publisher: Oreilly
• Instructor:   Brenden Matthews
• Training level: beginner to advanced
• Training duration: 5 hours and 24 minutes

Course headings

• Part 1. Building blocks
• Chapter 1. Rust-y patterns
• Chapter 1. What design patterns are
• Chapter 1. Why this book is different
• Chapter 1. Tools you’ll need
• Chapter 1. Summary
• Chapter 2. Rust’s basic building blocks
• Chapter 2. Traits
• Chapter 2. Summary
• Chapter 3. Code flow
• Chapter 3. Functional Rust
• Chapter 3. Summary
• Part 2. Core patterns
• Chapter 4. Introductory patterns
• Chapter 4. Passing arguments by value vs. reference
• Chapter 4. Constructors
• Chapter 4. Object-member visibility and access
• Chapter 4. Error handling
• Chapter 4. Global state
• Chapter 4. Summary
• Chapter 5. Design patterns: Beyond the basics
• Chapter 5. Optional function arguments
• Chapter 5. Builder pattern
• Chapter 5. Fluent interface pattern
• Chapter 5. Observer pattern
• Chapter 5. Command pattern
• Chapter 5. New type pattern
• Chapter 5. Summary
• Chapter 6. Designing a library
• Chapter 6. Do one thing, do it well, and do it correctly
• Chapter 6. Avoid excessive abstraction
• Chapter 6. Stick to basic types
• Chapter 6. Use the tools
• Chapter 6. Good artists copy; great artists steal (from the standard library)
• Chapter 6. Document everything, and provide examples
• Chapter 6. Don’t break the user’s code
• Chapter 6. Think of the state
• Chapter 6. Consider the aesthetics
• Chapter 6. Examining Rust library ergonomics
• Chapter 6. Summary
• Part 3. Advanced patterns
• Chapter 7. Using traits, generics, and structures for specialized tasks
• Chapter 7. Implementing traits for external crate types
• Chapter 7. Extension traits
• Chapter 7. Blanket traits
• Chapter 7. Marker traits
• Chapter 7. Struct tagging
• Chapter 7. Reference objects
• Chapter 7. Summary
• Chapter 8. State machines, coroutines, macros, and preludes
• Chapter 8. Coroutines
• Chapter 8. Procedural macros
• Chapter 8. Preludes
• Chapter 8. Summary
• Part 4. Problem avoidance
• Chapter 9. Immutability
• Chapter 9. Why immutability is not a magic bullet
• Chapter 9. How to think about immutable data
• Chapter 9. Understanding immutability in Rust
• Chapter 9. Reviewing the basics of immutability in Rust
• Chapter 9. Using traits to make (almost) anything immutable
• Chapter 9. Using Cow for immutability
• Chapter 9. Using crates for immutable data structures
• Chapter 9. Summary
• Chapter 10. Antipatterns
• Chapter 10. Using unsafe
• Chapter 10. Using unwrap()
• Chapter 10. Not using Vec
• Chapter 10. Too many clones
• Chapter 10. Using Deref to emulate polymorphism
• Chapter 10. Global data and singletons
• Chapter 10. Too many smart pointers
• Chapter 10. Where to go from here
• Chapter 10. Summary

Idiomatic Rust course images, Video Edition

 

Sample video of the course

download link

Download file – 743 MB

File(s) password: www.downloadly.ir

File size

743 MB