But that’s not actually true in general; there is a default branch concept in forges, and an integration and/or release branch in most recommended workflows. That’s the trunk.

Fair, but it’s one that the typical tools for finding bugs, tests and static analysis, cannot actually help with.

Believe me, whitespace-correct scripting is absolutely an issue.

You’re right that it’s annoying when filenames diverge right at a character that must be escaped.

For interactive use, tab-completion essentially makes this a non-issue, because shells add escaping in the appropriate places.

For scripting, where spaces are harder to deal with, unfortunately there’s just not much you can do; your two options are basically to learn all of your particular shell’s patterns for dealing with whitespace in filenames, or only write scripts in something other than a POSIX shell.

That’s fair; Python, Swift, and most Lisps all use or have previously used reference-counting. But the quoted sentence isn’t wrong, since it said no “garbage collection pauses” rather than “garbage collection.”

“Garbage collection” is ambiguous, actually; reference counting is traditionally considered a kind of “garbage collection”. The type you’re thinking of is called “tracing garbage collection,” but the term “garbage collection” is often used to specifically mean “tracing garbage collection.”

To be fair, the drop/dealloc “pause” is very different from what people usually mean when they say “garbage collection pause”, i.e. stop-the-world (…or at least a slice of the world).

This is hilarious. I’m not sure how often anyone would actually need to verbalize arbitrary binary data, but I do see an advantage over base64 since the English letter names are so often phonetically similar.

“Heartbreaking: the worst person you know just made a great point”

deleted by creator

Right, but their endorsement is still likely to do more harm than good in terms of public perception of the law, I think.

Well, that’s fair; first-class support for running an actual Linux kernel, with the containerization support that implies, is one of the reasons I prefer Windows with WSL as a dev environment when using Docker (at least, in companies where the IT team won’t just let you run native Linux).

MacOS and docker is asking for trouble.

That’s a real problem! MacOS and Docker are extremely common for development, and a scripting language like Python should just work with them, not just at the language level (which is good enough) but in the ecosystem and tooling. The latter is what Astral is trying to improve.

… until you have an off day, or you get bored of coding, run off to join the circus as a professional knife-juggler and your codebase is inherited by someone of more conventional aptitude.

Sometimes you even have to deal with having mere mortals on your team!

For what it’s worth, I agree with you about branches, and there are various ongoing discussions about how to make working with branches more convenient. I use an experimental feature called “advance branches” that makes it mostly fit my workflows, and the other benefits of jj are sufficient that I haven’t switched back to git.

I create log files of runs, temporary helper scripts, build output, etc. in my working copy all the time.

The solution to this is to just have a more aggressive .gitignore. But also, note that the “working copy commit” isn’t generally something you want to push or keep; think of it more like a combination of the git staging index and an automatic stash.

Same

You didn’t say “programmers should be aware that rust doesn’t automatically mean safe”. You said:

People just think that applying arbitrary rules somehow makes software magically more secure…

You then went on to mention unsafe, conflating “security” and “safety”; Rust’s guarantees are around safety, not security, so it sounds like you really mean “more safe” here. But Rust does make software more safe than C++: it prohibits memory safety issues that are permitted by C++.

You then acknowledged:

I understand that rust forces things to be more secure

…which seems to be the opposite of your original statement that Rust doesn’t make software “more secure”. But in the same comment:

It’s not not like there’s some guarantee that rust is automatically safe…

…well, no, there IS a guarantee that Rust is “automatically” (memory) safe, and to violate that safety, your program must either explicitly opt out of that “automatic” guarantee (using unsafe) or exploit (intentionally or not) a compiler bug.

…and C++ is automatically unsafe.

This is also true! “Safety” is a property of proofs: it means that a specific undesirable thing cannot happen. The C++ compiler doesn’t provide safety properties[1]. The opposite of “safety” is “liveness”, meaning that some desirable thing does happen, and C++ does arguably provide certain liveness properties, in particular RAII, which guarantees that destructors will be called when leaving a call-stack frame.

[1] This is probably over-broad, but I can’t think of any safety properties C++ the language does provide. You can enforce your own safety properties in library code, and the standard library provides some; for instance, mutexes have safety guarantees.

I guess what you mean is that Rust doesn’t advertise the compiler as being bug-free?

The massive difference here is that C++ has no soundness guarantees even when the compiler is working as intended, whereas Rust actually does in fact give soundness guarantees in the absence of compiler bugs.

Rust doesn’t have a formal specification other than “whatever the fuck our team hallucinated in this compiler version”

That’s simply not true. The Reference, while not an ISO-style formal spec, does actually specify most of the intended language behavior, and incrementally approaches completion over time. But even if you insist on an ISO-style formal spec, there’s Ferrocene: https://ferrous-systems.com/blog/the-ferrocene-language-specification-is-here/

it fucks your day because you’re not careful

The cve-rs vulnerability is actually not really something you’d ever write by accident. Also note that the bug report has multiple versions because, even though a “full” solution is pending some deeper compiler changes, the first two three versions of the exploit are now caught by the compiler. So, like I said, the compiler bugs do get fixed over time.

Yeah, and that falls under the first category, bugs in the compiler: https://github.com/rust-lang/rust/issues/25860

(All exploits in that repo are possible due to that bug.)