PDF Learn Rust Programming: Safe Code, Supports Low Level and Embedded Systems Programming with a Strong Ecosystem 1st Edition Claus Matzinger download
PDF Learn Rust Programming: Safe Code, Supports Low Level and Embedded Systems Programming with a Strong Ecosystem 1st Edition Claus Matzinger download
com
https://ebookmeta.com/product/learn-rust-programming-safe-
code-supports-low-level-and-embedded-systems-programming-
with-a-strong-ecosystem-1st-edition-claus-matzinger/
OR CLICK BUTTON
DOWNLOAD NOW
https://ebookmeta.com/product/low-level-programming-igor-zhirkov/
ebookmeta.com
https://ebookmeta.com/product/embedded-systems-design-programming-and-
applications-1st-edition-a-k-ganguly/
ebookmeta.com
https://ebookmeta.com/product/programming-101-learn-to-code-using-the-
processing-programming-language-2nd-edition-jeanine-meyer/
ebookmeta.com
https://ebookmeta.com/product/maggie-p-i-mysteries-box-set-
books-3-5-rose-pressey-betancourt/
ebookmeta.com
Numerical Methods in Computational Finance A Partial
Differential Equation PDE FDM Approach 1st Edition Daniel
J. Duffy
https://ebookmeta.com/product/numerical-methods-in-computational-
finance-a-partial-differential-equation-pde-fdm-approach-1st-edition-
daniel-j-duffy/
ebookmeta.com
https://ebookmeta.com/product/snowflakes-and-holidates-05-anastasia-
austin-my-cheerful-holidate-1st-edition-anastasia-austin/
ebookmeta.com
https://ebookmeta.com/product/south-australia-northern-territory-8th-
edition-anthony-ham-charles-rawlings-way/
ebookmeta.com
https://ebookmeta.com/product/playing-for-keeps-blue-moon-
wolves-3-siren-publishing-classic-manlove-jane-perky/
ebookmeta.com
https://ebookmeta.com/product/battle-of-fire-1st-edition-chesney-
infalt/
ebookmeta.com
Unstoppable A 90 Day Plan to Biohack Your Mind and Body
for Success Ben Angel
https://ebookmeta.com/product/unstoppable-a-90-day-plan-to-biohack-
your-mind-and-body-for-success-ben-angel/
ebookmeta.com
Learn
Rust Programming
Claus Matzinger
www.bpbonline.com
Copyright © 2022 BPB Online
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or
transmitted in any form or by any means, without the prior written permission of the publisher,
except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information
presented. However, the information contained in this book is sold without warranty, either express
or implied. Neither the author, nor BPB Online or its dealers and distributors, will be held liable for
any damages caused or alleged to have been caused directly or indirectly by this book.
BPB Online has endeavored to provide trademark information about all of the companies and
products mentioned in this book by the appropriate use of capitals. However, BPB Online cannot
guarantee the accuracy of this information.
ISBN 978-93-55511-546
www.bpbonline.com
Dedicated to
My wife and my daughter.
About the Author
Claus Matzinger: In the last 10 years as a Software Engineer I have
worked with many programming languages, but Rust stood out from the
beginning. With its unique approaches to some of the most challenging
issues when developing large-scale applications.
After getting to know the language in its infancy, I spoke at and hosted
several Rust Meetups (in Munich, Berlin, Linz, …), joined the official
Community team, connected Microsoft’s security engineers with the Rust
core team, and wrote several books and courses on Rust.
Today, I am a senior engineer working on a major Rust code base in
FinTech, covering everything from no_std code, to different CPU
architectures, and soon WebAssembly. In the past, I have created games for
improving mental health, helped build a distributed SQL database at a
startup, maintained a Smalltalk application, and worked on customer’s
business critical enterprise systems at Microsoft.
As a quickly evolving language that is deeply technical in nature, Rust has a
daunting learning curve, that I love to help new and experienced
programmers overcome. For that, I also blog regularly about practical
things to do with Rust at https://blog.x5ff.xyz.
Acknowledgement
Creating something as fundamental as a programming language is a major
undertaking by many people and it would require another book to honor
each contribution. However I’d like to thank all contributors to the Rust
programming language for creating such a great language - it has become
more than a tool for me and many others. With this book I want to pay it
forward by instilling this passion in others.
In these early days of Rust, it’s not common to work with my favorite
programming language on a daily basis. Thanks to the team at DEX Labs I
get to tinker and work in an exciting environment that takes Rust from the
lowest levels of CPUs to WebAssembly - I truly enjoy every minute of that.
Preface
Rust is still a young language and throughout its “formative years” it has
passed through many stages. Before Rust 1.0 was released, the language
had already tried different paradigms for memory management and even
types. However, leaving those initial ideas behind made the language what
it is today: a really fast and safe language with a quirky memory
management technique and an opinionated compiler.
While it comes with a steep learning curve, the ideas have spread and other
programming languages (for example Apple’s Swift) picked some parts up
quickly, resulting in an overall improvement for programmers and software
engineers. I am convinced that by learning Rust, you learn more about
programming as well and become better for it.
In many ways, the system of borrowing and ownership of memory keeps
the questions “Where does this come from?” and “Where does this go?”
always at the forefront of your programming mind. Even while writing
JavaScript, a much more permissible language, you will become aware of
where your objects are and where they should be, as well as whether or not
you should create a copy. Personally, I think that alone is worth learning
more Rust.
To start your journey, this book provides 16 chapters in increasing
difficulty. Starting with the basics, you will quickly advance towards
fundamentals of the standard library, memory management, and end with
highly advanced features such as Rust’s unsafe features. Each chapter
comes with a challenge in the end so you can experiment with what you
learned.
After completing this book, you will have built your own LinkedList data
structure and several other small programs from along the way. Before we
start off, let’s look at what each chapter contains:
Chapter 1 provides you with the basics of the Rust programming language.
To set the stage appropriately, you’ll learn about byte code, compilers and
compilation, simple types, and variables.
Chapter 2 goes a little deeper into program flow and controlling it. This is
where you see decision making with if, as well as while and for loops
introduced. Afterwards, reading short code examples in Rust won’t pose
much of a challenge for you any longer.
Chapter 3 covers the heart of how Rust stores data in memory. This
chapter is all about creating data structures (structs), modules, and
functions. For your programming journey, that means you can now store
data and attach behavior (do stuff with it).
Chapter 4 ventures further into the depths of Rust’s type system by
exploring enumerations (enums), traits, and pattern matching. These
constructs allow for more efficient decision making based on type variants
and share behavior between types using traits.
Chapter 5 gets to the heart of Rust’s memory management system:
borrowing and ownership. The chapter details sharing data structures
between functions, how to add mutability, and introduces the notion of
scopes. This chapter concludes the fundamentals of the programming
language, so afterwards you can solve basic and intermediate problems
using Rust.
Chapter 6 introduces the Rust standard library collections, which will play
an important role in any Rust programming career. This includes the Vector,
HashMap, HashSet, their BTree counterparts, and the Iterator trait which
allows to traverse these collections.
Chapter 7 covers working with input and output of various sorts, utilizing
the Read and Write traits of the Rust standard library, as well as interacting
with the outside world with command line arguments, Files and
environment variables. Afterwards your programs can easily interact with
the environment.
Chapter 8 gets into how to add third party dependencies from the crates.io
package repository. Additionally, the chapter covers custom build processes
and custom cargo commands.
Chapter 9 provides details on testing your Rust code, including unit tests,
integration tests, and benchmarking. Once you know this, there is no excuse
not to test your code!
Chapter 10 adds documentation to your Rust repository. This means that
you can generate websites from your code comments and even test the
examples. After testing, this is Rust’s way of making documenting code
convenient.
Chapter 11 starts the advanced part of the book by introducing macros.
These code constructs allow to generate code and insert it right before the
final steps of compilation. Next to using macros, you’ll learn how to create
the different kinds supported in Rust as well.
Chapter 12 dives deep into heap memory allocation and the types Rust
provides for managing it. Together with borrowing and ownership concepts,
this chapter explores reference counters, boxes, memory layouts, and the
interior mutability pattern.
Chapter 13 is all about concurrency using threads, locks, and
synchronization. Thanks to borrowing and ownership principles, this is
significantly less error-prone than in other languages.
Chapter 14 expands on concurrency by explaining async, short for
asynchronous programming. The chapter includes using the provided
syntax elements async and await and how to use Futures to schedule tasks
on an I/O loop.
Chapter 15 introduces the topic of generics. Generics are a way to provide
implementations on functions without relying on specific types, instead
using traits. This is complemented by a deeper dive on lifetimes, since those
may differ between the generic types.
Chapter 16 concludes the book with an overview over unsafe and the
foreign function interface (FFI). These language constructs allow you to
integrate with other programs, the operating system, or other programming
languages by linking libraries to Rust or creating linkable libraries from
Rust. You’ll also learn about the dark arts of writing unsafe code that the
compiler is less strict about…
Coloured Images
Please follow the link to download the
Coloured Images of the book:
https://rebrand.ly/8r7c0wi
We have code bundles from our rich catalogue of books and videos
available at https://github.com/bpbpublications. Check them out!
Errata
We take immense pride in our work at BPB Publications and follow best
practices to ensure the accuracy of our content to provide with an indulging
reading experience to our subscribers. Our readers are our mirrors, and we
use their inputs to reflect and improve upon human errors, if any, that may
have occurred during the publishing processes involved. To let us maintain
the quality and help us reach out to any readers who might be having
difficulties due to any unforeseen errors, please write to us at :
errata@bpbonline.com
Your support, suggestions and feedbacks are highly appreciated by the BPB
Publications’ Family.
Did you know that BPB offers eBook versions of every book
published, with PDF and ePub files available? You can upgrade to
the eBook version at www.bpbonline.com and as a print book
customer, you are entitled to a discount on the eBook copy. Get in
touch with us at: business@bpbonline.com for more details.
At www.bpbonline.com, you can also read a collection of free
technical articles, sign up for a range of free newsletters, and receive
exclusive discounts and offers on BPB books and eBooks.
Piracy
If you come across any illegal copies of our works in any form on the
internet, we would be grateful if you would provide us with the
location address or website name. Please contact us at
business@bpbonline.com with a link to the material.
Reviews
Please leave a review. Once you have read and used this book, why
not leave a review on the site that you purchased it from? Potential
readers can then see and use your unbiased opinion to make purchase
decisions. We at BPB can understand what you think about our
products, and our authors can see your feedback on their book.
Thank you!
For more information about BPB, please visit www.bpbonline.com.
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
1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside
the United States, check the laws of your country in addition to
the terms of this agreement before downloading, copying,
displaying, performing, distributing or creating derivative works
based on this work or any other Project Gutenberg™ work. The
Foundation makes no representations concerning the copyright
status of any work in any country other than the United States.
1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if
you provide access to or distribute copies of a Project
Gutenberg™ work in a format other than “Plain Vanilla ASCII” or
other format used in the official version posted on the official
Project Gutenberg™ website (www.gutenberg.org), you must,
at no additional cost, fee or expense to the user, provide a copy,
a means of exporting a copy, or a means of obtaining a copy
upon request, of the work in its original “Plain Vanilla ASCII” or
other form. Any alternate format must include the full Project
Gutenberg™ License as specified in paragraph 1.E.1.
• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
about donations to the Project Gutenberg Literary Archive
Foundation.”
• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.
1.F.
Most people start at our website which has the main PG search
facility: www.gutenberg.org.