> If a project in an unsafe language has ever had a memory bug (I'm looking at you, Bun), the maintainers objectively have a track record of not being capable of manual memory management. You wouldn't put a person who has a track record of crashing busses at the wheel of a school bus.

If you’re serious, you should stop using Rust (which happens to contain an unsafe language): https://github.com/rust-lang/rust/issues/44800

Just compare the Buns and Deno issue trackers.

Bun is segfaults galore, I’ve stumbled upon them.

In Deno they essentially only come from integrating with C and C++ libraries.

Hmm... A bug report from near a decade ago, where the bug was fixed within days. Not sure what your point is. If anything, it shows how much Rust cares about memory safety, because elsewhere it wouldn't be a compiler bug in the first place.

> Not sure what your point is

I’m not the previous poster but it seems pretty clear the point is to show how silly that absolutist pronouncement is.

Being so absolutist is silly but their counter argument is very weak. Can I invalidate any memory safe language by dredging up old bug reports? Java had a bug once I guess it's over, everyone back to C. The argument is so thin it's hard to tell what they're trying to say.

It's just as reductive as the person they're replying to.

> Being so absolutist is silly but their counter argument is very weak.

The entire point is that being so absolutist is silly.

The comment reflects the previous poster's logic back at them so they (or others) can hopefully see how little sense it makes.

You seem to be trying to see some additional argument about rust being bad/invalid, but there isn't one... The reason that argument is, indeed, "very weak" and "so thin", as you say, is that it isn't even there at all.

> The entire point is that being so absolutist is silly.

You're misinterpreting what Rust people are telling you.

- Rust is safe lang

- Nah, C is safe if you're good

- Rust evangelical gestures towards billions or CVEs brought on by overly-sure C programmers

- Yeah, well, a version of Rust was unsafe for few months ten years ago. Besides Zig prevents more bugs than C and is the successor

- Rust person points to Bun's abysmal record

- Stop being absolutist.

The issue is that in C or Zig few people can write mostly UB free code. In Rust anyone can write UB free code as long as they don't reach for unsafe.

It seems odd to me to put this much effort into misunderstanding what people are saying. You just end up talking past everyone, essentially talking to no one about nothing.

If it wasn't obvious from my ramble, Rust concerns are pragmatic, not absolutist. The only absolutism is that for memory safety to be truly upheld, you can't half-ass it (Zig) or ignore it (C).

Some properties are like that.

LISP ;-)

This, lisp is perfect for representing arbitrary data, nesting is just another sexpr, easy to produce, easy to parse and easy to debug / reason about

When I did my degree, the years prior to mine had some flexibility choosing the implementation language for compilers class.

Lisp and Prolog were forbidden due to how easy the whole exercise would be.

I can appreciate this answer, but I don't think it's really what I'm asking.

I think I'm more looking for some kind of standardized struct definition that translates easily to llvm IR and is flexible enough for a wide variety of languages to target.

Something like this: https://gist.github.com/thomaswp/8c8ef19bd5203ce8b6cd4d6df5e... (Which doesn't meet my criteria because AFAICT isn't used by anything, but is reasonably close to what I want) or this: https://docs.rs/sap-ast/latest/src/ast/lib.rs.html#1-83 (which seems specific to SAP, I would like something more general)

I am sure they have this. What tends to happen is that the gradual rollout system becomes too slow for some rare, low latency rollout requirements, so a config system is introduced that fulfills the requirements. For example, let’s say you have a gradual rollout for binaries (slow) and configuration (fast). Over time, the fast rollout of the configuration system will cause outages, so it’s slowed down. Then a requirement pops up for which the config system is too slow and someone identifies a global system with no gradual rollout (e.g. a database) to be used as the solution. That solution will be compliant with all the processes that have been introduced to the letter, because so far nobody has thought of using a single database row for global configuration yet. Add new processes whenever this happens and at some point everything will be too slow and taking on more risk becomes necessary to stay competitive. So processes are adjusted. Repeat forever.

Maybe it helps to think of matrix multiplication as a special case of the composition of linear transformation. In the finite dimensional case they can be expressed as matrix multiplications.

The whole article starts with the implicit assumption that all bases are orthonormal and then throws linear algebra out of the window completely.

Bismarck was afraid of workers unionizing and transformed a working healthcare system owned by workers into a state owned one. That move significantly reduced the utility of worker unions, which was the goal behind it.

A working healthcare system is dramatically overstating it, and his system - like the current German one - had relatively speaking low state involvement. The German system remains one of the least state controlled universal healthcare systems to this day.

I do agree with you that a lot of his motivation was to counter the socialists and unions though.

Though I'll note that already before Bismarck, the socialists largely didn't oppose state involvement - Marx famously lambasted the Gotha program of what became the SPD in part for their willingness to trust the state.

I don’t think it’s a wordplay with the r-word, but rather a reference to the famous Shakespeare quote: “Hoist with his own petard”. It’s become an English proverb. (A petard is a smallish bomb)

From péter, to fart.

Possibly entered the language as a saying due to Shakespeare being scurrilous.

Search for memory wall. Moore’s law died a decade ago for DRAM

I actually used the examples from that paper for testing. The results that they are showing in the paper are different from mine and I think that git changed as well. I believe the conclusions from that paper no longer hold.

Good point, thanks!