HNHacker News
TopNewBestAskShowJobs

flohofwoe

23,650 karma · joined October 15, 2013

submissionscomments
flohofwoe··on No one can afford to make Myst games anymore
> Once a player finishes a game, the desire to replay it soon after is going to be pretty low, no matter how good the experience was.

I think this has changed a lot since the early 2000s. There are now plenty of "forever games" where players spend hundreds or thousands of hours in, especially MMOs and free-to-play games. And even traditional AAA franchises like CoD or Battlefield are essentially just releasing new episodes of the same 'forever game' with updated graphics but the same gameplay.

flohofwoe··on No one can afford to make Myst games anymore
Video game sales usually have been very recession proof. E.g. people still want entertainment and escapism when shit hits the fan.
flohofwoe··on No one can afford to make Myst games anymore
The article reads like it's about 15 years late to reality. Trying to get funding from a publisher as an independent studio was always somewhere between hard and impossible, and especially towards the 2010s. That's why Kickstarter became such an unbelievable success.

PS: The one exception was when Epic was on its aggressive rampage to buy as many exclusives for the Epic Game Store as possible. But I guess that money shower has also dried up by now.

flohofwoe··on US strikes $1.2B deal to pay German firm to halt offshore wind projects
> US is rich in fossil energy so it doesn't have the same incentives as China does obviously.

China isn't rich in fossil energy? That's news to me.

They are the world's largest coal producer and still create over half of their electricity from coal. The difference to the US is that China seems to realize that this strategy isn't a long term solution.

flohofwoe··on Branchless Rust: Making a Filter 4x Faster by Removing an If
Memory access patterns are usually the main reason for low performance and should be optimized first because it's a great low hanging fruit (and usually the bigger problem is latency, not bandwidth).

And don't think of waiting for memory as making CPU optimizations irrelevant, but instead as an oppurtinity to hide more CPU operations in the remaining 'memory access gaps' (e.g. the CPU won't simply stop working when waiting for data to be loaded from memory, it can continue with other things that don't depend on that data).

flohofwoe··on Branchless Rust: Making a Filter 4x Faster by Removing an If
PS:

> fwiw I can't shake the feeling now that the article is recycled

Ok, I remembered wrong. The article I remembered was this: https://tiki.li/blog/blqsort

HN link: https://news.ycombinator.com/item?id=48375445

It's peddling the exact same myth though.

flohofwoe··on Branchless Rust: Making a Filter 4x Faster by Removing an If
German language: hold my beer ;)
flohofwoe··on Branchless Rust: Making a Filter 4x Faster by Removing an If
I'm German but still do all my computing in English (partly out of habbit, but also because Germanized technical text is usually painful to work with because it's full of anglizisms (is that actually an English word?)).
flohofwoe··on Branchless Rust: Making a Filter 4x Faster by Removing an If
The main problem with the article is that the idea to influence backend code generation decisions via specific highlevel code constructs is mostly just mystical bullshit (some compilers do detect specific patterns - usually for bit twiddling hacks, but not on a basic level like control flow optimization).

Using a highlevel language construct like "y += (x > 0) as usize;" doesn't "switch on" branchless code just because the source code looks branchless, compilers are not that dumb anymore.

E.g. I bet that writing

    if (x > 0) {
        y += 1;
    }
...generates the exact same code after optimization, otherwise I would consider that an LLVM bug.

The only reliable way is to mostly bypass the optimizer via simd intrinsics, or drop down to assembler, everything else is just cargo culting.

(fwiw I can't shake the feeling now that the article is recycled, I'm pretty sure I saw those exact same code examples in another "branchless" blog post, but maybe for a different language - because the next question was ineviatably "then why is the code using "if" slower? answer: because it also behaves differently). Or maybe I'm just having a strong dejavu ;)

flohofwoe··on Branchless Rust: Making a Filter 4x Faster by Removing an If
"The smoking gun" is right there in the text ;) (but also things like "Same million floats. Same threshold. Same function."). Don't know if other models have that same specific style, but it looks very 'claude-y'.

I wouldn't be surprised though if (especially) non-native speakers unconsciously start adopting the Claude writing style when they stare all day long at Claude generated text at work.

flohofwoe··on Xbox goes down. You can't play games you own on disc
> but the gaming experience is easier and less frustrating

??? It's not the early 1990s anymore where you had to fiddle with autoexec.bat and assigning IRQs to get your DOS games to run. The only "downside" of PC gaming is that the hardware isn't subsidized like game consoles are, so you're upfront investment is a couple hundred bucks more. But then you don't need a subscription for multiplayer gaming, and PC games are cheaper (80 Euros for a game? come on...)

flohofwoe··on US Military asks troops for 'creative and unconventional' ideas to punish Iran
> The real plan is a containment and a slow economic collapse of Iran anyway.

Quite optimistic to assume that there ever was a plan. Reminds me of the '4D chess' masterminds sitting in the Kremlin.

flohofwoe··on Xbox goes down. You can't play games you own on disc
> I don't want to know what life is like having xbox hardware

It was pretty great up to the 360, but with the Xbox One everything went to shit. Game consoles were meant to be plug-and-play, today they are more hassle to setup than a PC with Steam (ok, I guess Playstation isn't quite as terrible yet).

flohofwoe··on Cyberpunk Video Games
Try Satellite Reign. It's also almost retro by now (2015), but it's essentially a modernized Syndicate.
flohofwoe··on Cyberpunk Video Games
Not mentioned, but probably my favourite cyberpunk game of all time: Satellite Reign (2015).

It's a modern Syndicate remake in spirit, and a relatively small indie game (to set expectations), but the gameplay loop is tight and rewards experimenting. I still like to do a quick playthrough occassionally and it has aged great.

flohofwoe··on Cyberpunk Video Games
I mean, yes the technical problems have been fixed, but it's still the same old boring story, repetitive gameplay and a very abrupt ending. And for being a cyberpunk game there's definitely too little cyberspace and 'netrunning' in the game. It's essentially a "GTA 2077" with slightly better gunplay (FWIW though, I still enjoyed the first playthrough for what the game is - e.g. a first-person-shooter with some very light RPG elements, but I couldn't endure a second playthrough, for that the different character stories and builds simply don't differ enough).
flohofwoe··on Xbox goes down. You can't play games you own on disc
Steam games are not required to have DRM, it's entirely up to the game developer/publisher.
flohofwoe··on AI migrated legacy COBOL programs to Java, bugs included
> Also, humans are not deterministic either.

And that's why it's usually a stupid idea to nilly-willy migrate large code bases to different languages (also I'm getting really tired of the "but humans aren't either" trope).

flohofwoe··on The Prospects for 128 Bit Processors ( John Mashey SGI 1995)
That's the thing, bigger datatypes means less effective memory throughput. From that perspective 16-bit or even 8-bit floats are often more useful than 80 or 128 bit floats. Same problem with 64 bit pointers and why it's often better to store narrower indices instead of full pointers, data can be packed more tightly and accessed more efficiently.
flohofwoe··on The Prospects for 128 Bit Processors ( John Mashey SGI 1995)
Also arguably we already have 256 or 512 bit CPUs, what matters most for memory throughput is not the register width but essentialy the L1 cache line width (eg what in old CPUs was the databus width).

As for address width, we're not even close to get full 64 bit pointers from CPUs anyway, more like 48 or 52 bits.

Wide pointers (eg 128 bit general registers) would make sense for carrying capabilities for memory safety though I guess.

flohofwoe··on AI doesn't generate working products, that's still your job
> I sit in the middle a lot of the time as my opinion on code quality vary depending on how important the code actually is.

This is really the key insight that most people on the extreme ends of the discussion don't seem to grasp and then talk in absolutisms because they think that their tiny village is the whole world.

It's the same kind of 'extremism' that dominates most discussions about memory safety btw.

For some types of programs, code quality simply doesn't matter as long the program does its job, and generating those programs even with the most sloppiest vibecoding approaches is totally fine.

And in some areas of the industry (like web development) these types of programs are basically the norm - but this sort of code was already mostly hastily cobbled together slop even before AI.

I also see extreme differences in usefulness of LLM code generation. For anything JS or TS it works great because there's a giant corpus. For C code (or even more obscure languages) especially when using libraries which change all the time my experience is totally different (at least for code generation, bug scanning works quite well).

That's my experience so far anyway, literally "hit and miss" with some areas where there are more hits than misses, and other areas where it's the other way around.

flohofwoe··on Google fixed more Chrome bugs in June than over the past two years, thanks to AI
I would guess they have been confronted with an initial flood of newly discovered bugs whenever they added a new analysis tool or approach (e.g. automated static analysis, fuzzing, ...). Once working through that initial flurry of newly discovered bugs one would assume that the frequency goes down again.
flohofwoe··on Google fixed more Chrome bugs in June than over the past two years, thanks to AI
True, but at least IME, once you get beyond fixing the 'obvious bugs' (how many there are depends on the initial quality of the code base - but I agree that AI is really useful to find those), you'll get into a murky grey area of "maybe false positives" which require a lot of time to validate. As a result you sink a lot of time creating and tweaking code-base-specific rules to try filtering out false positives, and IMHO this is exactly the tipping point where the whole thing becomes pointless because it becomes a bureaucratic monster.

E.g. a good code analysis tool needs to work predictably at button press on any code base.

Still better than nothing of course, e.g. I actually think bug scanning / code analsysis is indeed the one area where LLMs are actually useful, but it suffers from the same 'diminishing returns' problem as traditional approaches, if not worse (e.g. still no silver bullet, but a mostly useful additional tool in the toolbox).

flohofwoe··on Google fixed more Chrome bugs in June than over the past two years, thanks to AI
> The place to find them would be performance profiles, query plans, telemetry.

Tbh, once this information is available (which is the tricky part), in 99% of cases there's really no AI needed to analyze the data, since the 'low hanging fruits' will usually stand out anyway. And once you get into the area where optimization hotspots are no longer obvious, you're already deep in the diminishing returns area and optimizations for one use case or hardware configuration may degrade performance on others. That's my experience anyway.

flohofwoe··on Google fixed more Chrome bugs in June than over the past two years, thanks to AI
That's something those products need to figure out, not the users, one potential solution is to erect paywalls and find out how much those products are actually worth to their users ;)
flohofwoe··on GCC steering committee announces AI policy
> You literally spend 99.999% og your time blindly trusting code ...

Please don't be personal ;)

flohofwoe··on GCC steering committee announces AI policy
> But the vast amount of software written, react components and rest endpoints, are very ripe to be entirely written by agents.

In that I agree, nobody should be forced to write React code manually, that's almost a human rights violation ;)

REST endpoints (and the code talking to those endpoints) should be code generated anyway though, no need for LLMs, and instead of human language prompting, a precise IDL should be the spec and basis for a mechnical code generation process. That problem was solved decades ago with much more pedestrian technology.

E.g. it basically comes down to "it's fine to use LLMs for software that shouldn't have been written in the first place", and funny enough that's where LLMs are really good at: creating software that has been written a million times before with only minor variations, and doing this type of work manually (cranking out one cookie cutter React webpage or REST API after another) is essentially what's called 'bullshit jobs' (which bring food on the table though, but that's another topic).

PS:

> and where software developers carefully will detail stear the work.

...I think the further a project evolves, the less this "detailed stearing" will be any more productive than doing the same without LLMs. The older a project, the more the work shifts from implementation to decision making, and in most cases the result of that decision is just a very tiny code change. I already see cases in my daily work when I use 'agentic workflows' where a tiny change takes longer and involves more 'collatoral updates' then just fixing that one frigging line of code by hand like in the olden days, and for LLM-generated code bases I really do prefer to not mix LLM and manual work, I think that's the worst of all options.

flohofwoe··on GCC steering committee announces AI policy
Compilers also usually give you the same output for the same input. And fwiw I do spend quite a lot of time reading compiler output to check that it's not doing something stupid or unexpected (usually as part of optimization work).

Also this sort of 'technological whataboutism' really isn't helpful, compilers are entirely different from LLMs. I agree that it doesn't make much sense to read or review LLM output in detail, but I also don't plan to use LLM output for anything important or mission critical. That would be irresponsible.

flohofwoe··on EU now fears US interference in European elections
I suspect that this was less about helping the US, but rather about gathering at least a bit of battlefield experience for the various European armies that took part, since at that time the thought was that the Cold War armies prepared for a type of warfare that would never happen again after the Cold War was "won" (and thus also the massive demilitarization of the 1990s).

Also quite famously, Germany gave the middle finger to the US when it wanted to pull allies into 3rd Gulf War with that made up Iraqi WMD claim (and we also weren't partaking in the 2nd Gulf War before - apparently we paid $10 billion in financial support and some non-combat roles).

But yeah, Afghanistan was a pointless endeavour all around, and we shouldn't have joined there either.

flohofwoe··on GCC steering committee announces AI policy
It has nothing to do with 'elite teams', it has to do with decades long and very careful maintenance.

It's too early to say whether LLM generated projects will ever reach that sort of maturity, most examples I've seen so far are basically "fire and forget". But lets talk again in one or two decades, maybe there will be counterexamples of successful open source projects which will be just as well llm-maintained as human-mainained.

But I suspect that to reach that sort of maturity, the resulting human effort will be mostly the same (e.g. not much of a productity win - except maybe on the 'edges', e.g. maintaining the test suite, documentation, helping to analyze bugs..., e.g. these are examples where LLMs are genuinely useful and where plagiarism hardly matters).

← PreviousPage 12 of 34Next →