📚 node [[lisp]]

Lisp

What all this boils down to is that most programming languages have similar semantic powers. However, basic Lisp code is different from code in any other major programming language in that it has a far simpler syntax. Having a simple syntax is a defining feature of the Lisp language.

– Land of Lisp

Cool how Lisp deals with big ints and fractions.

Code mode and data mode. That's helped understand a little bit what the quote is for.

By using quoting, you can tell Lisp, “This next part isn’t a command. It’s just a chunk of data for my program.”

– Land of Lisp

The creators of the other popular dialect of Lisp, Scheme, felt differently about this issue, and preferred to keep the concepts of falsity and empty list completely separate, at a slight cost to code brevity.

– Land of Lisp

Certainly so far, Racket (and probably that's as a result of coming from Scheme?) looks nicer than Common Lisp.

The various def functions are a bit ugly. The equality functions are very ugly (but that's also in Scheme?)

However, we’ll do this in a way that avoids constraining our code by artificially forcing the human notion of text into its design. This will allow us to write code that focuses on the strengths of a computer.

– Land of Lisp

Fair enough - but not 100% convinced we should cater to the computer and not the human…

By keeping your source data structures free from assumptions regarding the output format from the start, your coding can take full advantage of your programming language.

– Land of Lisp

Quasiquoting is cool.

This feature of Lisp, called quasiquoting, allows us to create chunks of data that have small pieces of Lisp code embedded in them.

– Land of List

Love functional paradigm and higher order functions manipulating a list.

Homoiconicity - using the same data structures to store both data and code.

`lambda` is a macro.

Have been enjoying the LOL and ROR books. Stopped with ROR when it started getting graphical for now - couldn't get it to work out of the box with Emacs. Switched to LOL. Enjoying Racket as a language more than CL, but LOL is a great book, and I prefer the text adventure example to be honest.

Really like functional programming. We did an ML course in university which was pretty terrible, wish I'd gotten the ideas behind it at the time…

Lisp may stand for List Processing, but it's really tree processing

[[The Nature of Lisp]]

In contrast with other langs

Together, FORTRAN and ALGOL spawned a long series of programming languages, called the ALGOL family. All mem- bers of this family are made from more or less the same material and for the same kind of programmers—those who love the machine more than the problem.

– Realm of Racket

Common Lisp is an oddity. It feels brutalist; a false, efficient, and democratic - even communist - vision of the future; a 60's theory that was never quite disproved, but also never quite succeeded, present as a story of computer science past, of McCarthy and Artificial Intelligence, of the optimism of the early computer age.

The language lacks facilities that are common or easy in other systems. Robust package management, typechecking in most forms, and modern network connectivity tools are lacking. Abstraction and data representation, however - through the incredibly expressive macro and class systems - are more powerful than most languages today.

There are new alternatives - Clojure, Scheme implementations, and Racket each incorporate ideas derivative of Lisp's REPL, parameters, pattern matching, and macro expansion capabilities - but new communities are fragmented, iterated upon, nad constantly in flux. Common Lisp is a future that was never quite realized, and its ANSI standard means the languages is fixed to be explored - forever.

Table of Contents

Ok, let's figure out why there is so much hype about lisp.

related [[programming]] [[elisp]] [[plt]] [[computing]]

[2019-10-18] What did Alan Kay mean by, "Lisp is the greatest single programming language ever designed"? | Lobsters [[lisp]]

https://lobste.rs/s/np3por/what_did_alan_kay_mean_by_lisp_is_greatest

[2019-12-04] eh, dunno feels like it's hard to appreciate Lisp now because it hasn't evolved much and concepts that were novel once are taken for granted now

[2020-01-16] Running Lisp in Production [[lisp]]

https://tech.grammarly.com/blog/running-lisp-in-production

[2019-10-23] Let Over Lambda

dunno, wasn't really impressed much…

[2021-01-01] I think it would be not that much better than prefix. Infix is easier to read, … | Hacker News [[lisp]]

The second thing is, intermediate variables makes code much more readable, but lisp strongly discourages this. The only way to create a lexical variable is with LET. But this causes indenting, which is pretty ugly. In fact, the use of indenting for both logical nesting and variable creation is a really nasty thing:

[2021-01-03] On repl-driven programming - by mikel evins [[repl]] [[lisp]]

[2021-01-08] Python for Lisp Programmers [[python]] [[lisp]]

[2021-01-01] Lisp: Common Lisp, Racket, Clojure, Emacs Lisp - Hyperpolyglot [[lisp]]

[2021-01-02] (1) Online Lisp Meeting Videos - YouTube [[lisp]] [[towatch]]

[2020-12-31] McCLIM – A powerful GUI toolkit for Common Lisp [[lisp]]

[2020-05-13] Janet: a lightweight, expressive and modern Lisp | Hacker News [[lisp]]

Okay, so when Clojure came along, it came with a strong underlying philosophy of what the language was supposed to be/do. Among them were design decisions such as, e.g.,:

  - VMs, not OSes, are the platforms of the future, so target the JVM
  - Object Orientation is overrated, but polymorphism is a good thing
  - Multi-core is here to stay, so use immutable data structures to greatly facilitate writing correct concurrent programs
  - Leverage the strengths of LISP but give it a modern overhaul (most notably, throw in different parenthesis)

[2021-01-01] Forth compiler in one literate x86 assembly file | Hacker News [[lisp]]

Syntax is of course the most obvious `backward' thing. Conceptually Lisp moves you away from the machine and closer to math, Forth stays way closer. Forth does not (normally) include a garbage collector. Naming variables is discouraged. Forth is almost untyped, Lisp is strongly-dynamically typed. 

[2020-07-03] [Joshua Ebner on Twitter: "@julesh_ @paulg Honest question: What's so great about Lisp?" / Twitter](https://twitter.com/Josh_Ebner/status/1278733040181817345 ) [[lisp]]

Honest question:
What's so great about Lisp?

[2018-10-03] Scheme Lisp: feel the cool Andy Balaam Accu 2018 [[lisp]]

  • 38:46 weird code as data (define s (lsit '+ 4 7))
  • [2019-10-20] eh, very basic talk and also doesn't really communicate why scheme/lisp are cool if you're experienced with multiple languages already. Thing with numbers and mscons at the end can be done on any PL

Write a post following that common lisp post and comparing [[python]] [[lisp]]

I don't mean to offend lisp lovers or anything. I'm just desperately trying to find what's so special about lisp I don't see, so would be happy to know if you Todo missing aspect

lisp sucks: dunno, my eyes kinda hurt without explicit else keyword… [[lisp]]

hmm, maybe show visual cues for indentation level? but this requires very strict formatting rules [[lisp]]

example of thing that would be 'discouraged' in lisp (emsg) [[python]] [[lisp]]

elif isinstance(e, ImportError):
    emsg = getattr(e, 'msg', '') # make mypy happy
    if 'failed to find libmagic' in emsg: # probably the actual library is missing?...
        defensive_msg = "couldn't import magic. See https://github.com/ahupp/python-magic#installation"

[2021-02-06] [jestem króliczkiem on Twitter: "Lisp is amazing, truly language of the future "not especially malicious" https://t.co/Wvhha6CCUl" / Twitter](https://twitter.com/karlicoss/status/1358183224929902593 ) [[lisp_sucks]]

Lisp is amazing, truly language of the future
"not especially malicious"

[2021-03-15] Smug Lisp Weenie [[lisp]]

ok, great discussion here

[2021-03-20] Pascal Costanza's Highly Opinionated Guide to Lisp [[lisp]]

📖 stoas
⥱ context
⥅ related node [[clarice lispector]]
⥅ related node [[elisp sucks]]
⥅ related node [[elisp]]
⥅ related node [[elisp koans]]
⥅ related node [[emacs lisp]]
⥅ related node [[the nature of lisp]]
⥅ related node [[20200604222651 lisp]]
⥅ related node [[20200713103540 emacs_lisp]]
⥅ related node [[20210204085035 lisp_machine]]
⥅ related node [[20210307170643 dialect_of_lisp]]
⥅ related node [[20210312162123 lisp_programs_are_also_data]]
⥅ related node [[20210403130020 implementing_lisp_scope_and_closure]]
⥅ related node [[20210404104508 lisp_primitives]]
⥅ related node [[20210521102127 alan_kay_on_lisp]]
⥅ related node [[20210713170740 lisp_timestamp]]
⥅ related node [[20210307152720 lisp_in_small_pieces]]