Errata

Below a code snippet, there is the text:

"In this case, when Rust creates the closure, it automatically borrows a reference to stat. It stands to reason: the closure refers to stat, so it must have a reference to it."

---

city.get_statistics(stat) inside the closure takes ownership of "stat", so the closure can't just borrow a reference to "stat". It is moved into the closure (even implicitly if no "move" keyword is specified) or copied if Statistic implements Copy.

I have written 145 notes/errata (all of which aren't in the errata page) for the book and it would be impractical and quite painful (both for me and for the authors) to write them one by one here.

And since I read the Kindle edition, I took advantage of its sharing-notes feature which shows notes/errata together with the highlighted relevant text and even includes the page number.

I just sent these errata/notes to both `booktech@oreilly.com` and `bookquestions@oreilly.com` and expect (and look forward to) some going back and forth.

I've tried more than a dozen programming languages over the years and probably only borrowing/lifetimes are new concepts to me. Most notes/errata are from an outsider perspective as I didn't start using Rust when I was reading the book.

However, I have now about 10days of Rust experience and have been using it productively. Still notes/errata haven't changed much as I edited/reviewed them as most points are quite intuitive from a programming and common-sense perspective.

Looking forward to hearing from you,

Current Copy
slice_a.swap(&mut slice_b)
Swaps the entire contents of slice_a and slice_b.
slice_a and slice_b must be the same length.

Suggested
slice_a.swap_with_slice(&mut slice_b)
Swaps the entire contents of slice_a and slice_b.
slice_a and slice_b must be the same length.

Chapter 2. Section "Writing and Running Unit Tests"
The crates recommended at the above location do not work. While trying to follow this exercise, I was repeatedly met with an error about actix-http failing to compile. More modern versions of actix-web, the crate you're asked to install, have a different API and so don't work with the rest of the instruction.

There was three command line examples which displays the version of the new installed rust tools cargo, rustc and rustdoc.
All commands print out the version "1.49.0" released in Dec. 2020 but this version does not support the Rust edition 2021, it only support edition 2018. All examples in this book use edition 2021.
The first Rust version which support edition 2021 is 1.56. (2021-10-04).

"Unlike C and C++, which require main to return zero if the program finished successfully, or a nonzero exit status if something went wrong, Rust assumes that if main returns at all, the program finished successfully."

This is in fact not required in C++, as per the C++ standard:

eel.is/c++draft/basic.start.main#5

escape_time never returns 0, thus 255 - count will never result in 255, thus the image will never contain truly white pixels.

At page page 35, the book makes the user write `if args.len() != 5` in order to prevent the program from running in case the wrong amount of arguments is passed to the terminal.
Afterwards, at page 36, it asks the user to run `time .\target\release\mandelbrot mandel.png 4300x3000 -1.20,0.30 -1.0,0.20` to verify that the program is running correctly (and check how long it takes to run).

The issue is that - at least on Windows - when you use commas in the terminal, they are considered separators. This means that `time .\target\release\mandelbrot mandel1.png 4000x3000 -1.20,0.35 -1.0,0.20` gets separated as `[".\target\release\mandelbrot", "mandel.png", "4000x3000", "-1.20", "0.35" , "-1.0", "0.20"]` (length 7, hence not allowed) instead of being separated as `[".\target\release\mandelbrot", "mandel.png", "4000x3000", "-1.20,0.35" , "-1.0,0.20"]` (length 5).

My solution to this was simply to `':'` as a separator of the pairs, rather than `','`

Best,

Alex

rows_per_band is supposed to be rounded upward, but it isn't really.
With bounds.1 set to e.g. 64 (a multiple of threads), this would result in 9 instead of 8.
This should work: let rows_per_band = (bounds.1 as f32 / threads as f32).ceil() as usize;

The book instructs the user to create a file via the echo command, using `echo "Hello, world" > test.txt`

When done in Windows (via cmd or PowerShell) this will result in the file getting a UTF-16 with BOM encoding.

Consequently, when running `cargo run "world" "Rust" test.txt test-modified.txt`, the program fails, with the error

```
error: failed to read from file '.\test.txt': Error { kind: InvalidData, message: "stream did not contain valid UTF-8" }
error: process didn't exit successfully: `target\debug\quickreplace.exe world Rust .\test.txt .\test-modified.txt` (exit code: 1)
```

The workaround is to create the file from outside the terminal.

The 3rd paragraph says
"A string literal is a &str that refers to preallocated text, typically stored in read-only memory along with the program’s machine code. In the preceding example, poodles is a string literal, pointing to seven bytes that are created when the program begins execution and that last until it exits."

This gave me the impression that poodles would exist in the program code and behave more like constants.

So I wrote this simple code to test that understanding
fn main {
{
// that persist till the program finished/
let crymoji = "ಠ_ಠ";
}
println!("crymoji: {}", crymoji);
}

and got this compiler error, which goes ahead to says that &str obey the ownership rules, hence it is deleted from memory when the program leaves its scope.

error[E0425]: cannot find value `crymoji` in this scope
--> fundamental_types.rs:135:29
|
135 | println!("crymoji: {}", crymoji);
| ^^^^^^^ not found in this scope

error: aborting due to previous error

For more information about this error, try `rustc --explain E0425`.


My opinion is that the text book should state that &str persist in memory through out the program execution when they are declared.

There's this comment:

/// If either range is empty, they don't count as overlapping.
///
/// assert_eq!(ranges::overlap(0..0, 0..10), false);

While the comment is true, the test is not appropriate, as this would also pass:

/// assert_eq!(ranges::overlap(0..1, 1..10), false);

A better test would be:

/// assert_eq!(ranges::overlap(1..1, 0..10), false);

At the very beginning of section: "Trait Object Layout"

Should the quoted text "In memory, a trait object is a fat pointer" be "In memory, a reference to trait object is a fat pointer"? I think that would be more accurate.

The following text

> The deref and deref_mut methods take a &Self reference and return a
&Self::Target reference.

should be changed to

The deref method takes a &Self reference and returns a
&Self::Target reference, while deref_mut takes a &mut Self and returns a &mut Self::Target.

"a closure is callable, but it's not a fn"

Suggested: "a closure is a callable, but it's not an fn if it captures from its environment"

The "Serving Pages to the Web" section of Chapter 2 makes use of the gcd function, which is defined in the previous section. But the "web" section creates a new project, and nowhere is it mentioned that one should copy and paste the gcd function from the previous example. The project in its current form in the text can't be run.

It is no longer necessary to split the `io::stdin()` call from a `lock()` call, and likewise for `io::stdout(), io::stderr()`. The following compiles fine on the Rust playground:

```
use std::io::{stdin, BufRead};

fn main() {
let lines = stdin().lock().lines();
for line in lines {
println!("{}", line.unwrap())
}
}```

"For security, verifying a password needs to be computationally intensive so that even if attackers [...] they can't simply try trillions of possible passwords".

That's not at all how it works with cryptography and the author should probably remove this statement because it's very misleading.

The verification process always aims at saving as much CPU power as possible and the protection only relies on the key (and the algorithm) to provide strong security. Of course the general idea is to make a brute-force attack impractical, but that doesn't mean long computational time is mandatory. Then there are other techniques like a voluntary pause between attempts.

For example, the hashing operation the author is mentioning and which is used to verify passwords on Unix and similar OSes, is not intensive at all.

With public-key cryptography this is even more obvious since the public key used for verification is chosen to be as simple as possible to limit the number of operations.