flohofwoe

More like Windows running in browser running Rebirth 338 (at least going by all the 'wine' in filenames) ;)

The webpage is loading an incredible amount of tiny compressed .js files (600 bytes each) which then decompress into 428 KBytes each, but then also loads two massive zip files (one around 100 MB, the other around 150 MB). I'd look into what's up with those tiny .js files, that can't be good for initial start time (it takes several minutes here on 50 MBit DSL).

Last I checked Norway doesn't have a border with the US ;)

Hmm, IME at least in emulators the switch tables usually have enough 'structure' that GCC or Clang have no trouble turning them into jump tables.

Well you check the compiler output and profile of course. But "generalized" performance advice like "use reverse loops" hasn't been relevant for a long time, it's a similar myth like "pre-increment is faster than post-increment".

C doesn't have an opinion, it allows negative indexing just fine when the index is a signed type (indexing-syntax is just syntax-sugar for pointer arithmetic).

> ...counting backwards in a for loop is faster...

Maybe in 1990 ;)

(it's one of many cargo cult wisdom snippets that have become mostly obsolete once C compilers got proper optimizer passes and CPUs got all sorts of pipeling tricks)

Eh I don't know, the straightforward solution is still to use a signed loop counter (and signed indices) and only ever use unsigned integer types for bit twiddling. Also, enable `-Wsign-conversion` (it's not in -Wall -Wextra) to catch all the places where the compiler implicitly converts between signed and unsigned behind your back.

TL;DR: "alomost always signed!" :)

> The introduction of the mouse led to developers paying less attention to keyboard shortcuts and function keys, but I don’t see anyone seriously saying computers should not have mice.

Well, a lot of devs did move back to the terminal ;)

> But the safe decision would be no to enter the train.

You might just as well never leave your bed, that's even safer ;) Train travel is much safer than travelling on roads, and in the same ballpark as commercial flight.

Safety systems don't help much when they fail themselves. E.g. usually there are automatic systems in place that prevent that two trains are on the same rail network section at the same time, but this system apparently has failed. Details are in the article.

How early it gets dark in winter depends on how far up north you are of course. On my latitude (Germany) it gets dark around 4:30pm and 5:30pm in winter, which for me is late afternoon (6:00pm would then be early evening)

Yeah same here, I don't even noticed the time switch this time. I remember it was worse as teenager, so maybe it affects young people more than old farts ;)

What? No! I find it utterly depressing to get up in the morning and it's still completely dark outside. A dark late afternoon is much nicer IMHO.

It's often used for more immediate 'consequences', like "Ich muß los, sonst verpass ich meinen Zug" (I need to leave, otherwise I'll miss my train).

True, but "wenn-dann-sonst" has a better "flow" ;)

Hmm, to me as native speaker, 'sonst' has pretty much only one meaning which is pretty much exactly 'or else'. There's a longer and 'more archaic' version 'ansonsten'.

The most likely German candidate would be 'sonst', which would be both in common use and short enough for a programming language keyword. E.g. the most like option for 'if-then-else' is 'wenn-dann-sonst', assuming that that German-origin theory is right of course.

One thing that's mostly forgotten today is that German had a very rich 'corpus' of wonderful nerdy computer science words up until the 1990s which unfortunately has fallen out of fashion. Nowadays it's a pretty terrible 'pidgin dialect' when Germans talk about programming and computers to each other (to a point where it's much less awkward to just speak English in the first place lol).

Maybe it comes and goes like the Touch Bar (yeah I know, quite unlikely, but one can dream) ;)

> Completely destroying any forward compatibility!

Microsoft breaking the ntdll.dll function interface is extremely unlikely, there's too much popular software in the wild depending on it.

> This is what RAII semantics in C++ are for.

...which typically has more overhead than a good GC though and much more overhead than using arenas for lifetime management.

That just means you haven't run into the problems yet that a global allocator brings with it. Other people have and welcome the better control over allocation provided by the Zig std library. The challenge is of course to balance convenience and flexibility. Also if you write code that prefers to not allocate in the first place (which should be the default), you're not affected anyway.

For me it's simply that iTerm2 got really fat over the years, and Ghostty was a nice and slim alternative - plus it has one of the better Kitty Graphics Protocol implementations which is fun to tinker with. e.g.: https://github.com/floooh/chipz-kitty (needs zig-0.17.0).

Why would you want greasy fingerprints all over your display and gorilla arm syndrome when there's a perfectly fine keyboard and touchpad attached to the display for free?

Hmm, still no OLED displays? I wonder what's the holdup? (I have a fairly mainstream PC laptop with OLED display, and the display is the one thing where my MBP looks pretty poor in direct comparison).

Yeah PC was a horrible platform before Win2k, but there was a beautiful short time period when we had alternatives like Amiga, Atari, NeXT and SGI (NeXT and SGI too expensive for the average nerd of course, but those machines played the same role as Ferrari or Lamborghini for the Opel Manta and Ford Escort garage tinkerers ;)

Fortunately "beauty lies in the eye of the beholder" ;) I definitely prefer the D3D model instead of the extension soup of GL or Vulkan.

Very interesting. Thanks for the insights! ...and yeah, Larrabee is an interesting case, I actually wonder whether it's time for another attempt :)

> don't forget that the drivers for GPUs would until recently get updates to patch specific video games for performance issues (not sure if they still do that ?)

I bet it's all the same if not worse, and that's why GPU drivers are closing in on the gigabyte "sound barrier" (and I guess on Linux that part is played by Proton... e.g. I bet there's a ton of game-specific 'workarounds' in Proton, if not for performance, then at least to fix 3D API misuse).

The rigid resource binding model via BindGroup objects in WebGPU is already outdated (and funny enough, an area where WebGPU is actually slower than WebGL2, at least when assuming that bindings need to change frequently and unpredictably).

This was a restriction of the Vulkan 1.0 API and modelling the WebGPU resource binding model around that was a quite predictable problem. It would have been better to come up with a slim abstraction that might cost some performance on Vulkan (which is only really relevant on Android phones and Linux desktops), but at least would not slow down WebGPU across all platforms.

And now even the Vulkan maintainers have realized the problem and are introducing the much more flexible descriptor-heap extension (about a decade late, but better late than never).

WebGPU is essentially the frozen cross-section of 3D APIs from about a decade ago, and the state of GPU hardware from about 15 to 20 years ago (but tbf, apart from the broken binding model there wasn't much that could be done, because most restrictions are coming from mobile GPUs which a browser 3D API simply must support).

> If they can’t program in C/C++ and debug the error messages how are they going to survive in the wild?

The problem is that you don't get *any* error messages from native GL in the first place (unless you wire up a debug-message callback via the optional KHR_debug extension which isn't available everywhere), and the builtin error system via glGetError() is pretty much completely useless.

Other APIs don't suffer from this problem, D3D, Vulkan and Metal all have excellent validation layers which give very helpful messages, and WebGL or WebGPU running in browsers basically implement such a validation layer out of the box.