please write a list of points from this section of the book, and clean up the explanations: 


10.2.2 Cross-compile your binary for different environments 
The binary size is not the only consideration when compiling Rust code. During com- pilation, the compiler uses operating system libraries to build the binary. Each build is dependent on the underlying API calls to the operating system it is running on. If you are on macOS, the binary you are producing will also run on macOS. If you try to copy the code over to a Linux machine and run it, it will fail. 
Rust supports the compilation for various environments, called targets (http://mng .bz/DDBE). You can get a list of available targets via the commandrustuptargetlist: 
       $ rustup target list
       aarch64-apple-darwin (installed)
       aarch64-apple-ios
       aarch64-apple-ios-sim
       aarch64-fuchsia
       aarch64-linux-android
... 

A full list can be found via the Platform Support section of the Rustc documentation website (http://mng.bz/lR8y). You have to first add an additional target to your tool- chain via Rustup before you can build your codebase for this specific environment. So, if you are on a macOS M1 machine and want to build a binary for an Intel Mac, you have to add the target first and then specify it at the build step: 
$ rustup target install x86_64-apple-darwin
$ cargo build --release --target x86_64-apple-darwin 
Another common use case is to create cross-compiled binaries. The terms used in this scenario are dynamically linked vs. statically linked binaries. When building a dynamically linked binary, the created executable will not pack every library it needs into itself but remembers the address spaces to call to when needing to make a system call to the operating system. The differences are shown in figure 10.3. 

This makes the binary smaller, but also means it relies on the exact operating system it is built on. If you use a statically linked process, the libraries will be put into the binary, so you don’t have to rely on the operating system to provide the exact code and don’t have to rely on the memory address of your current host machine. 
Rust offers a target for a cross-compiled Linux binary called x86_64-unknown- linux-musl. You can add this to your Rustup toolchain and build it: 
$ rustup target install x86_64-unknown-linux-musl
$ cargo build --release --target=x86_64-unknown-linux-musl 
The musl project (www.musl-libc.org/intro.html) provides an implementation of the standard C library optimized for static linking. Build systems can use musl to make 
system calls to the operating systems, and musl translates the calls to the operating sys- tem it is currently running on. 
This also means that your current operating system must have this library installed, so the Rust compiler can integrate it into your binary. The installation process depends on which operating system you are running on, and this book can’t offer musl installation instructions that remain up-to-date. If you run into problems, keep in mind that if you want to create a statically linked binary, you need musl installed on your machine, and sometimes tell your operating system explicitly (sometimes through environment variables in your shell) which environ-ment you are targeting. 


