How does the behavior of a buffered channel differ from my expectations in Go?

I am trying to understand how a buffered channel works and wrote a code snippet for it

package main

import (
	"fmt"
)

func squares(c chan int) {
	for i := 0; i < 4; i++ {
		num := <-c
		fmt.Println(num * num)
	}
}

func main() {
	fmt.Println("main() started")
	c := make(chan int, 3)
	
        go squares(c)

	c <- 1
	c <- 2
	c <- 3
	c <- 4 // blocks here

	fmt.Println("main() stopped")
}

As per how I expected the program to behave, the main goroutine starts and continues till c<-4, which at that point gets blocked and the control goes to square goroutine (as the buffer capacity is 3). The loop in the squares goroutine continues till 4th iteration at which point the channel is empty. A read operation on an empty channel is blocking and so the control goes back to main goroutine. At that point the write operation to the channel (c<-4) gets executed, we print "main() stopped" and the program ends.

Meaning I expected the output to be,

main() started
1
4
9
main() stopped

But I get an output,

main() started
1
4
9
16
main() stopped

How? Am I missing something about how exactly channels work?

That is not how channels work.

Goroutines run concurrently. That means when a goroutine sends to a buffered channel, another goroutine waiting to receive from that channel can receive it immediately. It does not wait for the channel to fill up.

As for the ending of the program, when you send the last number to the channel, there is no guarantee that the goroutine will pick it up and print the output before the program ends, because you are not waiting for the goroutine to complete. So, by luck, it runs and prints the output. There will be other executions where this does not happen, and the program terminates before the goroutine can print the output.

There is a race between main() and the goroutine after the goroutine receives the first value. Any execution order between main() and the goroutine is possible after that synchronization point.

Sprinkle in some calls to time.Sleep to observe the race. If the goroutine sleeps after receive, then it's probable that main() wins the race and exits before any squares are printed.

func squares(c chan int) {
	for i := 0; i < 4; i++ {
		num := <-c
		time.Sleep(100)
		fmt.Println(num * num)
	}
}

https://go.dev/play/p/x-3wiWwFQGj

If main() sleeps after the last send, then it's probable that the goroutine wins the race and prints the four squares.

func main() {
	fmt.Println("main() started")
	c := make(chan int, 3)

	go squares(c)

	c <- 1
	c <- 2
	c <- 3
	c <- 4 

	time.Sleep(100)
	fmt.Println("main() stopped")
}

https://go.dev/play/p/HIpRKdbA5qa

These are just two possible outputs from the program. The goroutine can print a value after the main() stopped is printed and before main exits. The goroutine can print between zero and four values.

I say "probable" above because the sleeps do not ensure the outcome described.