1,764 karma · joined December 23, 2021
Still, compared to the SFP+ gear it's ridiculously overpriced. NICs are <$20 on ebay and an 8x10G port managed switch is $120 on aliexpress.
> Over here in NL we now get more and more access to >1gbps speeds
Same in France, yet the main "geek" ISP (free) has an 8Gbps symmetric ISP router with a 10G SFP+ cage for full bandwidth to the LAN. RJ45 ports are 2.5G.
And it's hard to fault them, as customers that are likely to even hardwire stuff to the router and moreso at 10Gbps are usually enthusiasts that do prefer SFP+ due to the abundance of hardware on the used market. Oh, and their team designing the router are a bunch of nerds that most likely all have a 10Gbps network.
The nexus line being more modern in spirit also helps. Catalysts still reject non-cisco optics without a configuration line afaik.
A good rule of thumb is whether the equipment tries to vendor-lock you in.
Another example that comes to mind is at least one generation of Intel NICs (don't remember if it's the 5xx or the 7xx), where even the open-source mainline (!) driver will reject the optic without a driver argument passed to it when modprobe'ing it.
This is precisely the premise for their library: I don't have the mental context to fit all the boilerplate in, nor do I have the brainpower to sift through it.
Sure, assembly is readable: every line is one machine instruction. But that's way too many details. On the other hand, C++ templates are not enough details.
Another fact is just the sheer power density of those problematic north virginia datacenters. I'd bet us-east-1 is not an issue (old building and lower power density), but the newer AI ones are. Just take a look at how much AI clusters eat: a single DGX H200 box with 8 GPUs is 10kW. Most facilities provide 10kW for a whole rack, not 8Us. You're looking at 60kW racks, which is a mental power density: a single aisle trivially gets over the MW threshold. You used to feed rooms with megawatts. Heck, DC5 has 24MW of power, that's only 20000 H200 (again, think hyperscaler scale).
Still about cooling, the load profile is even different. DC5 is a general purpose datacenter, where the load is not full blast. Your AI datacenter has the GPU clusters full blast all the time. That's a LOT of power.
I happen to know pretty well the Scaleway infra and visited others of their datacenters. You can stand centimeters from the noise-dampening wall surrounding the dry coolers and not hear a thing; while almost needing noise protection within the wall.
Granted, in this day and age, it's a disgrace to still make locks that can be shimmed. Especially when the shim-proof alternatives they show just have an additional notch to catch the shim.
But, now I do ENIG everywhere because it's often the same price as lead-free HASL (or so close it does not matter), while looking way cooler. I've started to take quite seriously leaded stuff now, especially since low temperature lead-free solder exists (SAC305).
I would argue that no, there are many valid cases for commands to not produce a final \n in their output. The first example that come to mind is curl'ing a REST API whose body is a single line of JSON. Many of those will not bother with a final \n, and this does not qualify as "garbled output" in my book. I would even go as far as saying that a shell just printing the prompt at whatever place the cursor happens to be is a side-effect of how terminal emulation works and the fact it's just a character based terminal.
This is actually something that Warp does pretty well, with a strong integration with the shell where your command is in a dedicated text box, by the virtue of it being GUI and leveraging GUIs. (I don't use it however, I'm too much of a sucker for dense UIs).
However I do agree with your argument that it's not the role of the shell to protect you against `cat /dev/urandom` or `cat picture.png`. And fish indeed does not try.
IMHO a shell is built for humans when in interactive mode (one of the raison d'être of fish), and the lack of final \n is such an annoyance that handling this specific edge case is worth it.
It took a while before noticing I had no more /dev/null on the machine (read: the time needed to fill the rootfs). In a panic, I removed the file.
Seeing the machine collapse due to /dev/null missing was fun.
Thank you
I'm curious about the Goroutine pinning though:
// Pin goroutine to specific CPU
func PinToCPU(cpuID int) {
runtime.LockOSThread()
// ...
tid := unix.Gettid()
unix.SchedSetaffinity(tid, &cpuSet)
}
The way I read this snippet is it pins the go runtime thread that happens to run this goroutine to a cpu, not the goroutine itself. Afaik a goroutine can move from one thread to another, decided by the go scheduler. This obviously has some merits, however without pinning the actual goroutine...Most websites abuse the latter two, and makes my mouse wheel spin like a meth addict without a dose.
Please keep the default font size. It's aligned with the system's size, and is precisely what a browser's zoom function will scale.
These fonts have not been designed for pixelated displays. Yes, it's better on Retina / HiDPI displays (I even enjoy some serif fonts on those), but those have to be designed with pixels in mind. But they usually are atrocious on "classic" pixel densities.
And tangent: the print industry has a much wider typeface selection than "just" Times New Roman, which is rather rare in my personal experience (sample size of one, though).
For example, Rust iterators are lazily evaluated with early-exits (when filtering data), thus it's your first form but as optimized as possible. OTOH python's map/filter/etc may very well return a full list each time, like with your intermediate. [EDIT] python returns generators, so it's sane.
I would say that any sane language allowing functional-style data manipulation will have them as fast as manual for-loops. (that's why Rust bugs you with .iter()/.collect())
Also, as mentioned by another comment, an HTTP or crypto library can become obsolete _fast_. What about HTTP3? What about post-quantum crypto? What about security fixes? The stdlib is tied to the language version, thus to a language release. Having such code independant allows is to evolve much faster, be leaner, and be more composable. So yes, the library is well maintained, but it's tied to the Go version.
Also, it enables breaking API changes if absolutely needed. I can name two precendents:
- in rust, time APIs in chrono had to be changed a few times, and the Rust maintainers were thankful it was not part of the stdlib, as it allowed massive changes
- otoh, in Go, it was found out that net.Ip has an absolutely atrocious design (it's just an alias for []byte). Tailscale wrote a replacement that's now in a subpackage in net, but the old net.Ip is set in stone. (https://tailscale.com/blog/netaddr-new-ip-type-for-go)
Translating this to uv, this will streamline having multiple python packages in the same directory/git repo, and leave e.g. vendored dependencies alone.
Also, since their goal really is "making cargo for python", it will likely support package-scoped ruff config files, instead of begin file- or directory-based.
Nobody would write the configuration parsing code by hand, and just use whatever TOML library available at hand for Go. No INI shenanigans, and people would just use any available stricter format (strings must be quoted in TOML).
So yeah, Rust and Go and Python and Java and Node and Ruby and whatnot would not have the bug just by virtue of having a package manager. The actual language is irrelevant.
However, whatever the language, the same hand implementation would have had the exact same bug.