My game is using Corman CL 3.0 for all the level layout, game object behaviors, and high level control of the graphical effects. I was interested in starting a discussion with any other developers who have discovered that modern hardware isn't finding a 40mb runtime overhead to be anything bad. It almost seems that the widespread adoption of .net for games in the indy community should make lisp also seem to be a more likely choice. Both have a GC and can generate code at runtime. Both can hot reload code in a running application. I've been delighted with the results in my game for rapid prototyping. About the only pain is having to constantly update my FFI interface for lisp to access more features of the C++ based libraries that I'm using. (Gamebryo, FMOD, FantastiqUI, Chipmunk)

Lisp isn't used for three reasons:

First, as far as I'm aware, there are no good IDEs that help make sense of the parenthesis. I'd love to use Lisp if I could find an IDE that made it as easy as other languages, but the huge level of nesting that necessarily occurs makes reading large code very difficult. 100 lines of Lisp code could be one expression or 100, and there isn't any easy way to tell which it is without dissecting the whole thing. Indentation helps, but not enough - it makes small sections of code easily readable, but it can only help so much.

Second, common lisp is a behemoth, and is way, way larger than it needs to be. Not only is it overly large, but it omits a lot of things considered standard these days (such as just about everything the .Net framework does). It's great that every modern implementation provides custom solutions, but that just fractures things worse. You could always import functions from elsewhere, but they won't ever mesh properly with the rest of the code because Windows API (for example) doesn't follow the same philosophy as Lisp.

Third, Lisp is difficult. Well, maybe not difficult, but easy to screw up. Being able to mix object-oriented, procedural, and functional code might be good for flexibility, but it's not so great on maintainability. Throw in that the code can rewrite itself (at your direction, but still...) and it's a scary thing for large projects.

Your objections are silly. Perl has a difficult syntax, and it is highly used. .NET is a large runtime overhead, and it is used. C++ allows you to shoot yourself in the foot with a somewhat complex underlying system for virtual methods and vtables and this pointers that can change based on whether the code is in the base class's constructor or parent class's constructor, and people get work done with it.

Quote:Original post by pTymN
[...]Perl has a difficult syntax, and it is highly used.[...]

That was not one of my objections. Perl is not difficult to visually parse, it is difficult to understand because there are many details. Lisp is very difficult to visually parse, which is something a good IDE could help considerably with. Unfortunately, there are no such IDEs that I am aware of.

Quote:[...].NET is a large runtime overhead[...]

That was not one of my objections. .Net is large, but every feature in it serves a very specific purpose applicable to modern paradigms. Lisp is large, and half of it is no longer relevant, and the other half is pretty much only computational (meaning it has very limited functionality for communicating with outside world).

Quote:[...]C++ allows you to shoot yourself in the foot [...], and people get work done with it.

That was not one of my objections, but of the three, it was closest. Plenty of people get work done in C++, but plenty of people also write horrible overcomplicated code that is impossible to read and even more difficult to maintain. All the Lisp code I've found that wasn't explicitly a tutorial was along the same lines, and even that horrible code doesn't even abuse Lisp to it's fullest. Mix in all 3 paradigms, code modifying itself, and DSLs that make a syntax completely change meaning, and you've got something difficult NOT to make horrible code with.
It's one thing to make it work, and quite another to make maintainable code that is pleasant to work on months later. I don't think it is impossible to write decent code in C++ or Lisp, but I haven't ever seen any in a large application.

Quote:Original post by Rebooted

Quote:Original post by Extrarius
First, as far as I'm aware, there are no good IDEs that help make sense of the parenthesis.

Not even SLIME or Lispworks?[...]

It's been a long time since I've used Lisp, but using google to locate some screenshots of each, I don't see how either is any better than a generic 'programming editor' with respect to making the onslaught of parenthesis more visually distinguishable from eachother. 5 black curves in a row doesn't exactly tell you much about what is going on. At the simplest, I think something like coloring the text's background based on the nesting depth would help tremendously with making code readable. I should be able to look at a block and tell where one expression/statement starts and the next one ends, as it is trivial to do in most language, but in Lisp, since everything is uniform in appearance, it all blends together.

Quote:[...]

Quote:Being able to mix object-oriented, procedural, and functional code might be good for flexibility, but it's not so great on maintainability.

Why? I would have thought expressive languages lead to reduced code size and easier-to-understand programs that attack the problem more directly.[...]

Because programmers get messy - few people have enough discipline to stick to ideals forever, and as soon as you start indiscrimintely mixing the many possibilities, it'll be hell to know what is going on. Big code is difficult enough to understand without having to also figure out what type of code it is.

Quote:[...]The problem with CL in my opinion is a lack of abstraction.[...]

Even basic CL has a package system built in, and it uses : to dig down into them, which makes it fairly clear what is from where. Also, have you ever heard of CLOS or MOP?