plan9port

couldn't find a version in UNIX V6, so I'm guessing this is one of the earliest versions of this program. It decides to read from stdin if the number of arguments fed to it is zero, and reads character by character using the standard C getc function. The busybox version ([git.busybox.net](https://git.busybox.net/busybox/tree/coreutils/wc.c)) of wc sits at 257 lines (162 with comments stripped), while striving to be [POSIX-compliant](https://pubs.opengroup.org/onlinepubs/9699919799/), meaning it has a fair number of flags and a bit of complexity. It reads character by character by using the standard getc function, and decides to read from stdin or not using its own fopen_or_warn_stdin function. It uses two GOTOs to get around, and has some incomplete Unicode support. The [plan9](https://9p.io/sources/plan9/sys/src/cmd/wc.c) version implements some sort of table method in 331 lines. It uses plan9 rather than Unix libraries and methods, and seems to read from stdin if the number of args is 0. The plan9port version of wc ([github](https://github.com/9fans/plan9port/blob/master/src/cmd/wc.c)) also implements some sort of table method, in 352 lines. It reads from stdin if the number of args is 0, and uses the Linux read function to read character by character. The [OpenBSD](https://github.com/openbsd/src/blob/master/usr.bin/wc/wc.c) version is just *nice*. It reads from stdin by default, and uses a bit of buffering using read to speed things up. It defaults to using fstat when counting characters. It is generally pleasantly understandable, nice to read. I'm actually surprised at how pleasant it is to read. The [FreeBSD version](https://cgit.freebsd.org/src/tree/usr.bin/wc/wc.c) sits at 367 lines. It has enough new things that I can't parse all that it's doing: in lines 137-143, what is capabilities mode? what is casper?, but otherwise it decides whether to read from stdin by the number of arguments, in line 157. It uses a combination of fstat and read, depending on the type of file. Finally, the GNU utils version ([github](https://github.com/coreutils/coreutils/tree/master/src/wc.c), [savannah](http://git.savannah.gnu.org/gitweb/?p=coreutils.git;a=blob;f...)) is a bit over 1K lines of C. It does many things and checks many possible failure modes. I think it detects whether it should be reading from stdin using some very wrapped fstat, and it reads character by character using its own custom function. So this utility started out reasonably small, then started getting more and more complex. [The POSIX committee](https://pubs.opengroup.org/onlinepubs/9699919799/) ended up codifying that complexity, and now we are stuck with it because even implementations like busybox which strive to be quite small try to keep to POSIX.

patch ssh to set TCP_NODELAY, because at the time ssh only set it for sessions with ptys [3]. TCP_NODELAY being off is a terrible default for trying to do anything with more than one round trip. When I wrote the Go implementation of net.Dial, which I expected to be used for RPC-based systems, it seemed like a no-brainer to set TCP_NODELAY by default. I have a vague memory of discussing it with Dave Presotto (our local networking expert, my officemate at the time, and the listed reviewer of that commit) which is why we ended up with SetNoDelay as an override from the very beginning. If it had been up to me, I probably would have left SetNoDelay out entirely. As others have pointed out at length elsewhere in these comments, it's a completely reasonable default. I will just add that it makes no sense at all that git-lfs (lf = large file!) should be sending large files 50 bytes at a time. That's a huge number of system calls that could be avoided by doing larger writes. And then the larger writes would work better for the TCP stack anyway. And to answer the question in the article: > Much (all?) of Kubernetes is written Go, and how has this default affected that? I'm quite confident that this default has greatly improved the default server latency in all the various kinds of servers Kubernetes has. It was the right choice for Go, and it still is. [1] https://github.com/9fans/plan9port/commit/d51419bf4397cf13d0... [2] https://news.ycombinator.com/item?id=34180239 [3] http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TM-65...

ll as adding "snippets" that can be executed with one click of the middle mouse button. Acme by itself is already plenty useful (`win` is part of the "standard distribution" so to speak, in that it is part of the various Plan9 forks and of plan9port), and a lot of extra stuff can be built rather quickly by hooking into its 9p interface: For example, my tool to add commonly used tools to the tag (the blue line at the top of each text window that contains the file name and commands that act on the window) is a handful of lines of shell script that parse entries in acme's `acme/log` file and select the appropriate tools to add based on the name of newly opened files. My Git integration is a thin wrapper around `win` and `git commit --interactive` that pops open a window that allows me to author a Git commit similar to (but a lot simpler than) magit for emacs and fugitive for Vim work. Even if you're not in Plan9 (or one of the forks), I encourage you to give [plan9port](https://github.com/9fans/plan9port)'s Acme a spin. (FWIW, this post was written in an Acme window because it's a lot more intuitive to use after some getting used to than regular ol' GTK text boxes used by Firefox.)