Comment by Teckla
3 years ago
In my opinion, the Principle of Least Surprise applies here.
Go is defaulting to surprising (unexpected) behavior.
3 years ago
In my opinion, the Principle of Least Surprise applies here.
Go is defaulting to surprising (unexpected) behavior.
I think also “least surprise” depends on your background. In Go, also files don’t buffer by default, contrary to many languages including C. If you call Write() 100 times, you run exactly 100 syscalls. Intermediate Go programmers learn this and that they must explicitly manage buffering (eg: via bufio).
I don’t think it’s wrong that sockets follow the same design. It gives me less surprise.
that Write() doesn't call fsync() though, does it?
so there's no buffering going on in the application, but the bytes almost certainly don't hit the disk before Write() returns
they've just been staged into an OS buffer, with the OS promising to write them out to the disk at a later time (probably, maybe...? hopefully!)
which is exactly the same as a regular TCP socket (with Nagle disabled, i.e. the default, non Go way)
For userland programming, what matters is the syscall level, as that is expensive (and also the API you have for the kernel). Whether the kernel then does internal buffering is irrelevant and uncontrollable beyond any other syscalls which may or may not be implemented (maybe you're running on a custom kernel that doesn't buffer disk writes?).
One write == one syscall, easy. If you want buffering, you add it.
1 reply →
I think my C is getting rusty, but "write" operates on a file descriptor, doesn't it? It's unbuffered. The buffered versions are things like printf and puts.
That's POSIX; C's equivalent is a FILE, which generally is buffered.
I thought Linux does in kernel buffering with `write`
Only if you know that Nagle's algorithm exists and is used everywhere. For anyone with networking experience it's unexpected, but I still remember learning about Nagle's algorithm when trying to fix latency on a game server I was hosting as a teen. That was surprising behavior to me at the time.
Articles with titles like "How I spent 3 weeks discovering that Nagle's Algorithm exists" are a HN staple. Turning off Nagle follows the principle of least surprise. This article is the first time anyone has ever written about being surprised by Nagle's Algorithm being off.
Have you ever had to chase down strange latency issues? Arguably, this behavior is the least surprising for Go's typical deployment environment.
Twice I have run into this behavior having known and forgotten it. Chatty non http protocols with a few small messages doing auth or whatever before bulk data flow. Pissed me off and surprised me. Now I make sure my defaults for any framework I am using are no delay, and I make sure to plug my computing device into Ethernet whenever possible.
In my experience, you usually don't want to be Nagling in code that lives in a datacenter. Go's default is likely set up around that idea.