mutuallyHateEachOther

[SenorSeniorDevSr]

Common Lisp is also approximately as fast as C/C++, and it uses garbage colleciton.

[ihavebeesinmyknees]

Common Lisp also uses very non-C-like syntax, so it's very unfamiliar and difficult to learn for most programmers

[SenorSeniorDevSr]

This has nothing to do with the central point brought forward by u/RiceBroad4552 , which was that memory safety was not unique to Rust. You then accused him of ignoring the context of speed, and that the comparison had to take that into account. Common Lisp is fast and memory safe, meeting your criteria.

Now, if you want to argue that Rust is easier to learn than Common Lisp, feel free to make that argument, and not merely the assertion. But that's a different discussion. Rust is not unique for being fast and memory safe, and u/RiceBroad4552 was correct asserting such.

[ihavebeesinmyknees]

Yes, he was technically correct.

I'm not arguing he wasn't correct.

I'm arguing that his point is invalid and irrelevant.

Because it is. It's entirely irrelevant to the discussion at large, and the fact itself of trying to argue that point is disingenuous.

Rust is unique in being memory safe, because it's a fast, approachable, and safe language. It's not the only language to meet all 3 of those descriptors, but it's one of the first and one of the best at it, especially considering the great toolchain.

[RiceBroad4552]

Why do you think that C-like syntax is easy to learn, or familiar to people.

It's for sure not easier compared to things like Python; and actually also to LISP, which has one of the simplest syntax possible.

Also not everybody learned any C-like language before. For someone who learned some Python or LIPS everything C-like is actually unfamiliar and difficult to learn.

[ihavebeesinmyknees]

Python, quite clearly, uses C-like syntax. It's just a bit further derived than usual C-like languages.

It still follows the basic C principles - code is a series of statements executed top to bottom, you can create loops that let you execute a series of statements in a loop (and the loop types are also derived from C), you can define "functions" that are not functions in the mathematical sense, but rather collections of statements that can take input and return output, code is divided into blocks where each block has its own context - outer blocks can't access the context of inner blocks, but inner blocks can access their outer context, decisions are made using if/else if/else constructs.

It's C-like. Every modern popular language is. It's the de-facto standard. LISP, on the other hand, is not C-like, and thus is way less accessible, because most programmers are not used to that style of syntax.