Errata

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

> 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)