gopl.io | Example programs from `` The Go Programming Language | Functional Programming library

A full slice expression can set capacity short of the full underlying array.

You are right, zcap < 2*len(x) is equivalent to len(x) > 1. You could totally replace zcap < 2*len(x) with len(x) > 1 in this function.

But according to the source code, There is another function named appendslice. In this function, you couldn't do a replacement.

I think author use zcap < 2*len(x) only for keeping two function consistent. The main purpose here is to avoid frequent allocation.

It is because they need to be assigned value after they are created. The order of actions is:

1. Create variable var n = flag.Bool("n", false, "omit trailing newline") The value is false now.
2. Assign value with flag.Parse(). Variable is now assigned value passed as command line argument.

How go keyword works in Go, see Go_statements:

The function value and parameters are evaluated as usual in the calling goroutine, but unlike with a regular call, program execution does not wait for the invoked function to complete. Instead, the function begins executing independently in a new goroutine. When the function terminates, its goroutine also terminates. If the function has any return values, they are discarded when the function completes.

The function value and parameters are evaluated in place with the go keyword (same for the defer keyword see an example for defer keyword).

To understand the evaluation order, let's try this:

It's very easy to tell.

Your channel is unbuffered (you didn't specify any buffer size when make()ing the channel). This means that a write to the channel blocks until the value written is read. And you read from the channel after your call to wg.Wait(), so nothing ever gets read and all your goroutines get stuck on the blocking write.

That said, you do not need WaitGroup here. WaitGroups are good when you don't know when your goroutine is done, but you are sending results back, so you know. Here is a sample code that does a similar thing to what you are trying to do (with fake worker payload).

You understand that b.N has a really big value and thus Echo1 gets executed many many times ? The only explanation is that Echo1 is printing the text you are seeing.

Your Echo1() function probably contains something like this:

When c.NextSibling is not nil, it seems that the loop is exiting as the loop value is the same as the previous iteration

Not sure what you meant by that, but yes, you're misinterpreting something. But for loop is not to blame. It most certainly does not exit while its continue condition is still true.

Why is “MOVQ 0x30(SP), DX” slow?

You have provided insufficient evidence to show that the instruction is slow.

MOVQ — Move Quadword - is an instruction from the Intel 64 and IA-32 architectures instruction set. See Intel® 64 and IA-32 Architectures Software Developer Manuals

The MOVQ 0x30(SP), DX instruction moves the 8 bytes of a tree.value variable from memory to the DX register.

Performance measurement, like any other scientific endeavor, relies on reproducible results. You have provided insufficient information to reproduce your results. For example, where is the code for treesort_bench.test.exe, what processor, what memory, what operating system?.

I've tried, but I'm unable to reproduce your results. Add your code and the steps to reproduce your results to your question.