It's not an ultrageek wizz wozz local LLM performance junkie machine.

"Therefore, to implement this feature without an avalanche of bugs and inconsistencies, we need to make language changes."

"Put more simply, we are going to make these enhancements, but hacking them in for a flashy headline isn’t a good outcome for our users. Instead we’re approaching the problem with the care it deserves, so that when we ultimately ship it, we don’t cause regressions."

"So instead of wasting time writing a more robust implementation of this LLVM module splitting logic for a relatively minor improvement, we have instead put that effort towards features like self-hosted backends and incremental compilation, which can improve compilation speed by orders of magnitude.

[...]

There’s the 4x speedup claimed by the Bun team, already available on Zig 0.16.0!"

Every single new post-Go language, like Rust & Zig, ships with an opinionated autoformatter and a single go-to command to manage builds, packaging, etc.

And how many new languages do you see include inheritance and exceptions?

Older languages have started adapting what they can too:

- Python with `uv` and `black`

- Java with goroutine-like fibers and modern configuration-free gcs and the go-gc-like low pause times zgc

- Many languages now ship a production-ready http server, just like Go

Pretty much correct, yes.

> Zig will become THE C replacement and that will let me iterate at the speed of JS or Python with performance of C or Rust.

Fundamentally impossible. C/Zig/Rust have 100% performance as a top goal, which has to be traded off with something else and that's always realistically going to be programmer work/effort/time.

You can't have a house built 100% fast but also 100% cheap and with 100% quality. At best you could cleverly abuse the law of diminishing returns and aim for ~80% in all three areas. That's basically what Go's trying to do.

> once this linker and incremental compilation on other targets land,

In any case, why would a better linker and faster compile times of all things achieve this supposed goal?

Beyond being low level, Zig is still pretty memory unsafe and has you make choices about each allocation, making it unappealing as an applications language. Zig and Python are completely different worlds.

> [...]

> The information they harvest can include [...] whether you buckle your seatbelt, drive too fast or brake too hard.

In a way this is good -- I want bad drivers to be incentivized to change their behavior.

Just need to legislate away all the other, actually creepy stuff. Just.

Everybody's got a plan until they get punched in the face. Bravado and macho mindset are explicitly frowned upon in aviation for a reason.

Reminds me of "aviation experts" claiming Sulley didn't have to ditch in the Hudson at all, since some pilots in the simulator were later able to turn around and land back at the airport.

Sure they were! I'd be able to do so too, and I'm no pilot — I'm safe in a simulator, I already know I'm going to have a double engine failure x seconds after takeoff, and I get to try to land an infinite amount of times until I get it right. Easy peasy.

Things look a bit different when it's your ass in the seat and you lose both engines on a random takeoff.

They also look different when you're subjected to massive G forces, your plane isn't listening to your inputs, the computer is shouting erratic warnings at you, you're rapidly losing altitude, and your training didn't cover this scenario.

Your response is very human, but also deeply irrational. In practical terms of safety it is irrelevant if the pilot is to blame or not or to what degree.

All we should want to do is analyze the reasons why the crash happened and adjust the aviation safety system such that it never happens again.

If pilot actions contributed, then we must ask why and how exactly, then fix those factors through better airplane design and pilot training.

Just blaming someone, then moving on may make you feel good inside, but does nothing to improve safety.

> This is flying 101.

>

> How poorly trained in basic airmanship were they and how were they allowed to be pilots?

Thoughts like these about three experienced professional pilots should make you do at least a double take. It is far more likely that you're dead wrong than that those pilots were so incompetent they didn't even know the basics.

Because risk is relative, and not as you seem to think, absolute and binary.

The risks are being dismissed because they're so tiny, that they're irrelevant. You may as well start planning your life around the assumption you'll win the lottery.

That's why nuclear waste storage is such a common fear mongering tactic, it exploits the human liability of not understanding long-term statistics very well.

Even solar power is more dangerous due to people falling off roofs and such. Same with wind power. And don't get me started on dams. When those fail, people die.

And that's renewables. We're stil mostly burning fossil fuels and dumping the waste products into the atmosphere we all breathe.

Yes, we are literally, as we speak, doing that.

And you're talking about the massive problem of storing some barrels of solid waste.

You're off base in your perception of risk by several orders of magnitude.

Then you definitely don't understand the tradeoffs after all, and/or don't know the history of error handling.

Exceptions are an outdated concept that's inferior to explicit error returns for 99% of software.

The tradeoffs are super simple here - exceptions require very little of your input but lead to terrible spaghetti due to hidden control flow. Explicit error returns are seemingly the opposite, but their verbosity issues have mostly gone away thanks to modern language improvements, so they're just better, unless you're writing short scripts and the like.

The situation is very similar to static vs dynamic typing - dynamic typing used to make a lot of sense in the days of extremely verbose Java type declarations, but modern static type systems with inference have made dynamic typing basically obsolete.

> That said, the typical performance complaints made against the most common implementations of exceptions are valid.

This also sounds off and outdated to me. If anything, exceptions typically have better performance, so long as errors aren't common. Indeed, if optimized correctly, exceptions have zero cost if not thrown, which can get you better perf than error returns, which have a low, but constant cost.

> Nuclear reactors are inherently a very risky business,

Well, let me introduce you to airplanes — flying is inherently risky, and so many people have died on commercial flights. We should abolish it immediately!

> The fact that a Fukushima-scale nuclear disaster can happen at all is a major cause for concern.

Maybe. I'm more concerned about coal plants that are, as we speak, dumping metric tons of harmful materials, including radioactive ones, into the atmosphere we all breathe, which causes approximately 100_000 people to die each year.

These are real things happening right now, not some hypothetical problems that may happen, but haven't in the last 60 years of commercial nuclear reactor operations.

Seriously, all you can cling to are what, 2-3 major accidents in all this time? With negligible death tolls? Please. This is just concern trolling.

Rules of the road are generally designed in the same way — for cars. Nobody cares about carving out obvious exceptions for bikes, like the Idaho stop.

1. Cyclists live and die by inertia. Getting up to speed on a bike requires a lot of effort and every application of brakes erases that spent effort, which feels really bad.

In a car, it doesn't matter — you stop and accelerate with exactly the same trivial effort of pressing a pedal.

So all the grandstanding that cars stop at stop signs (since when, but ok), and cyclists don't is like bragging that you beat a disabled person in a 100m sprint. Good job, I guess.

2. Stop signs and traffic lights are made for cars, because of their speed, how dangerous they are, and how bad their visibility is. Cyclists are like pedestrians in that they do not need traffic lights, they can navigate just fine with just body language.

Telling whether running a red light would be safe in a car is essentially impossible, you're going too fast and can't see much, can't hear anything either. But on a bike you have perfect visibility, there's no box of metal all around you. You can hear quite well too.

Stop signs are an even better example. Literally the only reason for their use instead of yield signs is that the visibility at the intersection is bad enough that you need to stop to be able to yield. But that is only the case because your visibility is so bad in the first place.

Stop signs literally never make sense for bikes — there's no "hood", so your head is basically where the vehicle starts and you can lean forward to make that literally true if really needed, and you've got perfect visibility all around, no blind spots.

Hence why in a lot of places cyclists can legally treat red lights like stop signs and stop signs like yield signs.

[1]: "The frequency illusion is a cognitive bias in which a person notices a specific concept, word, or product more frequently after recently becoming aware of it."

[2]: "The negativity bias, is a cognitive bias that human cognition is relatively more affected by a negative affect than an equally potent positive affect."

Are you actually serious right now? If I'm walking/cycling to work, which I usually am, then what? Is your job more important than mine? How can you possibly tell where I work or where I'm going? Ridiculous.