>It is gradually becoming acceptable to dismiss IPv6 and suggest searching for a modern, practically minded alternative. Important first step in untangling the mess.

>Naturally opinions vary as to what exactly would constitute modern. Common complaint is the significant mixing of OSI layers, in particular application level concerns like significant baggage of encryption & authentication. And then there's my pet peeve of BSD Sockets API incompatibility which was introduced accidentally.

https://news.ycombinator.com/item?id=37119627

For a couple minutes observed people coming up to a terminal, trying a few things, and stepping away in frustration.

I sure hope administration did restart the terminals overnight to return regular function; normal users were unable to access the power & reset controls.

All in all a very enjoyable post.

I've had a bug like that and the intuitive way to handle it turned out to be entirely sufficient.

The bug (deep in networking stack, linux kernel on embedded device) was timing sensitive enough that printk() introduced unsuitable shifts. Instead I appended single-character traces into pre-allocated ring buffer memory. The overhead was down to one memory read and two memory writes, plus associated TLB misses if any; not even a function call. Very little infra was needed, and the naive, intuitive implementation sufficed.

An unrelated process would read the ring buffer (exposed as /proc/ file) at opportune time and hand over to the developer.

tl;dr know which steps introduce significant processing, timing delays, or synchronization events and push them out of critical path

Yep, that is piracy indeed, even if done under the figleaf of "privateering".

Lastly, having a simple and narrowly specified conversion routines allows one to create a small sub-set of C++ standard library fit for constrained environments like embedded systems.

I had a bug like that in my previous (telcom embedded dev) career. Ended up driving to the customer premises (luckily mere 200km), working two weeks on collecting traces for the repro, and a day on the patch. Once I figured out how to trace the repro, the rest was trivial - the bug was glaringly obvious in the trace. Which in hindsight means I didn't really need to drive there at all, I merely needed to properly implement tracing the repro, and send the built artifact to the customer.

The problem would have been trivially solved if I had sufficient experience with tracing, or found a colleague with sufficient experience. However this one time the experience was bought & paid for with the trip.

http://en.wikipedia.org/wiki/Plan_9_from_Bell_Labs follows the Unix philosophy. A lot of legacy has been shed. I can count 13 options to ls, 11 options to sed and just 5 to sed.

The standard Plan 9 shell, Rc, is described in mere ~500 lines of manpage, while Bash takes whooping ~5400 lines.

Oh, and there is no `dll hell' in P9 :-)

    df -h ~

Having lucked into using Lilo and no initramfs for several years now, I'm very happy with robustness and straightforwardness of the solution.

In contrast, on the rare occasion I've dealt with somebody elses' GRUB and initramfs setups, they turn out brittle and complex.

I am in the happy medium where I can just as well bike or drive to work. It takes 2x to 3x as long (latency) to bicycle than to drive. Aside of slower speed, numerous latencies add up along the way - I can't time bicycling to hit green wave; I require brief but measurable time to dress into bicycling clothes and then to change at the destination, to park & lock the bicycle - nowhere near as quick as clicking the car's remote!. I know both modes, and while bicycling is better for my health and likely has higher throughput along my route, it certainly has higher latency. Which is the OG subject.

Lastly there's matter of variability: between occasional flat tire, the rare drained headlight battery, and other uncommon issues, my bicycle is significantly less reliable than my car. And that's in spite of heavy, and ongoing, investment into the bicycle - including well known puncture-resistant tires. This unreliability adds non-trivial variability to the latency.

As a side effect, this greatly simplifies the API for manipulating both.

There's an important distinction between mass of the vessel's own structure, the bare necessities like fuel, stores & crew, and its payload. Naval engineering and insurance talks several interrelated measures, for our purposes "light load displacement" is the closest to the weight of the bare structure, while "full load displacement" includes all typical stores, fuel, crew, and payload. Conversely the linked measures "gross weight tonnage" is measure of volume rather than mass, and less relevant for this discussion.

For combat vessels like USS Gerald Ford, most of the weight is in the structure itself, and while we don't have exact measures for the carrier, it's about 100,000 tonnes. For reference, an older generation but comparable carrier USS Nimitz has structure of 78280 tons ("light load displacement"), and all up weight 101196 tons ("full load displacement").

However for transport vessels like the linked Seawise Giant, the structure is small part of all up weight. While the ship plus cargo can go up to 646,642 long tons ("full load displacement"), the structure itself is much lighter: 81,879 long tons ("light load displacement").

Also the linked cruise ship, Icon of the Seas, has impressively high "gross weight tonnage" but again that's measure of volume. The displacement is a bit hard to find, people quote variously 100,000t or 120,000t without being specific light load or full load. So while the cruise ship is much larger by volume than the military vessel, the weight of the structure is closely comparable. The later is much more densely packed - keeping size down is a necessity for any combat craft, even the largest ones.

Oh they absolutely did. Even the early optimizing compilers discovered new pathways and created code that surprised even their authors. The only difference is that now regular people can see and appreciate what computers create.