but with blogs, it’s like reading tabloids. It’s fun pastime. I saw this title, felt must read it! Then, unawares, it gave me a nice intro to newLISP.

very nice article. Thanks a lot.

about the including of 「defvar」, 「=」, 「eq」, 「eql」 in the syntax, am not sure i agree with the justification. By your justification, it should also include 「;」, 「#| |#」, 「[]」, 「1+」, 「<」 and i think a lot others.

however, i think it's nice the way you had it, because it does give a sense of the comparitive complexity of Common Lisp vs newLISP's syntax.

i find it hard to swallow for the justification of dynamic scope though… even suppose due to its faster speed, how many microseconds one might save today?

Also? Your site design is yummy.

http://kazimirmajorinc.blogspot.com/2008/12/speed-of-newlisp-eval-test-v100.html

You’ll see that PLT = Mz is very similar to Lispworks, Clozure and Allegro compilers. I.e. much faster than Newlisp if code doesn’t contain eval, and slower if it does. [Newlisp eval is fast because NL is closer to pure interpreter. Compiling is too expensive if some code (without loops) will be evaluated only once.]

One can test lexical vs dynamic scope in CL, because CL allows both.

I’ve spent one year using PLT. Excellent IDE, lot of tools, very helpful community.

Greg, nice article. 3.5 hours is impressive.

anyway, why argue when we have data:

17:03 ~/bench % cat ack.lisp
#!/usr/bin/newlisp -s1000000
;;
;; Ackermann’s Function
;;
;; By Brent Fulgham
(define (ack m n)
(cond ((= m 0) (+ n 1))
((= n 0) (ack (- m 1) 1))
(true (ack (- m 1) (ack m (- n 1))))))

(define (main)
(set ‘N (integer (last (main-args))))
(println
(format “Ack(3,%d): %d” N (ack 3 N))))

(main)
(exit)

17:04 ~/bench % cat ack.scm

#lang scheme
(define (A m n)
(cond
((= m 0) (+ n 1))
((= n 0) (A (- m 1) 1))
(else (A (- m 1) (A m (- n 1))))))

(let ((n (string->number (vector-ref (current-command-line-arguments)
0))))
(A 3 n))

17:04 ~/bench % time mzscheme ack.scm 9
4093
mzscheme ack.scm 9 0.29s user 0.05s system 93% cpu 0.368 total
17:04 ~/bench % time ./ack.lisp 9
Ack(3,9): 4093
./ack.lisp 9 6.07s user 0.04s system 98% cpu 6.202 total

mzscheme is a Scheme interpreter, so uses lexical scoping, and at least on this test is 20 times faster on a function-call heavy benchmark, which should test efficiency of variable lookup. There may be semantic reasons to use dynamic scoping, but performance is just a non-starter.

Until you produce something that discusses how lexical scope is faster in an interpreted language, I think I’ll trust in the benchmarks of newLISP’s eval and Lutz Mueller’s expertise. Everything that I’ve read so far seems to indicate that indeed, dynamic scope is the better choice to use for a Lisp geared towards scripting.

http://www.paulgraham.com/thist.html goes into a bit of the history as to why dynamic scoping was thought to be more efficient.

@Tim, I’m not sure how to answer your question as that is sortof what this entire post was about: newLISP is better suited than Clojure is for scripting, but that does not mean that it is better than Clojure in general. Use both for the tasks they excel at. I’ve never been at a loss for some library (especially since newLISP gives you easy access to every C library), and its community is very helpful.

@Mark, can you provide something to backup your claim? The fact remains, something is causing newLISP’s eval to beat all the others, and I wouldn’t be surprised if dynamic scope plays a role in that.

@CyberED, I did mention it, if indirectly. See the link in the “other goodies” for “Simple and powerful distributed computing.”