>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.
At my old uni there were a couple public terminals running DOS, most of the time sitting idle at the prompt. It was bespoke kiosk cabinets only exposing keyboard and screen. One April Fool's I had the bright idea to change PROMPT to something along the lines of "This terminal out of service." - and to increase the confusion, also to change PATH to a non-existent directory, so that most commands wouldn't work and instead flash "Bad command or file name.".
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.
In which Jerf longs for PHP.
Every single point has been in, and actively used, for a long while.
The __call() & friends is particularly nifty - simple mental model, broad applicability, in practice used sparingly to great effect.
>printing also will likely impact timing and can change concurrent behaviour as well.
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
For sake of example: a "locale-aware" number conversion routine would be the worst possible choice for parsing incoming network traffic. Beyond the performance concerns, there's the significant semantic difference in number formatting across cultures. Different conventions of decimal or thousands coma easily leading to subtle data errors or even security concerns.
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.
>Unless it's one of those cursed things installed at the customer thousands of miles away that never happens back in the lab.
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.
To further expand upon this, quickly ascending to high altitude (flying airplane or balloon) after diving is also dangerous, for the very same reason. Pilots are trained to wait out at least 24 hours after a dive, or at least 12 hours if the dive didn't require decompression steps.
It is sad to see the correct reply grayed out.
This kind of regulation is known to breed corruption & abuse, tilting the field heavily towards the highest spenders. Can only be enacted when ideology trumps well established knowledge & experience.
The article is about latency, the GP is about latency, you instead pivoted to throughput. Of course throughput can be made arbitrarily high when you don't measure latency. Doesn't help your case at all, quite the opposite.
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.
I particularly like how in Acme, when selection is zero-width ("empty"), it is the cursor. Conversely selection can be extended from cursor in any direction.
As a side effect, this greatly simplifies the API for manipulating both.
Love this. Aligns with some of my recent musings.
Even better, it would be largely immune to certain recently discovered problems with AI, including ingesting AI-generated content.
Surprisingly the difference isn't quite as it seems.
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.
>Computers and other automations never made creative decisions before
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.