دسترسی نامحدود
برای کاربرانی که ثبت نام کرده اند
برای ارتباط با ما می توانید از طریق شماره موبایل زیر از طریق تماس و پیامک با ما در ارتباط باشید
در صورت عدم پاسخ گویی از طریق پیامک با پشتیبان در ارتباط باشید
برای کاربرانی که ثبت نام کرده اند
درصورت عدم همخوانی توضیحات با کتاب
از ساعت 7 صبح تا 10 شب
ویرایش: نویسندگان: Kameron Hussain, Frahaan Hussain سری: ناشر: Sonar Publishing سال نشر: 2024 تعداد صفحات: 402 زبان: English فرمت فایل : EPUB (درصورت درخواست کاربر به PDF، EPUB یا AZW3 تبدیل می شود) حجم فایل: 2 Mb
در صورت ایرانی بودن نویسنده امکان دانلود وجود ندارد و مبلغ عودت داده خواهد شد
در صورت تبدیل فایل کتاب Mastering Rust Programming: From Foundations to Future به فرمت های PDF، EPUB، AZW3، MOBI و یا DJVU می توانید به پشتیبان اطلاع دهید تا فایل مورد نظر را تبدیل نمایند.
توجه داشته باشید کتاب تسلط بر برنامه نویسی Rust: از مبانی تا آینده نسخه زبان اصلی می باشد و کتاب ترجمه شده به فارسی نمی باشد. وبسایت اینترنشنال لایبرری ارائه دهنده کتاب های زبان اصلی می باشد و هیچ گونه کتاب ترجمه شده یا نوشته شده به فارسی را ارائه نمی دهد.
Chapter 1: Introduction to Rust 1.1 The Origin and Philosophy of Rust The Birth of Rust Rust’s Philosophy Zero-Cost Abstractions The Rust Community Adopting Rust 1.2 Key Features of Rust 1. Memory Safety 2. Ownership and Borrowing 3. Concurrency Without Data Races 4. Zero-Cost Abstractions 5. Pattern Matching 6. Ownership Guarantees 1.3 Comparison with Other Programming Languages 1. Safety and Memory Management 2. Concurrency 3. Performance 4. Ecosystem and Libraries 5. Learning Curve 6. Web Development 7. Systems Programming 8. Community and Support 1.4 Installing and Setting Up the Rust Environment 1. Installing Rust 2. Verifying the Installation 3. Setting Up a Rust Project 4. Understanding Cargo.toml 5. Building and Running Your Project 6. Exploring Rust Documentation 7. Integrated Development Environments (IDEs) 1.5 Writing Your First Rust Program 1. Creating a New Rust Project 2. Editing the Main Source File 3. Building and Running the Program 4. Understanding the Code 5. Expanding Your Program Chapter 2: Basic Concepts in Rust 2.1 Understanding Variables and Mutability 2.1.1 Variable Declaration and Initialization 2.1.2 Mutable and Immutable Variables 2.1.3 Shadowing Variables 2.1.4 Constants 2.1.5 Summary 2.2 Data Types and Structures 2.2.1 Scalar Types 2.2.2 Compound Types 2.2.3 Compound Data Structures 2.2.4 The String Type 2.2.5 Ownership and Data Types 2.3 Control Flow in Rust 2.3.1 Conditional Statements 2.3.2 Looping Constructs 2.3.3 Flow Control in Loops 2.3.4 The return Statement 2.4 Functions and Modular Programming 2.4.1 Function Definitions 2.4.2 Calling Functions 2.4.3 Function Parameters and Arguments 2.4.4 Function Return Values 2.4.5 Function Visibility 2.4.6 Function Overloading 2.4.7 Summary 2.5 Error Handling Basics 2.5.1 The Result Enum 2.5.2 Handling Errors with match 2.5.3 The Option Enum 2.5.4 Unwrapping Results and Options 2.5.5 Propagating Errors 2.5.6 Custom Error Types 2.5.7 Summary Chapter 3: Advanced Data Types 3.1 Exploring Enums and Pattern Matching 3.1.1 Enumerations in Rust 3.1.2 Using Enums 3.1.3 Pattern Matching 3.1.4 Exhaustive Matching 3.1.5 Matching with Values 3.1.6 Using _ for Placeholder 3.1.7 Combining Patterns 3.1.8 Summary 3.2 Generics and Their Applications 3.2.1 Understanding Generics 3.2.2 Using Generics with Functions 3.2.3 Using Generics with Structs 3.2.4 Using Generics with Enums 3.2.5 Using Generics with Traits 3.2.6 Limiting Generics with Trait Bounds 3.2.7 Summary 3.3 Traits and Abstract Data Types 3.3.1 Defining Traits 3.3.2 Implementing Traits 3.3.3 Trait Bounds 3.3.4 Default Implementations 3.3.5 Multiple Trait Implementations 3.3.6 Trait Objects 3.3.7 Summary 3.4 Collections in Rust 3.4.1 Arrays 3.4.2 Vectors 3.4.3 Strings 3.4.4 Slices 3.4.5 HashMaps 3.4.6 Iterators 3.4.7 Summary 3.5 Smart Pointers and Memory Safety 3.5.1 The Box Smart Pointer 3.5.2 The Rc and Arc Smart Pointers 3.5.3 The RefCell Smart Pointer 3.5.4 The Mutex and RwLock Smart Pointers 3.5.5 The Drop Trait 3.5.6 Summary Chapter 4: Ownership and Borrowing 4.1 The Ownership Model in Rust 4.1.1 Ownership Rules 4.1.2 Ownership and Variables 4.1.3 Ownership Transfer 4.1.4 Ownership and Functions 4.1.5 Borrowing 4.1.6 Ownership and Mutability 4.1.7 Ownership and Lifetimes 4.1.8 Summary 4.2 Borrowing and References 4.2.1 Mutable and Immutable References 4.2.2 Borrow Checker 4.2.3 Dangling References 4.2.4 References as Function Parameters 4.2.5 References in Structs 4.2.6 Summary 4.3 Lifetime Annotations 4.3.1 What Are Lifetimes? 4.3.2 Lifetime Annotations in Function Signatures 4.3.3 Lifetime Elision 4.3.4 Lifetime Bounds 4.3.5 Lifetime Annotations in Structs and Enums 4.3.6 Lifetime Bounds in Traits 4.3.7 Lifetime Annotations in Function Signatures 4.3.8 Lifetime Annotations in Struct and Enum Definitions 4.3.9 Summary 4.4 Understanding Memory Allocation 4.4.1 Stack and Heap 4.4.2 Ownership and Memory Allocation 4.4.3 Data Copies vs. Ownership Transfers 4.4.4 Clone Trait 4.4.5 Memory Leaks 4.4.6 Dangling Pointers 4.4.7 Summary 4.5 Ownership in Practice: Building Robust Applications 4.5.1 Memory Management 4.5.2 Error Handling 4.5.3 Design Patterns and Best Practices 4.5.4 Summary Chapter 5: Concurrency in Rust 5.1 Introduction to Concurrency and Parallelism 5.1.1 What is Concurrency? 5.1.2 What is Parallelism? 5.1.3 Concurrency vs. Parallelism 5.1.4 Thread-Based Concurrency 5.1.5 Asynchronous Programming 5.1.6 Summary 5.2 Threads and Thread Safety 5.2.1 Creating Threads 5.2.2 Thread Communication 5.2.3 Thread Safety and Data Races 5.2.4 Thread Safety and Send/Sync Traits 5.2.5 Summary 5.3 Rust’s Concurrency Guarantees 5.3.1 Ownership and Borrowing 5.3.2 Send and Sync Traits 5.3.3 The Send Trait and Concurrency 5.3.4 The Sync Trait and Concurrency 5.3.5 Summary 5.4 Asynchronous Programming in Rust 5.4.1 What is Asynchronous Programming? 5.4.2 Asynchronous Libraries in Rust 5.4.3 Benefits of Asynchronous Programming 5.4.4 async/await Syntax 5.4.5 Summary 5.5 Building Concurrent Applications in Rust 5.5.1 Identifying Concurrent Tasks 5.5.2 Thread-Based Concurrency 5.5.3 Asynchronous Programming 5.5.4 Synchronization 5.5.5 Channels for Communication 5.5.6 Choosing the Right Concurrency Model 5.5.7 Summary 6.1 Advanced Error Handling Techniques Result Combinators Custom Error Types Recoverable vs. Unrecoverable Errors Summary 6.2 Using Rust’s Debugging Tools Printing Debug Information Using the dbg! Macro Debugging with eprintln! Using the RUST_LOG Environment Variable Using a Debugger Summary 6.3 Writing Testable Code Writing Unit Tests Organizing Tests Writing Integration Tests Test Attributes and Features Summary 6.4 Benchmarking and Performance Analysis Benchmarking with bencher Analyzing Benchmark Results Profiling with cargo flamegraph cargo fmt and Code Formatting Profiling with cargo-profiler Summary 6.5 Common Rust Programming Mistakes and Solutions 1. Ownership and Borrowing Errors 2. Null Pointer Errors 3. Uninitialized Variables 4. Missing Result Handling 5. Incorrect Use of unwrap 6. Mutable Variables When Immutability Is Sufficient 7. Inefficient String Manipulation 8. Unnecessary Cloning 9. Missing Documentation and Comments 10. Ignoring Warnings Chapter 7: Rust’s Ecosystem and Tooling 7.1 Understanding Cargo and Crates What is Cargo? Crates in Rust Creating a New Rust Project Managing Dependencies with Cargo.toml Building and Running a Rust Project Publishing Your Crate Conclusion 7.2 Managing Dependencies Adding Dependencies Specifying Version Constraints Updating Dependencies Locking Dependencies with Cargo.lock Building and Managing Dependencies Conclusion 7.3 Rust Documentation and Community Resources Official Rust Documentation Crates.io Documentation Community-Driven Resources Editor and IDE Integration 7.4 Integrating Rust with Other Languages Foreign Function Interface (FFI) Rust Bindings Interoperability with C++ WebAssembly Integration Python Integration Node.js Integration C# and .NET Integration Conclusion 7.5 Building and Publishing Your Own Crate Creating a New Crate Structuring Your Crate Writing Your Crate Adding Dependencies Building and Testing Your Crate Publishing Your Crate Versioning Your Crate Conclusion Chapter 8: Functional Programming in Rust 8.1 Principles of Functional Programming Immutability First-Class and Higher-Order Functions Pure Functions Immutable Data Structures Pattern Matching Conclusion 8.2 Iterators and Closures Iterators in Rust Closures in Rust Chaining Iterators and Closures Laziness and Evaluation Conclusion 8.3 Functional Design Patterns 1. Map and Reduce 2. Pipe 3. Memoization 4. Currying and Partial Application 5. Monads 8.4 Functional Data Structures 1. Immutable Lists 2. Persistent Maps 3. Option and Result 4. Functional Queues 8.5 Leveraging Rust’s Functional Features 1. First-Class Functions 2. Closures 3. Iterators 4. Pattern Matching 5. Immutability Chapter 9: Rust for Web Development 9.1 Introduction to Web Assembly and Rust What is WebAssembly (Wasm)? Rust and WebAssembly Getting Started with Rust and WebAssembly 9.2 Building Web Applications with Rust Choosing a Web Framework Dependency Management with Cargo Handling HTTP Requests and Routes Templating and Views Database Integration Frontend Development with Yew 9.3 Rust in Backend Development Building HTTP Services Managing Dependencies with Cargo Database Integration Middleware and Authentication Testing and Deployment 9.4 Integrating Rust with JavaScript WebAssembly and Rust Using Rust in a Web Application JavaScript Interoperability Leveraging JavaScript Libraries Node.js and Rust 9.5 Case Studies: Successful Rust Web Projects 1. Rocket: A Web Framework for Rust 2. Warp: Asynchronous Web Services 3. Actix: Actor-Based Framework 4. Parcel: Web Application Bundler 5. Sonic: Fast Search Server Chapter 10: Cross-Platform Development with Rust 10.1 Rust on Different Operating Systems Why Cross-Platform Development? Rust for Cross-Platform Development Cross-Platform Rust Tools 10.2 Rust on Different Operating Systems: A Practical Guide Writing Cross-Platform Code Using Cross-Platform Libraries Cross-Compiling Rust Code Conclusion 10.3 GUI Development with Rust: Building Cross-Platform Interfaces Choosing a GUI Framework Developing a Cross-Platform GUI Application Considerations for Cross-Platform GUI Development 10.4 Mobile Development with Rust: Building Cross-Platform Mobile Apps Mobile Development with Rust and Flutter Building a Cross-Platform Mobile App with Rust and Flutter Considerations for Mobile Development in Rust 10.5 Building Cross-Platform Applications with Rust 1. Cross-Platform Development Frameworks 2. Web-Based Cross-Platform Apps 3. Mobile Cross-Platform Apps 4. Game Development 5. Desktop Applications 6. Command-Line Tools Chapter 11: Rust for Systems Programming Section 11.1: Rust in Operating Systems Development The Advantages of Rust in OS Development Use Cases for Rust in OS Development Challenges and Considerations Section 11.2: Network Programming with Rust Building Network Servers Asynchronous Networking Protocol Parsing and Serialization Section 11.3: File System and I/O Operations Reading and Writing Files Directory Operations Standard Input and Output Section 11.4: Building Command-Line Tools Command-Line Argument Parsing Running External Commands Creating Interactive Tools Section 11.5: Rust in High-Performance Computing Performance and Safety Parallelism and Concurrency Interoperability SIMD and Vectorization GPU Programming Numerical Computing Libraries Chapter 12: Advanced Rust Programming Techniques Section 12.1: Macros and Metaprogramming What Are Macros? Macro Invocation Code Generation DRY (Don’t Repeat Yourself) Principle Challenges and Pitfalls Section 12.2: Advanced Traits and Type Systems Associated Types Supertraits Phantom Types Advanced Type Constraints Advanced Traits and Type System Summary Section 12.3: Unsafe Rust for Low-Level Control The “unsafe” Keyword Unsafe Functions and Blocks Unsafe Traits and Implementations Safe Abstractions with Unsafe Code Guidelines for Using “unsafe” Section 12.4: Optimizing Rust Code Profiling and Benchmarking Data Structures and Algorithms Profiling and Optimizing Hot Loops Compiler Optimization Flags Unsafe Code for Low-Level Optimization Caching and Memoization Avoiding Unnecessary Allocations Parallelism and Concurrency Section 12.5: Exploring Rust’s Type System Strong and Static Typing Type Inference Ownership and Borrowing References and Borrowing Enums and Pattern Matching Traits and Polymorphism Custom Types and Abstraction Chapter 13: Rust for Game Development Section 13.1: Introduction to Game Development with Rust Section 13.2: Rust Game Engines and Frameworks ggez Amethyst Bevy Other Options Section 13.3: Graphics Programming in Rust Rendering with OpenGL and Vulkan Graphics Shaders 2D and 3D Graphics Section 13.4: Handling User Input and Events Event Loop and Event Handling Input Handling Abstractions GUI Libraries Section 13.5: Building a Simple Game in Rust Game Development Libraries Setting Up the Project Creating a Game Loop Adding Game Logic and Graphics Conclusion Chapter 14: Rust and Cryptography Section 14.1: Cryptographic Concepts in Rust What is Cryptography? Cryptographic Primitives Conclusion Section 14.2: Implementing Encryption Algorithms in Rust Choosing the Right Algorithm Using External Libraries Implementing Custom Algorithms Secure Key Management Conclusion Section 14.3: Rust in Blockchain and Cryptocurrency Building Blockchain Protocols Smart Contracts and dApps Cryptocurrency Wallets and Tools Security Auditing and Penetration Testing Conclusion Section 14.4: Secure Communication with Rust Web Servers Networking Protocols Messaging Systems Encryption and Authentication Secure Coding Practices Conclusion Section 14.5: Building Cryptographically Secure Applications Why Cryptographic Security Matters Rust’s Role in Cryptographic Security Building Cryptographically Secure Applications Conclusion Chapter 15: Rust for Data Science and Machine Learning Section 15.1: Rust in the World of Data Science The Advantages of Using Rust in Data Science Use Cases for Rust in Data Science Challenges and Considerations Conclusion Section 15.2: Data Processing and Analysis in Rust Reading and Parsing Data Data Transformation and Cleaning Numerical Computing Concurrency for Data Processing Visualization and Plotting Section 15.3: Machine Learning Libraries in Rust 1. ndarray and nalgebra 2. tangram 3. rust-learn 4. tract Section 15.4: Building Predictive Models with Rust 1. Data Preparation 2. Model Selection 3. Training the Model 4. Model Evaluation 5. Hyperparameter Tuning 6. Deployment 7. Monitoring and Maintenance Section 15.5: Case Studies: Rust in Data Intensive Applications 1. Servo: A Modern Web Browser Engine 2. Tantivy: A Full-Text Search Engine Library 3. DataFusion: A Distributed SQL Query Engine 4. Parquet: A Columnar Storage Format 5. Heim: A Cross-Platform System Information Library 6. Polars: A Data Manipulation and Analysis Library Chapter 16: Scalability and Performance in Rust Section 16.1: Writing High-Performance Rust Code Performance Considerations in Rust Profiling and Benchmarking Writing Efficient Algorithms Memory Management and Optimization Profiling Rust Code SIMD (Single Instruction, Multiple Data) Parallelism and Concurrency Load Balancing and High Availability Real-World Case Studies Section 16.2: Memory Management and Optimization Stack vs. Heap Lifetimes and Borrowing Reusing Memory Copy vs. Clone Rust’s Allocator API Cache-Friendly Data Structures Section 16.3: Scalable System Architectures Parallelism and Concurrency Asynchronous Programming Message Passing Load Balancing and High Availability Horizontal Scaling Microservices and Containerization Section 16.4: Load Balancing and High Availability Load Balancing High Availability Distributed Systems and Rust Section 16.5: Case Studies: Performance Optimization in Rust Case Study 1: Servo Browser Engine Case Study 2: Tokio Asynchronous Runtime Case Study 3: Data Serialization with Serde Case Study 4: Rust in Game Development Case Study 5: Rust in Cryptocurrency Chapter 17: Rust in the Enterprise Section 17.1: Adopting Rust in Large-Scale Projects The Rust Safety Promise Performance at Scale Productivity and Maintainability Real-World Examples Overcoming Challenges Section 17.2: Rust for Enterprise Security Memory Safety and Security Protection Against Data Races Secure by Default Third-Party Audits Cryptography and Secure Communication Secure Enterprise Solutions in Rust Section 17.3: Building Microservices with Rust Performance and Efficiency Safety and Reliability Concurrency and Parallelism Ecosystem and Libraries Containerization and Deployment Cross-Platform Compatibility Section 17.4: Rust in Cloud Computing Serverless Computing Containers and Orchestration Cloud-Native Databases Cloud Infrastructure as Code Cloud-Native Monitoring and Observability Section 17.5: Case Studies: Rust in Corporate Environments Dropbox: Rewriting Critical Components for Safety and Performance Mozilla: Building a More Secure Web Browser Cloudflare: Leveraging Rust for Networking and Security Microsoft: Utilizing Rust in Azure IoT Edge Figma: Empowering Design Collaboration with Rust Chapter 18: Future Trends and Directions in Rust Section 18.1: Rust’s Roadmap and Future Developments 1. Stabilization of Features 2. Ergonomics and Developer Experience 3. Async/Await and Concurrency 4. Wider Adoption in Systems and Web Development 5. Expansion of the Rust Ecosystem 6. Integration with Other Languages 7. Rust in Education 8. Community Involvement Section 18.2: Emerging Domains and Applications for Rust 1. WebAssembly (Wasm) Development 2. Blockchain and Cryptocurrency 3. Embedded Systems and IoT 4. Game Development 5. Machine Learning and Data Science 6. Cloud Computing 7. Networking and Network Services 8. Quantum Computing Section 18.3: Rust in the Open Source Community 1. Open Source Roots 2. Package Management with Cargo 3. Contributions to the Wider Open Source Ecosystem 4. Community-Driven Development 5. Education and Outreach 6. Cross-Project Collaboration 7. Security and Trust 8. Community Engagement Section 18.4: Challenges and Opportunities for Rust 1. Learning Curve 2. Library Ecosystem 3. Adoption in Legacy Codebases 4. Tooling 5. Cross-Platform Development 6. Integration with Other Languages 7. Security and Trust 8. Community Growth 9. Rust in Emerging Domains 10. Educational Initiatives Section 18.5: Preparing for the Future with Rust 1. Continuous Learning 2. Contribute to Open Source Projects 3. Explore Emerging Domains 4. Diversify Your Skill Set 5. Participate in the Rust Community 6. Stay Informed About Rust’s Roadmap 7. Experiment and Innovate 8. Mentorship and Teaching 9. Adapt to Industry Trends 10. Remain Adaptable Chapter 19: Real-World Rust Projects Section 19.1: Analyzing Open-Source Rust Projects Finding Open-Source Rust Projects Evaluating Project Relevance Cloning and Exploring Repositories Reading Documentation Analyzing Code Structure Studying Contributions and Pull Requests Running Tests and Benchmarks Contributing to Projects Tools for Analyzing Rust Projects Learning from Diverse Projects Section 19.2: From Concept to Code: Developing a Rust Project Defining Your Project Planning and Design Choosing Dependencies Setting Up the Development Environment Writing Code Version Control Testing Continuous Integration Documentation Community and Collaboration Security and Maintenance Deployment and Distribution Monitoring and Feedback Section 19.3: Project Management for Rust Development Choosing a Project Management Methodology Setting Clear Objectives Creating a Project Plan Managing Resources Communication and Collaboration Risk Management Task Tracking and Progress Monitoring Agile Development Practices Documentation Quality Assurance Change Management Project Closure Section 19.4: Rust in Production: Success Stories 1. Dropbox 2. Mozilla 3. Cloudflare 4. Parity Technologies 5. Microsoft 6. Figma 7. Discord Section 19.5: Learning from Real-World Rust Applications 1. Code Readability 2. Safety and Concurrency 3. Error Handling 4. Testing and Documentation 5. Dependency Management 6. Design Patterns and Architectural Choices 7. Performance Optimization 8. Community and Collaboration Chapter 20: Concluding Rust Journey Section 20.1: Best Practices in Rust Programming 1. Code Readability and Clarity 2. Embrace Rust’s Ownership System 3. Error Handling 4. Comprehensive Testing 5. Documentation 6. Dependency Management with Cargo 7. Design Patterns and Architecture 8. Performance Optimization 9. Open Source Contribution and Collaboration 10. Lifelong Learning Section 20.2: The Rust Community and Continuing Education The Rust Community Continuing Your Education Section 20.3: Future-Proofing Your Rust Skills Embrace Lifelong Learning Diversify Your Skill Set Build a Strong Portfolio Stay Adaptable and Resilient Networking and Collaboration Section 20.4: The Impact of Rust on Software Development 1. Memory Safety and Systems Programming 2. Concurrency and Parallelism 3. Web Assembly (Wasm) and Browser-Based Applications 4. Security and Safe Systems 5. Language Design and Innovation 6. Growing Ecosystem and Libraries 7. Education and Learning 8. Community and Collaboration Section 20.5: Final Thoughts and Next Steps in Rust Programming 1. Master the Fundamentals 2. Explore Specialized Domains 3. Contribute to Open Source 4. Stay Informed 5. Experiment with Advanced Features 6. Continue Learning 7. Collaborate and Network 8. Teach and Mentor 9. Embrace Challenges 10. Enjoy the Journey