fmt | Using f-strings ( PEP

Those are stray bytes like *, %, etc. prefixed with some of the lines.

The stray bytes appear to be a custom stream multiplexing protocol, allowing STDOUT and STDERR to be sent down the same connection.

Using stdcopy.StdCopy() interprets these custom headers and those stray characters are avoided by removing the protocol header for each piece of data.

Refer: https://github.com/moby/moby/blob/master/pkg/stdcopy/stdcopy.go#L42

According to the Go memory model:

https://golang.org/ref/mem

There are no guarantees that one goroutine will see the operations performed by another goroutine unless there is an explicit synchronization between the two using channels, mutex. etc.

In your example: the fact that a goroutines sees done=true does not imply it will see a set. This is only guaranteed if there is explicit synchronization between the goroutines.

The sync.Once probably offers such synchronization, so that's why you have not observed this behavior. There is still a memory race, and on a different platform with a different implementation of sync.Once, things may change.

If you plan to write a lot of WASM in Go, you might want to consider compiling with TinyGo, which is a Go compiler for embedded and WASM.

TinyGo supports a //export or alias //go:export comment directive that does what you're looking for.

I'm copy-pasting the very first example from TinyGo WASM docs:

From your question I understand that you want to build a time ticker program ,which would take number as input and invoke tick() method for those number of times .I have created a simple program for your scenario as follows:

Without seeing exactly how your Go code is written it's difficult to fully understand what you're doing on that side, especially since you stated:

So I'm 100% sure I'm doing it wrong within golang

However, as an example to fill in the blank, I'm going to make the assumption you're doing something like so:

Create int array with your IDs and marshal it and write it to your response.

Replace your last tree lines with following code and test.

Yes, it sounds like this book needs a better editor!

the channel capacity is indeed indicated as the 2nd argument to make:

So we have an actually correct answer here, the issue is that you're writing to the boolean but never reading from it. Without the Println(), it's not used in a conditional or any other expression anywhere that depends on its value, so the assignments to it don't affect the program flow. You could remove all of the lines assigning values to insideValley and the program would act no differently than it does right now (excepting the Println(), of course, which is why adding that "fixed" the issue).

Go is specifically designed to flag "junk" code like that, that adds nothing to the program flow, as a compiler error (well, in most cases. Unused globals and unused functions are some exceptions to that). Simply add in whatever is supposed to be using that boolean's value (such as a conditional based on its value), and you'll stop getting the "variable unused" error.

And as noted in the comments of Vishwa Ratna's answer, vars do not have to be used in every logical pathway. They only need to be used (ie. read from) in at least one logical pathway.

You're correct, fs.FileInfo implement the interface fileInfo!

However, that does not mean that you can assign a value of type []fs.FileInfo to a variable typed []fileInfo - these are completely different types.

In fact - the types cannot even be converted to each other, they are laid out completely differently in memory: interface values are a pair of {concrete type,data struct pointer}, and struct values are just what you see in the struct!

So, the short answer is that you have to do something like your loop which assigns values and appends them to the slice of interface values... behind the scenes what is happening is Go is creating an interface value for each of the struct slice elements for you, automatically.

A succinct way to say this all is: "Go interfaces types are covariant with the struct types that implement them, but slices of interface values are not type-covariant with slices of structs that implement those values."

For more info on slices of structs vs. interface types, see https://www.timr.co/go-interfaces-the-tricky-parts/