Comment by csomar

Wow man, "horrific code" can be worse than no code. Bad code can damage hardware, destroy data, allow exploits, etc. all manner of bad things.

Unless your meaning is that you already have work-in-progress code that you are working on to make much better whereas they have not even started, I don't see how your point makes sense.

But even then it debatable whether making bad code good is better than creating good code from the start.

I absolutely don't want to run "horrific code" as my OS. Why would anyone?

You're talking about code with the potential to damage hardware. So, no.

That's just... not how it works.

Even good code is a liability. Admittedly "horrific" code is a 10x or 50x liability. Sometimes you accept that kind of technical debt because "it's really important" — e.g. the company will go bankrupt, or whatever.

(Historically, btw, this is why proprietary corporate code is often so much worse than even fairly incompetent open-source code. Because it's just not really that important to ship horrific slop when nobody's income depends on it.)

The idea that shipping "horrific" code now is somehow better than not shipping it until it is fit for human consumption works in some narrow business life-cycle scenarios, but not in any kind of user-facing scenario, and certainly absolutely fucking not any kind of user-facing OS implementation scenario... (T_T)

"Code is a liability" - is one of the fundamental tenets of programming.

So, "it's better because our code exists, and their code doesn't" isn't the brag you think it is. Yes, a quick thrown together utility is better than having to manually do something. But that's not the same for an OS, or god forbid, a filesystem.

Especially since the only reason your code exists in the first place is that they did the hard work and your project forked.

> Hasn't been shipped yet

Does it though?

> however bad our code is (and I have no issues saying that most of our linux driver code is absolutely horrific

It's the operating system, mate. People don't just use operating systems to take screenshots and then post on social media.

> it's better than Asahi code, because our code exists, and their code doesn't

This is an especially horrific comment if you are really related to the project and this also adds to the perspective on why Asahi team might have wanted to have no nothing to do with this project and related people and their thought process. Anyway, good luck.

Uhm, I don’t think this is the flex you think it is.

>Who cares if it gives you the features with good-enough performance?

Some of us still care.

>Are you saying "vibe-coded slop" because of the quality of the end result? Who cares if it gives you the features with good-enough performance?

There are a few significant reasons worth considering when getting down to the level of OS and hardware drivers. Long term maintainability is one. But another big one is that such software is capable of physically and permanently destroying the hardware it's operating on, with the textbook example for Macs being the speakers found in Macbooks. The only way to get the kind of performance they offer out of that physically light/thin package is to give them the power to destroy themselves if run at full force continuously but then run it from software so that they aren't run at full force continuously, but rather take advantage of the headroom that offers for very brief audio spikes whose overall integrated power still falls below safe limits. This all needs to be done from software since response of real world analog isn't instant. That enables much more range then if they were hardware capped at the maximum level they could run constantly, but it also means that if they're driven wrong, poof. The drivers have to never go to certain bad states, purely from software.

LLMs can't offer those kinds of guarantees, they don't really "know" how things work and then produce something deterministic off of that. It's even worse if, as-is the case with this sort of vibecoding effort, the LLM operator is in fact depending on the LLM for that part because they don't know how it really works either (vs someone who is just using it for boiler plate and knows exactly where the critical paths are).

Obviously everyone is welcome to roll the dice with their own hardware as they wish, and it may be ok. Or if using really old hardware one might just not care. And not all hardware is as sensitive as modern notebooks of course. Just be aware the analog world can be messy and you might not actually have the guardrails to screw up that you're used to in a higher level software environment.

>Otherwise one can also say Asahi is compiler-generated slop compared to hand written assembler code.

No, one cannot say that. Or at least not without looking really stupid.

I prefer reliable software for the Operating System. Like, I can tolerate slop for a game or a one-time-thing of converting a doc or something. But for running the base software (your OS), I think you need better standards.