Errata

log.Fatal("error: %v", err) should be log.Fatalf("error: %v", err)

Item #2 reads: "Next, we create a slice with a length of zero. Since we know we’ll eventually add 10 items, we instantiate it with a capacity of 10."

However, the code is written as to never add more than 2 items to the 'queue' slice, so it's a bit confusing to initialize the queue slice with capacity of 10 and then more confusing to state that the it will eventually hold 10 items when in fact it only ever holds 2.

On page 88 you show an example with a `printData := func(wg *sync.WaitGroup, data []byte)` that supposedly offers confinement to protect access to the `data` variable.

You state:
> In this example, you can see that because `printData` doesn't close around the data sice it cannot acces it, and needs to take in the slice of a `byte` to operate on.

And further down
> Because of the lexical scope we've made it impossible[^1] to do the wrong thing
[^1]: I'm ignoring the possibility of manually manipulating memory via the `unsafe` package. It's called `unsafe` for a reason!

This method of confinement by passing a slice into a function like this isn't entirely safe. Due to fact that slices are pointers to arrays and `append` on a slice will reuse more elements at the end of the array if available it is possible that manipulate memory in a different part of the array accidentally, thus braking down confinement.

Here is a quick example showing my point, it closely mirrors your example, it doesn't use goroutines so as to make it easier to see what is happening but I think you will see my point.

```
func printData(data []byte) {
fmt.Println(string(data))
data = append(data, []byte("xxx")...)
}

func main() {
data := []byte("golang")
printData(data[:3])
printData(data[3:])
}
```

To truly ensure confinement you would need to make a copy of the array for each call to `printData`
```
func printData(data []byte) {
fmt.Println(string(data))
data = append(data, []byte("xxx")...)
}

func main() {
data := []byte("golang")
d1 := make([]byte, 3)
copy(d1, data[:3])
d2 := make([]byte, 3)
copy(d2, data[3:])
printData(d1)
printData(d2)
}
```

> 2. Here we make the producer sleep for one second to make it less active than the observer goroutines.

This should actually read “nanosecond”, not “second”. Or the code sample on the page before should be extended with a time.Second multiplier - but that would substantially change the outcome shown in the table.

The statement given in sentence is incorrect:

"Were it not for the clickRegistered waitgroup, we could colud call button.Clicked.Broadcast() multiple times...".

Goroutine started by "subscribe" will be executed only once and terminate. Subsequent calls to button.Clicked.Broadcast() will have no effect.

The callout numbering is incorrect.

4 should be 3,
5 should be 4,
6 should be 5,
7 should be 6,
3 partly corresponds to 7.

"8 calculators were created" should read "4 calculators were created".

I tested this by running the code.

We let the producer wait for 1s
This should not be 1s, it should be 1 Nanosecond

Line 2 of table should read:

"Open and Not Empty Value, true"

"...whether it be set by the languages community..."

should be -

"...whether it be set by the language's community..."

There is a line in the example:

case takeStream <- <- valueStream:

That should be:

case takeStream <- valueStream:

In the function "toString", the following line will of course panic if anything but a string is passed in:

"case stringStream <- v.(string):"

The text says "fanning means multplexing or joining together multiple streams of data ..."

Multiplexing is the fan _out_ part. The fan in is demultiplexing (or demuxing).

`buffer := buffer(done, 2, short)` should be error on compile time as both are not in the same type. (channel and function)

I assume the following is the intended code.

```
done := make(chan interface{})
defer close(done)

zeros := take(done, 3, repeat(done, 0))
short := sleep(done, 1*time.Second, zeros)
buf := buffer(done, 2, short) // Buffers sends from short by 2
long := sleep(done, 4*time.Second, buf)
pipeline := long
```

Instead of:

func BenchmarkBufferedWrite(b *testing.B) {
bufferredFile := bufio.NewWriter(tmpFileOrFatal())
performWrite(b, bufio.NewWriter(bufferredFile))
}


I guess should be:

func BenchmarkBufferedWrite(b *testing.B) {
bufferredFile := bufio.NewWriter(tmpFileOrFatal())
performWrite(b, bufferredFile)
}

So we don't need to wrap twice in a buffer.

indicate that CancelFunc is a function, and Context is an interface, e.g. change from:

type CancelFunc
type Context

to:

type CancelFunc func()
type Context interface { ... }

Though there's a function call to `isGloballyExec()` in the function `runJob`, this will be error on compile time, as `isGloballyExec` is in "lowlevel" package. The sample code should be:

```
type IntermediateErr struct {
error
}

func runJob(id string) error {
const jobBinPath = "/bad/job/binary"
isExecutable, err := lowlevel.isGloballyExec(jobBinPath)
if err != nil {
return err
} else if isExecutable == false {
return wrapError(nil, "job binary is not executable")
}

return exec.Command(jobBinPath, "--id="+id).Run()
}
```

"results" should be "workStream" ie

"We don't want to include this in the same select black as the send on workStream because..."

The paragraph talks about "nanoseconds" but the code is using seconds.

zeros := take(done, 3, repeat(done, 0))
=>
zeros := take(done, repeat(done, 0), 3)