dom0

Because this site is clearly in need of 250 KB surveillance JavaScript.

So even this "plain text" site still transfers ~98 % bloat and just ~2 % content.

Stress relief. Thermal / moisture expansion of the PC board (and this looks like shoddy phenolic paper) bends the leads a tiny bit and the bending forces go through the component. By making the leads longer, they are less stiff and require less force to accommodate, so less drift due to this.

It was a relatively common method in precision electronics.

There could be other reasons as well, e.g. if these were ceramic capacitors they might do that to avoid cracking issues. (Because ceramic capacitors drift a lot by themselves, a drift/precision explanation does not make sense)

Not any more, of course. It also deserves to be mentioned that lots of higher-end equipment used a lot of custom parts, and not always out of necessity (like custom µPs in HP multimeters, or stuffing solenoid drivers into unrelated hybrids ... and of course anything handling higher frequencies almost always used some custom chips or selected transistors hidden behind opaque part numbers).

Sometimes there are still schematics, Agisight still does it e.g. for low-end power supplies.

I've failed to track down who invented it; but a 1993 patent by Schlumberger describes this already as prior art (US5237540).

Very clever...

Things like the Carlo Verre hack (also a thing you can't change —any more— in Python: builtins), editing objects during their construction (via e.g. gc)... generally, the gc module allows other ways as well to crash your interpreter.

    >>> import gc
    >>> 'foo'.lower()
    >>> gc.get_referents(str.__dict__)[0]['lower'] = str.upper
    >>> 'foo'.lower()
    segmentation fault (core dumped)  python

(That's the method lookup cache)

A talk in this direction is https://www.youtube.com/watch?v=qCGofLIzX6g

> "Python is inherently harder to optimize than JS since it has <very dynamic features>"

Python is not a very dynamic language in the sense that you actually can't change a lot of stuff (and a number of the things you can change just segfault CPython). I think JS is more dynamic, for example. Or Ruby.

You seem to assume that a comprehensive test suite exists...

Congratulations, your "white hats" just earned five years prison each.

With a fixed n, GCC does get it right as well (kinda has to, because that's the only portable way to do fixed rotations in C). I'd sort it under range analysis.

Formal parsers do without indexing, but those rolled by hand often do, for simplicity's sake. I think these cases can still be serviced by permitting indexes, but backing them by a lazily computed index table.

Delete cartridge, fill in paint directly, and voila we are talking about a high throughput ink printer. These don't have, or at least didn't use to, cartridges, they draw ink from tanks and wet an ink sponge with it.

There are multiple projects providing user-space file systems for Windows, dokany and WinFSP for example.

> That said, isn't it true that Windows drivers are userspace-based, anyway?

No.

> * Newer languages expose strings as an array of Unicode code points, which is cleaner because it's independent of any particular encoding.

Don't do that (the array part). Guaranteeing O(1) indexing isn't very useful but precludes efficient storage.

> the only downside [is] that there is no good option to enforce HTTPS

You also have to use GitLab.

LE doesn't work here. As the fine article points out, GitHub Pages does not support TLS on custom domains. With CF, this works.

For the sort of thing that you'd host on GHP, this is totally fine in my opinion. In fact, because CF is a pretty good CDN it likely accelerates page load times considerably for Non-Americans.

(I wish it'd be possible to do something similar for readthedocs, which only has one origin and it's located in North America, but alas this doesn't really work).

POSIX and Linux are generally believed to be different entities.

Doesn't matter, the stable interface in Linux is the syscalls, not the libc. Same goes for WSL.

llpp, depending on your definition of "fully formed".

And there is/was a tiling window manager, but everyone I know who used it at some point migrated away because the configuration was Haskell as well.

So far they only announced to go with a heavily modified ARM ISA for their next-gen supercomputer (forgot the name), while saying yadda yadda remain committed to SPARC yadda yadda. At least as far as I know. Probably still means life-support-only for SPARC.

As far as I know Oracle stopped developing SPARC systems, it is all Fujitsu now, including the chips.

Since OMP Tasks it is kinda useful for non-numerical non-trivial applications as well, though still kinda... odd. Odd but neat.

> fewer features

My two 0.02 € on this:

Features have external and internal complexity. External complexity is documentation, usage, support while internal complexity is time spent on maintenance and development, increased complexity of the code, reduced stability etc.

External and internal complexity are unrelated, and when deciding whether to add some feature both must be considered against the assumed advantages of the feature.

Somewhat related household tip:

When something wooden cracks or breaks and needs gluing, but you don't have any wood glue at home, you don't need to buy any. Just dissolve a sheet of gelatine (which you do have, no? :) in a bit of water and warm that in a water bath for five minutes. Use a brush to apply some of that to both glue sides and press it firmly together. As an added bonus, these glue joints become soft at ~50-60 °C, so can be fixed up later again. Structurally, it's pretty much as strong as any wood glue.

Well that's stretching the meaning of second sourcing quite a lot. Normally it means that you can get an exact replacement part from someone else. For example, industry standard things like nuts, bolts, ball bearings, SRAM and DRAM (most stuff specced by JEDEC) can be sourced from many sources. There is literally no difference at all between a M8×20 8.8 bolt between manufacturer A and B. Similarly, if you have a design with a LM358 (a non-standardised part), then there are multiple manufacturers that will sell you a part with identical specs under a slightly different name or even the same name.

This is also the way it started with x86 and other second-sourceable processors. An Intel 8086 and an AMD 8086 are drop-in compatible. This is not the case with modern processors, they don't even fit the same sockets.

The memory ECC is a tiny bit of logic right next to all other memory logic in the MC, it seems very far fetched to me that there would be a binning process for specifically the instance of that logic being broke but the data logic next door working just fine.

Note that the ECC on the processor's internal data buses and caches is completely independent of whatever ECC the memory controller may or may not use.

I own two SPARC servers (a 2003ish V245 and a 2007 T5120) and both are rather ridiculous ... idle power draw for a V245 is like 240 W and just 150-180 W of that are the fans. [1] A T5120 draws some 180 W idle as well. Especially the latter was also heavily marketed as green computing / efficient data centres / throughput computing. Completely ridiculous offering at the time.

Needless to say, I didn't even bother to set these up lest build a rack for them (my normal rack is both full and too short). If packaging weren't so annoying with computer servers I would've sold them long ago.

[1] The good stuff. High static pressure, high flow fans from Delta with ball-bearings, and of course only speed monitoring, no regulation. These Sun servers make for excellent magnet boards for holding papers just without using any magnets.

No, if you try this with the various optimization levels you can see that it's not a bug; without optimization it doesn't happen. Instead what seems plausible to me is that some optimization pass analyses the possible values for "Do", which is tractable, since it's static and can't be aliased. Because the value must be initialized before Do() the optimizer seems to unconditionally use the only possible initialization, even if it is unreachable.

With -O1 you can see that this part already happens. With optimization cranked further up it just inlines EraseAll, and EraseAll ceases to exist as a separate symbol. This is possible since Do is static and not aliased. Meanwhile NeverCalled continues to exist as a retq, since it is not static.

Gasoline engines can be plenty reliable. I think the main reason why a lot of cars from the 80s and 90s are able to go to 400k and more is (1) cheaper and easier maintenance, so more inclined to do it regularly (2) no fancy shit going on, no turbo chargers, no high-pressure fuel injection, thus far less wear on parts, no unreliable high-pressure pumps etc.

Replacement parts on these are also far more expensive. New turbo is a four-figure number just for the part. Injection pumps are bloody expensive, too.

Less optimized designs may also be a factor. CAD and FEM modelling has only become better with time, so back in the day engineers would rather make a more conservative design, nowadays that's not so necessary any more.

> The same forces are at work on Python (or Ruby, which gets faster at every iteration.)

Python performance has been one step forward two steps back. For example, dict() has significantly evolved over time and some other things became faster as well, but most stuff just becomes slower as more stuff is added or previously native code is replaced by pure Python (see io in 3.0, which was reverted, or import).

Ditto for Python application performance. Python has exactly no zero-cost abstractions, so when something is refactored to use classes or big methods are split up, the result is almost always slower than before.

> human-centric temperature scale

One point (100 °F ~ 37 °C) doesn't make a scale.