While it’s true that Python requires more explicit code, and favors readability (which is definitively not a “ridiculous” concern, n’en déplaise à Michael Barry), it doesn’t mean the language doesn’t have a great support for metaprogramming (and one that doesn’t rely on eval()).

Have a look at the source of Ian Bicking’s FormEncode package – more specifically on the ‘declarative’ module – and you’ll find out that Python can get really magical.

About template rendering in Pylons vs Rails: it should be quite easy to make Pylons behave the Rails way using the __after__ hook in the project’s base controller class.

My 2 cents…

Its simple. The more magical the language the more you can get done.
Syntax and readability are overvalued. Explicit is not “always” better than implicit.
Less is more….etc.

People will argue that with too much abstraction you can create an unreadable mess. Ya, you always have the option of being stupid.
(or just inexperienced)
The difference is that if you “have” the power available and know how to create meaningful indirection you can save yourself an amazing amount of time.

Other arguments are centered around
readability of code. This is ridiculous. After a few years of real programming experience you realize the best code only has only been touched by a “single” mind.
The more cooks in the kitchen the more of a mess the code becomes.
Putting too many controlled processes in place to control the mess slows development down too much.

Every developer in the small group knows the system they are developing inside and out. Therefore they know about their wacky meta code solutions.
Smaller teams using more magic (meaningful indirection) can dramatically outproduce a larger team using less magic. They have too. (Its economically advantageous)

In the past (say 20-30 years ago) the more magical languages were not as popular because of efficiency concerns. The popularity of more magic has increased over time because its practically possible.
This trend is going to continue. (Its economically inevitable) If you have the power to do more with less….then you should do more with less or go extinct.

I think the majority of new programmers are realizing this. This is great. This is going to push us to a new language that has more features from the functional programming paradigm. Functional programming is not a silver bullet but anytime you can avoid state in code the happier life is. Managing state can be like trying to solve a suduko puzzle. Too many dependencies. While some may think that is fun, its incredible waste of time that can be avoided. Save your brain power for meaningful problems.

I’d use scheme more today if it
had better online community support and libraries.

Then why do I like Python and Ruby so much more than C or Java? Why, indeed, doesn’t everyone just write bare machine code?”

Because writing machine code is a pain in the arse. Give me a ruby like assembly language that allows me magical control over my hardware, and I’ll send you my available ram when my system is idling.

When learning Ruby (a few months ago), this community acceptance of weird syntax blew me away. Their library of idioms is just part of the language, and once you pick them up, you can immediately recognize them. Almost like having language specific features for a bunch of common programming scenarios since they are instantly recognizable and easy to write (setting default values, checking for nil case, etc).

In some other languages, its not a good idea to be too clever. In some recent C# code I wrote (inspired by ruby), I decided to use a delegate interface to my API in order to perform an action over a dynamic set of control instances, where my delegate was essentially the block. It was extremely elegant until someone had to make a modification and even though it was commented, another developer rewrote the entire thing in a for loop because he hadnt understood what the code was trying to do. If I had wrote the initial code that way from the beginning it would have saved us both a lot of time, with the only downside of it being 50% more code and me not feeling as elite while writing it.

But I am also a (random) fan of Ruby, I only wish more people knew how to do it. (People that I know, at least.) I always wanted to “collaborate” with some of my coding friends, but they stand by C++ and PHP.

Never really tried anything with Perl. I guess I should give it a shot.

Strong code conventions – that do generate more lines of code or at least longer winded code – are easy habits to learn until they become second nature, and I find writing readable code really isn’t any slower than writing mangled code. But the longterm payoff is definitly there, if only so when you get rich and hire other programmers you don’t have to explain what your code does.

I may be completely wrong, but C++ does pure good “magic”

They call it operator overloading.

You can redefine most of the operators + – * / , (yes comma) *= += etc etc

But there are strict typechecking rules.

So you have to involve a CLASS or a USER DEFINED DATATYPE in there.

You just can’t do this if the operator operates only on the predefined datatypes (int. float. char. double.)

Type checking, I believe, gets rid of the evilness of “magic” in C++.

I might be wrong, I haven’t done operator overloading in a year or so. But you can easily check it out.