22 ms·

How Lisp Became God's Own Programming Language

614 points by chwolfe 8y ago

keithnz 8y ago
I thought god mucked around on quantum computers, and I think we can all feel a little bit better that god can't seem to write bug free code either.
- wwweston 8y ago
  Either that, or it's all a feature.
  - azernik 8y ago
    And on the seventh day, he set the version number to pi and declared all bugs to be features.
- unit91 8y ago
  If you don't believe in God, why speak so spitefully about him?
  - monocasa 8y ago
    Because of the damage the concept has done?
    - dang 8y ago
      Please keep religious flamewar far away from this site.
vertline3 8y ago
in XKCD comic "Lisp" God also says the universe was mostly hacked together with Perl. Edit: I see I read the story but I didn't click the first comic, just the second one, Sorry disregard. Another language that gets holy reverence is smalltalk.
- piinbinary 8y ago
  https://xkcd.com/224/ https://xkcd.com/224/
  - vertline3 8y ago
    Thank you!
adamnemecek 8y ago
The lisp circle jerk is a little too much sometimes.
- gnulinux 8y ago
  Why do you think it's a circlejerk? I'm yet to see an idea in the domain of PLs that's as effective as lisp (dependent types come close). Lisp is a whole package, it solves bunch of problems very elegantly. All "good" languages solve problems one by one by introducing exceptions and rules and features whereas lisp did it by introducing a totally novel, elegant concept. It's hard not to be mystified by lisp. I'm not an old school hacker, but there is certainly something fascinating about lisp.
  - adamnemecek 8y ago
    Sure but calling it a “God’s language” is a little too much.
- jnordwick 8y ago
  Better than the Haskell one.
  - hyperion2010 8y ago
    Just because it has been going on for longer and the veterans actually know how to get someone other than themselves off ;)
- tannhaeuser 8y ago
  I must agree. "God's Own Programming Language" (not meant as satire) is certainly indicative of the psychological phenomenon of a superiority complex in the Lisp community.
  - johan_larson 8y ago
    Yeah, even MIT eventually gave up on using Scheme as a first programming language. The Lisp community may have the worst ratio of self-regard to actual accomplishments in our entire industry. Not one of the great companies is built on Lisp. I don't think it's even a second-tier language at the FAANGs.
oldandtired 8y ago
Lisp - oh what it could have been. It had such potential, but then it got broken. I find it fascinating that those who are dedicated to the proselytisation of Lisp don't see the brokenness of the language. For them, all of the broken things are the features of the language. Scheme was one attempt to fix some of those flaws. In latter times, we see the development of Kernel to fix other flaws. So many second class citizens, so many exceptions to the rule. I am going through the source code for Maxima CAS (written in Lisp) and in so many ways, it's a mess. I am not at all disparaging those who have been involved in writing the Maxima CAS system and its source. They have done an incredible job and what they have achieved is remarkable. However, like any software system of any complexity in any language, it has lots of areas that are difficult to maintain, let alone advance. In that regard, Lisp has not been as an advantageous language as it could have been. Lisp (as in Common Lisp and its add-ons) is not a simple language and it is not a consistent language (see CLHS - Common Lisp Hyper Spec docs). When I first came across it in the latter 1970's, I thought "wow". But its flaws quickly came to the fore. So, there is no way that it would ever be God's own programming language. Especially since, God doesn't need to program, that's just for us very limited mortals.
- Ericson2314 8y ago
  Lisp indeed doesn't live up to its admirable ideals. Parent comment is on the mark.
- reikonomusha 8y ago
  Maxima (née Macsyma) is a program dating back to the 1960s—1968 specifically—that has largely kept the style from the 1960s. Isn’t it a bit amazing you’re even able to read a modern, running, maintained program that’s lasted for 50 years? Five decades is an enormous amount of time that should really be appreciated, even if for a moment, especially in the era of extremely rapid technological growth. I’d estimate at least three, if not more, generations of programmer have worked on Macsyma/Maxima. Maxima could be modernized with even the features of Common Lisp, but it’s very architecturally stuck in its ways. It’s rife with lists-as-data structures, symbol-plists, and other early Lisp baggage that isn’t found in modern Common Lisp code. The Maxima developer team is also not interested in gratuitous modernization. I don’t think Maxima’s style is a reflection on Lisp so much as it is a reflection of the style of programming at the time, and a reflection on the style of maintenance.
joe_the_user 8y ago
Lisp is a powerful language that allows one to mix multiple logical levels within a program (especially through it's homoiconicity). Shrdlu is perhaps the most classic illustration of Lisp's power[1], A classic program from 1968-70 that allowed natural language communication about a micro world. It was written in a version of Lisp even more free-form than today. When I looked at the source code a while back, it's parsing of natural language involved a wide-variety of on-the-fly fix-ups and such to take into account the multiple irregularities of human language. The thing about Lisp's power is it allows the production of complex program quickly but doesn't particularly have a standard way of gluing these programs together. The other classic Lisp work, The Bipolar Lisp Programmer[2], describes how Lisp has multiple partial implementations of important libraries and programs simply because it allows a certain type of personality to by themselves produce something that's remarkably good but doesn't encourage any particular group effort. Lisp is certainly evidence that "language matters" but not evidence that Lisp is where one should stop. [1] https://en.wikipedia.org/wiki/SHRDLU https://en.wikipedia.org/wiki/SHRDLU [2] http://marktarver.com/bipolar.html http://marktarver.com/bipolar.html
- kazinator 8y ago
  I first came across SHRDLU in Gödel, Escher, Bach. I thought it was fictional!
  - trainingaccount 8y ago
    I think the vast majority of coders would struggle to write anything like SHRDLU.
    - kazinator 8y ago
      The problem is that you can't arrive at such a thing by ordinary exploratory coding without a strong conceptual framework guiding what you're doing.
      - joe_the_user 8y ago
sova 8y ago
>nobody has or will make anything practical with Lisp I made a website with Clojure (a Lisp) that is indeed practical: http://practicalhuman.org http://practicalhuman.org
- mr_toad 8y ago
  > I made a website with Clojure (a Lisp) Seems like you’d be in good company ‘round here then. https://en.m.wikipedia.org/wiki/Viaweb https://en.m.wikipedia.org/wiki/Viaweb
- lisper 8y ago
  Barefoot Networks designs chips using an internal design tool written in Common Lisp.
- abtinf 8y ago
  Wasn’t PG’s original, pre-yahoo-acquisition e-commerce site written in Lisp?
  - Annatar 8y ago
    Yep, and he made mucho dinero when they sold it to Yahoo. As far as I understood it, Lisp enabled them to implement features so fast that their would-be competitors couldn't keep pace.
    - allenbrunson 8y ago
      and yet. pg has been cheerleading for lisp since 2002 or so, and almost nobody has followed in his footsteps. the reddit guys believed him, tried it, and wound up doing a complete rewrite in python. https://redditblog.com/2005/12/05/on-lisp/ https://redditblog.com/2005/12/05/on-lisp/ so i'd have to say that the prevailing evidence says, to me, that pg's advice pretty much doesn't work, in the average case.
      - Annatar 8y ago
        Seems to me that the uptake has been picking up, in no small part to "Hacker News". Bear in mind that since Lisp programs get compiled to machine code, you might be using software written in it and not know it. And that's how it should be: high quality software should be small, fast, easy to install and the user shouldn't have to care what it's written in.
zepto 8y ago
Prolog is probably the language of god.
- robotresearcher 8y ago
  No. (note: this is a genuine Prolog joke)
  - smnplk 8y ago
    ?- What
- toxik 8y ago
  Probably, ... or provably?
- collyw 8y ago
  Prolog looks like a really interesting language. Why isn't it used more?
  - restalis 8y ago
    Here's my opinion: https://news.ycombinator.com/item?id=17124643 https://news.ycombinator.com/item?id=17124643
andrewstuart 8y ago
Is assembly the devil's own programming language?
- Timothycquinn 8y ago
  I would think he would sway toward VB ;)
  - earthscienceman 8y ago
    I mean, if we stick with the spirit of the article I think that it's even more likely to be Fortran. Seemingly interesting, accomplishes certain very specific tasks well, turns into an absolute monolithic nightmare when encountered in the wild.
    - C1sc0cat 8y ago
      Not if you plan and architect it well. BT back in the day wrote a billing system for its dialcom / telecom gold online service in mostly Fortran 77. Apart from one module which our US colleges wrote in a completely different language (PL1/G) we only found that out when it was delivered. And at my first job at BHRA /BHR Group our fluid dynamics simualor was written in Fortran and was well structured I certainly don't recall any major problems
- nickpsecurity 8y ago
  Assembly is too honest about what the program is doing to be the Devil's work. That would be C with undefined behavior kicking in on malicious input from the Devil's children.
  - qwerty456127 8y ago
    Indeed. Assembly is the language of the nameless ancient horror that was there before the devil was born. The language of the devil is C and the languages of his demons are JavaScript and PHP.
loosetypes 8y ago
For whatever reason I really enjoyed the Symbolics graphics and animations demo[0] linked in the article. I was born in the 90s and have constantly heard the narrative that technological progress is getting faster and faster, and that we're currently at the forefront. And then I see something like this. They had basically photoshop before I was even alive!? [0] https://www.youtube.com/watch?v=gV5obrYaogU https://www.youtube.com/watch?v=gV5obrYaogU
- kazinator 8y ago
  According to Wikipedia, Adobe Photoshop was created in 1988. So yes, we literally had that Photoshop before you were alive, not just some photoshop. I used GIMP in 1996, on a Sun Sparcstation 20, running Red Hat Linux.
- acqq 8y ago
  http://www.computerhistory.org/atchm/macpaint-and-quickdraw-source-code/ http://www.computerhistory.org/atchm/macpaint-and-quickdraw-... "The Apple Macintosh combined brilliant design in hardware and in software. The drawing program MacPaint, which was released with the computer in January of 1984, was an example of that brilliance both in what it did, and in how it was implemented." "The high-level logic is written in Apple Pascal, packaged in a single file with 5,822 lines. There are an additional 3,583 lines of code in assembler language for the underlying Motorola 68000 microprocessor" But, almost two decades before that, in 1968(!) not directly the Paint program, but all kinds of interactivity and simple drawing using the first mice ever: https://m.youtube.com/watch?v=yJDv-zdhzMY https://m.youtube.com/watch?v=yJDv-zdhzMY https://en.wikipedia.org/wiki/The_Mother_of_All_Demos https://en.wikipedia.org/wiki/The_Mother_of_All_Demos
- oblio 8y ago
  Photoshop in its first versions had fewer features than MSPaint in 2018 :)
  - opencl 8y ago
    What are you talking about? Paint is still incredibly barebones and Photoshop 1.0 already had lots of major features that Paint lacks. Magic wand select, stamp, filters, perspective transform, etc.
sn41 8y ago
In addition to SICP, John Allen's "The Anatomy of Lisp" is also a great book to learn computing concepts through Lisp.
- mark_l_watson 8y ago
  It is especially good if you want to implement a Lisp.
  - raphlinus 8y ago
    I loved this book as a kid, but I'm really not sure I would recommend it today. The Lisp of that era had "dynamic scope," and a great deal of Allen's book is concerned with fancy data structures and techniques to implement it in a reasonable fashion. But today I think we understand that stuff as basically wrong, and that "lexical scope" works better (and is much closer to the original lambda calculus that served as an inspiration). There are probably some proponents of dynamic scoping, but I think it's a lost battle. So definitely yes, if you want to implement a historic Lisp. Otherwise, not so much.
    - lispm 8y ago
      A later text on the same topic (implementing Lisp/Scheme) is: https://en.wikipedia.org/wiki/Lisp_in_Small_Pieces https://en.wikipedia.org/wiki/Lisp_in_Small_Pieces Highly recommended.
default-kramer 8y ago
> McCarthy built Lisp out of parts so fundamental that it is hard to say whether he invented it or discovered it. I loved that sentence! I'm guessing epistemology or a similar field has pondered the "invented or discovered" question already, and if so, I want to read about it. > [on SICP:] Those concepts were general enough that any language could have been used What?? In chapter 4, you write your own Lisp interpreter. If they had chosen C++, would you be writing a C++ compiler? Or a Lisp interpreter in C++? Either way, it would be ugly. And most languages would encounter problems even before they got to chapter 4. What made SICP great was building abstractions out of primitives. Most languages give you some abstractions, and others simply can't be built (at least not elegantly). I can't imagine SICP using a language that doesn't feel a lot like Lisp. That said, count me among the people whose first Lisp exposure was SICP. And yeah, it was really fun and really enlightening. I am loving Racket now, but Racket is big and practical. SICP is small and beautiful - as I recall, the authors deliberately avoid using most of the language. (They used Scheme, but I think Lisp would have worked fine too, right?)
- fsloth 8y ago
  Incidentally, I found building a Lisp interpreter in C++ using the SICP interpreter recipe a great exercise.
  - deleted 8y ago
    [deleted]
  - yvdriess 8y ago
    We had a follow-up course to SICP that started with the meta-circular interpreter, broke that one down even further and eventually moved completely to a C-implementation. Most insightful course I ever had. We got assignments such as: "add co-routines to the continuation-passing style meta-circular interpreter, and to the stack-based C interpreter."
- yiyus 8y ago
  Chuck Moore always says he did not invent FORTH, but discovered it. It's fascinating the relationship between Lisp and Forth. I am quite sure there is something about these two old simple languages and the concept of duality in mathematics that we are missing.
aportnoy 8y ago
How do you build a simple beautiful website like this?
- sharvil 8y ago
  It's Jekyll [1] powered static site, here is the source code: https://github.com/sinclairtarget/sinclairtarget.github.io https://github.com/sinclairtarget/sinclairtarget.github.io [1] https://jekyllrb.com/ https://jekyllrb.com/
  - aportnoy 8y ago
    Thank you!
- kqr 8y ago
  With HTML and minimal CSS?
  - aportnoy 8y ago
    Right, how do you build a website that looks like the OP as opposed to like that: http://math.mit.edu/~etingof/ http://math.mit.edu/~etingof/ (Not that it's a bad website, it's the most common format in the academia, just an example of a plain HTML website)
    - mastazi 8y ago
      Just add a bit more CSS then :-)
    - setr 8y ago
      You’d get 90% of the way there with just font selection, paragraph spacing, and margins. Maybe colors as well. Butterick’s typography stuff and tufte will carry you through, and then just steal some more specific detailing from sites like this, gwern, xxyxyz etc I compiled a list of such sites I was planning to steal details from for my own blog, but never actually followed through on, if you care: https://github.com/setr/pollen-site/ https://github.com/setr/pollen-site/
zakum1 8y ago
In the history of Lisp, the paper by Richard Gabriel: https://www.dreamsongs.com/WIB.html https://www.dreamsongs.com/WIB.html, “Lisp: Good News, Bad News, How to Win Big” is insightful and beautifully written. I am surprised it is not mentioned in the article wrt the “winter period” in which Lisp popularity waned.
pjmlp 8y ago
> Ruby got… well, Ruby is a Lisp If only it had the same level of AOT/JIT compilers that most Lisp variants enjoy.
unixhero 8y ago
... I thought that was HolyC :-)
Phemist 8y ago
http://kingjamesprogramming.tumblr.com/ http://kingjamesprogramming.tumblr.com/ contains a selection of "verses" generated with a markov chain trained on SICP, the King James Bible and some other works. The results are oftentimes hilarious and some of the Lisp related quotes are very thematic: 13:32 And we declare unto you the power and elegance of Lisp and Algol. Lisp, whose name is Holy (and one that doesn't necessarily mix in something from King James) A powerful programming language should be an effective program that can execute any Lisp program.
collyw 8y ago
Would it be worth going through SCIP without prior knowledge of LISP (i.e. could I pick it up from the book) or is it better to have some knowledge beforehand?
- ___matthias 8y ago
  Yes. Lisp is fundamentally simple and is introduced in the beginning. I can recommend Racket with the sicp language extension to get the dialect used in the book.
  - augusto2112 8y ago
    How is the math? I've heard it's not exactly easy.
    - snazz 8y ago
      I’m just finishing chapter 1 (1/5th of the book) and the math so far hasn’t been too challenging, but you should certainly go in with the expectation that you’ll do some Googling to figure out some context to complete the exercises.
- gumby 8y ago
  At the time the book was written it was not uncommon for a new MIT student to arrive without having used a computer at all. 6.001 was intended to be the first introduction to a computer so not only is no lisp assumed but no programming at all!
  - kamaal 8y ago
    It also depends on how motivated enough you are. Even as early 2005 most of us in India couldn't afford computers. I remember we wrote 8085 programs all on paper. Limited time was available, with limited kits in the lab, but we were motivated enough to do it on paper alone. These days where everything is supposed to be easy, newbie friendly, accommodating and all that. People have a tendency to quit early and expect the ecosystem to make it easy for them. These days you get a decent computer under $100 if you use a Rasberry Pi. I could do anything for something like that a decade back.
ancarda 8y ago
Having spent months learning Haskell, I'm interested to pickup another mind-expanding language. If I read SICP (and also watch the MIT lectures), what dialect should I follow along in? Ideally I would learn something people are using today so there would be usable libraries. I mostly write website backends and APIs. Clojure? Common Lisp? Something else?
- vnorilo 8y ago
  SICP is not so much about a particular language. I think there's a Clojure port of SICP somewhere, and Clojure has a good impedance match with web backends. If you want an "authentic" experience, Scheme would be a good choice.
- specializeded 8y ago
  DrRacket IDE [0] + the SICP compt language [1] and you can start writing it instantly in a well built and maintained environment that’s racket based and pretty fleshed out library wise, certainly nothing compared to Clojure but among the rest, it’s the best (imo), I recall Carmack writing a server in Racket for fun and praising the experience a few years back. [0] - https://racket-lang.org https://racket-lang.org [1] - http://docs.racket-lang.org/sicp-manual/index.html?q=sicp#%28part._.Introduction_to_the__lang_sicp_language%29 http://docs.racket-lang.org/sicp-manual/index.html?q=sicp#%2... Additionally, if SICP proves too slow going or difficult math wise [3] you can always use drracket for HtDP [4] and it’s corresponding misnamed edX course(s) [5] and later on, PLaI [6]. [3] - http://cs.brown.edu/~sk/Publications/Papers/Published/fffk-htdp-vs-sicp-journal/paper.pdf http://cs.brown.edu/~sk/Publications/Papers/Published/fffk-h... [4] - https://htdp.org/2018-01-06/Book/part_preface.html https://htdp.org/2018-01-06/Book/part_preface.html [5] - https://www.edx.org/course/how-code-simple-data-ubcx-htc1x https://www.edx.org/course/how-code-simple-data-ubcx-htc1x [6] - http://cs.brown.edu/courses/cs173/2012/book/ http://cs.brown.edu/courses/cs173/2012/book/
- CodeArtisan 8y ago
  Racket has a package for SICP https://pkgs.racket-lang.org/package/sicp https://pkgs.racket-lang.org/package/sicp More SICP stuff at https://bitbucket.org/snippets/Tetsumi/ke6jL4/sicp https://bitbucket.org/snippets/Tetsumi/ke6jL4/sicp
armitron 8y ago
On SICP and Lisp, I was recently asked: "Thanks a lot for this insightful reply! I've read about how powerful are Lisp languages (for example for AI), my question is: does Emacs really use all this theoretically powerful functionality of these languages? In what way is this metalinguistic abstraction used? In the built-in functions of Emacs, the powerful packages made by the community, or the Elisp tweaking of a casual Emacs user to customize it (or all three of those). I've read a lot of people praising and a lot of people despising Elisp. Do these people who dislike Elisp do it because they want a yet more powerful Lisp dialect (like Scheme) or because they want to use a completely different language? PD: Excuse my ignorance, I'm still learning about programming. As a side note, would you recommend me to read SICP if I just have small notions of OOP with Python and Java and I want to learn more about these topics? Will I be able to follow it? Let me start from the end: Reading SICP changed everything I thought I knew about programming and shattered any sort of non-empirical foundation - that I had built up to that point - regarding how my mind worked and how I interfaced with reality. It's not just a book about programming, there are layers of understanding in there that can blow your worldview apart. That said, you do need to make an effort by paying attention when you go through the book and (mostly) doing the exercises. The videos on youtube are also worth watching in-parallel with reading the book. The less you know about programming when you go through SICP, the easier it will be for you to "get" it since you'll have no hardwired - reinforced by the passage of time and investment of personal effort - prior notions of what programming is and how it should be done. * Metalinguistic abstraction Short answer: all three. Long answer: The key idea behind SICP and the philosophy of Lisp is metalinguistic abstraction which can be described as coming up with and expressing new ideas by first creating a language that allows you to think about said ideas. Think about that for a minute. It follows then that the 'base' language [or interpreter in the classical sense] that you use to do that, should not get in your way and must be primarily focused in facilitating that process. Lisp is geared towards you building a new language on top of it, one that allows you to think about certain ideas, and then solve your problems in that language. Do you need all that power when you're making crud REST apps or working in a well-trodden domain? Probably not. What happens when you're exploring ideas in your mind? When you're thinking about problems that have no established solutions? When you're trying to navigate domains that are fuzzy and confusing? Well, that's when having Lisp around makes a big difference because the language will not get in your way and it'll make it as easy as possible for you to craft tools that let you reason effectively in said domains. Let's use Python as an example since you mentioned it. Python is not that language since it's very opinionated and constrained by its decisions in the design space and, additionally, has been deliberately created with entirely different considerations in mind (popular appeal). This is very well illustrated by the idiotic Python moto "There's only one way to do it" which, in practice, isn't even the case for Python itself. A perfect example of style over substance, yet people lap it up. You can pick and choose a few features that superficially seem similar to Lisp features but that does not make Python a good language for metalinguistic abstraction. This is a classic example of the whole of Lisp being much more than the sum of its parts, and in reality languages like Python don't even do a good job of reimplementing some of these parts. This is the reason I don't want to just list a bunch of Lisp features that factor into metalinguistic abstraction (e.g. macros and symbols). * Feedback loops The other key part of Lisp and also something expressed fully by the Lisp machines is the notion of a cybernetic feedback loop that you enter each time you're programming. In crud, visual terms: [Your mind - Ideas] <--> Programming Language <--> [Artifact-in-Reality] You have certain ideas in your mind that you're trying to manipulate, mold and express through a programming language that leads to the creation of an artifact (your program) in reality. As you see from my diagram, this is a bidirectional process. You act upon (or model) the artifact in reality but you're also acted upon by it (iterative refinement). The medium is the programming language itself. This process becomes much more effective the shorter this feedback loop gets. Lisp allows you to deliberately shorten that feedback loop so that you _mesh with your artifact in reality_. Cybernetic entanglement if you will. Few other languages do that as well as Lisp (Smalltalk and Forth come to mind). Notice that I emphasized your mind and reality/artifact in that previous diagram, but not the medium, the programming language. I did that in order to show that the ideal state is for that programming language not to exist at all. * Differences between Lisps All Lisps allow you to express metalinguistic abstraction (they wouldn't be Lisps otherwise). Not all Lisps allow you to shorten the feedback loop with the same efficiency. The Lisps that best do the latter come out of the tradition of the Lisp machines. Today this means Common Lisp and Emacs Lisp (they're very similar and you can get most of what Common Lisp offers on the language level in Emacs Lisp today). For that reason, I don't think Scheme is more powerful than Emacs Lisp, since Scheme lacks the focus on interactivity and is very different to both CL and Emacs Lisp. As far as other people's opinions go, my rule of thumb is that I'd rather educate myself about the concepts and form my own opinions than blindly follow the herd. Which is why I also think that people who are sufficiently impressed by an introduction to Lisp (such as the OP article) to want to learn it and ask "Which Lisp should I learn? I want something that is used a lot today" are completely missing the point. You'll notice that most programming today is done for money, in languages that are geared towards popularity and commoditization. For me, programming is an Art or high philosophy if we take the latter to stand for love of wisdom. And as someone has said, philosophical truths are not passed around like pieces of eight, but are lived through praxis. P.S. The talk by Gerry Sussman (https://www.infoq.com/presentations/We-Really-Dont-Know-How-To-Compute https://www.infoq.com/presentations/We-Really-Dont-Know-How-...) that I saw mentioned in HN yesterday provides an excellent demonstration of metalinguistic abstraction and also serves as an amalgamation of some of my other ideas about Lisp.
zimablue 8y ago
I think this article reverses cause and effects. It seems to start from the assumption that there's nothing special about LISP and then points to big cultural moments where programmers revered it and said "this accounts for 20% of the meme" etc. I'd say those cultural moments exist because LISP /is/ something special. You could write SICP in Java (someone probably has) but the code would be way longer and less beautiful.
YeGoblynQueenne 8y ago
>> They do this even though Lisp is now the second-oldest programming language in widespread use, younger only than Fortran, and even then by just one year. And the third-oldest is COBOL (it's at least as widespread as FORTRAN; arguably, it's even more widespread than both FORTRAN and LISP together, considering that it's used by pretty much every financial org on the planet). It seems that, alredy from such an early time, the kind of languages we would end up creating was already pretty much set in stone: FORTRAN, as the grandady of languages aimed at scientists and mathematicians, that modern-day R, Python, Julia etc draw their heritage from; LISP as the grandmother of languages aimed to computer scientists and AI researchers, still spawning an unending multitude of LISP variants, including Scheme, ML and Haskell; and COBOL, the amorphous blob sitting gibbering and spitting at the center of the universe of enterprise programmers, that begat the Javas, VBs and Adas of modern years. (Note that I'm referring to language philosophy and intended uses- not syntax or semantics). (I'm also leaving out large swaths of the programming community: the Perl uses and the C hackers etc. It's a limited simile, OK?).
- truculent 8y ago
  I would say that R (and probably Julia as well, although I'm much less familiar) draws it's heritage from Lisp more than FORTRAN.
  - bachmeier 8y ago
    R was originally a Scheme dialect, so that's a pretty safe assertion.
- ThomasBHickey 8y ago
  Don't forget Algol (1958). It had a profound influence on syntax and how programs are organized.
  - pjmlp 8y ago
    Followed by what was the first almost safe systems programming language variant from Algol, ESPOL in 1961, with support for UNSAFE blocks.
YeGoblynQueenne 8y ago
>> Two decades after its creation, Lisp had become, according to the famous Hacker’s Dictionary, the “mother tongue” of artificial intelligence research. More precisely, Lisp became the "mother tongue" of AI research in the United States. Europe and Japan, which at the time also had a significant output into AI research, instead used Prolog as a lingua franca. This is interesting to note, because a common use of Lisp in AI was (is?) to write an interpreter for a logic programming language and then use that interpreter to perform inference tasks as required (this approach is evident, for example, in Structure and Interpretation of Computer Programs, which devotes chapter 4.3 to the development of a logic programming language, the query language, which is basically Prolog with Lisp parentheses). Hence the common response, by Prolog programmers, to Greenspun's tenth rule, that: Any sufficiently complicated Lisp program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of Edinburgh Prolog.
- varjag 8y ago
  > This is interesting to note, because a common use of Lisp in AI was (is?) to write an interpreter for a logic programming language and then use that interpreter to perform inference tasks as required Not sure how you come to that conclusion. Literally none of the notable Lisp AI programs (ELIZA, STUDENT, SHRDLU, AM, EURISKO, MICYN) had anything to do with reimplementing Prolog. Implementing Prolog however is trivial in Lisp, so many textbooks used it as an intermediate level exercise.
  - deleted 8y ago
    [deleted]
  - YeGoblynQueenne 8y ago
    It's the response to Greenspun's tenth rule that mentions Prolog explicitly. My previous comment states that AI programs written in Lisp implemented an interpreter for a logic programming language, unspecified. Although to be fair, that usually means "an informally-specified, ad-hoc, bug-ridden, slow implementation of Prolog" (1). Now, my knowledge of Eliza, Shrdlu, etc is a little limited (I've never read the source, say; btw, have you?) but let's see. Wikipedia is my friend, below. According to wikipedia MYCIN was a backwards chaining expert system. That means a logic programming loop, very likely a resolution-based theorem prover, or, really, (1). ELIZA was first implemented in MAD-SLIP, which, despite the name was not a Lisp variant (although it was a list-processing language). STUDENT is actually part of ELIZA- it's one of the two scripts that came with the original implementation, by Wizenbaum. The other script is DOCTOR, which is the one more often associated with ELIZA (it's the psychoanalyst). If I understand correctly, STUDENT solves logic problems, so I'm guessing it incorporates an automated theorem prover; so basically, (1). Eurisko was written in a frame-based (think OOP) representation language called RLL-1, the interpeter for which was written in Lisp. SHRDLU was written in Lisp and MicroPlanner an early logic programming language (with forward chaining, if memory serves). In the event, (1) was not necessary, as MicroPlanner was already all that- and more! The Automated Mathematician (AM) was indeed written in Lisp, but I don't know anything about its implementation. However, from the description on its wikipedia page it appears to have included a very basic inference procedure and a rule-base of heuristics. Sounds like a case of (1) to me.
etatoby 8y ago
Lisp and Scheme are great. They would be my favorite programming languages, if they had a statically typed, Hindley-Milner type system. As they stand, they are great learning tools, but I would never build something serious with them. Let alone questions about parallelism, concurrency, available libraries, development tools, etc. Any suggestions are welcome.
- sevensor 8y ago
  Typed Racket? It's not Hindley / Milner, but it seems pretty powerful.
- ballpark 8y ago
  I'm interested to see how contracts (`clojure.spec` is a new implemenation of them Clojure) can be used to make reading, debugging and maintaining Clojure easier.
- Royalaid 8y ago
  I think that part of the power of LISP is it's dynamic nature but if you want typed options they exist for Clojure and Racket. There is also development on a language called Carp that aims to be a Clojure style language for C https://github.com/carp-lang/Carp https://github.com/carp-lang/Carp.
- lalaithion 8y ago
  There's an experimental Racket language called Hackett which is attempting to give you the best of both worlds of Lisp's macros and Haskell's types. https://github.com/lexi-lambda/hackett https://github.com/lexi-lambda/hackett
kbumsik 8y ago
As a dev from non-CS major, I personally havn't learnt anything about Lisp but I would like to know. Is Clojure (specifically ClojureScript) a good start to study about it?
- bartq 8y ago
  Yes.
- cjallen88 8y ago
  Sure, start here: https://www.braveclojure.com/clojure-for-the-brave-and-true/ https://www.braveclojure.com/clojure-for-the-brave-and-true/
- knowingpark 8y ago
  Clojure is a modernised version of Lisp. It compiles to Java bytecode and runs on the JVM. Clojurescript compiles to Javascript for use in the browser. Some amazing programming tools have been written for Clojurescript. The community is very robust and opinionated, in a good way I think. Clojure is very modern with its vectors and maps. Lisp is more of an antique, a very valuable antique though. its very interesting to learn about both at the same time, as I did :)
  - deleted 8y ago
    [deleted]
  - pjmlp 8y ago
    Contrary to popular belief, Common Lisp has support for vectors, maps, records, stack and heap allocation. What Clojure has going for it is the wealth of Java libraries.
- Royalaid 8y ago
  I just want to say that the tooling setup isn't great and you kinda have to buy into a small ecosystem to do clojurescript Dev and the easiest is probably to use lein+lein-figwheel. If you have any questions feel free to ask!
ASipos 8y ago
> a field as esoteric as “recursive function theory” How can this kind of descriptions persist when recursive functions are the very thing that a computer computes.
- deleted 8y ago
  [deleted]
- thrmsforbfast 8y ago
  Because rft is esoteric. A lot of more applied CS departments don't require a CS theory course, and many programmers didn't major in CS or never attended university. So there are far more computer programmers than there are people who know what recursive function theory is or how it relates to modern computers.
- AnimalMuppet 8y ago
  Are they? They are the very thing that lambda calculus models computation on. They are not the very thing that Turing Machines model computation on. They also are not the very thing that CPUs use, or that assembly uses, or even that most high-level languages use. (Unless you're going to say that most high-level languages use a recursive descent parser to generate the binaries that the CPUs run, and that's the basis for your statement...)
  - ASipos 8y ago
    Neither lambda calculus, nor Turing machines "model computation on" recursive functions. Rather, these two, and all the other models of computation are equivalent as they compute the same class of functions from the naturals to the naturals. And we call that class the class of recursive functions. That being said, a computer is a physical device that is able to compute this entire class of recursive functions. It is what makes it a computer and not a pen or a chair. It's not some esoteric notion. It's the whole thing about it.
    - AnimalMuppet 8y ago
      That's like saying that the basis of computation is the standard model, since all actual physical computers are made out of particles that are in the standard model. It may be true, but it's so far abstracted from what's actually going on that it's not useful at all.
Shorel 8y ago
I think the test to find out if a programmer can eventually learn to work on a Lisp codebase lies in his/her opinion about the conditional (ternary) operator. If the programmer hates the C(T)O because it is too confusing, that programmer is hopeless about using Lisp. If the programmer sees the C(T)O as a trivial syntax that helps to make the code short and neat, then that programmer will love Lisp.
- ratsimihah 8y ago
  I can't think of anyone who'd hate the CTO, it's hardly more confusing than an if/else statement.
  - jimmy1 8y ago
    I work in JavaScript on a regular basis, and I have grown to despise them because of their overuse when a simple if statement would have made the code much clearer.
- weliketocode 8y ago
  I haven't dived into lisp, but if you're telling me it'll make my code shorter, I'm sure I'll love it.
  - deleted 8y ago
    [deleted]
decafbad 8y ago
Lisp programmers and Lisp braggers are distinct groups.
aswanson 8y ago
Far too many intelligent programmers swear by lisp for there to be no "there" there. I'm trying to learn it in my nonexistent spare time.
- gagege 8y ago
  I know what you mean and I think that feeling comes from a difference between lisp the language (learn in a matter of hours) and lisp the ecosystem (takes much longer to get confident with). And, you really need to learn both, unless you have time to make everything from scratch.
  - bunderbunder 8y ago
    Well, you need to learn both if you're going to make a career of working in Lisp. But even if that isn't in the cards (and it isn't for most of us, for all sorts of reasons), there's still a whole lot of value in learning the language enough to go through and make a few things from scratch. I tend to agree with ESR on the subject: "LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot." (http://www.catb.org/esr/faqs/hacker-howto.html http://www.catb.org/esr/faqs/hacker-howto.html)
    - deleted 8y ago
      [deleted]
- 3pt14159 8y ago
  Look, here is the deal with Lisp. It shows you the data structure of your computer program and lets you operate on it and that is neat. But it's not useful for actual work because the way you manipulate it makes it hard for you to understand what is happening without knowing all the ways your code is being manipulated. I have to write lisp for my editor (emacs) and I don't hate it, but I don't love it either. The syntax is hard to read quickly because it's cluttered and (usually) nest-y. If you're willing to trade complete purity away, try Ruby. It's basically everything you want from Lisp without the mess. Give up purity, get comprehensibility. Blocks are a really great way of doing things. You can even investigate the block source code as a string if you really want to. Dynamic method definition is well supported and predictable. Data structures are easy to compose and operate on. It's basically all the power but in a more comprehensible way. There's a reason why Rails came out of Ruby. It's naturally powerful.
leshow 8y ago
I'm not familiar with any of these memes about lisp. If anything, the stuff you're claiming about lisp I've heard about Haskell.
metonymy 8y ago
If you want to read SICP, it is available in HTML, EPUB here: https://github.com/sarabander/sicp https://github.com/sarabander/sicp also here: https://sicpebook.wordpress.com/ebook/ https://sicpebook.wordpress.com/ebook/. Not available in EPUB on Amazon or Google.
deleted 8y ago
[deleted]
kidsnow 8y ago
The principle of orthogonal design is something I learned in CS, but hardly anyone mentions any more. The idea boils down to building software parts in a consistent way such that can be combined and re-used to form new things. The way you can accomplish this is by having very few rules. The more "syntaxy" a language is, the less orthogonal it is. For more reading and discussion on this topic: https://softwareengineering.stackexchange.com/questions/103567/what-is-the-most-orthogonal-programming-language https://softwareengineering.stackexchange.com/questions/1035...
zeveb 8y ago
Another two factors in the '00s re-rise of Lisp were Steve Yegge's Drunken Blog Rants (https://sites.google.com/site/steveyegge2/blog-rants https://sites.google.com/site/steveyegge2/blog-rants) & Practical Common Lisp (http://gigamonkeys.com/book http://gigamonkeys.com/book). The former was, at the time, very influential (and deservedly so); the latter was and remains the best reference for actually using Common Lisp to write real software (Edi Weitz's Common Lisp Recipes is an excellent companion volume).
robbrit 8y ago
Back in 2007 I thought it was silly that SBCL (and SmallTalk too) distributed its applications as "images". Seems they've been re-invented today as "containers", which are suddenly an amazing idea.
catacombs 8y ago
Lisp is God's language. TempleOS is God's operating system.
cztomsik 8y ago
Everybody's just praising lisp like it's the best language ever, yet very few people are actually using it - and I think it's because it's really easy to write smart code which has to be explained over and over again to new people (and to your future-you). I think this should be noted.

614 points by chwolfe 8y ago

I thought god mucked around on quantum computers, and I think we can all feel a little bit better that god can't seem to write bug free code either.

wwweston 8y ago
Either that, or it's all a feature.
- azernik 8y ago
  And on the seventh day, he set the version number to pi and declared all bugs to be features.
unit91 8y ago
If you don't believe in God, why speak so spitefully about him?
- monocasa 8y ago
  Because of the damage the concept has done?
  - dang 8y ago
    Please keep religious flamewar far away from this site.

vertline3 8y ago

in XKCD comic "Lisp" God also says the universe was mostly hacked together with Perl. Edit: I see I read the story but I didn't click the first comic, just the second one, Sorry disregard. Another language that gets holy reverence is smalltalk.

piinbinary 8y ago
https://xkcd.com/224/ https://xkcd.com/224/
- vertline3 8y ago
  Thank you!

adamnemecek 8y ago

The lisp circle jerk is a little too much sometimes.

gnulinux 8y ago
Why do you think it's a circlejerk? I'm yet to see an idea in the domain of PLs that's as effective as lisp (dependent types come close). Lisp is a whole package, it solves bunch of problems very elegantly. All "good" languages solve problems one by one by introducing exceptions and rules and features whereas lisp did it by introducing a totally novel, elegant concept. It's hard not to be mystified by lisp. I'm not an old school hacker, but there is certainly something fascinating about lisp.
- adamnemecek 8y ago
  Sure but calling it a “God’s language” is a little too much.
jnordwick 8y ago
Better than the Haskell one.
- hyperion2010 8y ago
  Just because it has been going on for longer and the veterans actually know how to get someone other than themselves off ;)
tannhaeuser 8y ago
I must agree. "God's Own Programming Language" (not meant as satire) is certainly indicative of the psychological phenomenon of a superiority complex in the Lisp community.
- johan_larson 8y ago
  Yeah, even MIT eventually gave up on using Scheme as a first programming language. The Lisp community may have the worst ratio of self-regard to actual accomplishments in our entire industry. Not one of the great companies is built on Lisp. I don't think it's even a second-tier language at the FAANGs.

oldandtired 8y ago

Lisp - oh what it could have been. It had such potential, but then it got broken. I find it fascinating that those who are dedicated to the proselytisation of Lisp don't see the brokenness of the language. For them, all of the broken things are the features of the language. Scheme was one attempt to fix some of those flaws. In latter times, we see the development of Kernel to fix other flaws. So many second class citizens, so many exceptions to the rule. I am going through the source code for Maxima CAS (written in Lisp) and in so many ways, it's a mess. I am not at all disparaging those who have been involved in writing the Maxima CAS system and its source. They have done an incredible job and what they have achieved is remarkable. However, like any software system of any complexity in any language, it has lots of areas that are difficult to maintain, let alone advance. In that regard, Lisp has not been as an advantageous language as it could have been. Lisp (as in Common Lisp and its add-ons) is not a simple language and it is not a consistent language (see CLHS - Common Lisp Hyper Spec docs). When I first came across it in the latter 1970's, I thought "wow". But its flaws quickly came to the fore. So, there is no way that it would ever be God's own programming language. Especially since, God doesn't need to program, that's just for us very limited mortals.

Ericson2314 8y ago
Lisp indeed doesn't live up to its admirable ideals. Parent comment is on the mark.
reikonomusha 8y ago
Maxima (née Macsyma) is a program dating back to the 1960s—1968 specifically—that has largely kept the style from the 1960s. Isn’t it a bit amazing you’re even able to read a modern, running, maintained program that’s lasted for 50 years? Five decades is an enormous amount of time that should really be appreciated, even if for a moment, especially in the era of extremely rapid technological growth. I’d estimate at least three, if not more, generations of programmer have worked on Macsyma/Maxima. Maxima could be modernized with even the features of Common Lisp, but it’s very architecturally stuck in its ways. It’s rife with lists-as-data structures, symbol-plists, and other early Lisp baggage that isn’t found in modern Common Lisp code. The Maxima developer team is also not interested in gratuitous modernization. I don’t think Maxima’s style is a reflection on Lisp so much as it is a reflection of the style of programming at the time, and a reflection on the style of maintenance.

joe_the_user 8y ago

Lisp is a powerful language that allows one to mix multiple logical levels within a program (especially through it's homoiconicity). Shrdlu is perhaps the most classic illustration of Lisp's power[1], A classic program from 1968-70 that allowed natural language communication about a micro world. It was written in a version of Lisp even more free-form than today. When I looked at the source code a while back, it's parsing of natural language involved a wide-variety of on-the-fly fix-ups and such to take into account the multiple irregularities of human language. The thing about Lisp's power is it allows the production of complex program quickly but doesn't particularly have a standard way of gluing these programs together. The other classic Lisp work, The Bipolar Lisp Programmer[2], describes how Lisp has multiple partial implementations of important libraries and programs simply because it allows a certain type of personality to by themselves produce something that's remarkably good but doesn't encourage any particular group effort. Lisp is certainly evidence that "language matters" but not evidence that Lisp is where one should stop. [1] https://en.wikipedia.org/wiki/SHRDLU https://en.wikipedia.org/wiki/SHRDLU [2] http://marktarver.com/bipolar.html http://marktarver.com/bipolar.html

kazinator 8y ago
I first came across SHRDLU in Gödel, Escher, Bach. I thought it was fictional!
- trainingaccount 8y ago
  I think the vast majority of coders would struggle to write anything like SHRDLU.
  - kazinator 8y ago
    The problem is that you can't arrive at such a thing by ordinary exploratory coding without a strong conceptual framework guiding what you're doing.
    - joe_the_user 8y ago

sova 8y ago

>nobody has or will make anything practical with Lisp I made a website with Clojure (a Lisp) that is indeed practical: http://practicalhuman.org http://practicalhuman.org

mr_toad 8y ago
> I made a website with Clojure (a Lisp) Seems like you’d be in good company ‘round here then. https://en.m.wikipedia.org/wiki/Viaweb https://en.m.wikipedia.org/wiki/Viaweb
lisper 8y ago
Barefoot Networks designs chips using an internal design tool written in Common Lisp.
abtinf 8y ago
Wasn’t PG’s original, pre-yahoo-acquisition e-commerce site written in Lisp?
- Annatar 8y ago
  Yep, and he made mucho dinero when they sold it to Yahoo. As far as I understood it, Lisp enabled them to implement features so fast that their would-be competitors couldn't keep pace.
  - allenbrunson 8y ago
    and yet. pg has been cheerleading for lisp since 2002 or so, and almost nobody has followed in his footsteps. the reddit guys believed him, tried it, and wound up doing a complete rewrite in python. https://redditblog.com/2005/12/05/on-lisp/ https://redditblog.com/2005/12/05/on-lisp/ so i'd have to say that the prevailing evidence says, to me, that pg's advice pretty much doesn't work, in the average case.
    - Annatar 8y ago
      Seems to me that the uptake has been picking up, in no small part to "Hacker News". Bear in mind that since Lisp programs get compiled to machine code, you might be using software written in it and not know it. And that's how it should be: high quality software should be small, fast, easy to install and the user shouldn't have to care what it's written in.

zepto 8y ago

Prolog is probably the language of god.

robotresearcher 8y ago
No. (note: this is a genuine Prolog joke)
- smnplk 8y ago
  ?- What
toxik 8y ago
Probably, ... or provably?
collyw 8y ago
Prolog looks like a really interesting language. Why isn't it used more?
- restalis 8y ago
  Here's my opinion: https://news.ycombinator.com/item?id=17124643 https://news.ycombinator.com/item?id=17124643

andrewstuart 8y ago

Is assembly the devil's own programming language?

Timothycquinn 8y ago
I would think he would sway toward VB ;)
- earthscienceman 8y ago
  I mean, if we stick with the spirit of the article I think that it's even more likely to be Fortran. Seemingly interesting, accomplishes certain very specific tasks well, turns into an absolute monolithic nightmare when encountered in the wild.
  - C1sc0cat 8y ago
    Not if you plan and architect it well. BT back in the day wrote a billing system for its dialcom / telecom gold online service in mostly Fortran 77. Apart from one module which our US colleges wrote in a completely different language (PL1/G) we only found that out when it was delivered. And at my first job at BHRA /BHR Group our fluid dynamics simualor was written in Fortran and was well structured I certainly don't recall any major problems
nickpsecurity 8y ago
Assembly is too honest about what the program is doing to be the Devil's work. That would be C with undefined behavior kicking in on malicious input from the Devil's children.
- qwerty456127 8y ago
  Indeed. Assembly is the language of the nameless ancient horror that was there before the devil was born. The language of the devil is C and the languages of his demons are JavaScript and PHP.

loosetypes 8y ago

For whatever reason I really enjoyed the Symbolics graphics and animations demo[0] linked in the article. I was born in the 90s and have constantly heard the narrative that technological progress is getting faster and faster, and that we're currently at the forefront. And then I see something like this. They had basically photoshop before I was even alive!? [0] https://www.youtube.com/watch?v=gV5obrYaogU https://www.youtube.com/watch?v=gV5obrYaogU

kazinator 8y ago
According to Wikipedia, Adobe Photoshop was created in 1988. So yes, we literally had that Photoshop before you were alive, not just some photoshop. I used GIMP in 1996, on a Sun Sparcstation 20, running Red Hat Linux.
acqq 8y ago
http://www.computerhistory.org/atchm/macpaint-and-quickdraw-source-code/ http://www.computerhistory.org/atchm/macpaint-and-quickdraw-... "The Apple Macintosh combined brilliant design in hardware and in software. The drawing program MacPaint, which was released with the computer in January of 1984, was an example of that brilliance both in what it did, and in how it was implemented." "The high-level logic is written in Apple Pascal, packaged in a single file with 5,822 lines. There are an additional 3,583 lines of code in assembler language for the underlying Motorola 68000 microprocessor" But, almost two decades before that, in 1968(!) not directly the Paint program, but all kinds of interactivity and simple drawing using the first mice ever: https://m.youtube.com/watch?v=yJDv-zdhzMY https://m.youtube.com/watch?v=yJDv-zdhzMY https://en.wikipedia.org/wiki/The_Mother_of_All_Demos https://en.wikipedia.org/wiki/The_Mother_of_All_Demos
oblio 8y ago
Photoshop in its first versions had fewer features than MSPaint in 2018 :)
- opencl 8y ago
  What are you talking about? Paint is still incredibly barebones and Photoshop 1.0 already had lots of major features that Paint lacks. Magic wand select, stamp, filters, perspective transform, etc.

sn41 8y ago

In addition to SICP, John Allen's "The Anatomy of Lisp" is also a great book to learn computing concepts through Lisp.

mark_l_watson 8y ago
It is especially good if you want to implement a Lisp.
- raphlinus 8y ago
  I loved this book as a kid, but I'm really not sure I would recommend it today. The Lisp of that era had "dynamic scope," and a great deal of Allen's book is concerned with fancy data structures and techniques to implement it in a reasonable fashion. But today I think we understand that stuff as basically wrong, and that "lexical scope" works better (and is much closer to the original lambda calculus that served as an inspiration). There are probably some proponents of dynamic scoping, but I think it's a lost battle. So definitely yes, if you want to implement a historic Lisp. Otherwise, not so much.
  - lispm 8y ago
    A later text on the same topic (implementing Lisp/Scheme) is: https://en.wikipedia.org/wiki/Lisp_in_Small_Pieces https://en.wikipedia.org/wiki/Lisp_in_Small_Pieces Highly recommended.

default-kramer 8y ago

> McCarthy built Lisp out of parts so fundamental that it is hard to say whether he invented it or discovered it. I loved that sentence! I'm guessing epistemology or a similar field has pondered the "invented or discovered" question already, and if so, I want to read about it. > [on SICP:] Those concepts were general enough that any language could have been used What?? In chapter 4, you write your own Lisp interpreter. If they had chosen C++, would you be writing a C++ compiler? Or a Lisp interpreter in C++? Either way, it would be ugly. And most languages would encounter problems even before they got to chapter 4. What made SICP great was building abstractions out of primitives. Most languages give you some abstractions, and others simply can't be built (at least not elegantly). I can't imagine SICP using a language that doesn't feel a lot like Lisp. That said, count me among the people whose first Lisp exposure was SICP. And yeah, it was really fun and really enlightening. I am loving Racket now, but Racket is big and practical. SICP is small and beautiful - as I recall, the authors deliberately avoid using most of the language. (They used Scheme, but I think Lisp would have worked fine too, right?)

fsloth 8y ago
Incidentally, I found building a Lisp interpreter in C++ using the SICP interpreter recipe a great exercise.
- deleted 8y ago
  [deleted]
- yvdriess 8y ago
  We had a follow-up course to SICP that started with the meta-circular interpreter, broke that one down even further and eventually moved completely to a C-implementation. Most insightful course I ever had. We got assignments such as: "add co-routines to the continuation-passing style meta-circular interpreter, and to the stack-based C interpreter."
yiyus 8y ago
Chuck Moore always says he did not invent FORTH, but discovered it. It's fascinating the relationship between Lisp and Forth. I am quite sure there is something about these two old simple languages and the concept of duality in mathematics that we are missing.

aportnoy 8y ago

How do you build a simple beautiful website like this?

sharvil 8y ago
It's Jekyll [1] powered static site, here is the source code: https://github.com/sinclairtarget/sinclairtarget.github.io https://github.com/sinclairtarget/sinclairtarget.github.io [1] https://jekyllrb.com/ https://jekyllrb.com/
- aportnoy 8y ago
  Thank you!
kqr 8y ago
With HTML and minimal CSS?
- aportnoy 8y ago
  Right, how do you build a website that looks like the OP as opposed to like that: http://math.mit.edu/~etingof/ http://math.mit.edu/~etingof/ (Not that it's a bad website, it's the most common format in the academia, just an example of a plain HTML website)
  - mastazi 8y ago
    Just add a bit more CSS then :-)
  - setr 8y ago
    You’d get 90% of the way there with just font selection, paragraph spacing, and margins. Maybe colors as well. Butterick’s typography stuff and tufte will carry you through, and then just steal some more specific detailing from sites like this, gwern, xxyxyz etc I compiled a list of such sites I was planning to steal details from for my own blog, but never actually followed through on, if you care: https://github.com/setr/pollen-site/ https://github.com/setr/pollen-site/

zakum1 8y ago

In the history of Lisp, the paper by Richard Gabriel: https://www.dreamsongs.com/WIB.html https://www.dreamsongs.com/WIB.html, “Lisp: Good News, Bad News, How to Win Big” is insightful and beautifully written. I am surprised it is not mentioned in the article wrt the “winter period” in which Lisp popularity waned.

pjmlp 8y ago

> Ruby got… well, Ruby is a Lisp If only it had the same level of AOT/JIT compilers that most Lisp variants enjoy.

unixhero 8y ago

... I thought that was HolyC :-)

Phemist 8y ago

http://kingjamesprogramming.tumblr.com/ http://kingjamesprogramming.tumblr.com/ contains a selection of "verses" generated with a markov chain trained on SICP, the King James Bible and some other works. The results are oftentimes hilarious and some of the Lisp related quotes are very thematic: 13:32 And we declare unto you the power and elegance of Lisp and Algol. Lisp, whose name is Holy (and one that doesn't necessarily mix in something from King James) A powerful programming language should be an effective program that can execute any Lisp program.

collyw 8y ago

Would it be worth going through SCIP without prior knowledge of LISP (i.e. could I pick it up from the book) or is it better to have some knowledge beforehand?

___matthias 8y ago
Yes. Lisp is fundamentally simple and is introduced in the beginning. I can recommend Racket with the sicp language extension to get the dialect used in the book.
- augusto2112 8y ago
  How is the math? I've heard it's not exactly easy.
  - snazz 8y ago
    I’m just finishing chapter 1 (1/5th of the book) and the math so far hasn’t been too challenging, but you should certainly go in with the expectation that you’ll do some Googling to figure out some context to complete the exercises.
gumby 8y ago
At the time the book was written it was not uncommon for a new MIT student to arrive without having used a computer at all. 6.001 was intended to be the first introduction to a computer so not only is no lisp assumed but no programming at all!
- kamaal 8y ago
  It also depends on how motivated enough you are. Even as early 2005 most of us in India couldn't afford computers. I remember we wrote 8085 programs all on paper. Limited time was available, with limited kits in the lab, but we were motivated enough to do it on paper alone. These days where everything is supposed to be easy, newbie friendly, accommodating and all that. People have a tendency to quit early and expect the ecosystem to make it easy for them. These days you get a decent computer under $100 if you use a Rasberry Pi. I could do anything for something like that a decade back.

ancarda 8y ago

Having spent months learning Haskell, I'm interested to pickup another mind-expanding language. If I read SICP (and also watch the MIT lectures), what dialect should I follow along in? Ideally I would learn something people are using today so there would be usable libraries. I mostly write website backends and APIs. Clojure? Common Lisp? Something else?

vnorilo 8y ago
SICP is not so much about a particular language. I think there's a Clojure port of SICP somewhere, and Clojure has a good impedance match with web backends. If you want an "authentic" experience, Scheme would be a good choice.
specializeded 8y ago
DrRacket IDE [0] + the SICP compt language [1] and you can start writing it instantly in a well built and maintained environment that’s racket based and pretty fleshed out library wise, certainly nothing compared to Clojure but among the rest, it’s the best (imo), I recall Carmack writing a server in Racket for fun and praising the experience a few years back. [0] - https://racket-lang.org https://racket-lang.org [1] - http://docs.racket-lang.org/sicp-manual/index.html?q=sicp#%28part._.Introduction_to_the__lang_sicp_language%29 http://docs.racket-lang.org/sicp-manual/index.html?q=sicp#%2... Additionally, if SICP proves too slow going or difficult math wise [3] you can always use drracket for HtDP [4] and it’s corresponding misnamed edX course(s) [5] and later on, PLaI [6]. [3] - http://cs.brown.edu/~sk/Publications/Papers/Published/fffk-htdp-vs-sicp-journal/paper.pdf http://cs.brown.edu/~sk/Publications/Papers/Published/fffk-h... [4] - https://htdp.org/2018-01-06/Book/part_preface.html https://htdp.org/2018-01-06/Book/part_preface.html [5] - https://www.edx.org/course/how-code-simple-data-ubcx-htc1x https://www.edx.org/course/how-code-simple-data-ubcx-htc1x [6] - http://cs.brown.edu/courses/cs173/2012/book/ http://cs.brown.edu/courses/cs173/2012/book/
CodeArtisan 8y ago
Racket has a package for SICP https://pkgs.racket-lang.org/package/sicp https://pkgs.racket-lang.org/package/sicp More SICP stuff at https://bitbucket.org/snippets/Tetsumi/ke6jL4/sicp https://bitbucket.org/snippets/Tetsumi/ke6jL4/sicp

armitron 8y ago

On SICP and Lisp, I was recently asked: "Thanks a lot for this insightful reply! I've read about how powerful are Lisp languages (for example for AI), my question is: does Emacs really use all this theoretically powerful functionality of these languages? In what way is this metalinguistic abstraction used? In the built-in functions of Emacs, the powerful packages made by the community, or the Elisp tweaking of a casual Emacs user to customize it (or all three of those). I've read a lot of people praising and a lot of people despising Elisp. Do these people who dislike Elisp do it because they want a yet more powerful Lisp dialect (like Scheme) or because they want to use a completely different language? PD: Excuse my ignorance, I'm still learning about programming. As a side note, would you recommend me to read SICP if I just have small notions of OOP with Python and Java and I want to learn more about these topics? Will I be able to follow it? Let me start from the end: Reading SICP changed everything I thought I knew about programming and shattered any sort of non-empirical foundation - that I had built up to that point - regarding how my mind worked and how I interfaced with reality. It's not just a book about programming, there are layers of understanding in there that can blow your worldview apart. That said, you do need to make an effort by paying attention when you go through the book and (mostly) doing the exercises. The videos on youtube are also worth watching in-parallel with reading the book. The less you know about programming when you go through SICP, the easier it will be for you to "get" it since you'll have no hardwired - reinforced by the passage of time and investment of personal effort - prior notions of what programming is and how it should be done. * Metalinguistic abstraction Short answer: all three. Long answer: The key idea behind SICP and the philosophy of Lisp is metalinguistic abstraction which can be described as coming up with and expressing new ideas by first creating a language that allows you to think about said ideas. Think about that for a minute. It follows then that the 'base' language [or interpreter in the classical sense] that you use to do that, should not get in your way and must be primarily focused in facilitating that process. Lisp is geared towards you building a new language on top of it, one that allows you to think about certain ideas, and then solve your problems in that language. Do you need all that power when you're making crud REST apps or working in a well-trodden domain? Probably not. What happens when you're exploring ideas in your mind? When you're thinking about problems that have no established solutions? When you're trying to navigate domains that are fuzzy and confusing? Well, that's when having Lisp around makes a big difference because the language will not get in your way and it'll make it as easy as possible for you to craft tools that let you reason effectively in said domains. Let's use Python as an example since you mentioned it. Python is not that language since it's very opinionated and constrained by its decisions in the design space and, additionally, has been deliberately created with entirely different considerations in mind (popular appeal). This is very well illustrated by the idiotic Python moto "There's only one way to do it" which, in practice, isn't even the case for Python itself. A perfect example of style over substance, yet people lap it up. You can pick and choose a few features that superficially seem similar to Lisp features but that does not make Python a good language for metalinguistic abstraction. This is a classic example of the whole of Lisp being much more than the sum of its parts, and in reality languages like Python don't even do a good job of reimplementing some of these parts. This is the reason I don't want to just list a bunch of Lisp features that factor into metalinguistic abstraction (e.g. macros and symbols). * Feedback loops The other key part of Lisp and also something expressed fully by the Lisp machines is the notion of a cybernetic feedback loop that you enter each time you're programming. In crud, visual terms: [Your mind - Ideas] <--> Programming Language <--> [Artifact-in-Reality] You have certain ideas in your mind that you're trying to manipulate, mold and express through a programming language that leads to the creation of an artifact (your program) in reality. As you see from my diagram, this is a bidirectional process. You act upon (or model) the artifact in reality but you're also acted upon by it (iterative refinement). The medium is the programming language itself. This process becomes much more effective the shorter this feedback loop gets. Lisp allows you to deliberately shorten that feedback loop so that you _mesh with your artifact in reality_. Cybernetic entanglement if you will. Few other languages do that as well as Lisp (Smalltalk and Forth come to mind). Notice that I emphasized your mind and reality/artifact in that previous diagram, but not the medium, the programming language. I did that in order to show that the ideal state is for that programming language not to exist at all. * Differences between Lisps All Lisps allow you to express metalinguistic abstraction (they wouldn't be Lisps otherwise). Not all Lisps allow you to shorten the feedback loop with the same efficiency. The Lisps that best do the latter come out of the tradition of the Lisp machines. Today this means Common Lisp and Emacs Lisp (they're very similar and you can get most of what Common Lisp offers on the language level in Emacs Lisp today). For that reason, I don't think Scheme is more powerful than Emacs Lisp, since Scheme lacks the focus on interactivity and is very different to both CL and Emacs Lisp. As far as other people's opinions go, my rule of thumb is that I'd rather educate myself about the concepts and form my own opinions than blindly follow the herd. Which is why I also think that people who are sufficiently impressed by an introduction to Lisp (such as the OP article) to want to learn it and ask "Which Lisp should I learn? I want something that is used a lot today" are completely missing the point. You'll notice that most programming today is done for money, in languages that are geared towards popularity and commoditization. For me, programming is an Art or high philosophy if we take the latter to stand for love of wisdom. And as someone has said, philosophical truths are not passed around like pieces of eight, but are lived through praxis. P.S. The talk by Gerry Sussman (https://www.infoq.com/presentations/We-Really-Dont-Know-How-To-Compute https://www.infoq.com/presentations/We-Really-Dont-Know-How-...) that I saw mentioned in HN yesterday provides an excellent demonstration of metalinguistic abstraction and also serves as an amalgamation of some of my other ideas about Lisp.

zimablue 8y ago

I think this article reverses cause and effects. It seems to start from the assumption that there's nothing special about LISP and then points to big cultural moments where programmers revered it and said "this accounts for 20% of the meme" etc. I'd say those cultural moments exist because LISP /is/ something special. You could write SICP in Java (someone probably has) but the code would be way longer and less beautiful.

YeGoblynQueenne 8y ago

>> They do this even though Lisp is now the second-oldest programming language in widespread use, younger only than Fortran, and even then by just one year. And the third-oldest is COBOL (it's at least as widespread as FORTRAN; arguably, it's even more widespread than both FORTRAN and LISP together, considering that it's used by pretty much every financial org on the planet). It seems that, alredy from such an early time, the kind of languages we would end up creating was already pretty much set in stone: FORTRAN, as the grandady of languages aimed at scientists and mathematicians, that modern-day R, Python, Julia etc draw their heritage from; LISP as the grandmother of languages aimed to computer scientists and AI researchers, still spawning an unending multitude of LISP variants, including Scheme, ML and Haskell; and COBOL, the amorphous blob sitting gibbering and spitting at the center of the universe of enterprise programmers, that begat the Javas, VBs and Adas of modern years. (Note that I'm referring to language philosophy and intended uses- not syntax or semantics). (I'm also leaving out large swaths of the programming community: the Perl uses and the C hackers etc. It's a limited simile, OK?).

truculent 8y ago
I would say that R (and probably Julia as well, although I'm much less familiar) draws it's heritage from Lisp more than FORTRAN.
- bachmeier 8y ago
  R was originally a Scheme dialect, so that's a pretty safe assertion.
ThomasBHickey 8y ago
Don't forget Algol (1958). It had a profound influence on syntax and how programs are organized.
- pjmlp 8y ago
  Followed by what was the first almost safe systems programming language variant from Algol, ESPOL in 1961, with support for UNSAFE blocks.

YeGoblynQueenne 8y ago

>> Two decades after its creation, Lisp had become, according to the famous Hacker’s Dictionary, the “mother tongue” of artificial intelligence research. More precisely, Lisp became the "mother tongue" of AI research in the United States. Europe and Japan, which at the time also had a significant output into AI research, instead used Prolog as a lingua franca. This is interesting to note, because a common use of Lisp in AI was (is?) to write an interpreter for a logic programming language and then use that interpreter to perform inference tasks as required (this approach is evident, for example, in Structure and Interpretation of Computer Programs, which devotes chapter 4.3 to the development of a logic programming language, the query language, which is basically Prolog with Lisp parentheses). Hence the common response, by Prolog programmers, to Greenspun's tenth rule, that: Any sufficiently complicated Lisp program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of Edinburgh Prolog.

varjag 8y ago
> This is interesting to note, because a common use of Lisp in AI was (is?) to write an interpreter for a logic programming language and then use that interpreter to perform inference tasks as required Not sure how you come to that conclusion. Literally none of the notable Lisp AI programs (ELIZA, STUDENT, SHRDLU, AM, EURISKO, MICYN) had anything to do with reimplementing Prolog. Implementing Prolog however is trivial in Lisp, so many textbooks used it as an intermediate level exercise.
- deleted 8y ago
  [deleted]
- YeGoblynQueenne 8y ago
  It's the response to Greenspun's tenth rule that mentions Prolog explicitly. My previous comment states that AI programs written in Lisp implemented an interpreter for a logic programming language, unspecified. Although to be fair, that usually means "an informally-specified, ad-hoc, bug-ridden, slow implementation of Prolog" (1). Now, my knowledge of Eliza, Shrdlu, etc is a little limited (I've never read the source, say; btw, have you?) but let's see. Wikipedia is my friend, below. According to wikipedia MYCIN was a backwards chaining expert system. That means a logic programming loop, very likely a resolution-based theorem prover, or, really, (1). ELIZA was first implemented in MAD-SLIP, which, despite the name was not a Lisp variant (although it was a list-processing language). STUDENT is actually part of ELIZA- it's one of the two scripts that came with the original implementation, by Wizenbaum. The other script is DOCTOR, which is the one more often associated with ELIZA (it's the psychoanalyst). If I understand correctly, STUDENT solves logic problems, so I'm guessing it incorporates an automated theorem prover; so basically, (1). Eurisko was written in a frame-based (think OOP) representation language called RLL-1, the interpeter for which was written in Lisp. SHRDLU was written in Lisp and MicroPlanner an early logic programming language (with forward chaining, if memory serves). In the event, (1) was not necessary, as MicroPlanner was already all that- and more! The Automated Mathematician (AM) was indeed written in Lisp, but I don't know anything about its implementation. However, from the description on its wikipedia page it appears to have included a very basic inference procedure and a rule-base of heuristics. Sounds like a case of (1) to me.

etatoby 8y ago

Lisp and Scheme are great. They would be my favorite programming languages, if they had a statically typed, Hindley-Milner type system. As they stand, they are great learning tools, but I would never build something serious with them. Let alone questions about parallelism, concurrency, available libraries, development tools, etc. Any suggestions are welcome.

sevensor 8y ago
Typed Racket? It's not Hindley / Milner, but it seems pretty powerful.
ballpark 8y ago
I'm interested to see how contracts (`clojure.spec` is a new implemenation of them Clojure) can be used to make reading, debugging and maintaining Clojure easier.
Royalaid 8y ago
I think that part of the power of LISP is it's dynamic nature but if you want typed options they exist for Clojure and Racket. There is also development on a language called Carp that aims to be a Clojure style language for C https://github.com/carp-lang/Carp https://github.com/carp-lang/Carp.
lalaithion 8y ago
There's an experimental Racket language called Hackett which is attempting to give you the best of both worlds of Lisp's macros and Haskell's types. https://github.com/lexi-lambda/hackett https://github.com/lexi-lambda/hackett

kbumsik 8y ago

As a dev from non-CS major, I personally havn't learnt anything about Lisp but I would like to know. Is Clojure (specifically ClojureScript) a good start to study about it?

bartq 8y ago
Yes.
cjallen88 8y ago
Sure, start here: https://www.braveclojure.com/clojure-for-the-brave-and-true/ https://www.braveclojure.com/clojure-for-the-brave-and-true/
knowingpark 8y ago
Clojure is a modernised version of Lisp. It compiles to Java bytecode and runs on the JVM. Clojurescript compiles to Javascript for use in the browser. Some amazing programming tools have been written for Clojurescript. The community is very robust and opinionated, in a good way I think. Clojure is very modern with its vectors and maps. Lisp is more of an antique, a very valuable antique though. its very interesting to learn about both at the same time, as I did :)
- deleted 8y ago
  [deleted]
- pjmlp 8y ago
  Contrary to popular belief, Common Lisp has support for vectors, maps, records, stack and heap allocation. What Clojure has going for it is the wealth of Java libraries.
Royalaid 8y ago
I just want to say that the tooling setup isn't great and you kinda have to buy into a small ecosystem to do clojurescript Dev and the easiest is probably to use lein+lein-figwheel. If you have any questions feel free to ask!

ASipos 8y ago

> a field as esoteric as “recursive function theory” How can this kind of descriptions persist when recursive functions are the very thing that a computer computes.

deleted 8y ago
[deleted]
thrmsforbfast 8y ago
Because rft is esoteric. A lot of more applied CS departments don't require a CS theory course, and many programmers didn't major in CS or never attended university. So there are far more computer programmers than there are people who know what recursive function theory is or how it relates to modern computers.
AnimalMuppet 8y ago
Are they? They are the very thing that lambda calculus models computation on. They are not the very thing that Turing Machines model computation on. They also are not the very thing that CPUs use, or that assembly uses, or even that most high-level languages use. (Unless you're going to say that most high-level languages use a recursive descent parser to generate the binaries that the CPUs run, and that's the basis for your statement...)
- ASipos 8y ago
  Neither lambda calculus, nor Turing machines "model computation on" recursive functions. Rather, these two, and all the other models of computation are equivalent as they compute the same class of functions from the naturals to the naturals. And we call that class the class of recursive functions. That being said, a computer is a physical device that is able to compute this entire class of recursive functions. It is what makes it a computer and not a pen or a chair. It's not some esoteric notion. It's the whole thing about it.
  - AnimalMuppet 8y ago
    That's like saying that the basis of computation is the standard model, since all actual physical computers are made out of particles that are in the standard model. It may be true, but it's so far abstracted from what's actually going on that it's not useful at all.

Shorel 8y ago

I think the test to find out if a programmer can eventually learn to work on a Lisp codebase lies in his/her opinion about the conditional (ternary) operator. If the programmer hates the C(T)O because it is too confusing, that programmer is hopeless about using Lisp. If the programmer sees the C(T)O as a trivial syntax that helps to make the code short and neat, then that programmer will love Lisp.

ratsimihah 8y ago
I can't think of anyone who'd hate the CTO, it's hardly more confusing than an if/else statement.
- jimmy1 8y ago
  I work in JavaScript on a regular basis, and I have grown to despise them because of their overuse when a simple if statement would have made the code much clearer.
weliketocode 8y ago
I haven't dived into lisp, but if you're telling me it'll make my code shorter, I'm sure I'll love it.
- deleted 8y ago
  [deleted]

decafbad 8y ago

Lisp programmers and Lisp braggers are distinct groups.

aswanson 8y ago

Far too many intelligent programmers swear by lisp for there to be no "there" there. I'm trying to learn it in my nonexistent spare time.

gagege 8y ago
I know what you mean and I think that feeling comes from a difference between lisp the language (learn in a matter of hours) and lisp the ecosystem (takes much longer to get confident with). And, you really need to learn both, unless you have time to make everything from scratch.
- bunderbunder 8y ago
  Well, you need to learn both if you're going to make a career of working in Lisp. But even if that isn't in the cards (and it isn't for most of us, for all sorts of reasons), there's still a whole lot of value in learning the language enough to go through and make a few things from scratch. I tend to agree with ESR on the subject: "LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot." (http://www.catb.org/esr/faqs/hacker-howto.html http://www.catb.org/esr/faqs/hacker-howto.html)
  - deleted 8y ago
    [deleted]
3pt14159 8y ago
Look, here is the deal with Lisp. It shows you the data structure of your computer program and lets you operate on it and that is neat. But it's not useful for actual work because the way you manipulate it makes it hard for you to understand what is happening without knowing all the ways your code is being manipulated. I have to write lisp for my editor (emacs) and I don't hate it, but I don't love it either. The syntax is hard to read quickly because it's cluttered and (usually) nest-y. If you're willing to trade complete purity away, try Ruby. It's basically everything you want from Lisp without the mess. Give up purity, get comprehensibility. Blocks are a really great way of doing things. You can even investigate the block source code as a string if you really want to. Dynamic method definition is well supported and predictable. Data structures are easy to compose and operate on. It's basically all the power but in a more comprehensible way. There's a reason why Rails came out of Ruby. It's naturally powerful.

leshow 8y ago

I'm not familiar with any of these memes about lisp. If anything, the stuff you're claiming about lisp I've heard about Haskell.

metonymy 8y ago

If you want to read SICP, it is available in HTML, EPUB here: https://github.com/sarabander/sicp https://github.com/sarabander/sicp also here: https://sicpebook.wordpress.com/ebook/ https://sicpebook.wordpress.com/ebook/. Not available in EPUB on Amazon or Google.

deleted 8y ago

[deleted]

kidsnow 8y ago

The principle of orthogonal design is something I learned in CS, but hardly anyone mentions any more. The idea boils down to building software parts in a consistent way such that can be combined and re-used to form new things. The way you can accomplish this is by having very few rules. The more "syntaxy" a language is, the less orthogonal it is. For more reading and discussion on this topic: https://softwareengineering.stackexchange.com/questions/103567/what-is-the-most-orthogonal-programming-language https://softwareengineering.stackexchange.com/questions/1035...

zeveb 8y ago

Another two factors in the '00s re-rise of Lisp were Steve Yegge's Drunken Blog Rants (https://sites.google.com/site/steveyegge2/blog-rants https://sites.google.com/site/steveyegge2/blog-rants) & Practical Common Lisp (http://gigamonkeys.com/book http://gigamonkeys.com/book). The former was, at the time, very influential (and deservedly so); the latter was and remains the best reference for actually using Common Lisp to write real software (Edi Weitz's Common Lisp Recipes is an excellent companion volume).

robbrit 8y ago

Back in 2007 I thought it was silly that SBCL (and SmallTalk too) distributed its applications as "images". Seems they've been re-invented today as "containers", which are suddenly an amazing idea.

catacombs 8y ago

Lisp is God's language. TempleOS is God's operating system.

cztomsik 8y ago

Everybody's just praising lisp like it's the best language ever, yet very few people are actually using it - and I think it's because it's really easy to write smart code which has to be explained over and over again to new people (and to your future-you). I think this should be noted.