I've abandoned Pomo (see below) in favor of Lisp. See why on the other side:

Basically, Pomo would've been a crippled Lisp. I didn't even begin the implementation; a few hours thought about implementing macros in Python, combined with some exploration of the existing metaprogramming facilities, led me to the conclusion that macros in Python would be more trouble than they're worth -- both because the implementation would be complicated, and because Python's existing metaprogramming functionality covers a lot of the territory anyway.

Python in Lisp's clothing would have great platform support and libraries, but on the other hand there are Lisps with great platform support and libraries. (At the moment I'm looking mostly at Schemes, specifically PLT and Chez Scheme.) Sure, Python is very consistent because it is a sole-source product; but if I choose a Lisp and stick with it, I am in essentially the same position as I am when using Python. So the apparent advantages of Python over Lisp turn out to be illusory, at least for my purposes. It only remains to convince myself that there are not any significant *disadvantages* to using Lisp.

I've seen a lot of arguments against Lisp, the most frequent being:

1. It's ugly.
2. No one uses it.
3. If you can redefine the language, as Lisp allows, you'll end up with a language that no one else can understand.

Of these, only 3 is at all substantive.

1. Ugliness: it's in the eye of the beholder, and I strongly prefer regular syntax in a programming language. I find Lisp code and Python code to be approximately equal in readability, and I find both to be vastly more pleasing to the eye than Java or C++.

2. Popularity: I don't particularly care whether a language I use is popular. The only reason to care about this issue is that other users provide a useful support network, at least ideally. Both Lisp and Scheme have active communities -- but not *too* active. The Lisp and Scheme newsgroups are populated predominantly by people who have some clue what they're doing, and if you have a question, it's likely to be answered by someone who really knows what they're talking about. When I first started using Python, in 1999 or so, its community was similar in nature, and people intimately involved in the language's implementation were regular contributors. But Python has reached the level of popularity where the vast majority of posts to comp.lang.python are newbie questions, and where many, *many* of the answers they receive are either suboptimal, or just plain wrong.

3. The nature of a "programmable programming language": this is the one that worried me a bit. But I realized that the foundation of this sort of objection -- "you'll end up building something that no one understands" -- has the situation exactly backwards!

"How", goes the argument, "are we to expect to be able to maintain your code, if you have extended the language in all sorts of bizarre ways? How are we supposed to know what the hell is going on?" The implicit argument is that Lisp's metaprogramming capabilities -- specifically, macros -- must be so complicated to understand that normal programmers should never have to wade into that swamp.

I assert, on the other hand, that the major source of confusing source code is *lack of expressiveness* in the implementation language. I further assert that this is exactly what Lisp macros cure, and that they are, contrary to popular opinion, actually quite simple both in concept and in practice. [More later.]