The Landscape of Lisp | Hacker News Reader

The Landscape of Lisp

churchofturing.github.io

55 pointstodsacerdoti27 comments

I'm not a Lisp expert but one of the most fun languages I've used recently is Janet [1], it's a single binary, very easy to get started, decent docs and battery-included. It's great for little CLI tools or solving Advent of Code for example.

I'm curious why they don't mention being a Lisp in their page though, perhaps it's not a "real" lisp?

[1]: https://janet-lang.org/

I’ve been playing with Janet recently as well and really enjoying it. It does seem slightly abandoned though. I can’t tell if it’s similar to what’s happening with Common Lisp where thins are simply complete, or if the small ecosystem that did exist has mostly faded away. As a result I’ve been tending towards Fennel because Lua does have complete packages. But I really want to like Janet.

> It does seem slightly abandoned though

I think in general "free-time projects" just move a bit slower. Still, it seems to get ongoing work (https://github.com/janet-lang/janet/graphs/contributors), so doesn't seem abandoned to me at all.

Maybe it would be more accurate to say the ecosystem seems abandoned? But I think what’s actually happening there is I’m coming from the nonsense that is npm so I see one option for making http requests that is just bindings to libcurl and think that’s a downside. When really the ease of C interop is a selling point for Janet.

This. I tried to use Janet a few times but the joy web framework seems to have completely stalled, and database support likewise.

Are you able to distribute fennel builds in a single binary easily ?

> Fennel because Lua does have complete packages

Do you end up using a lot of lua packages in fennel ?

Not a lot of packages but more than 0. For example I’m working on a small static site generator so I’m using lunamark.

Fennel has the ability to compile[0] to a binary that works pretty well and very well so long as you don’t have any dynamic links.

0: https://wiki.fennel-lang.org/Distribution#binary-executable

I use Fennel with TIC80, Love and Raylib. Such a fun little Lisp that was the first one to really stick. Really helped that Fennel has anti-fennel that converts between Fennel and Lua.

Defining what a "real lisp" is... a bit like defining what a "real roguelike" is.

Depending on who you ask it either becomes yet another common lisp or just "a lot of parentheses" :-)

Janet is cool though. And it is a lisp. And hades is a roguelike.

I don’t think there’s any confusion over the definition of roguelike vs roguelite.

The key difference is that roguelikes lack the meta progression that roguelites have. Rogue and friends didn’t have meta progression.

So hades is a roguelite, not a roguelike.

It’s a well known distinction.

sigh

The key difference according to the famous Berlin interpretation is that roguelikes are supposed to have certain traits [1] making them into a variation of classic games: ADOM, (B)Rogue, Nethack, etc.

Metaprogression can or cannot be in the game. Doesn't even matter.

In this worldview roguelites, generally speaking, only borrow certain aspects of the definition, with permadeath being the main one.

Either way, there are many (very) influential devs who do not agree even with this strict definition [2].

[1] https://www.roguebasin.com/index.php/Berlin_Interpretation

[2] http://www.gamesofgrey.com/blog/?p=403

Sure some devs may split hairs over the precise semantics, but for the market at large, the difference is understood.

Talk to any average roguelike/lite enjoyer and they’ll identify that as the difference.

“Roguelikes” do tend to have that same top down grid style, though.

Can’t think of any permadeath games without metaprogression which encourage replaying the whole game on death and which don’t use that format.

Just like with lisps. Some devs may split hairs over what is and is not a lisp, but for most people, if the language is dynamic, garbage collected, has a regular parens-heavy syntax, and has powerful macro features, it’s a lisp.

Isn't this what i am trying to point out? Definitions are kinda hard to come up with here, only general features/expectations are possible.

And then there's also genre/language evolution at play. Most people would say that Clojure is a lisp but semantically it is a very different language when compared to, say, common lisp.

"No true Scotsman..."

Lisp-1 and Lisp-2 are the only interesting distinctions. Everything else boils down to "does it use S-expressions?" The "OMG! it doesn't have ~cons~!" is a silly argument, but that's because it's an opinion (just like this).

https://www.nhplace.com/kent/Papers/Technical-Issues.html

Note that there's far less disagreement over the designation "Lisplike".

I think this is mostly due to the more niche nature of the discussion. Many people play games, not too many people (or even devs) know about all the numerous Lisp-likes.

In relevant communities. I have seen A LOT of arguments in niche communities over what a Lisp should be like. It all started around the introduction of Scheme compilers. Some say a Lisp should have macros, others focus on lists/vectors/hashes, then there's dynamic execution vs compilation, let's not forget about dynamic vs lexical binding; and the big one - Lisp-1 or Lisp-2.

I work in a mid-tier tech company with 800 devs. Been here for years, know everyone. There are maybe 3 devs/admins who know what Racket is!

I dunno, but maybe "real Lispers" don't like languages that have imperative features like "for" and "while"?

OK, real Lispers, don't kill me!!!

Not at all.

Common Lisp has the loop macro which is fairly imperative.

It also has a really great OOP implementation in CLOS

Lisp need not be purely functional.

> I'm curious why they don't mention being a Lisp in their page though, perhaps it's not a "real" lisp?

Maybe to avoid some of the zealots who refuse to call Clojure et al "lisps" since they're missing cons, X, Y and so on.

I remember reading somewhere in a GitHub issue or PR that the author/maintainer also calls Janet "lisp-like" rather than "a lisp", fwiw.

It doesn't grow from cons cells, which some people think is crucial for an authentic Lisp. They also tend to exclude Clojure.

I think maybe the Janet designers don't want to get bogged down in the language wars, and don't really care whether lispers enjoy their language or not.

A language with Lisp in the name and cons cells that a purist might argue isn't an authentic Lisp is Picolisp, e.g. because it has FEXPR:s rather than SEXPR:s and no macros. It's a great tool either way, easy to be very productive in when inventing ad hoc tools in a shell. The 'match function is quite different from e.g. the PEG:s in Janet but I really like it when doing something obtuse and gnarly with strings. Having a Prolog engine at hand is always good too.

https://picolisp.com/wiki/?home

> They also tend to exclude Clojure.

As a CL (sbcl, mainly) I'm not interested in discussion about whether a language is a "true" lisp or not. I don't think that is a useful measure.

Something I recommend keeping in mind in classifying lisp-like languages would be based on how much code they share. With CL and Clojure, it is pretty much zero. This can lead to a practical understanding of differences and strengths.

I have a friend who is a long-time lisp guy who recently has made a living programming Clojure.

It is now listed as a Lisp at r/lisp, courtesy of your truly ;)

Regarding the Common Lisp writings, I rather liked the third edition of LISP by Patrick Henry Winston and Berthold K.P. Horn (1989).

I'm quite excited by the prospect of jank so us Clojurists can get in on some of the ML fun with the torch C++ bindings.

Is system (OS kernel, microcontroller, etc) etc these days in Lisp is still a thing?

My impression is if you want a minimalist lang to do that, that would be Forth.

Would love to see Lisp is used for anything low level. I've read about Lisp machine, but that doesn't like average computer users would use.

Can't say that I disagree, but there is Sector Lisp https://justine.lol/sectorlisp/ which I think is very remarkable.

Ah why do I forget about that? Thanks for the reminder.

I also found movitz:

- https://github.com/dym/movitz

- https://github.com/karlosz/movitz

- https://github.com/PuercoPop/Movitz

But couldn't build it. My Lisp-Fu isn't good enough.

Reply on news.ycombinator.com