flohofwoe

It's a bit harder to reverse engineer a game from a video stream than from a binary+data dump ;) (of course an LLM can come up with a knock-off that roughly has the same theme of what it sees in the video-stream, but that would basically be "Italian Spiderman - the Game".

> This is an awesome timeline for old game preservation.

It's not preservation though, it's basically remastering. We'll still need to preserve as much data from the original games (including, if possible, original source assets and source code). And yeah, I have no qualms about the legality of it all, a proper legal definition of the concept of abandonware would be nice though.

OTH: cheaper games, more aggressive sales, and modding(!).

GH Actions problems are so frequent that they are really not newsworthy anymore. Most of the time they don't even show up on the status page because they seem to be completely random (e.g. manually cancelling and restarting may resolve the issue).

Apparently the old mold version had a couple of plain C source files in the source tree (both vendored 3rd party libs but also in the 'regular' source code), so technically C/C++ is correct in this case ...and looks like the Rust version also has some (very minimal) C code left (looks like mostly varargs stuff, I guess Rust doesn't have a concept of varargs?), so it could be called a C/Rust project ;)

https://github.com/rui314/mold/tree/main/c

I think the main reason why high income Germans switch to private health insurance is less about service quality, but because they may actually pay less than public insurance (at least until they get near pension age). Can't talk for US citizens of course.

Complaining about the service quality for public health insurance customers in Germany is pretty much the definition of "first world problem" though. FWIW I never switched over to private insurance even though my income would allow it, also once you get above a certain age you can't switch back and that's when the private insurers really start to rip you off ;)

Maybe fully read the comment I'm responding to? The implication is that European countries (and especially Germany) spend an extraordinary amount of tax money on health care and that's why taxes are so high. This is basically wrong from start to finish. You also don't pay half of your wage in taxes in Germany. The chunk that's removed from your gross wage before pay out includes your mandatory employee insurances (health-, pension- and unemployment-insurances), and that's how you end up "losing" about 30% to 45% of your gross salary before pay out (the actual "tax part" is somewhere between 10 and 25% depending on income, marriage status etc...)

That "health care argument" is getting a bit tiring tbh. The US government spends much more than any European country per capita on health care (the US system is simply less efficient), and the chunk of your wage that goes into your health insurance isn't a tax either.

It's also the region where the Russians mined the first Uranium for their a-bombs [0], and where curiously a small triangle of land was neither occupied by the Russians nor the Yanks after WW2 [1].

[0] https://en.wikipedia.org/wiki/Wismut_(company)

[1] https://en.wikipedia.org/wiki/Free_Republic_of_Schwarzenberg

The HN link has changeed since I wrote that comment, the original was this:

https://tej.as/blog/aleph-alpha-kolibri

This is a blog post by some "random" dude right? The company webpage appears to be German (at least when accessed from Germany: https://aleph-alpha.com/)

The current macOS version is 27.2 (e.g. it's not like they can only do one release per year now with the new version scheme).

The problem isn't the 20% actual bugs found (that's great), but the 80% false positive rate which are reported with high confidence and (most likely) misleading reproduction code. An experienced programmer familiar with the code base first needs to validate all reports and throw away 4 in 5. That's a massive waste of time. If a traditional static analyzer had an 80% false positive rate nobody would take it serious.

In my hobby projects I use LLMs in my development workflow mainly for passive bug scanning, reviewing and helping to maintain tests, they are definitely useful for catching some bugs early and noticing unhandled edge cases, but they're also definitely no silver bullet (they sometimes ignore quite obvious bugs, and the fewer 'obvious' bugs remain the more one has to be careful about false positives). E.g. the funny thing is that now I'm actually slower than before due to the intense 'rubber ducking' with LLMs and cross-checking their results, but I still want to pretend that the resulting code is more robust out of the door.

Eg everything that Greg KH says in the video sounds very familiar, and it's very disappointing that Mythos still suffers from the same issues (or maybe even worse) as older models.

Well now they can just point the AI at the backlog (just kidding)

Search for "Security in the LLM age" in this HN page for a reality check, apparently 80% of the security vulnerabilities that Mythos initially flagged in the Linux kernel turned out to be false positives. Better than nothing of course, but it really doesn't look like Mythos is quite the "wonder weapon" it was marketed as (and the situation by far isn't as dire as the initial flurry of Mythos news).

I expect that the incremental model improvements will become smaller and smaller until they run into the same diminishing returns effect like all other new technologies (FWIW I've not beeen seeing a lot of difference between the latest Opus and Fable models for the stuff I'm doing, so I just stick to Opus for most things. There's a noticeable difference between Sonnet and Opus though).

I'm not ready to take any bets when exactly the curve will be flat though ;) (e.g. in a just couple of months or a couple of years)

It depends? LLMs are not a silver bullet for writing bug free software (IME at least, and of course it also depends on the "threshold" what actually counts as a bug). They're definitely good at not creating the trivial "mechanical" type of bugs a tired and overworked human programmer would create (but oth those are also the easiest to find with traditional debugging tools and testing).

They're definitely a useful additional tool for finding more (and more obscure) bugs, but that takes a lot of both human and compute effort too (quite a few of the reported bugs are actually false positives on close inspection, and apparently even with the latest locked down "wonder weapon" models like Mythos), and after all the reports are clean and validated you still can't be 100% sure (but at least a bit more confident) that the code is now free of bugs.

No, it will be a tsunami of new discoveries in old code bases at first, but that will settle down as those old bugs are fixed. It's been like this with every new code analysis tool (the wave may be exceptionally high this time though).

They should probably ask Deepseek to optimize their webpage first before attempting to tackle the desktop...

The webpage is a completely unusable stuttery mess on my Android phone (at most 5fps).

MIT License requires 'attribution', e.g. at the very least the original copyright notice and license text (which tbf is the case in aloshdenny's copy because he left the LICENSE.md intact (or just forgot to "clean up").

Bernal Diaz' account is definitely recommended reading. But you'll have to read between the lines when he's talking about Cortez (there's a bit of "good Czar, bad boyars" going on).

What's interesting is how highly he speaks of his indigenous allies and even opponents, there's not a hint of disrespect (well, minus the Aztec practice of human sacrifices of course), he praises the skill, courage and discipline of the warriors, the craftmanship of their weapons and armor, and he's full of awe and wonder when they first arrive in Tenochtitlan:

"Among us were soldiers who had been in many parts of the world, including Constantinople, all over Italy, and Rome, and they said that they had never seen a plaza so well laid out, so orderly, so large, and so full of people."

I think the horses proved useful in some situations (at least to scare the people who had never seen riders), but then the number of horses was somewhere between a dozen at the start and never more than a hundred. And from what I've been reading their use in battle was often hit and miss because the cavalery often didn't have enough room to be effective.

I don't think there's a single and simple answer. One thing that Cortez managed to do was "demystify" the mighty Aztecs in the eyes of the people conquered and supressed by the Aztecs.

There was unrest and violence in the region long before Cortez arrived on the scene, when he did he was the external catalyst to ignite the powder keg. When reading accounts of the conquest, information gathering, political scheming and negotiations were often more "decisive" than the actual fighting.

Aztec warriors were not European peasants though . They were highly skilled and well equipped. They didn't have steel blades (except what they captured from the invaders), but their obsidian "swords" were not that much worse in the hands of a skilled fighter. Plus the European handguns were not that reliable and accurate yet to be all that useful except for showing off. If the first shot missed (assuming it didn't misfire) there was no time for another. And guns need a steady supply of powder and bullets, which Cortez didn't have most of the time since he was also at odds with the governor of Cuba.

There's also plenty of accounts from the early days of Cortez' invasion where the Spaniards had a very hard time against the indigenous warriors even when the Spaniards were not largely outnumbered.

The idea that the Spaniards were gods didn't hold very long. The Aztecs even sent body parts of captured and killed Spanish soldiers (and their horses) to display in cities and villages for the propaganda effect (see: they are not gods they bleed and die like everybody else).

In the end the defeat of the Aztecs was decided just as much by politics as by violence.

Also it's not like Cortez won every battle, they were even catastrophically defeated in the "night of tears". Coming back from that defeat wouldn't have been possible without indigenous allies and their thousands of skilled and well-equipped warriors fighting on Cortez' side against the Aztecs even after Cortez was driven out of Tenochtitlan (and not to mention logistic support which was probably even more important).

Almost 8ms on 1080p resolution seems extremely expensive, does the original also eat into the rendering budget as much?

Slug doesn't use "bitmap" font data but more like parameter lookup tables in storage buffers, pre-processed from TTF files. The lookup data can of course also live in textures (so that it works in WebGL), but using those textures as "poor-man's storage buffers", e.g. fetching the data directly without filtering.

The pixel shader is indeed quite complex compared to SDF:

https://github.com/floooh/sokol-samples/blob/8afa83928ce1870...

Tbf, the Github repo doesn't look particularly 'sloppy' to me, more like some mild AI assistance. There's several months of fairly regular looking git history, a couple of commits with an LLM disclaimer for python bindings, and two llm-context files.

https://github.com/AlphaPixel/slughorn

The details are in Eric's post here:

https://terathon.com/blog/decade-slug.html

The timeline basically checks out, maybe it simply took the patent office over a year to process the patent application?