bonzini

It's not exactly the same problem, in that you can parallelize usage of an LLM and copy it over to another computer, but cannot do the same things with a brain. Put it another way, humans do not have the processing power needed to answer hundreds of millions of queries per day, while LLMs do.

From https://github.com/zepouet/Xee-xCode-4.5/blob/master/XeePhot...:

    // At this point, I'd like to take a moment to speak to you about the Adobe PSD format.
    // PSD is not a good format. PSD is not even a bad format. Calling it such would be an
    // insult to other bad formats, such as PCX or JPEG. No, PSD is an abysmal format. Having
    // worked on this code for several weeks now, my hate for PSD has grown to a raging fire
    // that burns with the fierce passion of a million suns.
    // If there are two different ways of doing something, PSD will do both, in different
    // places. It will then make up three more ways no sane human would think of, and do those
    // too. PSD makes inconsistency an art form. Why, for instance, did it suddenly decide
    // that *these* particular chunks should be aligned to four bytes, and that this alignement
    // should *not* be included in the size? Other chunks in other places are either unaligned,
    // or aligned with the alignment included in the size. Here, though, it is not included.
    // Either one of these three behaviours would be fine. A sane format would pick one. PSD,
    // of course, uses all three, and more.
    // Trying to get data out of a PSD file is like trying to find something in the attic of
    // your eccentric old uncle who died in a freak freshwater shark attack on his 58th
    // birthday. That last detail may not be important for the purposes of the simile, but
    // at this point I am spending a lot of time imagining amusing fates for the people
    // responsible for this Rube Goldberg of a file format.
    // Earlier, I tried to get a hold of the latest specs for the PSD file format. To do this,
    // I had to apply to them for permission to apply to them to have them consider sending
    // me this sacred tome. This would have involved faxing them a copy of some document or
    // other, probably signed in blood. I can only imagine that they make this process so
    // difficult because they are intensely ashamed of having created this abomination. I
    // was naturally not gullible enough to go through with this procedure, but if I had done
    // so, I would have printed out every single page of the spec, and set them all on fire.
    // Were it within my power, I would gather every single copy of those specs, and launch
    // them on a spaceship directly into the sun.
    //
    // PSD is not my favourite file format.

It's a bit different when "training on any data" means basically storing a lossily-compressed copy of that data, that could be spit out years later if the model decides to do so.

Yes, but the premise here is that for national calls it becomes harder to spoof the caller id. In fact, here in Italy we're seeing an increase in telemarketing calls from Spain and France, so it's not entirely hypothetical.

Reading it in Italian (my native language) is fascinating, as it's a weird mix of mostly modern Italian flexion and Latin sentence construction. It's incredibly taxing, enough so that I stopped after 70-ish stories, but it also makes it very clear that the whole thing was written 700 years ago.

I feel the same about Haskell...

Sure but the caller network bills the telemarketer and they could be in cahoots.

International calls pay whatever the caller network wants them to pay. You're assuming that the caller network isn't part of the scam.

0x86 and 0x87 (XCHG rm,r with byte- and word-sized operands) encode nops in the same way as 0x90, but were never redefined as prefixes.

It's interesting that a lot of ALU operations occupy four opcodes (memory source/memory destination x byte/word) but 0x84/0x85 and 0x86/0x87 only need two because not only are they commutative, but also 0x84/0x85 do not write to any operands and 0x86/0x87 write to both. So there is no difference between memory as the source or destination operand.

z386 is in development right now, and isn't even finished. Do you mean between ao486 and z386?

None was. XCHG AX,AX is special because XCHG AX,reg has a one-byte encoding.

You're probably confusing with:

- POP CS being broken and later becoming a prefix

- some opcodes being "reserved NOPs", i.e. reserved without generating #UD. They are used for instructions that may be defined in the future while guaranteeing backwards compatibility, for example new kinds of prefetches. MPX bounds checking instructions were also encoded in reserved NOPs.

I am doing something similar to that C-to-Rust rewrite. Except: 1) I'm clearly saying that it's only for my own learning experience and to find ways to improve the original program 2) I am leaving the original license in place and explicitly treating the output as a derivative.

And yet I am worried that my actions are perceived as hostile. Some people just don't care.

The problem is that the original formulation was "most people" are unaware of being unskilled, but by now the name is used to mean "some group of people" is unaware of being unskilled. In that sense the article confirms that “a small number are", 5-6%, and therefore the effect exists in the colloquial sense but not in the scientific sense.

Mentioning the Dunning-Krueger effect incorrectly is wonderfully meta...

They write garbage if you turn off your brain. They write code as good as yours if you work together.

Yeah I never use non-interactive rebase. Even if I don't need to edit the todo list, reading it gives me a confirmation of what git will do.

But the real question is 1) whether other human lawyers would catch the error 2) in how much time 3) which of the errors introduced by AI vs. human would have bigger consequences. On 1 and 2 the answers are very likely to be "yes" and "it would take humans more time", but the question that really matters is 3.

First of all I want to say it is not your fault, and also your article is clearly partly human, despite what Pangram says.

The thing that I like the least is the headings and the way LLMs always try to put a punchy line. "Correctness time splits in two" says nothing if you don't know what it splits in. Maybe "making it correct vs. describing what's correct"?

Another trope is short sentences: "Good engineers used to say this before LLMs, and now nobody can argue about the sunken cost of having written that code." instead of the longer and redundant "Good engineers said this before LLMs. It was true then. It is enforceable now in a way it was not, because nobody can argue that writing more code was the hard part".

Another clearly AI paragraph is "Plumbing time collapsed. Scaffolding a service, generating tests, translating between frameworks, writing the first draft of a migration: all of this is fast now, and any timeline built on those costs deserves compression." Instead: "The time to bring up a proof of concept or refactor old code has compressed, and you should take that into account when planning your timeline".

There are videos on YouTube about AI style, you just need to learn them and undo them when they're the most blatant.

It's depressingly hard to find one that isn't. You see the title, think this might be interesting, and puke by the second paragraph.

Ah, so it is basically a single rotr(x|2, 2), nice

How does it do that? When the 64-bit pointer is actually a pointer, does it mangle it into something that is certainly not UTF-8 (e.g. changing its top byte to 0xC0, and assuming that bits 56-63 are the same as bits 48-55, or something like that)?

Is the runtime compiled by the Fil-C compiler, or is it a single huge unsafe block? I honestly don't know the answer.

That's not supposed to happen. I would like to have more info.

Wikipedia does have a rule allowing "routine calculations"

https://en.wikipedia.org/wiki/Wikipedia:No_original_research...

Of course given the magnitude of the statement a bit of care is warranted, but the rules do allow it.

What is the manufacturing tooling that you mention?

True, but adding the hollow tube to the bottom side greatly improved how much the bricks stuck together, compared to Kiddicraft. It's not a small change.

Lego also tried other designs like crosses on the bottom but then kept the tube (and later the filled small tube that you can see on 1xN bricks and plates).

It doesn't have a carry flag either. Multiprecision integer operations absolutely suck in RISC-V, you need three operations (SLT and two adds, with an awful dependency chain too) to do an add with carry, and op fusion can only do so much. At least add an instruction that computes the carry out, like "Rd = Cout(Rs1 + Rs2)" and the similar one for overflow...

https://gmplib.org/list-archives/gmp-devel/2021-September/00...

Indeed, it's hard to find a balance between what's too verbose and what's too hard. For relatively complex models it's also almost impossible to do "quality control" without actually building it.

However, I agree with the other poster that you can get good at it. And you really have to do it anyway, since creating instructions will find bugs in anything but the simplest models and you want to solve those before paying for the pieces.

AI is good at coding if there's an oracle. If the system is ancient, unreadable, untestable, that's exactly the opposite. It won't get the exact set of corner cases.

It depends on how much the code has changed, how easy it is to test old releases, how far back you need to merge the fix... "Cherry picking from the top of tree" is the most common workflow but git itself uses "merge the same topic branch in all trees".

I interpreted "I squashed them" as "I used git rebase -i to squash the oopses and fixes". If that's not what the user does, and rather squashes the PRs, then indeed I would be disagreeing with him.