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?
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.
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.
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.
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].
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.
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).
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!
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.
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.
30 comments
[ 2.2 ms ] story [ 82.2 ms ] threadI'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 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.
> Fennel because Lua does have complete packages
Do you end up using a lot of lua packages in fennel ?
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
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.
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.
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
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.
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.
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
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!
OK, real Lispers, don't kill me!!!
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.
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.
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
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.
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.
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.