palordrolap

This has bell curve meme vibes. I’m just not sure what the middle guy would be saying.

Is it still the norm to go to the dev’s office, yank their power cord and when they ask what we’re doing, tell them we’re shipping their machine to the client because it’s the only one that the code runs on?

And can we do that with whatever server ChatGPT-4o is running on?

I’m assuming that this response from 4o isn’t real and was invented for the laugh, but it would be tempting to throw this scenario at it if it decided to give this response.

My guess is a “solution” to the age-old problem of needing to store a secret in a file that the user can download, thus making the entire system insecure.

This “solution” appears to be either that the string itself is so outrageous that the user would not believe that it’s the real secret when it is in fact the real secret, leveraging security through obscurity, or else it’s there in place of the real secret that cannot be revealed under pain of death firing, and therefore is accidentally being used instead of that intended secret… so it’s not secret after all.

Unless they’re doing something incredibly clever to substitute that secret string for the real thing when the time is right and doing it in such a way that the user can’t intercept, someone’s getting fired.

Someone told me every processor used 0xEA

Not sure if this is a riff on the joke or not.

Back in the day I dabbled in 6510 code, and up until today hadn’t even bothered to look at a chart of opcodes for any of its contemporaries. Today I learned that Z80 uses $00 for NOP.

Loth as I am to admit it, that actually makes sense. Maybe more sense than 65xx which acts more like a divide-by-zero has happened.

The rest of the opcode table was full of alien looking mnemonics though, and no undocumented single byte opcodes? Freaky, man.

But the point is that not even Z80 used $EA. If the someone was real they probably meant every 65xx processor.

Someone else points out that Python’s native bool is a subtype of int, so adding a bool to an int (or performing other mixed operations) is not an error, which might then go on to cause a hard-to-catch semantic/mathematical error.

I am assuming that trying to add a NumPy bool_ to an int causes a compilation error at best and a run-time warning, or traceable program crash at worst.

80 characters

Two hours and no-one’s challenged this? People must be asleep.

(This is not that challenge. Only pointing out that someone usually has by now.)

Comparing audio cassettes to modern high-density tape storage is pretty much the same comparison as an 8-bit computer with a modern 64-bit server, or, say, a hamster with a human.

Basically the same thing, but the differences are somewhat notable.

512KB? At the risk of going all Four Yorkshiremen, that sounds luxurious.

Floppy disks held 170KB if you were lucky to have a drive. The PET line, like many 8-bit computers, used a cassette tape drive (yes, those things that preceded CDs for holding and playing music). Capacity depended on the length of the tape. And it took ages to load.

The PET was fancy because it had a built-in cassette drive. That’s what you can see to the left of the keyboard in the picture.

Wow. I totally forgot that Commodore BASIC ignores spaces in variable names. I do remember that it ignores anything after the first two letters though. That said, there’s a bit more going on here than meets the eye.

PRINT HELLO WORLD is actually parsed as PRINT HELLOW OR LD, that is: grab the values of the variables HELLOW (which is actually just HE) and LD, bitwise OR them together and then print.

Since it’s very likely both HE and LD were undefined, they were quietly created then initialised to 0 before their bitwise-OR was calculated for the 0 that appeared.

Back in the day, people generally didn’t put many spaces in their Commodore BASIC programs because those spaces each took up a byte of valuable memory. That PET2001, if unexpanded, only has 8KB in it.

</old man rant>

In some interpretations of “bug-driven” programming, no file, or perhaps an empty file, is an instance of the zeroth-bug: The project does not exist.

One could argue that this bug zero is the true ancestor of all other bugs. There’s something satisfyingly set-theoretic about it.

Different Strokes might well be more of a Gen-X thing. I remember it being on TV (in England) when I was a kid and remember recognising Gary Coleman when he showed up in the '80s Buck Rogers TV series, but I was very young at the time. Pre-school age definitely.

Also, the younger cast of Scrubs are Gen-Xers and they definitely threw in a few references to it.

But let’s not forget that years-later re-runs were and still are a thing, even on the handful of channels that most people had back then, so there are bound to be some people younger than Gen-X who also grew up with those shows as their parents enjoyed them the second time around.

The iPod got me. Never had one. Never had a friend who did. This could be a Gen X experience or a cash-poor Millennial experience. If it hadn’t been for the hint I would not have got past that part.

I also didn’t have that particular Nokia so it took me a moment to figure out which button deleted mistakes. Mistakenly thinking that the CAPTCHA designers might not have implemented that part of the interface didn’t help.

Had to guess on the boomerang. I’ve seen boomerangs but didn’t know that’s what they’re called nor have I ever posted one. Again, this could be an “I don’t post on that platform” or an “I only post pictures and haven’t used that feature” experience. I definitely have an account on at least one platform that hosts them though.

I am technically not a Millennial. The term for my cohort is Xennial, I believe.

Depends on how you define “scripting language”.

Older techs remember when it was only browser-based and they thought of, and perhaps still think of, “scripting languages” as something that would run from some command-line or another. Starting a GUI browser to run a mere script was a ridiculous concept. (There was also that JavaScript had no filesystem access. At least initially. And then it became a gaping security hole, but I digress.)

Today, there exist command-line accessible versions of JavaScript but even there (I figure) most people wince and choose anything else instead. Maybe even Perl.

But another definition of “scripting language” is “(any) interpreted programming language” and where it runs is unimportant.

From that perspective, sure, JavaScript qualifies. And so does QBASIC.

In some languages
a newline does not
necessarily indicate
the end of a statement.

In others, sometimes it could, but would leave things ambiguous
as to whether the statement was ended or not.

And so, punctuation is necessary.

Perl:

Just another Perl hacker, (sic)

This was coined by Randall Schwartz on Usenet a very long time ago. The comma has become part of it despite it originally being necessary for the English sentence it first appeared in.

Part of being a Perl aficionado is to write a japh script, that is a Perl script that prints out the above line, comma and all. The more obfuscated it is, the better. Another part is to not write code like that in production, at least not without comments explained what the heck the symbol soup is doing.

“(Perl) Wizard” has been applied to those who are notably proficient, thought that’s usually a title bestowed by others.

The self-deprecating alternative is “funny character(s)” for both the symbols that appear all over Perl code as well as those who use them (I think this one was coined by Perl creator Larry Wall himself).

Over the top tone: “Pretty sure that won’t compile. $EVAL_ERROR modulo what you get from the filehandle called = isn’t an lvalue that can be put through the Goatse operator that I’m aware of.”

But seriously(?), I’m almost certain that’s not how that would be parsed. = isn’t a valid bareword, so Perl would choke on the spaceship operator not being a term… I think.

After testing… It’s worse. I think it’s parsing <> as the glob operator and = as a filespec.

For those who don’t know Perl:

Because of its appearance, <=> really is called the spaceship operator (at least, when it can be parsed as an operator and not whatever happened above).

=()= by comparison has unofficially been called Goatse. If you don’t know what Goatse is, find out at your own risk. If you do know, you can see why this particular pseudo-operator was given that name.

And if you’re still reading, =()= is a pseudo-operator because it’s not actually parsed as part of the syntax. It’s literally an assignment operator = followed by an empty list () followed by another assignment operator =, providing list context to the outside of the equals signs that wouldn’t otherwise be there.

[Why are you still still reading?] Context is important in Perl. If a function returns a list of values (which is something Perl functions can do) and you try to store the result in a scalar variable, replacing the usual = with =()= will store the number of elements returned rather than the last element of the list.

Could be an instance of BSD where (so I hear) PIDs are assigned randomly from the unused numbers, or else the system has massive process churn going on elsewhere and the old timer is from a previous cycle of consecutive PIDs.

Some systems still have /proc/sys/kernel/pid_max set to something around 32768, so wrapping back to 0 can happen fairly often.

Given all the PIDs in the comic seem pretty low, it might even be as low as 1024 wherever this is.

(Yes, I know I’m taking this way too seriously.)

Personal project a while ago. Had an idea in my head that I needed to rewrite using a particular language feature but had been putting it off because I couldn’t quite wrap my head around the implementation details.

Eventually decide to sit down and plug away at it. Find the code already uses the language feature.

I had either written it with that language feature in the first place or had been back at some time I don’t remember and done the work I didn’t think I was capable of doing.

I could still be convinced that it was done by pixies or the whatever might be the programming equivalent of shoemaker elves.

Self-administering amnestics

Ah, I see you have discovered an infinite loop. Not that you’ll remember.

“Bounds checking, mobof–ker! Do you speak it?”