Read it here:
http://www-formal.stanford.edu/jmc/recursive.html
"This paper appeared in Communications of the ACM in April 1960. It is the original paper on Lisp."
The name stands for "LISt Processor", which is a lot like calling a computer "a thing that does calculations" - while true it is massively understating its capabilities. LISP is nothing less than the second most mutable language in terms of syntax that I am aware of and despite it having been invented in 1960 the Lisp family of languages is very much alive - in good part due to the bastard child Javascript which, unbeknownst to most, is actually a distant cousin of LISP (in that it got started as a Scheme clone, and Scheme is a modern variant of LISP)
Unlike Javascript, however, LISP is extremely abstract and has the rather unique feature that data and code are rather interchangeable - to the point where the language defines an "apply" and an "eval" function, which we'll later see, are defined entirely in the language but at the same time are full LISP interpreters and therefore allow arbitrary runtime compilation trivially.
It's the original paper on LISP, it introduces LISP from the very start at a time where programming was very new, x86 did not exist yet and your average person had never seen a computer much less used one. As such the introduction begins with Math, not particularly difficult Math either. It then step by step introduces every concept you need to understand this glorious language. You won't see any use of weird nebulous buzzwords either because it's a research paper in a time where there wasn't a huge private industry interested in looking like they have the shiniest new thing, nor was there enough time yet to cloud things, as such you have a certain amount of clarity.
If you were to instead try to read a modern report on a language and its features you'd get a way more convoluted and lengthy read, where all those additional features are added already and those intricacies and historic idiosyncrasies that only make sense because removing them would cost more and therefore are difficult to understand, instead of the clear and relatively concise read the paper provides. For example the C++14 draft is 1352 pages, while the LISP paper is only 34 pages - and most of them concern themselves with the introducing the concept and not just describing it.
One of the most profound realizations I've made when reading said paper is that the set of builtin functions for LISP is extremely low. All we need is car, cdr, cons, label, quote, atom, eq and conditionals and the only builtin syntax elements we have are "(", "." and ")" - everything else, including extensive syntax modifications, can be implemented via those, yes this includes the general function application function "apply". For comparison C provides about 48 builtin operators (although some of them could be expressed using combination of the other ones) and many more things, which bogs compilation and the expressiveness of the language down - in C there are no ways to implement those builtins while if you read the paper you'll see in LISP it's very much possible.
This might be the first paper which describes Garbage Collection, what with it having just been invented by McCarthy, and it does so in a short, clear and succinct way. If you don't want to read anything else from the paper - read at least this section. Starting on page 26, in Section 4.c "Free-Storage List", he explains what it is, how it works/how one would implement it and a key limitation it had back then (and to a degree still has).
Have you ever had to worry about whether or not to use punch cards to store your compiled code on for speed? Or how machine representation corresponds with magnetic tape representation?
If you are reading this, chances are you hadn't. However McCarthy had to and the paper reflects those things, as such it's almost an archaeological endeavour to read the paper - it's a remnant from a world long gone, familiar in parts and unimaginable strange in others and at all times do you get this feeling that you are reading a crucial piece of history.
Remember how I said LISP is the second most mutable language I know in terms of syntax? This paper casually introduces the most mutable: linear LISP. It removes "(", "." and ")" from the set of builtins. And as the paper notes: "mathematically, linear LISP includes LISP", meaning that any LISP program is a valid linear LISP program, but linear LISP programs are not necessarily valid LISP programs. I might do a post on linear LISP itself somewhen in the future, since it seems like no one knows about it and its L-Expressions.
Do you want to see where everything came from? A view on the world that was when computer science was young? A view on a paper that profoundly changed the world and a glimpse of the man who made it all possible? Or do you simply want to learn about a new (well, technically old) way of programming? Or just expand your horizon a bit?
If you said yes to any of those, you should definitely read the paper, give it a shot and don't just give up if you get stuck - try a different section, Section 3 can get a bit difficult to digest on the first reading but still worth the read.
Read it here:
http://www-formal.stanford.edu/jmc/recursive.html
"This paper appeared in Communications of the ACM in April 1960. It is the original paper on Lisp."