Learn Rust Programming Safe Code Supports Low Level and Embedded Systems Programming with a Strong Ecosystem 1st Edition by Claus Matzinger 935551154X 9789355511546

Learn Rust Programming Safe Code Supports Low Level and Embedded Systems Programming with a Strong Ecosystem 1st Edition by Claus Matzinger- Ebook PDF Instant Download/Delivery: 935551154X, 9789355511546

Full download Learn Rust Programming Safe Code Supports Low Level and Embedded Systems Programming with a Strong Ecosystem 1st Edition after payment

Product details:

ISBN 10: 935551154X

ISBN 13: 9789355511546

Author: Claus Matzinger

“Learn Rust Programming” assists every programmer in learning Rust and filling in the gaps left by other programming languages in developing full-proof apps and systems. This book covers every vital feature a programmer requires, including basic principles, syntax, clean coding, application testing, popular libraries, and numerous examples and small programmes.

As a first step in understanding the language, this book tries to present a profoundly practical method for overcoming this learning curve. Using engaging coding challenges and practical projects, the reader can anticipate learning programming fundamentals, developing advanced concurrent code, contributing to open-source projects, and ultimately pursuing a career in Rust. In addition to programming, this book covers the fundamentals of software engineering to develop maintainable and well-documented projects with the help of built-in tools.

As novice software engineers, readers of this book will be able to develop excellent software independently as part of a bigger team. Using Rust, they can join one of the numerous crypto, gaming, IoT, or cloud infrastructure organizations to mark their success of knowledge.

Learn Rust Programming Safe Code Supports Low Level and Embedded Systems Programming with a Strong Ecosystem 1st Table of contents:

1. Building the Basics
Structure
Objectives
Compiling Rust code
What is compilation
Memory management and dynamic versus static typing
Executing the code
Programming in Rust
Managing memory in Rust
Writing Rust code
Working with variable types
Being literal
Conclusion
Challenge
2. Controlling the Program Flow
Structure
Objectives
Making decisions with if
Using conditions
What if condition fails
Using If/Else expressions
Repetitions and repetitions with loop
Continuing and breaking with values
Enumerating with for
Breaking on conditions with while
Conclusion
Challenge
3. Organizing for Reuse
Structure
Objectives
Encapsulating behavior with functions
Parameterizing functions
Encapsulating data with structs
Getting a deeper look
Exporting and importing with modules
Aliasing types and exporting imports
Conclusion
Challenge
4. Interfacing with Code and Errors
Structure
Objectives
Using traits for fun and pleasure
Implementing traits
Using traits in functions
Creating variations with enums
Handling errors with enums
Matching patterns to extract data
Conclusion
Challenge
Further reading
5. Borrowing Ownership with Scopes
Structure
Objectives
Taking ownership of memory
Working with both kinds of memory
Borrowing memory
Working in scopes
Controlling mutability
Introducing clones
Conclusion
Challenge
6. Working with Collections
Structure
Objectives
Using sequential collections: slices and Vec
Operating the Vec
Borrowing the Vec: slices
Deriving keys from values with sets and maps
Sorting keys: trees and hashes
Using sets and maps
Iterating over any collection
Chaining iterators together
Collecting the results
Conclusion
Challenge
Further reading
7. Reading Input and Writing Output
Structure
Objectives
Reading from and writing to I/O streams
Console, networking, and file systems
Using formatted print
Configuration options for programs
Using command-line arguments
Using environment variables
Conclusion
Challenge
8. Using Crates with Cargo
Structure
Objectives
Creating crates with cargo
Writing the build manifest
Adding third-party crates
Going deeper into cargo
Customizing the build
Using workspaces for large projects
Conclusion
Challenge
Further reading
9. Testing What you Build
Structure
Objectives
Testing Rust code
Testing units
Testing integration
Benchmarking Rust code
Conclusion
Challenge
10. Documenting What You Build
Structure
Objectives
Documenting Rust code
Using sections, links, and others
Writing documentation tests
Publishing your documentation
Conclusion
Challenge
11. Generating Code with Macros
Structure
Objectives
Declarative macros
Using arguments with names and designators
Adding complexity to arguments
Exporting macros
Procedural macros
Writing function-like macros
Deriving stuff with macros
Using attributes to extend code
Conclusion
Challenge
12. Using Heap Memory Effectively
Structure
Objectives
Putting things in boxes
Boxing data
Boxing behavior
Counting references
Counting references with multi-threading
Creating mutability as required
Using locks for global mutability
Conclusion
Challenge
Further reading
13. Running Concurrent Code
Structure
Objectives
Threading with Rust
Using Send and Sync
Using alternatives
Bridging threads with channels
Conclusion
Challenge
14. Writing Async Code
Structure
Objectives
Scheduling tasks in a loop
Polling futures
Using futures-rs
Using async-std
Working asynchronously
Running blocking code
Conclusion
Challenge
15. Working with Generics
Structure
Objectives
Using Generics
Parameterizing functions
Parameterizing structs, traits, and enums
Going deeper
Using const Generics
Working with lifetimes
Conclusion
Challenge
16. Calling Unsafe and Foreign Functions
Structure
Objectives
Working with unsafe
Sharing native Rust code
Importing a shared library
Binding Rust code
Exporting as shared library

People also search for Learn Rust Programming Safe Code Supports Low Level and Embedded Systems Programming with a Strong Ecosystem 1st: 

unsafe rust

learn rust codecademy

learn rust programming online

 learn rust coding

Tags:

Claus Matzinger,Programming,Supports,Embedded