Errata

walk := func(walking *sync.WaitGroup, name string) {
var out bytes.Buffer
defer func() { fmt.Println(out.String()) }()//
defer walking.Done()// These 2 defer statements should be reversed to print the result all the time.
fmt.Fprintf(&out, "%v is trying to scoot:", name)
for i := 0; i < 5; i++ { 1
if tryLeft(&out) || tryRight(&out) { 2
return
}
}
fmt.Fprintf(&out, "\n%v tosses her hands up in exasperation!", name)
}

The generator function takes in a variadic slice of integers, constructs a
buffered channel of integers with a length equal to the incoming integer slice,

This sentence may be incorrect, as in previous demo, it create a unbuffered channel other than a buffered one with following code.

instStream := make(chan int)

Note from the Author or Editor:
Thank you! I have corrected the code rather than the sentence. I had intended for the `generator` function to use a buffered channel, but this must have gotten lost somewhere along the way.

I would think that the workCounter/Sleep operations would be placed inside the default case to simulate work to be done while waiting for the done channel to close as opposed to being part of the for loop.

Note from the Author or Editor:
Thank you for the comment! Semantically, the code as written and your suggestion are the same. As it is written, the `select` statement will fall through to the `default` clause and then exit and the remainder of the loop body will execute. It comes down to preference, and I like to limit indentation where possible, so I enjoy writing it as part of the loop.

In the sentence "now that we have four goroutines", it says there are 4 goroutine in the sample shown above, it should be eight goroutines, as the number of goroutines should be the same as `runtime.NumCPU()`, which is eight.
The previous paragraph also says "We now have eight goroutines..."

Note from the Author or Editor:
Oops! This is the consequence of writing portions on different machines which have a different number of cores.

The printed version is `long := sleep(done, 4*time.Second, short)`, but should this be `long := sleep(done, 4*time.Second, buffer)` instead?

In the source snippet before the 5th paragraph, the function name is `wrietTallyToState`. However, in the 5th paragraph, it's written like "...call to `writeToState`".

I grepped `writeToState` in chapter 5, the line is the only place where `writeToState` is mentioned.

I'm not sure the original intention for the function name, these 2 should be consistent.

Note from the Author or Editor:
Thanks, corrected.

In the sentence "the goroutines will sleep for a random amount of time between one and six nanoseconds to simulate load", the order of sleeping duration is "nanosecond", in the example code, the duration is set in "second" order as the following:

simulatedLoadTime := time.Duration(1+rand.Intn(5))*time.Second

In the sentence "Later this will help stress our `APIClient` and exercise our rate limiter", though the variable "APIClient" is mentioned, it doesn't come up in the source code samples in the book. I think it should be "APIConnection".

I grepped the whole text in the book and I only found 2 lines where "APIClient" shows up, both are not source code snippets.