7 ms·
Yes, code is data, but that's not what makes Lisp cool
- deleted 9y ago[deleted]
- deleted 9y ago[deleted]
- erikj 9y agoI think some charts would communicate the point better than pure text in this case.
- torstenvl 9y agoThis is good! Why did you omit the analogy that code-manipulation-in-Lisp : code-manipualtion-in-C :: webpage-manipulation-via-the-DOM : webpage-manipulation-via-regex ? I thought it was very effective.
- lisper 9y agoOversight. I wrote this in a hurry. Maybe you can post that as a comment on the blog.
- taeric 9y agoFun read. Though, I suspect this is what it feels like to be in a choir. :D Small critique on presentation. The title clearly indicates there are two parts to this, a brief exploration on "code is data", followed by a dip into what makes lisp cool. Having some visual indicator saying "we are now at the cool part" would be good.
- ljm 9y agoFor years I've tried to play with Lisp languages: reading books like Beautiful Racket, experimenting with Clojure/ClojureScript, etc. and it's often conflicted with what I'm trying out in other languages to understand different approaches to programming (Rust, F#, Haskell...). Almost every year I come crawling back to emacs and I start putting the pieces back together (first, by hand, then Spacemacs a couple of times, then by hand again but in a different way). It has such an incredible allure and it's a joy to write. I don't know what else I would write in Lisp right now so I just abandon my config and rebuild it to get that feeling again.
- cgearhart 9y agoThis was very helpful. Thanks.
- lisper 9y agoMy pleasure. Thanks for the kind words.
- mattgreenrocks 9y agoThis was great, thank you!
- kqr 9y agoThere is one more thing that frequently comes up -- for good reason -- but is not really a feature unique to Lisp, only a strong part of Lisp culture: live coding, inspection, self-documentation and hotswapping, or what we call hackability. If you don't like how some Lisp application works, you can frequently just replace the contentious parts as the program is running. If something does not seem right, it is trivial to inspect all parts of the internal state. If you don't understand a variable, you can look up its documentation inside the running program. It's a fantastic experience.
- hippich 9y agoCould you point total newb to tutorial showing these off?
- taeric 9y agoWould you be ok seeing an interactive session in emacs? If so, I can easily get you an example created of that.
- michaericalribo 9y agoI sure would
- taeric 9y agoI'll work to get a basic video by tomorrow. Nothing fancy, just showing how you can immediately define and redefine things in an emacs session. (I have aspirations to use this as an excuse to fix something in how org-mode connects to postgres databases...)
- taeric 9y agoI grossly overestimated my chances of getting on a computer this weekend. To the extent that I didn't. :( So, I didn't get a video made. My humble apologies. Rather than just leave this hanging with no response, I'll still try and get a video while at the office this week. In the meantime, https://www.youtube.com/watch?v=VEcobuYr5wg https://www.youtube.com/watch?v=VEcobuYr5wg shows a much more impressive example than what I was planning. This one actually shows "live coding" with a webpage. I was just going to show how the help system and some basic debugging in emacs works.
- nocman 9y ago> First, the idea that "code is data" is a popular aphorism, but even the most casual reflection on what this slogan actually means will reveal that it can't possibly be the right answer. I disagree with this statement. Support for your argument seems to stem from the other statement you then make: "What makes Lisp cool is not that programs are data (because all programs are data), but that they are a particular kind of data.". Personally I think it's not a good argument, for the following reason: I would guess that 99% of the people who argue that "code is data" is what makes Lisp cool, mean exactly that -- that code is expressed as lists of lists (and they are thinking of all the nice implications of that). So effectively, you are saying that the statement is invalid because it could mean something else, but almost all of the people who make that statement are making the exact same argument you are for why Lisp is cool. I opened your article expecting to find an explanation of why some other feature or set of features of Lisp was way more important/useful than just code being written as lists of lists, only to find that you were arguing for the importance of that exact feature. So while it is worth pointing out that having code as a list of lists has awesome implications, I guess I would have gone about discussing in a different way.
- AnimalMuppet 9y agoI don't think he's trying to persuade people who already buy Lisp. And for everyone else, they can get hung up on "code is data" if it's presented as a "Lisp only" kind of thing, so he avoids that whole discussion and comes at it another way.
- nocman 9y agoAs I said in my reply above, I'm all for the clarification of what Lisp programmers mean by "code is data". I just disagree that the fact that someone may misunderstand what Lisp programmers mean when they use the phrase somehow makes it an invalid thing for them to say. "code is data" has a specific meaning to Lisp programmers, and it is completely valid.
- lisper 9y agoThis piece was written specifically as a followup to this comment: https://news.ycombinator.com/item?id=16388578 https://news.ycombinator.com/item?id=16388578 and the subsequent replies. I was surprised that this message resonated. I thought it was obvious, but it's obviously not. > I would guess that 99% of the people who argue that "code is data" is what makes Lisp cool, mean exactly that -- that code is expressed as lists of lists But "code is data" and "code is expressed as lists of lists" are not the same statement. And the difference matters.
- AnimalMuppet 9y agoThat was a great explanation. But if I understand this correctly, you're actually agreeing that homoiconicity is (at least a big part of) what makes Lisp cool, but you're avoiding using the word. Or, perhaps, you're saying that it's not just homoiconicity. It's that it's the right homoiconicity - lists. Lists are well-suited for being processed as data in Lisp (kind of the point of Lisp, really), and lists are great for representing code (abstract syntax trees), and lists are really simple to parse if they're represented cleanly.
- lisper 9y ago> it's not just homoiconicity. It's that it's the right homoiconicity That is exactly right.
- deleted 9y ago[deleted]
- carapace 9y agoThe name LISP derives from "LISt Processor". ;-P Very nice article.
- anon04532 9y agoIt's actually Language of Irritating Superfluous Parenthesis. Anyway, even saying "code is linked list" does not really cut it as you can represent 'ordinary' programming language program as a list of tokens. What makes LISP special is that code is a first class citizen and the mapping between code you edit and the programs run-time memory representation is trivial. Combined, you get this special feeling that "code is data".
- carapace 9y agoWell, I think lisper nailed it in the article: It's not just that the code is represented as data structured in linked-lists, it's that that data exposes the semantic structure of the code in ways that are more pragmatically useful (among other nice properties) than char strings. When you get into the LISP interpreter itself, which is just a linked-list structure describing how to process linked-list structures (like itself) as code, well... Here's William Byrd on "The Most Beautiful Program Ever Written" (ye LISP interpreter) https://www.youtube.com/watch?v=OyfBQmvr2Hc https://www.youtube.com/watch?v=OyfBQmvr2Hc
- lispm 9y agoI don't think programs are usually strings. Most programs I see are text files. If I edit them in an editor, I don't know what data structure represents them, but it might be a doubly linked list of strings, or some other data structure. If a compiler reads a program, it uses typically a stream of characters. A string would be something like this: a delimiter, some characters, the delimiter. Example: "a + b". It could also be a string data object in some program. But programs are not always represented as strings and many are not. Sometimes they are. For example an EVAL procedure may take a string as an argument - then code is represented as a string or passed at runtime as a string object. When we say in Lisp code is data, we actually mean code is data, but not in the trivial form of text representation formats (text files, strings, ...). It's an abbreviation. We expect usually not to mention, that it is not of the trivial version. Like when we speak of a picture with lots of color, we don't mention that this excludes pictures with only black, white and shades of grey. Generally, if I see a + b then it says nothing about a data structure and its syntax to represent that. All I know that it must be a syntactical legal expression in some programming language. If I see Lisp code in the form of (+ a b) I know that this uses the data syntax for s-expressions to represent that code. I then would require that this is syntactical legal Lisp - THIS requires that in an s-expression, the + operator comes first - that it uses prefix syntax. Wien we mean code as data, we mean that Lisp uaes an actual and explicit data format to encode its programs: s-expressions. The data format is similar to JSON or XML, in that it has an explicit external representation. It's also similar to JSON, because both have an internal representation in a programming language. If we would use JSON as a format to encode programs, we would also be able to say, code is data. S-expressions are slightly more effective as data encoding for programs than JSON, because it uses less delimiters and encodes a rich set of data structures. So, yes. Code with a non-trivial and simple data-representation makes Lisp cool.
- xfer 9y ago> Wien we mean code as data, we mean that Lisp uaes an actual and explicit data format to encode its programs: s-expressions. Every programming language uses an "actual" and explicit data format to encode its programs, the valid programs all parse to the corresponding AST. The only thing unique about Lisp here is a construct to parse the serialization format(s-expressions) and perform actions on it i.e. macros. The fact that parsing s-expressions is so trivial makes it seem like manipulating code as data is somehow unique to Lisp.
- bsder 9y ago> Parsing S-expressions is super easy. No, it's !@#$%^& not. This pisses me off every single time I see it. Parsing s-expressions requires on-the-fly allocation of memory and something resembling recursion. If you can't allocate memory--good luck. If you don't have recursion in your language, you're going to have to build it yourself--good luck. And god help you if you have dot notation--(a b) is a tree of (a . (b . null)) while (a . b) is an actual pair. Clojure shooting the idea of building things out of cons pairs and using lists composed of arrays is one of its most important design choices.
- taeric 9y agoStrictly, parsing s-expressions shouldn't require the allocation of memory "on-the-fly". At least, not moreso than anything else you will be doing. Now, defun/define/etc will require more memory management than people would care to admit to. However, just parsing the s-expression is dead simple. Recursion will make it easier, but I'm actually not sure it is required here. For the most part, just keeping a manual stack of what you're dealing with would be easy enough and won't take much effort. Again I'll stress, though; that anyone that thinks implementing a lisp is dead easy, is likely overstating how easy it can be done. Easier than you could think. Not guaranteed easier than you think.
- phoe-krk 9y agoParsing s-expressions requires on-the-fly allocation of memory and something resembling recursion. Parsing any code requires on-the-fly allocation of memory because your function can contain 10 or 100 or 1000 lines of code and, when you are at the beginning, you don't know how long the whole function is. Parsing any code requires something resembling recursion because your function can contain 3 or 10 or 20 nested scopes and, when you are at the beginning, you don't know how deep the whole function is. Of course that you can say that you can pre-read the code and compute how much memory you need beforehand, but that applies to Lisp as much as it applies to any other language.
- bsder 9y ago> Parsing any code requires on-the-fly allocation of memory because your function can contain 10 or 100 or 1000 lines of code and, when you are at the beginning, you don't know how long the whole function is. This is not necessarily true. Parsing a language can be bounded by the grammar. If you don't have indefinitely nested structures (like arithmetic open parentheses), your parsing is linear and you can bound the memory (ie. your parsing memory cannot be longer than your input string, for example). I believe that Tcl and Microsoft Basic fell into this category. (I believe that Ousterhout used to actually generate code in the input buffer behind the current parsing point precisely because Tcl was designed to do this). > Parsing any code requires something resembling recursion because your function can contain 3 or 10 or 20 nested scopes and, when you are at the beginning, you don't know how deep the whole function is. Indefinitely nested lexical scoping is not a requirement for a language. Famously Javascript screws up all manner of programmers because they expect that to be true, but it is not. And many languages start out with a single global scope and grow lexical scoping only after they gain some complexity.