[bawr]

I should know better, but I'll bite as well - were those Lisp programs, by chance, written as quick prototypes without any optimizations or by people who didn't really grok Lisp? Saying that "algorithms were the same" isn't terribly informative - after all, using the worn out factorial example, both the tail-optimized and stack-using versions of it would still use the same algorithm.

[zandorg]

First off, 'by people who...' is me - I wrote this Lisp program. It was OCR software to turn images of text into ASCII.

I had read On Lisp and learned about macros, which I used heavily, and created a language to describe the elements of each character in macros - for instance, 'I' is typically a single vertical line.

So yes, I used some unique aspects of Lisp, and the port to C was done by basically transforming the untyped structures in the Lisp code, into C structs/datatypes. It wasn't a Greenspan law - it was just more declarations, and hand compiling I guess, which worked well in my C compiler, and better than the Lisp compilers I tried.

I hate replying so many times in a single thread, but you did ask! :-)

[Postscript] I used a good profiler which could tell me slow lines and functions. My speedups were entirely due to finding clever ways of optimising, thanks to the profiler. So that's the secret weapon...

[shiro]

Yes. Profiler is the secret weapon.

When I write optimized Lisp code, I heavily rely on the profiler of Allegro Common Lisp. Sometimes per-line or per-function isn't not fine enough and I go down to per-machine-instruction level profiling for the innermost loop, which is quite handy.

If you didn't use good profiler in your Lisp environment, well, you can't really compare performance of Lisp and C... (Unfortunately, there seems no such compiler that is clever enough to take quick-prototype Lisp code and emits fully-optimized code.)

[bawr]

I see. This is still anecdotal evidence, but now it's better than most, for what it's worth. While I think that a dedicated Lisp hacker could have done far better, without seeing the code in question this is all a moot point on both sides, really. Edit: Especially since it's not big news than non-optimized Lisp is slower than heavily-optimized C. ;)