21 ms·

The Evolution of Lisp (1993) [pdf]

155 points by swatson741 2y ago

dang 2y ago
Related: The Evolution of Lisp (1993) [pdf] - https://news.ycombinator.com/item?id=14937424 https://news.ycombinator.com/item?id=14937424 - Aug 2017 (17 comments) The Evolution of Lisp - https://news.ycombinator.com/item?id=3528694 https://news.ycombinator.com/item?id=3528694 - Jan 2012 (4 comments and a video re-enactment from 2008: https://www.infoq.com/presentations/Lisp-Guy-Steele-Richard-Gabriel/ https://www.infoq.com/presentations/Lisp-Guy-Steele-Richard-...) The Evolution of Lisp [pdf] - https://news.ycombinator.com/item?id=2082417 https://news.ycombinator.com/item?id=2082417 - Jan 2011 (1 comment)
behnamoh 2y ago
People should clarify what they mean by "Lisp". It's not a programming language or even a family of languages, it's a whole different computing system which just happens to have a programming language syntax on top. To get the most out of it and benefit from the powerful CL REPL, one needs to use Emacs (also written in Lisp). Some variants just drop that part and focus on the language only. Clojure and Racket are in that category. They lack the full power of CL; so they're just Lisp-syntax languages, not an actual Lisp. Maybe this high barrier to entry is why Lisp hasn't caught on even after 30 years of CL standardization. People often don't want to learn a new IDE to get the most out of Lisp. And if they stick to their current IDEs, they only get a glimpse of Lisp through its syntax (and much limited macro system). At that point, it's questionable whether whatever remains of Lisp does indeed provide any advantage over more mainstream languages (e.g., instead of learning Clojure, why not just learn a functional language like Elixir or Haskell? It's not like Clojure gives you the full Lisp power anyway.) Addendum: As one of the comments below mentioned (thank you @lispm), what I meant by "dropping the full power of Lisp" is the ability to modify a running program (continuation/restart system). Does Clojure REPL drop you in a new REPL in case of errors so you can literally change the running code or enter value for a missing variable?
- tvink 2y ago
  Why do you say that one needs to use Emacs? Like, I love using Emacs for the elisp and having the power of a full lisp machine, but for CL I didn't find sly-mode/slime to offer anything particular paradigm-shiftingly more powerful than the vim/nvim adaptions? This very side is written in CL in vi, if I'm not mistaken?
  - kagevf 2y ago
    It's written in arc, a lisp language Paul Graham created. I think you're right about vi, though.
  - bmitc 2y ago
    The site is written in Arc, which is a language written in an older version of Racket.
- jay-barronville 2y ago
  Clojure isn’t an “actual” Lisp because it’s not Common Lisp? Are you serious? Purity spiral much?
  - tmtvl 2y ago
    Parent stated that some variations drop the 'whole different computing system' part of Lisp; which makes them Lisp-syntax languages rather than actual Lisps. I believe he means things like modifying a class and updating all existing instances without having to restart the application, the continuation/restart system, and so on. As an aside, please remember the guidelines: 'Please respond to the strongest plausible interpretation of what someone says, not a weaker one that's easier to criticize. Assume good faith.'
    - bmitc 2y ago
      The comment was well within the guidelines and is a viable point. When people make broad statements on Lisp like the original great-grandparent comment, they really need to clarify whether they're talking about Common Lisp or Lisp-likes. The original LISP doesn't have the features that Common Lisp has, so it'd be weird indeed to say that LISP wasn't an actual Lisp. In retrospect, the comment was talking about Common Lisp and not just Lisp-likes and tried to make the distinction but did a poor job of it with comments like: > Clojure and Racket are in that category. They lack the full power of CL; so they're just Lisp-syntax languages, not an actual Lisp.
lispm 2y ago
Uncut version: https://www.dreamsongs.com/Files/HOPL2-Uncut.pdf https://www.dreamsongs.com/Files/HOPL2-Uncut.pdf A Pattern of Language Evolution, Gabriel/Steele 2008, https://www.dreamsongs.com/Files/PatternOfLanguageEvolution.pdf https://www.dreamsongs.com/Files/PatternOfLanguageEvolution....
- optimalsolver 2y ago
  That website's homepage really takes me back to the Old Web: https://www.dreamsongs.com https://www.dreamsongs.com
aj7 2y ago
Lisp is far and away the best of the nonreadable programming languages.
- Zambyte 2y ago
  It's all the way up at the best readable ones instead :)
- marcosdumay 2y ago
  It takes getting used to it, just like every other programming language syntax. If you are comparing it to the ones you are used to, of course you'll find it harder. (IMO, I don't like the Lisp syntax, but it's really not "non-readable".)
  - 7373737373 2y ago
    It is hard to read though. As a beginner or someone unfamiliar with a new codebase you never know whether you are recursing into a special form or not. If you are, the semantics and order in which you ought to read and understand and further recurse into the argument list changes completely. How other programming languages limit the depth of this recursion and the variation/complexity of a code block, by splitting the semantics into a limited set of reusable syntactic constructs is very powerful. It is sad that most aren't homoiconic though.
    - iLemming 2y ago
      > It is hard to read though. What isn't? Java or C# with deep hierarchies of nested classes and tons of boilerplate, extensive use of interfaces or overuse of exception checking? Python with its magic methods and decorators and misindentation? Javascript with the callback hell, inconsistent type coersion and sometimes tricky async code? Ruby with its weird metaprogramming and monkey patching? C with the pointers mental acrobatics and pre-processor macros? Perl with weird default vars like $_ and tons of regexps? Haskell with its monadic structures and heavy use of weird symbols and operators? PHP with the crapload of its historical baggage, global vars and inconsistent, non-standardized function naming? Any programming language can be considered hard to read, quirky, slow, inconsistent, or lacking some feature. Everyone knows there are only three God-given, bullet-proof, guaranteed ways to write robust, fast, consistent, bug-free and scalable software. Three... Humankind has yet to discover those.
aj7 2y ago
Paul Graham felt all development should be in Lisp. Problem is readability by maintainers in the future. To facilitate that, the number of characters in the comments would have to exceed that in the code.
- barrell 2y ago
  Even with all those comments, it still ends up being less characters than other languages :D
- CaptainOfCoit 2y ago
  > Problem is readability by maintainers in the future Sounds like a problem that exists in every single programming language to date. And the reason that problem appears is not because of the languages themselves.
  - giovannibonetti 2y ago
    Some languages are designed with a strong focus in simplicity and great compiler errors to overcome that issue as much as possible. Gleam and Elm are some of them.
- iLemming 2y ago
  > Problem is readability by maintainers in the future. Of course. That's why some massive projects got abandoned because nobody understood the code they were originally written in. Does anyone even remember Emacs, or AutoCAD, or Datomic? There were companies that went bankrupt because their Lisp codebases became obsolete. Remember Cisco? Or Apple (those idiots tried to build their payment system in Clojure), or Walmart? Or NASA (before they succumbed to the will of evil Elon). Maybe smaller companies like Pitch, or Funding Circle, or CircleCI, or Grammarly? No? Sigh, nobody cares anymore about the history of dead programming languages.
  - Capricorn2481 2y ago
    Do you have anything suggesting these weren't just abandoned like most projects are? Is there some interview with the CTO saying "Lisp made this impossible"? We abandoned a project in Python. Is Python unusable?
theodpHN 2y ago
Got a link to fairly simple examples comparing Lisp solutions to those in another more 'mainstream' language (e.g., C, Python, BASIC, Java) that illustrate the benefits of using Lisp over another language for a 'practical' application? Thanks!
- Jtsummers 2y ago
  https://rosettacode.org https://rosettacode.org https://rosettacode.org/wiki/Category:Common_Lisp https://rosettacode.org/wiki/Category:Common_Lisp This has a lot of problems solved in multiple languages.
  - theodpHN 2y ago
    Thanks, that is a great site! Will have to look at more, but looking at examples like the following, I'm not having a Lisp Aha! moment when I compare the Lisp and Julia/Python implementations, e.g., Cheryl's birthday https://rosettacode.org/wiki/Cheryl%27s_birthday https://rosettacode.org/wiki/Cheryl%27s_birthday Seems like part of the problem is that Lisp is often demonstrated with examples that your average programmer can turn to 'black box' pre-built functions/packages/software for. That Lisp can help one extend a programming language to add a CASE statement, for example, is not going to win the hearts and minds of those who are already using a programming language with a built-in CASE statement. It may be neat from an intellectual standpoint, but not from a practical one. And the merits of the example linked to below of how Lisp can be used to implement an in-memory database will surely be completely lost on anyone with access to in-memory database software like DuckDB. Practical Common Lisp: An MP3 Database https://gigamonkeys.com/book/practical-an-mp3-database https://gigamonkeys.com/book/practical-an-mp3-database DuckDB: SQL Introduction https://duckdb.org/docs/archive/0.8/sql/introduction.html https://duckdb.org/docs/archive/0.8/sql/introduction.html
    - Jtsummers 2y ago
      I don't think anyone should expect to get an "Aha! moment" from looking at algorithmic code. That's going to be the same in most languages. If you want a "Lisp Aha! moment" you'd probably be better off looking at something that's actually Lisp-centric like Paradigms of AI Programming by Norvig (https://github.com/norvig/paip-lisp https://github.com/norvig/paip-lisp). You eventually build up to a Prolog to CL compiler written in CL.
7373737373 2y ago
Is there any old or new Lisp variant with excellent, beginner friendly (or even loving) documentation?
- pgt 2y ago
  Clojure: http://clojurescriptkoans.com/ http://clojurescriptkoans.com/
- swatson741 2y ago
  R6RS has a book that describes everything simply except for setting up the interpreter. [1] Racket has all of that and everything else you need to get started like tooling and modules. [2] Both lisps are no nonsense scheme variants. [1](https://www.scheme.com/tspl4/ https://www.scheme.com/tspl4/) [2](https://racket-lang.org https://racket-lang.org)
  - ethagnawl 2y ago
    I was going to suggest Racket, too. Its documentation is some of the best I've ever come across. It doesn't hurt that it's beautiful, too. I smile every time I use Racket or its documentation.
- sourcepluck 2y ago
  https://janet.guide/ https://janet.guide/ this document can definitely be described as loving.
- iLemming 2y ago
  Emacs Lisp is known for its great documentation, but I bet you're not asking about that. Try Fennel - it's a zero-overhead Lisp->Lua compiler. 'Zero-overhead' means that Fennel compiles directly to Lua without adding any extra runtime costs or abstractions beyond those present in standard Lua, ensuring Fennel code runs as efficiently as native Lua code. It has a relatively small set of features and is a very lovely language. I use it for dealing with things that need Lua - Hammerspoon, AwesomeWM, Neovim, etc. I jokingly call Fennel "the best Lua formatter" because Fennel code looks much more compact, cleaner, and easier to reason about than Lua. Lua syntax is weird, and I can never figure out how to format it for the best readability; standard tools and formatters rarely help here, sometimes making things even worse. The problem I almost never had with Fennel.
gjvc 2y ago
anyone got the .tex source for this?
kazinator 2y ago
Please link to uncut version on Gabriel's own site. See https://news.ycombinator.com/item?id=40484444 https://news.ycombinator.com/item?id=40484444
ggm 2y ago
The abiding value of Lisp may be that it's a talking point, in the idea of what a programming language is. Forth has a similar quality. The reductionist sweetspot of "implemented as a stack language" and "one step up from machine code" C is the "no guide rails" conversation. Some would say it's one step down from assembly because it has none of the rigour and only some of the speed. That lack of rigour, the ability to cast within a memory region if you know how your structure maps into that region, I find extremely useful. Pascal's version of it was more clumsy but that said, perhaps the semicolon (and full stop) alone make Pascal part of the C family. (you can't directly compute over a value in both float and int in assembler if you are in the ALU/FPU register space. You do "cheats" which are not rigorous, but more rigorous than C)
throw156754228 2y ago
What's a good resource for learning to write a lisp compiler?
- cess11 2y ago
  https://buildyourownlisp.com/ https://buildyourownlisp.com/ is a good start.
  - hayley-patton 2y ago
    It is a very bad start and teaches writing an interpreter and not a compiler. https://gist.github.com/no-defun-allowed/7e3e238c959e27d4919bb4272487d7ad https://gist.github.com/no-defun-allowed/7e3e238c959e27d4919...
    - cess11 2y ago
      Do you imagine it to be especially hard or impossible to replace an interpreter with a compiler instead of implementing a compiler from scratch? It makes it harder to have decided on the language design rather than inventing it in parallel? From an interpreted Lisp system to a compiler it's mostly a slog of studying compilers and assembly (or machine code) and possibly translating the interpreter, which you can use to bootstrap the compiler implementation if you'd like. It's common path, see https://mpov.timmorgan.org/i-built-a-lisp-compiler/ https://mpov.timmorgan.org/i-built-a-lisp-compiler/ and https://bernsteinbear.com/blog/compiling-a-lisp-0/ https://bernsteinbear.com/blog/compiling-a-lisp-0/ .
      - hayley-patton 2y ago
        It's especially hard when you don't have semantics for your language outside of what your interpreter does. Then the semantics of the language in the book are plain bad: there is only dynamic scoping (oh, and the book often has plain misinformation - the provided definition of "lexical scoping" is wrong), and setting a local variable only affects the innermost LET if you nest environments, since the interpreter deep-copies environments (as it does with everything, to cope with lack of GC). The book also uses something more like fexprs than macros, which I don't have an opinion _outside of this book_ on with regards to language UX, but fexprs are generally harder to compile. That is in part because they control if/when their arguments are evaluated, but the fexpr-alike things here do not (instead "Q-expressions" delay evaluation like QUOTE). You still would want to do something about calls to EVAL though. The fexpr system _in this book_ also does have bad UX: it only incidentally works with dynamic binding (Shutt's lexically scoped fexprs explicitly pass the environment around) and it also leaks every variable binding from the fexpr function into what it evaluates. The book also just doesn't cover compilers, so you're doing that slog on your own.
timonoko 2y ago
Never seen Lisp-in-Lisp without additional (and boring) yapping. Just CAR, CDR and CONS. And assign and type-test and COND. It would probably be about 300 lines. "Most beautiful program ever" is short but the associated yapping takes almost 2 hours. https://www.youtube.com/watch?v=OyfBQmvr2Hc https://www.youtube.com/watch?v=OyfBQmvr2Hc
martyalain 2y ago
I discovered LISP late in life. For a long time, I didn't understand it at all, and reading that LISP was the most natural, the clearest and the most beautiful of all languages didn't help. Until I discovered that LISP was a dialect of lambda-calculus. For a long time, I didn't understand it at all, so hermetic was this formal language dating back to the 30s, and apparently reserved for an academic elite. But then I realized that it was nothing more than a sophisticated text replacement tool. So, using a single regular expression and a few lines of javascript code, I wrote an s-expression evaluation/reduction engine. Then I added 9 special forms -- lambda, def, if, let, quote, macro, style, script, require -- to end up with a real language, lambdatalk, capable of taking advantage of the web's tremendous potential. The result can be seen here: http://lambdaway.fr http://lambdaway.fr . I explored many algorithms, and even if this exploration remained solitary, I learned a lot. This is my LISP experience and I don't regret it. Thank you LISP.

155 points by swatson741 2y ago

dang 2y ago

Related: The Evolution of Lisp (1993) [pdf] - https://news.ycombinator.com/item?id=14937424 https://news.ycombinator.com/item?id=14937424 - Aug 2017 (17 comments) The Evolution of Lisp - https://news.ycombinator.com/item?id=3528694 https://news.ycombinator.com/item?id=3528694 - Jan 2012 (4 comments and a video re-enactment from 2008: https://www.infoq.com/presentations/Lisp-Guy-Steele-Richard-Gabriel/ https://www.infoq.com/presentations/Lisp-Guy-Steele-Richard-...) The Evolution of Lisp [pdf] - https://news.ycombinator.com/item?id=2082417 https://news.ycombinator.com/item?id=2082417 - Jan 2011 (1 comment)

behnamoh 2y ago

People should clarify what they mean by "Lisp". It's not a programming language or even a family of languages, it's a whole different computing system which just happens to have a programming language syntax on top. To get the most out of it and benefit from the powerful CL REPL, one needs to use Emacs (also written in Lisp). Some variants just drop that part and focus on the language only. Clojure and Racket are in that category. They lack the full power of CL; so they're just Lisp-syntax languages, not an actual Lisp. Maybe this high barrier to entry is why Lisp hasn't caught on even after 30 years of CL standardization. People often don't want to learn a new IDE to get the most out of Lisp. And if they stick to their current IDEs, they only get a glimpse of Lisp through its syntax (and much limited macro system). At that point, it's questionable whether whatever remains of Lisp does indeed provide any advantage over more mainstream languages (e.g., instead of learning Clojure, why not just learn a functional language like Elixir or Haskell? It's not like Clojure gives you the full Lisp power anyway.) Addendum: As one of the comments below mentioned (thank you @lispm), what I meant by "dropping the full power of Lisp" is the ability to modify a running program (continuation/restart system). Does Clojure REPL drop you in a new REPL in case of errors so you can literally change the running code or enter value for a missing variable?

tvink 2y ago
Why do you say that one needs to use Emacs? Like, I love using Emacs for the elisp and having the power of a full lisp machine, but for CL I didn't find sly-mode/slime to offer anything particular paradigm-shiftingly more powerful than the vim/nvim adaptions? This very side is written in CL in vi, if I'm not mistaken?
- kagevf 2y ago
  It's written in arc, a lisp language Paul Graham created. I think you're right about vi, though.
- bmitc 2y ago
  The site is written in Arc, which is a language written in an older version of Racket.
jay-barronville 2y ago
Clojure isn’t an “actual” Lisp because it’s not Common Lisp? Are you serious? Purity spiral much?
- tmtvl 2y ago
  Parent stated that some variations drop the 'whole different computing system' part of Lisp; which makes them Lisp-syntax languages rather than actual Lisps. I believe he means things like modifying a class and updating all existing instances without having to restart the application, the continuation/restart system, and so on. As an aside, please remember the guidelines: 'Please respond to the strongest plausible interpretation of what someone says, not a weaker one that's easier to criticize. Assume good faith.'
  - bmitc 2y ago
    The comment was well within the guidelines and is a viable point. When people make broad statements on Lisp like the original great-grandparent comment, they really need to clarify whether they're talking about Common Lisp or Lisp-likes. The original LISP doesn't have the features that Common Lisp has, so it'd be weird indeed to say that LISP wasn't an actual Lisp. In retrospect, the comment was talking about Common Lisp and not just Lisp-likes and tried to make the distinction but did a poor job of it with comments like: > Clojure and Racket are in that category. They lack the full power of CL; so they're just Lisp-syntax languages, not an actual Lisp.

lispm 2y ago

Uncut version: https://www.dreamsongs.com/Files/HOPL2-Uncut.pdf https://www.dreamsongs.com/Files/HOPL2-Uncut.pdf A Pattern of Language Evolution, Gabriel/Steele 2008, https://www.dreamsongs.com/Files/PatternOfLanguageEvolution.pdf https://www.dreamsongs.com/Files/PatternOfLanguageEvolution....

optimalsolver 2y ago
That website's homepage really takes me back to the Old Web: https://www.dreamsongs.com https://www.dreamsongs.com

aj7 2y ago

Lisp is far and away the best of the nonreadable programming languages.

Zambyte 2y ago
It's all the way up at the best readable ones instead :)
marcosdumay 2y ago
It takes getting used to it, just like every other programming language syntax. If you are comparing it to the ones you are used to, of course you'll find it harder. (IMO, I don't like the Lisp syntax, but it's really not "non-readable".)
- 7373737373 2y ago
  It is hard to read though. As a beginner or someone unfamiliar with a new codebase you never know whether you are recursing into a special form or not. If you are, the semantics and order in which you ought to read and understand and further recurse into the argument list changes completely. How other programming languages limit the depth of this recursion and the variation/complexity of a code block, by splitting the semantics into a limited set of reusable syntactic constructs is very powerful. It is sad that most aren't homoiconic though.
  - iLemming 2y ago
    > It is hard to read though. What isn't? Java or C# with deep hierarchies of nested classes and tons of boilerplate, extensive use of interfaces or overuse of exception checking? Python with its magic methods and decorators and misindentation? Javascript with the callback hell, inconsistent type coersion and sometimes tricky async code? Ruby with its weird metaprogramming and monkey patching? C with the pointers mental acrobatics and pre-processor macros? Perl with weird default vars like $_ and tons of regexps? Haskell with its monadic structures and heavy use of weird symbols and operators? PHP with the crapload of its historical baggage, global vars and inconsistent, non-standardized function naming? Any programming language can be considered hard to read, quirky, slow, inconsistent, or lacking some feature. Everyone knows there are only three God-given, bullet-proof, guaranteed ways to write robust, fast, consistent, bug-free and scalable software. Three... Humankind has yet to discover those.

aj7 2y ago

Paul Graham felt all development should be in Lisp. Problem is readability by maintainers in the future. To facilitate that, the number of characters in the comments would have to exceed that in the code.

barrell 2y ago
Even with all those comments, it still ends up being less characters than other languages :D
CaptainOfCoit 2y ago
> Problem is readability by maintainers in the future Sounds like a problem that exists in every single programming language to date. And the reason that problem appears is not because of the languages themselves.
- giovannibonetti 2y ago
  Some languages are designed with a strong focus in simplicity and great compiler errors to overcome that issue as much as possible. Gleam and Elm are some of them.
iLemming 2y ago
> Problem is readability by maintainers in the future. Of course. That's why some massive projects got abandoned because nobody understood the code they were originally written in. Does anyone even remember Emacs, or AutoCAD, or Datomic? There were companies that went bankrupt because their Lisp codebases became obsolete. Remember Cisco? Or Apple (those idiots tried to build their payment system in Clojure), or Walmart? Or NASA (before they succumbed to the will of evil Elon). Maybe smaller companies like Pitch, or Funding Circle, or CircleCI, or Grammarly? No? Sigh, nobody cares anymore about the history of dead programming languages.
- Capricorn2481 2y ago
  Do you have anything suggesting these weren't just abandoned like most projects are? Is there some interview with the CTO saying "Lisp made this impossible"? We abandoned a project in Python. Is Python unusable?

theodpHN 2y ago

Got a link to fairly simple examples comparing Lisp solutions to those in another more 'mainstream' language (e.g., C, Python, BASIC, Java) that illustrate the benefits of using Lisp over another language for a 'practical' application? Thanks!

Jtsummers 2y ago
https://rosettacode.org https://rosettacode.org https://rosettacode.org/wiki/Category:Common_Lisp https://rosettacode.org/wiki/Category:Common_Lisp This has a lot of problems solved in multiple languages.
- theodpHN 2y ago
  Thanks, that is a great site! Will have to look at more, but looking at examples like the following, I'm not having a Lisp Aha! moment when I compare the Lisp and Julia/Python implementations, e.g., Cheryl's birthday https://rosettacode.org/wiki/Cheryl%27s_birthday https://rosettacode.org/wiki/Cheryl%27s_birthday Seems like part of the problem is that Lisp is often demonstrated with examples that your average programmer can turn to 'black box' pre-built functions/packages/software for. That Lisp can help one extend a programming language to add a CASE statement, for example, is not going to win the hearts and minds of those who are already using a programming language with a built-in CASE statement. It may be neat from an intellectual standpoint, but not from a practical one. And the merits of the example linked to below of how Lisp can be used to implement an in-memory database will surely be completely lost on anyone with access to in-memory database software like DuckDB. Practical Common Lisp: An MP3 Database https://gigamonkeys.com/book/practical-an-mp3-database https://gigamonkeys.com/book/practical-an-mp3-database DuckDB: SQL Introduction https://duckdb.org/docs/archive/0.8/sql/introduction.html https://duckdb.org/docs/archive/0.8/sql/introduction.html
  - Jtsummers 2y ago
    I don't think anyone should expect to get an "Aha! moment" from looking at algorithmic code. That's going to be the same in most languages. If you want a "Lisp Aha! moment" you'd probably be better off looking at something that's actually Lisp-centric like Paradigms of AI Programming by Norvig (https://github.com/norvig/paip-lisp https://github.com/norvig/paip-lisp). You eventually build up to a Prolog to CL compiler written in CL.

7373737373 2y ago

Is there any old or new Lisp variant with excellent, beginner friendly (or even loving) documentation?

pgt 2y ago
Clojure: http://clojurescriptkoans.com/ http://clojurescriptkoans.com/
swatson741 2y ago
R6RS has a book that describes everything simply except for setting up the interpreter. [1] Racket has all of that and everything else you need to get started like tooling and modules. [2] Both lisps are no nonsense scheme variants. [1](https://www.scheme.com/tspl4/ https://www.scheme.com/tspl4/) [2](https://racket-lang.org https://racket-lang.org)
- ethagnawl 2y ago
  I was going to suggest Racket, too. Its documentation is some of the best I've ever come across. It doesn't hurt that it's beautiful, too. I smile every time I use Racket or its documentation.
sourcepluck 2y ago
https://janet.guide/ https://janet.guide/ this document can definitely be described as loving.
iLemming 2y ago
Emacs Lisp is known for its great documentation, but I bet you're not asking about that. Try Fennel - it's a zero-overhead Lisp->Lua compiler. 'Zero-overhead' means that Fennel compiles directly to Lua without adding any extra runtime costs or abstractions beyond those present in standard Lua, ensuring Fennel code runs as efficiently as native Lua code. It has a relatively small set of features and is a very lovely language. I use it for dealing with things that need Lua - Hammerspoon, AwesomeWM, Neovim, etc. I jokingly call Fennel "the best Lua formatter" because Fennel code looks much more compact, cleaner, and easier to reason about than Lua. Lua syntax is weird, and I can never figure out how to format it for the best readability; standard tools and formatters rarely help here, sometimes making things even worse. The problem I almost never had with Fennel.

gjvc 2y ago

anyone got the .tex source for this?

kazinator 2y ago

Please link to uncut version on Gabriel's own site. See https://news.ycombinator.com/item?id=40484444 https://news.ycombinator.com/item?id=40484444

ggm 2y ago

The abiding value of Lisp may be that it's a talking point, in the idea of what a programming language is. Forth has a similar quality. The reductionist sweetspot of "implemented as a stack language" and "one step up from machine code" C is the "no guide rails" conversation. Some would say it's one step down from assembly because it has none of the rigour and only some of the speed. That lack of rigour, the ability to cast within a memory region if you know how your structure maps into that region, I find extremely useful. Pascal's version of it was more clumsy but that said, perhaps the semicolon (and full stop) alone make Pascal part of the C family. (you can't directly compute over a value in both float and int in assembler if you are in the ALU/FPU register space. You do "cheats" which are not rigorous, but more rigorous than C)

throw156754228 2y ago

What's a good resource for learning to write a lisp compiler?

cess11 2y ago
https://buildyourownlisp.com/ https://buildyourownlisp.com/ is a good start.
- hayley-patton 2y ago
  It is a very bad start and teaches writing an interpreter and not a compiler. https://gist.github.com/no-defun-allowed/7e3e238c959e27d4919bb4272487d7ad https://gist.github.com/no-defun-allowed/7e3e238c959e27d4919...
  - cess11 2y ago
    Do you imagine it to be especially hard or impossible to replace an interpreter with a compiler instead of implementing a compiler from scratch? It makes it harder to have decided on the language design rather than inventing it in parallel? From an interpreted Lisp system to a compiler it's mostly a slog of studying compilers and assembly (or machine code) and possibly translating the interpreter, which you can use to bootstrap the compiler implementation if you'd like. It's common path, see https://mpov.timmorgan.org/i-built-a-lisp-compiler/ https://mpov.timmorgan.org/i-built-a-lisp-compiler/ and https://bernsteinbear.com/blog/compiling-a-lisp-0/ https://bernsteinbear.com/blog/compiling-a-lisp-0/ .
    - hayley-patton 2y ago
      It's especially hard when you don't have semantics for your language outside of what your interpreter does. Then the semantics of the language in the book are plain bad: there is only dynamic scoping (oh, and the book often has plain misinformation - the provided definition of "lexical scoping" is wrong), and setting a local variable only affects the innermost LET if you nest environments, since the interpreter deep-copies environments (as it does with everything, to cope with lack of GC). The book also uses something more like fexprs than macros, which I don't have an opinion _outside of this book_ on with regards to language UX, but fexprs are generally harder to compile. That is in part because they control if/when their arguments are evaluated, but the fexpr-alike things here do not (instead "Q-expressions" delay evaluation like QUOTE). You still would want to do something about calls to EVAL though. The fexpr system _in this book_ also does have bad UX: it only incidentally works with dynamic binding (Shutt's lexically scoped fexprs explicitly pass the environment around) and it also leaks every variable binding from the fexpr function into what it evaluates. The book also just doesn't cover compilers, so you're doing that slog on your own.

timonoko 2y ago

Never seen Lisp-in-Lisp without additional (and boring) yapping. Just CAR, CDR and CONS. And assign and type-test and COND. It would probably be about 300 lines. "Most beautiful program ever" is short but the associated yapping takes almost 2 hours. https://www.youtube.com/watch?v=OyfBQmvr2Hc https://www.youtube.com/watch?v=OyfBQmvr2Hc

martyalain 2y ago

I discovered LISP late in life. For a long time, I didn't understand it at all, and reading that LISP was the most natural, the clearest and the most beautiful of all languages didn't help. Until I discovered that LISP was a dialect of lambda-calculus. For a long time, I didn't understand it at all, so hermetic was this formal language dating back to the 30s, and apparently reserved for an academic elite. But then I realized that it was nothing more than a sophisticated text replacement tool. So, using a single regular expression and a few lines of javascript code, I wrote an s-expression evaluation/reduction engine. Then I added 9 special forms -- lambda, def, if, let, quote, macro, style, script, require -- to end up with a real language, lambdatalk, capable of taking advantage of the web's tremendous potential. The result can be seen here: http://lambdaway.fr http://lambdaway.fr . I explored many algorithms, and even if this exploration remained solitary, I learned a lot. This is my LISP experience and I don't regret it. Thank you LISP.