[1] https://courses.engr.illinois.edu/cs421/sp2012/project/mccar...
It's usual programming style to use CAR/CDR when working with CONS trees/graphs and FIRST/REST when working with lists.
Do I think it's a big problem? Not really. Are the names less than optimal? Yes.
> Are the names less than optimal? Yes.
I don't think that's self-evident. The only better alternatives I've ever heard suggested are something like left and right, which I think are probably slightly clearer names for what the functions do, but not significantly so (I don't think "a cons is a thing with a left and right side" is that much more intuitive than "a cons is a thing with two parts called a car and a cdr").
Further, I think in 1959 when most everyone using Lisp was hacking on the implementation itself, names that are mnemonic for what the machine they were actually using is actually doing make sense; I don't think they're clearly sub-optimal now, but I think they were even less so in 1959.
(And then you ask me what would be a better name, and I don't have a perfect answer. "left" and "right" are the best I know of...)
I think it's perfectly acceptable if there aren't really any better names for the abstraction you're creating. car and cdr work just fine as made-up arbitrary names for an abstraction that doesn't really have any more natural names for them; the fact that 60 years ago they weren't actually entirely arbitrary doesn't really change that.
By the way, the C and R are not machine specific; any machine can have a "register" and any register can have "contents". On any machine where we implement cons cells, we can just call the two fields registers, understood as being A and D.
These, in turn, can be "ante" and "de", if someone desperately needs mnemonics:
https://en.wiktionary.org/wiki/ante
https://www.etymonline.com/word/de-
"active word-forming element in English and in many words inherited from French and Latin, from Latin de "down, down from, from, off; concerning."
> By the way, the C and R are not machine specific; any machine can have a "register"
Slight nitpick: the first machine on which I had a decent Lisp to use (Portable Standard Lisp) was a Burroughs 6800, a stack machine with no general purpose registers, or indeed any registers directly accessible by the programmer.
If a cons cell is a context with two registers (R) whose contents we can access (C), the only vestiges of that IBM machine are the A and D letters sandwiched in between to distinguish them.
Compared to how option letters change meaning between Unix commands, it's nothing. -h help? Nope, h)uman readable sizes.
^ to anchor regex at beginning; $ for end. Because on common keyboards, ^ is on the right, and $ on the left!
Are there other, much better names for the two parts of a pair? First and second aren't great because they're not clear that it's a pair and not a larger sequence (and the difference is important in Lisp; since lists are built on conses, it would be odd to get the tail of a list by calling 'second'). The only other names I can think of would be something like left and right, but I don't think those would be substantially easier to understand for beginners than car and cdr.
When working with lists, many people prefer to use the functions first and rest, which behave identically to car and cdr but are more meaningfully named for list applications. They would be terrible names for the general cons-handling functions, though.
I learned car/cdr in school so that's what I use.
I don’t mind car and cdr though. I kind of wish they were in Clojure tbh. It feels nice to pay tribute to a half-century of computing history.
Are you talking about Either types? OCaml and Haskell at least both call car and cdr fst and snd respectively, but they're rarely used.
As for left and right as names, I don't think they're any worse than car and cdr, I just don't think they're substantially better.
Calling the lefthand child of a node in a binary tree the "first" and the righthand child the "rest" seems like a markedly worse naming system than random made-up names, to me, because the use of English names seems to be implying meaning that it doesn't really offer.
The idea of a thing with two values, one on the left side and one on the right side is probably a bit more intuitive, but I really doubt it's that much moreso than just saying it has two parts called the car and the cdr. People who've never touched a 704 have been learning about conses as a data structure with two parts, a car and a cdr, for almost 60 years; to most of them, it's just vocabulary you learn now, the same way that numerator and denominator are just arbitrary names to people learning fractions.
I also think it's interesting how much people complain about car and cdr yet it's very rare that people complain about cons, which is just as badly named. It should probably have been called make-pair or something, which I think is a much bigger improvement than car vs lhs. But really, it's 3 words of vocabulary, whose definitions can be completely understood by
(car (cons x y)) = x
(cdr (cons x y)) = y
While lisp is old, it's never picked up many users. This is the kind of little thing which makes me not want to teach it (not just this, but just lots of little ways it seems stuck in history).
(with-open-file (input "foo.txt")
(loop for line = (read-line input nil)
while line
do (write-line line)))
This was my experience too. In university, Lisp seemed like an awkward, limited language for doing some CS algorithms. So i totally overlooked it.
Fast forward 12 years later, reading in depth about Common Lisp and using it as a general purpose programming language, it's totally awesome.
Man, I sure dodged a bullet there. Some decade later, I got into Lisp in a big way (the real one); the rest is history.
Basically when the world "rebooted" into garbage collected, managed languages, it was amid a sort of Lisp amnesia. A lot of that was due to new people who had no such memory to recall.
Prior to this general movement, there were severe barriers in place against anything memory-managed.
And anyway, even if everyone who had already been programming in 1980 switched to Lisp today, it would be a drop in the bucket.
I think the original Lisp people didn't persevere enough. They peaked early. By the time Java and whatnot came around, the presence wasn't there.