tom_

I just got served a big chunk of JSON, not even pretty-printed, with the text in there... somewhere. Difficulty level: quite high, even in reader mode.

(same on macOS+Firefox and iPhone+Safari)

I for one always appreciate it. The comments help me judge whether I'm right or wrong in my own opinion.

Right, but if you're referring to Return as Enter, then there's no reason to refer to Enter as Return. The reason for the change is that people don't distinguish the two. If we're going to eliminate this distinction, we should do it properly!

(I've had blank looks from a few colleagues after suggesting they press the Return key (that being the term I used to refer to the Return key) - which makes me wonder what percentage of people even know that Return is the name of a key. Perhaps we should retire the term entirely.)

Judging by my PCs (M4 Max Mac Studio; 2990WX desktop PC), Geekbench might flatter the Apple chips for multicore a bit I think:

Geekbench 7 results:

* AMD 2990WX: 1384 (single), 13052 (multi) (https://browser.geekbench.com/v7/cpu/181239)

* Apple M4 Max: 3552 (single), 29863 (multi) (https://browser.geekbench.com/v7/cpu/390256)

For parallelisable stuff that can occupy all cores for an extended period, the 2990WX typically takes about ~1.2x as long to do the same work/does ~0.83x the work per unit time, assuming code compiled with clang or gcc. Which isn't really coming across in the numbers here.

CPUMark is a bit better:

* AMD 2990WX: 2282 (single), 32040 (multi) (https://www.cpubenchmark.net/cpu.php?cpu=AMD+Ryzen+Threadrip...)

* Apple M4 Max: 4590 (single), 43911 (multi) (https://www.cpubenchmark.net/cpu.php?cpu=Apple+M4+Max+16+Cor...)

I haven't spent much time timing single core stuff, except - regarding clang, which looks like it contributes to the Geekbench 7 score, I did some measurements a few months ago suggesting that clang compiles for x64 more slowly than for ARM, all else being as equal as I could be bothered to try to make it: https://news.ycombinator.com/item?id=46938682 - and the single threaded test runs I did of my code suggest that the Geekbench 7 single core might be about right?

(Whether the clang timing discrepancy is actually relevant to Geekbench, I've no idea, but I thought it interesting anyway.)

If you need a benchmark that makes the PC look massively faster than the Mac, I'm sure those are available too.

Yeah, all of that would be great. Good ideas all round, and thank you for gathering all these sensible requests into one centralized list.

Slight problem, and it's not clear whether you've realised this: everybody else in the world knows that we can't have everything! Still, it's good to have goals, even if they can't be met, and it'd be monstrous to mock the ambition on display - which I do declare we should in fact salute. Good on you sir/madam, for not being a cynical jaded asshole like the rest of us.

Lest it seem like I'm patting myself on the back for my ability to detect Claude's writing style, as if this instance would be evidence of any particular skill in that department: I did skim the README enough to note that bit.

Evergreen: https://randomascii.wordpress.com/2018/02/04/what-we-talk-ab...

(Feels like it should probably say "1.16x as fast" or "1.16x the throughput" - or something like that.)

So much Claude text. I'm sure this is great (I did a bunch of stuff with/to aardappel's lobster, years ago, and it was pretty tidy, and quite easy to work with), but: Claude's writing makes my brain melt.

It's a no from me. I'm sorry.

Maybe that's the trap I'm falling into? From memory it doesn't have any actually atomic operations, only an ll/sc sort of mechanism - which I've never really thought of as an atomic operation?

Though it's true you can end up with the same end result, in that you can just keep trying the operation until you accidentally do a read-modify-write that's ended up - well, "atomic" is a valid way to describe it.

So maybe it is good enough to count, though personally I'm still not quite convinced.

Quad core ARMv8-A, e.g., Nintendo Switch.

It's intriguing. Danny! Infuriating.

I think it's slightly worded if you swore. No. Slightly worded. No. Slightly worse if you swipe left handed. Yes. At last.

In the long term, it'll be at least be the year 2030. Let's not get ahead of ourselves.

I've got a 7 port USB 3.0 hub that connects with a double ended USB-A cable.

I assume it's because Flock is a YC company, and HN is the YC board, and somebody has instituted a policy of not making the link clear (and it worked on me! I had no idea) due to the negative publicity - but that's so obvious, that you must be thinking of something else.

Presumably it's a machine command runner (like shell commands and whatnot - as opposed to an Emacs command runner, perhaps).

The computer's the one running the code, and it'll be running it a lot (or so its author hopes), so it's probably worth bearing its limitations in mind in the interests of making its life easier (so to speak) rather than prioritising the people who will modify the interpreter - a far less common occurrence.

The bit operations involved are pretty simple and won't take you long to figure out even if you've never done them before.

Purported white-hat hackers. The implication is that these people are presumably describing themselves as such, but it may not actually be true.

Curious indeed that the Yale Babylonian Collection should, out of all the possible options, choose the cooking of Ancient Babylon. I wonder what we should read into this. I have some theories, but it might be dangerous for me even to mention that I have them.

Let us hope that the poster happens to see this, and is moved to comment, so they can address your points.

If you pick up an additional machine gun powerup, the plane should fire more bullets simultaneously.

Well I dunno, man, this looks like the sort of amusing prototype I'd expect to take a couple of days - though not to understate the value of getting it in 4 hours (and probably with less than 4 hours' continuous effort from the human). Iteration time is an important factor!

(Regarding the parting shot, I find myself once again, for the numerousth time, reminded of this curious lobsters comment that I'm having difficulty forgetting: https://lobste.rs/s/omq8rt/vibecoding_gets_emacs_patch_rejec... - perhaps not quite entirely directly germane here, I don't think, but, still, somehow, not quite entirely directly not.)

Be the change you want to see!

I care. If the article was AI written, I'm massively less interested in writing it, and in fact I'll only do it if absolutely necessary, or if I'm getting paid.

That's just how it is for me. If you disagree: no problem! Some people are inclined to argue with people about their opinions, but I'm not one of them, at least not on this matter.

Yes. I missed that specific bit, but, the more I read on, the less it felt like a nice in-flight magazine-tier diversion and the more it felt like I was reading the result of asking Claude to write an essay about the bearing of loads.

(Which makes me personally a lot less interested in reading it.)

If the author is reading: both complicated examples are the same.

The C64 disk drive would still have left you with plenty of reading time.

Same reason there is a button saying "View all 50 cities" (with a down pointing arrow) below the list of all 50 cities, that, when you click it, scrolls back up to the start of the list that you just looked at.

How long have we had 15-core iPhones with 64 GB RAM and active cooling though?

I assume it's because trains play a part in Atlas Shrugged: https://en.wikipedia.org/wiki/Atlas_Shrugged

Nested functions may require a context pointer of some kind, which the caller can't supply. One way of doing this: create a thunk on the stack that provides the context pointer, and use that address as the pointer to the nested function.

But now the stack needs to be executable.