Just because it doesn't matter for most users doesn't mean it isn't a real limitation. I acknowledged as much in my original comment.

Indeed, I had no idea there are multiple languages referred to as "APL".

I feel like most people defending C++ resort to "people shouldn't use those features that way". 😅

As far as I can tell, pointer arithmetic was not originally part of PASCAL; it's just included as an extension in many implementations, but not all. Delphi, the most common modern dialect, only has optional pointer arithmetic, and only in certain regions of the code, kind of like unsafe in Rust. There are also optional bounds checks in many (possibly most) dialects. And in any case, there are other ways in which C is unsafe.

True, but AFAIK they all sucked really bad.

That's pure assumption and, as far as I can tell, not actually true. PASCAL was a strong contender. No language was competitive with handwritten assembly for several decades after C's invention, and there's no fundamental reason why PASCAL couldn't benefit from intense compiler optimizations just as C has.

Here are some papers from before C "won", a more recent article about how PASCAL "lost", and a forum thread about what using PASCAL was actually like. None of them indicate a strong performance advantage for C.

• https://link.springer.com/content/pdf/10.1007/3-540-09745-7_3.pdf
• https://dl.acm.org/doi/pdf/10.1145/356869.356872
• https://www.deusinmachina.net/p/pascal-the-language-that-almost-took
• https://news.ycombinator.com/item?id=10202666

Sounds like we're actually in agreement about most of this.

I'm okay with languages limiting their "expressive" power in order to provide stronger correctness guarantees or just limit how "weird" code looks; but this is largely because I've worked on many projects where someone had written a heap of difficult-to-understand code, and I doubt such limitations would be appealing if I were working strictly on my own.

I also don't really see the appeal of Java-style inheritance, but to be honest I didn't use Scala for long enough to know whether or not I agree that Scala does inheritance "right".

It does make sense that Rust provides mutability in some cases where Scala doesn't. Rust's superpower, enabled by the borrow checker, is effectively "safe mutability." I hope other, simpler languages build on this invention.

I mean, if you're talking about CVEs permitting attackers to get control of the hardware of lots of systems, then yes, I agree

How is await like comefrom, any more than threading is like comefrom? The variable context is preserved and you have no control over what is executed before the await returns.

Does the catchphrase "blazing fast" ring any bells? Some people care.

(Arguably that's just the pendulum swinging the other way; Ruby, Python, and Java ruled the software world for a while, and I think that's a large part of why the Go and Rust communities make such a big deal about speed.)

Yeah, agreed.

Well, for GitHub Actions, there's this: https://github.com/nektos/act

The only semi-realistic way I can see Bash becoming mostly obsolete is with a tool that provides automated migration of large scripts, and the only project I know of that's even attempting that is Oil: https://www.oilshell.org/

But for spawning a command in a subprocess, there really ought to be a standard OS API that doesn't involve invoking a shell at all. I expect that most or all implementations of posix_spawn and execve don't invoke a shell, but the standard call to start a process on Windows, CreateProcess, apparently does involve cmd.exe for some bizarre reason, and that's why this is a problem in the first place.

That quote from Meyer about contravariance not being "useful" is either a misreading of the cited source (the closest thing to a direct quote is about C++'s lack of variance) or, more charitably, a massive oversimplification. I don't know Eiffel, but from Meyer's speech, it sounds like Eiffel lets you choose between something like covariance and something like contravariance for each method. Unfortunately, the second link provided for context seems to be broken.

...I didn't say that it does.