
NewLisp - qwertyuiop924
http://www.newlisp.org/
======
kazinator
From a Lisp POV, the only thing wrong with NewLisp is the name.

It flouts McCarthy's wish that no language be called just Lisp. Well, okay,
it's not literally called Lisp; it has the "New" in front. On the surface, it
seems to be sticking to the letter of the wish. Does it conform to the
_spirit_ , though? Is a common English adjective enough? Is "New" a sufficient
qualifier?

The mere prefixing of "New" looks like it's claiming to be a new version of
something that is just Lisp, unqualified. A "New Lisp" is plausibly something
that was "Lisp" before, and was then enhanced to create a new version derived
from "Lisp". Lots of projects get rewritten, or otherwise revampd and called
"New Whatever". But NewLisp certainly has no such lineage.

One historic dialect was called NIL which stood for "New Implementation of
Lisp". But it went by the name NIL, with the acronym just being an explanation
for that name (as far as I can tell).

Change the arrogant name, and you will not hear another criticism from Lisp
programmers. Make it LutzLisp or whatever. It doesn't matter what it is if it
is called LutzLisp; it's not that type of thing that's claiming to be a new,
improved version of Lisp.

Breaking, or skirting a sacrosanct rule is now how you play along in the broad
Lisp family.

~~~
kbutler
Well, okay, it's not literally called Lisp; it has the "Common" in front. On
the surface, it seems to be sticking to the letter of the wish. Does it
conform to the spirit, though? Is a common English adjective enough? Is
"Common" a sufficient qualifier?

Yes. Yes it is.

("new" is more common than "common", but not incredibly so:
[https://books.google.com/ngrams/graph?content=common%2Cnew&y...](https://books.google.com/ngrams/graph?content=common%2Cnew&year_start=1800&year_end=2000&corpus=15&smoothing=3&share=&direct_url=t1%3B%2Ccommon%3B%2Cc0%3B.t1%3B%2Cnew%3B%2Cc0))

~~~
kazinator
I've never seen a rewrite or next generation of any program or function called
"common". But new is common: ntalkd -- new talkd; nvi -- new vi; nftw -- new
version of the ftw POSIX function (file tree walk); ncurses -- new curses;
ncal -- new cal program; nawk -- new awk, ...

Basically Lutz calling his project NewLisp is a form of trolling.

------
jurip
Paul Graham on newLISP, 12 years ago: [http://lambda-the-
ultimate.org/node/257#comment-1889](http://lambda-the-
ultimate.org/node/257#comment-1889)

With hindsight, turns out that none of newLISP, Goo or Arc set the world on
fire.

~~~
keyle
I genuinely would love to see apps written in lisp. It's all Javascript
nowadays, with about 5-8 frameworks dominating this sad landscape.

Imagine how refreshing it'd be to see Lisp driving webapps, front and back-
end.

Not even saying that should be the one size fits all, I'm saying, anything
else...

~~~
village-idiot
I've personally worked on a Lisp backend, it was probably worse than most of
the JS sites you lament about.

Of course, it's probably not Lisp's fault that that project was a mess, but
the ultimate level of flexibility that CL provided let bad ideas worm their
way down to the compilation level, making it really hard to work your way back
out.

Honestly, you've never felt tech debt pain like unwinding reader macros.

~~~
qwertyuiop924
Which is why the rule of thumb with any sort of macro is: use minimally and
tastfully, and do not write one until there is a proven need.

------
taylodl
If you want to use a Lisp for scripting, embedding it into an application and
having great interoperability with C then you also have Guile Scheme
([https://www.gnu.org/software/guile/](https://www.gnu.org/software/guile/))
as an option. I don't have comparative benchmarks but I've never had any
issues with its performance.

------
eddieh
I wish every programming language homepage had a small code example. I know
this is a LISP-like language and I can expect it to look like any other LISP.
But I still appreciate getting a glimpse of the language without having to
hunt through documentation for a tutorial.

A small code example can tell you way more than a language description. An
example is the PL equivalent of the picture is worth a thousand words adage.

Additionally, it is not a given that a LISP will use S-expressions. It could
use M-expressions, or even G-expressions (form a LISP like language I helped
develop that nobody has ever heard of).

Go, Rust, Ruby, Python all have examples on their homepage. Oddly, Swift does
not.

~~~
clamberson
Did you work on Ginger? I'd love to see what that looked like :)

~~~
eddieh
Yup, it was Ginger. The syntax was like a mix of Python and Scheme.

    
    
       define fib (n)
         if (= n 0) 0
         elsif: (= n 1) 1
         else: (+ (fib (- n 1)) (fib (- n 2)))
        
       println (fib 20)

------
sriku
The slew of differences dont seem very "designed", meaning some corner of the
world won't end if life wasn't that way. They seem more like a consequence of
"my pet lisp interpreter as I began implementing it". I know that smell 'cos
I've been through it myself and subsequently redesigned and reimplemented
things.

~~~
zeveb
Exactly. After playing with different Lisp dialects for well over a decade
I've come to the conclusion that Common Lisp's decisions are, generally,
reasonably well-thought-out and not often terrible. I've not found a Lisp
better-suited for the name.

I'd love to see a new version of Common Lisp fixing some of the decisions
which _were_ terrible, but I don't see that happening.

~~~
JohnStrange
Why not, by the way? I've always wondered why the CL community hasn't come up
with a new, improved standard for such a long time. Other old languages like
Fortran and Ada are continuously updated. Why not CommonLisp?

~~~
whyever
As a lisp noob, I found many of common lisp's function names to be extremely
arcane.

------
shakna
Including Bayes in the standard library is cool, but newLISP must be one of
the slowest LISP interpreters out there.

Its certainly useable - usually on par with Python... But picolisp, Gambit,
SBCL are more on par with D or Rebol.

So when newLISP claims to be great for embedding, I feel cautious.

~~~
tluyben2
For me Picolisp is a very nice Lisp implementation; easy to understand,
enthused founder who has been at it since the 80s. Which is amazing in it's
own right. And a solid community. Won't go away any time soon. Gambit is the
same age, but I find the source code far harder to read. That's a matter of
taste I guess.

~~~
shakna
F-Expressions are awesome fun.

Gambit internals does kind of look like black magic half the time, but the
author implemented environments because I asked [0], which is very cool.

The more experimental lisps, the better we can make the future. I love how the
lispish community views PLT, and always tries out someone's new idea. (Bayes
integration in newLISP is cool. LFE is also cool.)

[0]
[https://github.com/gambit/gambit/issues/204](https://github.com/gambit/gambit/issues/204)

~~~
eggy
Ditto on Fexprs, and PicoLisp!

Xtlang in Extempore is a whole lot of fun [1].

Echolisp has amazing built-ins and runs in the browser [2].

Gambit is great to get C code out of.

I like LFE, but I have to learn more OTP/BEAM to really use it.

Wasp Lisp is a lot of fun for me, and for playing with distributed programs.

[1] [http://extempore.moso.com.au/](http://extempore.moso.com.au/)

[2] [http://www.echolalie.org/echolisp/](http://www.echolalie.org/echolisp/)

~~~
shakna
Hadn't heard of Wasp [0] before. Looking forward to trying it out!

[0] [https://github.com/swdunlop/WaspVM](https://github.com/swdunlop/WaspVM)

------
life_is_short
In NewLisp's memory management model, I didn't understand if one-reference-
only limits what the programmer can do.
[http://www.newlisp.org/MemoryManagement.html](http://www.newlisp.org/MemoryManagement.html)

Does it mean it's impossible for more than one variable to refer to a variable
already referenced? If yes, is this a problem in practice? If no, is this the
way of the future?

~~~
david-given
A brief skim of the document suggests:

\- single-reference-only for expressions (so, static object lifetime);
deletion is delayed until a stack slot gets reused, allowing return values

\- assignment to variables or values passed into functions are done by copy

\- EXCEPT certain types are passed into functions by reference as an
optimisation

So, basically, values are owned by either the stack or a variable. Assignment
to a stack cell destroys what was there before. To keep a stacked value, it
needs to be copied into a variable.

That all seems pretty intelligent, and I might steal the idea; except that I
don't see any mention of how cyclic data structures or mutable data structures
are implemented. Does anyone know how these are handled?

~~~
astrobe_
For mutable structures you use the "context" concept, which is also used to
build a form of OOP.

For cyclic data structures, I'm not sure. I think one can pass a function, a
list or a context to a function that expects a list. This it might do the
trick.

~~~
david-given
From Wikipedia:

> Sharing of sub-objects among objects, cyclic structures, or multiple
> variables pointing to the same object are not supported in newLISP.

Dang.

------
bitwize
Ah, Newlisp -- the Isagenix of programming languages. Sooner or later, every
general-programming community will have to deal with a deployment of
Newlispoids eager to convince you how great the language is and that _finally_
, programming is fun again. As if programmers hadn't enjoyed themselves much
more using "old" Lisps that embraced advanced features like lexical scoping
and hygienic macros.

------
qwertyuiop924
It's interesting. I'm not a fan of dynamic scoping, but it's okay. ORO looks
no worse than Rust's borrowing, so that's not a worry, aside from cyclical
datastructures.

------
the_duke
> newLISP is LISP reborn as a scripting language: pragmatic and casual, simple
> to learn without requiring you to know advanced computer science concepts.

How is this different from LISP?

~~~
throwaway7645
If you play with the examples it becomes more apparent, but you can use it
alongside gnu-utils like grep with pipes on the command line easier than a lot
of traditional lisps that have a slower startup (ex: Clojure). Kind of like
Perl.

~~~
justinhj
There are ways around the slow startup of Clojure such as

[http://leiningen.org/grench.html](http://leiningen.org/grench.html)

~~~
klibertp
From that website:

> Grenchman lets you run Clojure code quickly. By connecting to a running
> nREPL server you _avoid JVM startup time_ , streamlining your development
> workflow.

It's irritating to see the same claim repeated again and again. It's _not_ JVM
startup time, it's _Clojure startup time_. Whether it's because JVM is ill-
suited for the kind of code Clojure uses or for other reasons I don't know,
but JVM itself starts up 100x faster than Clojure on JVM.

Moreover, a daemon running in the background is a just a workaround. To use it
you need to write your app in a certain way so that reloading works, and you
still need to start the daemon at some point.

I've been working with Clojure for a few months full-time and it was kind of
ok, however, for command line utilities, almost anything is better than
Clojure. Python, JS with Node, Racket, Ruby, GNU Smalltalk, even Io - all
these start up much faster than Clojure. ClojureScript with Node would be an
option, but then ClojureScript (and Node). In short: if you need to write a
cmd line utility program you should avoid Clojure as much as possible.

~~~
xavi
I don't agree. Planck
([https://github.com/mfikes/planck](https://github.com/mfikes/planck)) is
quick and great for command line utilities written in ClojureScript. It runs
on macOS' built-in JavaScriptCore. There's also an alpha version that runs on
Ubuntu.

Please check the Planck User Guide's section on Scripts [http://planck-
repl.org/scripts.html](http://planck-repl.org/scripts.html)

------
quickben
It would be interesting to see some speed benchmarks.

~~~
criddell
Speed of development or speed of execution? :)

I don't think anybody anywhere has ever chosen a Lisp language because it's
fast.

~~~
cestith
Actually I know of a couple projects that have played with using CL as an
intermediate language because of the performance they got compiling with SBCL.

