Janet: newLISP's spiritual successor

[itistoday]

Hey folks, as you might've noticed, it appears newLISP is, unfortunately, no longer with us.

The main website has been down for many months now. I haven't heard anything from Lutz. I'm not sure if he's with us either.

What Lutz created will always have a special place in my heart. I've loved this language so much, and I've used it for so many personal projects.

It's such a simple, beautiful language, that it saddens me to see its story come to what appears to be an end.

However, all is not lost.

Lately, I've been exploring Janet.

This lisp-like language is also incredibly well designed. Like newLISP, it too is batteries-included in a tiny single-binary.

However, the similarities end there. Janet is a significantly more sophisticated language. In many ways it is better designed than newLISP and much more modern. It has real garbage collection, lexical closures, special syntax for non-list data structures, a sophisticated fibers-based runtime with support for real threads, a real module system, and more!

Yes, it is a bit more complicated than newLISP, and newLISP's simplicity is a significant part of its appeal. However, there really are no better options AFAICT, and we small-language communities need to stick together!

I encourage newLISPers to have a look at Janet, and consider migrating their code over using LLMs as helpful assistants. That's what I've been doing and it excites me once again to learn a new language.

newLISP, we love you, we're sad to see you go.

Thank you for all of your work, Lutz!

You've forever set an example of the power of simplicity, and the power of Lisp.

EDIT: some docs for learning Janet:

• https://janet.guide/
• https://janet-lang.org/docs/index.html

[boris]

Thanks for that, I had kind of given up on newlisp.

Good to see something being actively maintained and not calling itself "xxxlisp" to inflame the haters....

Janet looks like it could be an interesting replacement for newlisp.

[hapco]

Still, we have the source code, and people who appreciate newlisp, so it's not really gone because the site is. I briefly tried Janet, and may again, but at the time it just didn't do it for me. Too many dots, square brackets, and random punctuation. And what's wrong with lists? Not a list to be found...

[boris]

Having tried it for a while I came to the same conclusion as you.
The thing about newlisp is that it hits that sweet spot of being a lisp for the rest of us.

[itistoday]

One of the things that I really appreciate about newLISP is the design of the function names themselves. The API just makes sense, English-wise, more so than any other Lisp. I think it has to do with Lutz's background in psychology.

That said, I personally like Janet's use of square brackets, braces, etc. for distinguishing different data structures. It helps break up what otherwise would be a very monotonous looking syntax. I definitely am not a fan of "lots of syntax", but having nothing but parenthesis everywhere can make it hard to notice the datastructures vs functions vs whatever else. I think Janet picked a fairly good sweet spot.

And the lack of lists is interesting, true. However, for all intents an purposes arrays are sufficient and performance-wise faster. Same with real hashtables, which newLISP doesn't have.

[oofoe]

Hi! I'm glad this forum is being revived, and I hope that NewLisp finds alternate hosting and maintainers.

With respect to Janet -- for what it's worth, I did successfully make the jump from NewLisp. So, if you'll indulge, a few notes about why and what I found.

I got re-interested in Lisp about the time Paul Graham started writing about his Viaweb experience (e-commerce server, written in Common Lisp). I couldn't make Common Lisp click for me though... Too many exceptions, nutcase documentation (CLHS, need I say more?), every kind of data structure was handled a different way, etc. After a long walk through the desert, I stumbled on NewLisp. It was a long drink of cool water! Many times, things worked exactly the way I expected them to. Often I could just guess at what the appropriate function would be and it was. Combine that with excellent documentation and quick interpreter and I was off to the races. I did a number of things with it, both for work and for fun (current link to my weight+balance calculator: https://hg.sr.ht/~oofoe/wb, and an implementation of Jef Raskin's FLOW language: https://hg.sr.ht/~oofoe/flow)

However, I started finding the need to distribute compiled executables and with the Oracle legal stuff, I wasn't too keen on continuing to use Java for the GUI parts. I dabbled for a bit in Dr. Racket, it at least seemed simpler than Common Lisp, and had the GUI/graphics built in. I tried other things, including ill-advised flirtations with Python compilers. And then... One day I stumbled across Janet.

The initial experience was positive; it had some of the most important features of NewLisp like implicit data access. It does do some strange things, like "#" for comments, but once you see what they're doing with the semicolon for the splice operator, you forgive it. However, for me, the three absolute killer features of Janet are PEGs, multitasking and compiling.

Parsing Expression Grammars (PEG) are something I got used to in REBOL and will never voluntarily give up. They turn parsing from mysterious incantations at midnight (yacc or PCRE) into clear, documented rules that can stand the light of day. I even wrote an PEG that transpiles Janet formatted source code into JavaScript. Absolutely indispensable for correct, reliable parsing. Janet's implementation is clean and flexible.

With multiple network connections, GUIs and long running processes, multitasking of some sort is a must. Janet provides several flavours. The simplest is a "fiber", which is a kind of in-process green thread. Then, threads (of course), and finally actual multiple process synchronization. So far, I've only needed fibers, but it's been more than enough to handle multiple data streams for simulating and controlling scientific instruments.

And compiling. If you're on Linux (or Mac, I think), it works like falling off a log. If you're on Windows it's annoying (thanks Micro$oft), but still doable. It uses a two stage compilation that allows you to control what gets compiled in your source (like C macros, but much nicer). Compared to Racket (or even other scripting language compilers, e.g. Nuitka?), it produces a tiny result (1.7MB for a commercial product where I compiled in all the resources and even the user manual to a single executable).

There are other things that I've discovered, but those are the big three for me. I think if any of that whets your appetite, you should definitely give Janet a look-see.

However! I would never have gotten to Janet without NewLisp. Its simplicity, complete documentation and friendliness to an uninitiated seeker are what brought me into the Lisp fold to stay. I hope it will always remain available for others to discover.

P.S. A really nice book-length tutorial for Janet: https://janet.guide/

[itistoday]

That's a lovely story thanks for sharing oofoe!