Mark Tomczak @mtomczak@qoto.org

The zen of #cplusplus is that there is no zen. Every codebase is unique, no two large projects share every convention, and there are quirks everywhere. You'd no sooner expect two C++ codebases to conform to each other than you'd expect two families to have the exact same customs, tastes, and taboos.

The language is optimized for two things: making memory manipulation very explicit and, in that context, making the quirks from having every codepath make up its own rules for memory manipulation be tractable.

How to remote-shell connect from a Linux to Windows machine using VSCode.

https://blog.fixermark.com/posts/2023/vscode-linux-to-windows/

People predicting the death of information online through the use of ChatGPT-powered falsehood-generators as if I'm not spending my days slogging through an eternal stream of human-generated-and-curated plausible falsehoods.

Bad news: we don't need an AI; we already Mechanical Turk'd this problem by building a system to let everyone put stuff on the Internet. 😉

The Lemony Snicket Limit is the value asymptotically approached by summing a (finite) series of unfortunate events.

The theorem that you will never reach the Lemony Snicket Limit by summing a finite series of unfortunate events is the Lemmany Snicket.

"Yeah welcome to the club pal." #chatgpt #bing

Y'know... Linux kinda sucks as a development environment.

I'm working on a project that just upgraded one of its dependencies to glibc_2_32. But my development machine is a tiny laptop running Ubuntu LTS 20.04.

It looks like the simplest way to keep up with this project is going to be the plunk down $2,000 on a new laptop because Lord knows I am 0 for every attempt on upgrading the version of Linux on a laptop without losing half of the functionality in the laptop hardware (sleep, sleep on lid close, power management, all that stuff).

I use Linux for the flexibility. Take that away and it's a really crummy user experience---badly-tuned and ill considered for the way pieces of software interact with each other. And in this case, the flexibility just isn't there.

Windows, meanwhile, maintains backward compatibility nearly to the Reagan administration.

I'd been away from #cplusplus for long enough to forget how *bad* it is at discoverability.

Most languages that came after learned the lesson about using well-defined (if verbose) module naming to point to the origin of something, and if a client (module importer) wants to rename a module for convenience it may but if it doesn't the pattern is standardized. The best (read: my favorite) languages went ahead and glued module access to the filesystem organization so you can guess, easily, what file a given module loads; while you can sometimes play games with that, it gives you a starting point.

C++ is a billion years old and benefits from none of those learnings. The namespaces are completely disjoint from the filesystem. Literally any file included *from any file you include* can dump new symbols into your context. That was fine for, like, eight-file projects, but on modern thousand-file projects it's nightmare-time unless your team develops a rule for keeping sane, therefore every team does and every team's rules are different.

Good bloodly luck figuring out where a macro like TEST_CASE is defined if the project creators didn't document their thought process.

#superbowl

Someone should let Google know that "We are the arbiters of history" is probably not the vibe they want to broadcast right now. #superbowl

(*DISCLAIMER* That was really, really stupid of me; do *not* test safety limits on live test subjects, even yourself. It ended badly for Dr. Jekyll and it'll end badly for you.)

#frc Screwed up my toe having the robotics team test a safety limiter we added on my body.

To the team's credit, the code did exactly what it was supposed to and the robot hit me exactly as anticipated.

... Except that instead of catching the bulk of my foot, it hit right on the nail of my big toe.

Broadly speaking, computer user experiences have bifurcated into two kinds:

* Those that do not assume the user knows anything about computers and must therefore spot-check every operation ("Do you wish to install X, the thing you just told me to install by clicking the 'Install X' button?")

* Those that assume the user knows a lot about computers, verifies that by having an obtuse interface documented elsewhere, but then backs off when the user tries to do things.

This API has like a dozen classes that implement a `double calculate(double)` method.

None of them implement an interface. Every time I want to switch between them, I"m either writing my own jank wrapper class or changing all their constructors and variable types.

Sometimes I hate this hell language. #java

I never write fiction.

But sometimes, an idea just won't get out of your head until you slam-dunk it into some prose.

This arrangement is not a bad thing per se; it's probably actually good that web core techs move relatively slowly and things that are mostly developer sugar live in the toolchain.

... it just means that, yeah, the toolchain to write modern web sites *is* complicated. It's bridging about eight years of feature-gap between what developers want to write and what browsers are capable of reading.