I was under the impression that Naughty Dog used Lisp primarily for Jak
(the postmortem linked to is for Jak and Daxter)) and not for Crash
Bandicoot.  I know that Sucker Punch also uses a Lisp for their Sly
Cooper games, though from talking to them it appears to be a stripped
down Lisp without most of the interactive development features that make
Lisp so appealing.

:-)

You write:

"(loop (progn
         (update-ai)
         (update-physics)
         (render-world)))"

But why not just:

(loop
 (update-ai)
 (update-physics)
 (render-world))

?

Further down you write "most of the advantages Lisp has in processing
numbers (bignums, inherent complex data types, etc) aren't used in
games, anyway".  I agree with this, but I do wonder whether such
features don't just remain unused only because they aren't readily
available.  Compare this with Paul Graham not missing recursion in
Basic. [1]

Overall I like your essay, but with all due respect, I seriously doubt
its ability to stop any flame wars. ;)

Kind regards,

Dirk Gerrits

Your abstract doesn't mention your thesis, instead it discusses why you
felt compelled to write the essay.

We don't actually get your thesis until the conclusion: "Hopefully I've
shown that [Lisp] is just as good as C++, and that C++ is just as good
as Lisp [for games programming]."

Unfortunately, the reader isn't shown that the thesis is likely. You
mention a number of factors for and against each language, but without
data on the relative weightings of each, it is difficult to conclude
more than "there are advantages and disadvantages to each." More
concrete numbers, e.g. "As code and assets typically occupy 10% and 90%
of the storage medium respectively, a 25% increase in code size reduces
asset storage available by 2.8%" would help the reader weigh the
probability of your argument being correct.

That's the end of my comments on the form of the essay. As to the
argument itself, I think I must disagree.

It seems to me highly unlikely that two languages with such marked
differences in underlying philosophy and such different typical
developer use patterns would turn out to be so evenly matched in one
particular domain, viz the construction of state of the art video games.

Lisp will never win this argument.  When I mentioned ND and
Crash may years ago in this newsgroup, it was met with a
comment like "but that's not _really_ using Lisp for games;
show me a game that actually _runs_ in Lisp, and I'll be
convinced".  So when Andy Gavin did just that (unbeknownst to me,
until he asked us for help in optimizing the compiler) - we now
get "yes, but there are not enough of them to _really_  be
considered as using Lisp in games".  And so on, and so on...

Maybe GQ should be talking to them instead of us. :)

Jeff M.

Jeff M.

Jeff M.

It is now two years later to the day, and all my ambitions of working
60-80 hour weeks in a cubicle of some game development house hacking C++
have melted away.  Does any one sell "Lisp shattered my life-long
dreams" T-shirts? ;)

Kind regards,

Way back when Lisp was young (and was still called LISP) people were
using it for things that were absolutely inconceivable in other
languages of the time.  All that despite these languages all being
Turing complete and thus "equivalent in power".

Nowadays, the other language camps have a huge advantage in numbers, and
have stolen some bits and pieces from Lisp here and there, allowing them
to also pull off incredible feats.  

I am very interested to see whether or not, and to what extent, an
advantage in language outweighs an advantage in numbers.  Can Lispers
create really good games that would not be reasonable to create in
C/C++/Java/C#?  I don't know, but I'd rather try then torture myself
with C++ any longer.

Kind regards,

We've had a lot of experience with customers moving away from CL;
we do our best to make sure that it wasn't something we did or did
not do, but then we just say goodbye without stressing over it,
they need to do what they need to do.  We had a sales manager
many years ago that would say "OK, goodbye; I'll see you in
a year or two" and many times, sure enough, we'd see them back
again after a failled attempt to go back to C++...

Sometimes they do not actually _leave_ CL, but just run some
parallel development on another language, "just in case".

I understand your request for numbers, but, to be honest, I don't
really have the time to try and pump out a mini-game for each, but a
co-worker and I have thought about doing it for a "show and tell"
argument. The difficulty in doing this is that (as you say) patterns
used for each -- even if they were the same end product -- would be
very different. Enough so, that perhaps a benchmark would be useless.
Then again, this may be exactly the kind of benchmark that is needed.

What I find most difficult to discuss in the essay are the differences
in programming styles, and how that would affect the final product.
Lisp programmers would (hopefully) take advantage of many things
available to him/her that a C++ programmer wouldn't. I wasn't
attempting to claim a draw between the two languages anywhere except
game-side, in terms of graphical performance. There is so much more to
game development other than this (tools, scripting, level design, the
list goes on), and that was a point I tried to stress. These are the
areas where one language will outperform another (but not necessarily
in all areas). Perhaps that didn't get stressed enough.
Thanks for taking the time to read and reply.

"Lisp, on the other hand, doesn't need an interpreter. It can just run
Lisp code that is stored on the disk (and even compile it at load time
for more speed)."

Well, Lisp can also compile code into binary files too. One thing you
should also mention is that the structure of most Lisp runtimes
permits them to dump the entire application memory image to disk very
quickly. Depending on how large the image is and what portion of it is
static, this may be a good way to do save games (at least on systems
with hard-drives).

I think Lisp's dynamism and malleability is the one thing that not
even Greenspun's Tenth can provide an ersatz for. Shiro Kawai wrote an
excellent pair of articles on how Lisp and Allegrostore were used for
production tracking at Square films that made an impression on me
(change-class totally kicks ass), and that I think are relevant to the
more general problem of game production pipelines as well:
http://www.lava.net/~shiro/Private/essay/gdc2002.html
http://www.shiro.dreamhost.com/scheme/docs/jlugm2000.html

Then of course you shouldn't knock Lisp for numerical computations
either until you've read about the Supercomputer Toolkit project at
MIT and HP:
ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-1329.pdf

I think Lisp numerical mini-languages such as the one used in the
Toolkit can be a very big win over C++ in terms of performance,
especially on vectored processors. It almost pains me to think of all
the effort wasted on trying to squeeze out parallelism from for loops
by vectorizing C compilers.