Historical errata for Programming WebAssembly with Rust

“wast” instead of “wasm”, towards the bottom of the page

checkers/func_test.js

console.debug(“Black is not white”, instance.exports.isWhite(black));

should be

console.debug(“Black is white”, instance.exports.isWhite(black));

because ‘Black is not white’ expects the function to return true, but the function is supposed to return false in this case.

“has spurred years of refinining” (should be “refining”)

“What is WebAssembly NOT?”

Switching from positive claim to negative, it doesn’t flow well. Rather than trying to mirror “What is WebAssembly” it is better to contrast it - change it to “What WebAssembly is not!”

There is no “try and”, only “try to” :)

www(dot)blog(dot)givemesomeenglish(dot)com/try-and-vs-try-to/

I cannot copy/paste the text “rust uptarget add wasm32-unknown-unknown” - when I do it copies to the clipboard as “rustuptargetadd wasm32-unknown-unknown” which then obviously fails in the console.

Wording is a bit a awkward, the commas look like I am about to see a list of points when in fact it is an interjection:

“This allows you to nest modules, fosters some really good isolation and encapsulation practices, but it can….”
Peter Leslie Morris

Instead try
“This allows you to nest modules, and it fosters some really good isolation and encapsulation practices, but it can…”

“Since we put mod board in the root module (which is always called lib.rs in a library), the board module is one below the rustycheckers module (the root module name comes from the Cargo.toml file), and you can refer to elements defined in this module with the rustycheckers::board prefix. ”

I had to re-read this a few times to understand it. It’s a bit forwards/backwards/forwards in the depth of the concepts it is describing.

TRoot module => where root module is => sub-module => where to name root module => how to access elements within the sub-module.

The sub-module introduction should come after you’ve finished describe the root module. Try something like this (emphasis indicated with * before and after text)

Each Rust library has is a single root module, the name of this module is specified in the Cargo.toml file (the name setting under the section). By convention, the code for the root module is always found in the lib.rs file, so by including mod board; in the top of lib.rs we have declared a sub-module named board that exists directly under the root. Elements within this sub-module can be referenced from anywhere by using the rustycheckers::board prefix.

There are no carriage returns in the source code samples, so I cannot copy/paste the source. It ends up looking like this

#[derive(Debug, Copy, Clone, PartialEq)] pub enum PieceColor { White, Black, } #[derive(Debug, Clone, Copy, PartialEq)] pub struct GamePiece { pub color: PieceColor, pub crowned: bool, } impl GamePiece { pub fn new(color: PieceColor) -> GamePiece { GamePiece { color, crowned: false, } } pub fn crowned(p: GamePiece) -> GamePiece { GamePiece { color: p.color, crowned: true, } } }

Copy/paste the soure also copies the (1) (2) and (3) symbols when reading in PDF. Change layout so the source can be copied to clipboard without these.

x <= 7 && y <= 7

should also check >= 0

x >= 0 && x <= 7 && y >= 0 && y <= 7

“Its genesis moment is when a compiler written in that language is able to compile that language—a compiler inception”.

I’m not English native speaker, but

“its genesis moment is when a compiler of some language is written in that language—a compiler inception”
seems to better convey the idea.

To Peter Morris:

“x <= 7 && y <= 7” in the book is OK. Coordinate structure consists of usizes (which are unsigned), and as such x and y are always >=0, no need to additionally check it.

“wast” term appears to be used for the first time without definition or context. Suggest adding some description or orientation to the two WebAssembly formats (text and binary).

“In the case of those virtual machines, developers are spared the
effort of writing assembly or thinking in postfix (where the operator comes
first) notation”

I would have said that in postfix the operator comes LAST. Maybe I’m not understanding this properly. I have an old HP calculator that uses Reverse Polish Notation a.k.a. postfix. You type in “8 enter 2 +” and 10 pops up on the display. From the user’s point of view the operator comes last, but from the stack machine’s point of view the operator is popped first, so I dunno.

“wasm” should be “Wasm” according to the official specification.

Missing a final } in the first code sample.

Slight confusion.
On page 20 it states - create checkers.wat file. Page 21 says compile using wat2wasm. Compile as what, checkers.wasm or empty_module.wasm? It would be my presumption to compile as checkers.wasm, keeping consistency between source and destination files. The following objdump makes no reference to checkers.wasm but does to empty_module.wasm.
Where has the path code/checkers/ come from? There’s no mention of it prior to that point, nor has there been a reference to any other directory than the one we are working in.

Directly opening in the browser the file from the filesystem seems to work fine without need for and http server, Firefox 63.0.3, Archlinux.

Why do we have some
if (predicate)
then true
else false

Footnote link is now broken.

Need to include “copy-webpack-plugin” in package.json dependencies. The webpack.config.js file depends on this.

Building the release with the stable channel failed. I had to use #![feature(uniform_paths)] with the nightly (1.33) to get it working.

The colors on the chart explaining the AND operations are mixed up for both the Meaning and Result columns.

In chapter 1, we are taken through the installation of the tooling, but on this page, we are asked to create a single file called “checkers.wat”. Before this line, there is no indication of the directory structure of where the file lives, where the commands need to be run, etc. For a beginner who is going to read this book to learn about Wasm, I feel there’s a gap here.

From page 48, the “context” that the reader follows is being run on the parent directory of where the project was created using `cargo new —lib rustwasmhello` was being run. Suddenly, the instruction for `cargo build` command does not say where this should be run from. Missing a `cd rustwasmhello` command?

Unable to copy-paste the code block in the beginning of page 52 inside the function `crowned`.

Use a callout with a bolded title like “Pro Tip” for places where you want the reader to pay special attention. For eg, in page 61, you can put this whole sentence in such a callout: “In production-grade applications,…”

In latest version of wasm-bindgen, 0.2.29, the generated code differs slightly:
const ptr0 = passStringToWasm(arg0);
const len0 = WASM_VECTOR_LEN;
instead of
const [ptr0, len0] = passStringToWasm(arg0);

I had to install manually

webpack
webpack-cli
webpack-dev-server
copy-webpack-plugin

Why does one need to specify the namespace ROT for the draw function, and nothing is required for the Display type, if it is in the ROT namespace?

Source snippets can come with line numbers and syntax highlighting - there are online libraries that can do this in html, maybe use one of them in the PDF? This makes it easier to describe errata, etc when referring to line numbers.

The code snippet formatting for the `package.json` file are missing.

Clicking on the green strip for the “roguewasm/index.html” link renders the html page - as opposed to showing the raw html content. This is different from the behavior of the other code snippets throughout the book.

Need to add the copyright headers for the linked raw source code in each green background line. This is for all the files in this whole chapter - not limited to page 95 alone.

It says ‘wast’, but I think it should be ‘wasm’.

Originally:

But when you’re writing wast by hand, it could trip you up in unexpected ways.

I think the “lineary” was supposed to be “linear”.

“Your WebAssembly module can grow the lineary memory block in increments called pages of
64KB if it needs more space.”

I think it should be “assigning meaning to”

“Bit flags is a technique for assigning meaning individual bits within a number.”

For those, like me, who don’t know js/node/npm at all, it would be great to add the instructions for installing webpack, webpack-dev-server and html-webpack-plugin: `npm install —save-dev (webpack|webpack-dev-server|html-webpack-plugin)`. Otherwise, `npm run build` fails, and since these instructions were missing, I assumed `npm run build` would download these as needed.

Only js! macro is defined by stdweb, html is defined by yew.

The book says p112 app is served at /wasmchat.js but the index.html in the code given online and earlier in the chapter links js/app.js which is deprecated.

It looks like PubNub have changed how to create a chat app considerably.
Now they seem to want you to download SDKs and set up local environments for it all.

I tried to build the game locally but kept running into a runtime error in the browser console where the game would break after the first player move. After doing some digging I found that this will happen for anyone building from source with a recent version of the wasm-bindgen-cli binary installed, due to a recent change in the behavior of local JS dependencies, see RFC 6: github.com/rustwasm/rfcs/blob/master/text/006-local-js-dependencies.md

The existing bindgen syntax for stats_updated will not generate the needed ‘import’ statement in roguewasm.js, which causes an undefined method error at runtime. This can be fixed by moving the stats_updated function out to its own “extern” block and annotating the whole block with #[wasm_bindgen(raw_module = “./index”)]

Note the use of raw_module rather than module

See also: github.com/rustwasm/wasm-bindgen/issues/1343

Errors in commands and code

In wasmcheckers/index.js the moves appear to have the wrong x and y positions. The first one says black moves from (0, 5) to (0, 4)… but black doesn’t have a piece at (0, 5) and that isn’t a valid move anyway. Replacing it with (2,6) -> (3,5) makes a move.

In order to successfully build for the wasm target, it was necessary after rust installation to also install the build target:

rustup target add wasm32-unknown-unknown

In the second block of code on the page, after checking if a piece should be crowned, it lists the function to call as `call $crownPiece`` , but earlier in the book, this function is named `$withCrown`. The line should read `(then (call $withCrown (get_local $toX) (get_local $toY))))`

Not a bug :)

RE: errata #86696 by Ada, the book is correct. The $crownPiece function is different than $withCrown, and is defined on page 34 (at the bottom). On page 37, where Ada suggests $withCrown is the same as $crownPiece, $crownPiece actually first gets the piece by coordinates, then crowns the piece using $withCrown before emitting the $notify_piececrowned event. What’s printed in the book is what you want.