palordrolap

GNOME and its applications have been headed in that direction for a while now, but I’m not sure Canonical are behind those changes. If they were, I’m sure they would have done something about GNOME apps looking alien on Xubuntu, for example.

Source

As that link suggests, the Mint team are looking to produce apps that run on any desktop environment, forking GNOME apps that don’t comply with that. Hopefully that keeps the momentum going for that sort of thing.

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.)

In addition to other advice here: If you want to save on keystrokes, set yourself up a shell alias that’s short but unlikely to be a valid command anywhere else.

I have one that’s kind of the inverse of yours, called mntStorage (no prizes for guessing its purpose). It wasn’t intentional, but mixing case like that is pretty rare in important commands too.

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.

If you’re using GNOME or a derivative, you should probably be using gio mount to do the same mounting as the file manager would. Then again, you say that the file manager isn’t working, so gio mount probably won’t work either.

I admit I had no idea about the guts of this - and maybe still don’t - but the user who suggested looking at udisks is probably right. It’s always been there in the background as long as I remember (Mint/Cinnamon, many years), and has hooks into something I mounted with gio after the last reboot.

Another search term that might help is “gvfs”, or GNOME virtual file system, which I’ve definitely poked around with before.

Importantly, Nautilus and gio don’t need sudo because they call into what’s already running. They (or the subsystem) automatically create the mount point directory (and remove it on unmount). If the directory already exists, they use the “append a 1” technique you experienced, presumably so they don’t clobber or hide something that might be important.

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.

That probably works for any closely related language pairs. Finns thinking the same of Estonian, some English folks definitely formed that opinion of Scots the first time seeing it in print, Polish and Czech, etc. etc.

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.

This could be an XY problem, that is, you’re trying to solve problem X, rather than the underlying problem Y. Y here being: Why do you need things to be in decimal in the first place?

Arithmetic can be performed on values stored in binary without going through a decimal stage at any point.

Large integer types can be absolutely anything under the hood and only displayed in decimal when a human needs to read it.

Now, if human readability is a necessity, that underlying representation might well be decimal-oriented for simplicity. e.g. using arrays of 32-bit integers but forcing a carry when they reach 10^9. That way barely any conversion is needed when they’re printed out. Multiplications could use 64-bit integers as intermediaries.

Where that’s not available, something less than or equal to 32-bit integers up to 10^4 - 1 and 32-bit integers for multiplication.

Or, if the 52 bits in a 64-bit floating point value are a more tempting target, a restriction to 10^7 - 1 as the max digit allows for use of the same data type for multiplication intermediaries.

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).