funny how well this fits for both meanings

Yeah, same for simcity 4

Yeah, it’s in my edit I realized the same thing. I’m thinking it doesn’t actually really make sense and the real reason is more “the specific way C does it causes a lot of problems so we’re not poking syntax like that with a 10 foot pole” + “it makes writing the parser easier” + maybe a bit of “it makes grepping easier”

So I think it’s still probably unclear to people why “mix of keywords and identifiers” is bad: it means any new keyword could break backwards compatibility because someone could have already named a type the same thing as that new keyword.

This syntax puts type identifiers in the very prominent position of “generic fresh statement after semicolon or newline”

…though I’ve spent like 10 minutes thinking about this and now it’s again not making sense to me. Isn’t the very common plain “already_existing_variable = 5” also causing the same problem? We’d have to go back to cobol style “SET foo = 5” for everything to actually make it not an issue

yep, it’s almost all banana pi, and at least 4 different ‘models’ of it it seems. But the word is also used in some string processing tests and as an example comment of how suffix arrays work…

And most of those cases are of course using the word sarcastically

The next function to implement is called, amazingly, next(); its job is to
move the iterator forward to the next position in the sequence.

if (lc->sync == NOSYNC)
	for (i = lc->header.nr_regions; i < lc->region_count; i++)
		/* FIXME: amazingly inefficient */
		log_set_bit(lc, lc->clean_bits, i);
else
	for (i = lc->header.nr_regions; i < lc->region_count; i++)
		/* FIXME: amazingly inefficient */
		log_clear_bit(lc, lc->clean_bits, i);

/*
 * Amazingly, if ehv_bc_tty_open() returns an error code, the tty layer will
 * still call this function to close the tty device.  So we can't assume that
 * the tty port has been initialized.
 */

 *   this header was blatantly ripped from netfilter_ipv4.h
 *   it's amazing what adding a bunch of 6s can do =8^)

/*
 * I studied different documents and many live PROMs both from 2.30
 * family and 3.xx versions. I came to the amazing conclusion: there is
 * absolutely no way to route interrupts in IIep systems relying on
 * information which PROM presents. We must hardcode interrupt routing
 * schematics. And this actually sucks.   -- zaitcev 1999/05/12

 * corresponding ABS_X and ABS_Y events. This turns the Twiddler into a game
 * controller with amazing 18 buttons :-)

 * In an amazing feat of design, the Enhanced Features Register (EFR)
 * shares the address of the Interrupt Identification Register (IIR).
 * Access to EFR is switched on by writing a magic value (0xbf) to the
 * Line Control Register (LCR). Any interrupt firing during this time will
 * see the EFR where it expects the IIR to be, leading to
 * "Unexpected interrupt" messages.

 * Thanks BUGabundo and Malmostoso for your amazing help!

You can still be snobby by instead insisting on “fold, scan, iterate”

It’s a technicality about the pointer type. You can cast the type away which typically doesn’t change the actual value (but I’m pretty sure that causes undefined behavior)

For your example, int x = 0xDEADBEEF; signifies the integer -559038737 (at least on x86.)

char *p = (char*)0xDEADBEEF; on the other hand may or may not point to the real memory address 0xDEADBEEF, depending on factors like if the processor is using virtual or real addressing, etc

Lots of em-dash usage

Service goes down after emitting an event but before persisting internal state—causing partial failures that are hard to roll back.
Subscribe to an existing event and start processing—no changes to publishers.
Helps track a request across multiple services—even through async events.
We once had a refund service consume OrderCancelled events—but due to a config typo, it ignored 15% of messages.
Takeaway: fire-and-forget works—until someone forgets to monitor.
Use it when the domain fits—fan-out use cases, audit logs, or workflows where latency isn’t critical.

combined with other chatgpt-isms like the heavy reliance on lists, yeah safe to say it’s mostly AI generated

it does kinda fit in that if you forced people to learn linux, the basic stuff most people do should in the end not be much more difficult than windows (assuming you don’t run into more bugs)

but that would never happen unless a “linux revolution” was already in full swing

My major version updates on 2 computers with linux mint in the past few years have been just one click, wait, reboot when prompted, everything works and you barely even notice that anything changed. Though maybe I’ve just been lucky

though the rest of the video’s takes on the linux experience for new users seems pretty accurate to me (lol downloading an application and using it requires at least a manual chmod +x and that’s the best case scenario. Maybe there’s a distro that has a solution but I have doubts (and “have everything you could possibly need in the package manager” is obviously a nonstarter))

But the community parts seem odd to me:

Is “just disable secure boot” a bad take? Has someone been holding everyone out on a better solution?

and

The only way linux is going to change is when money and development power is given to major dekstop Linux projects. It’s time to stop wasting time on customization or packaging

is just… sure, herd all the cats into one place, make them all work together in harmony, and summon 500 million dollars out of thin air to wrap it all together. Instead of writing bash scripts everyone should be praying to gabe newell to save us lol

People who cant use linux never learned the basics of computers

that’s like 80% of all people

I actually kind of looked at (jpeg) compression artifacts, and it’s indeed true to the extent that if you compress the image bad enough, it eventually makes it impossible to determine if the color was originally flat or not.

(eg. gif and dithering is a different matter, but it’s very rare these days and you can distinguish it from the “AI noise” by noticing that dithering forms “regular” patterns while “AI noise” is random)

Though from a few tests I did, compression only adds noise to comic style images near “complex geometry”, while removing noise in flat areas. This tracks with my rudimentary understanding of the discrete cosine tranform jpeg uses*, so any comic with a significantly large flat area is detectable as AI based on this method, assuming the compression quality setting is not unreasonably low

*(which should basically be a variant of the fourier transform)

I recreated most of the comic image by hand (using basic line and circle drawing tools, ha) and applied heavy compression. The flat areas remain perfectly flat (as you’d expect as a flat color is easier to compress)

But the AI image reveals a gradient that is invisible to the human eye (incidentally, the original comic does appear heavily jpeg’d, to the point I suspect it could actually be chatgpt adding artificial “fake compression artifacts” by mistake)

there’s also weird “painting” behind the texts which serves no purpose (and why would a human paint almost indistinguishable white on white for no reason?)

the new ai generated comic has less compression, so the noise is much more obvious. There’s still a lot of compression artifacts, but I think those artifacts are there because of the noise, as noise is almost by definition impossible to compress

The thing missing here is that usually when you do texture, you want to make it visible. The AI ‘watercolor’ is usually extremely subtle, only affecting the 1-2 least significant bits of the color, to the point even with a massive contrast increase it’s hard to notice, and usually it varies pixel by pixel like I guess “white noise” instead of on a larger scale like you’d expect from watercolor

(it also affects the black lines, which starts being really odd)

I guess it isn’t really a 100% proof, but it’s at least 99% as I can’t find a presumed-human made comic that has it, yet every single “looks like AI” comic seems to have it

I also noticed how it suddenly went from great to crap.

But the real reason I think is ironically AI. It used to be that you could easily crawl the web, but after the AI craze, images suddenly became valuable to crawl and every website gets bombarded by scrapers, and are adding more and more countermeasures to make it more difficult, so tineye’s own image scraper probably can’t compete with them and so can’t find any new images

I agree that the “arm things” are wrong, as it’s pretty clearly just an ‘artistic choice’ that a human could very much do.

But that said these images are 100% provable to be AI. If you haven’t built up the intuition that immediately tells you it’s AI (it’s fair, most people don’t have unlimited time for looking at AI images), these still have the trademark “subtle texture in flat colors” that basically never shows up in human-made digital art. The blacks aren’t actually perfectly black, but have random noise, and the background color isn’t perfectly uniform, but has random noise.

This is not visible to the human eye but it can be detected with tools, and it’s an artifact caused by how (I believe diffusion) models work

technically I guess it’s between Cosmic latte and Desert sand

or “light grayish yellow”

…I had to look those up but it’s definitely not a plain white

well it’s supposed to be the “passive” you (or “indeterminate” you)

but I think anyone can learn to notice the pattern of comics with this particular odd color style ^{(assuming you would want to learn it for some reason, and if we ignore color blindness or other similar problems etc)}

The new one by openai, “gpt-4o image generation”

it’s funny how you can tell at a glance exactly what model generated this image, just based off the background color