php vs python

[Joel Koltner]

"Arnaud Delobelle" <arnodel at googlemail.com> wrote in message 
news:m2y75oa1xp.fsf at googlemail.com...
> This is wrong, because if you know well one language only, you tend to
> think that the principles that underpin it are universal.  So you will
> try to shoehorn these principles into any other language you use.

Fair point, although I guess I was assuming the language you were good in was 
something that covers, say, 90% of contemporary programming practices, e.g., 
something like C++ : If you're truly good at C++ (and percentage-wise of all 
programmers, relatively few are), there are not many things that I'm aware of 
that are tremendously different in any other programming language.  Function 
decorators from Java and some of the function programming stuff from Lisp, 
perhaps, but those are pretty small additions (well within the "10%").

Perhaps I should reduce my claim to those good at programming in any "first 
class" language like C++ are generally going to write at least above-average 
code in any other language. :-)

> You may be great at building Turing machines.  That doesn't make you a
> master of crafting lambda-expressions.

Certainly the most important thing for any programmer to know is where his 
skills lie and where he should purposely keep things "braindead simple" 
because he's more likely to introduce bugs by trying to be "eloquent."

> I find that eloquent Python speakers often tend to write a for loop
> when mere good ones will try to stick a list comprehension in!

This is the trap I refer to above -- beginning programmers are far more likely 
to mis-use more sophisticated language features than experienced programmers 
are.  Heck, you see entire languages like Java built around such premises, 
that it's better to have a simpler language that's harder to mis-use than a 
more sophisticated one that could be readily abused.  C++ is perhaps the 
ultimate "anything goes" langauge -- tons of power and sophistication, very 
little nannying.  Python has its own philosophy, of course, although at times 
it's somewhat arbitrary, e.g., for "explicit is better than implicit" -- sure, 
fine, but "of course" only applied to things that we haven't already decided 
"should be" implicit!  Something like Python iterators are not at all 
explicit/obvious, for instance, to someone coming from, say, a Visual BASIC 
background... although I suppose they're still a lot simpler than, e.g., C++ 
scoping rules for name resolution.

---Joel