Some Things Wrong With Python
* Immutable strings[0]
* Everything a reference[1]
* Environment copied on loop entrance (implying assignments often break when done in loops)
* Lack of braces[2]
* Lack of enums[3]
* Standard debugger pdb reminds me of the first debuggers ( used on the PDP-1 and EDSAC) in its feature list.
* Exception-oriented design, which clutters code with "try/catches" everywhere.
* Exceptions aren't just exceptions, they are also overloaded to provide signals.
* Two forms of objects (old style vs. new-style)
* Object inheritance is pointer to parent. Metaprogramming becomes an exercise in hackery.
* Objects are actually dictionaries with some pointers behind the scenes.
* Duck typing will automagically cast certain things[4]
* As an interpreted language, code that is not tested can be assumed to be syntactically correct but in error (this is a horrible problem when testing for rare error conditions)[4.5]
* When Python is fast, it's because it's calling out to C.
* Python objects are gigantic. An empty string is 40 bytes, for example. This adds up.
* Python can not meaningfully multithread, due to the global interpreter lock.
* Python suffers from many different versions being installed on different versions of Linux[5]
* Lambdas are totally broken[6]
* Large-scale module importing is a half-baked job[7]
* Python 3 routes around some these issues by using generators for everything[8].
[0] Ever try to step through a string and modify it in-memory? Well, you can't. Sorry. ;-)
[1] I.e., a function can modify something unexpectedly.
[2] Which means block commenting or commenting out tops of loops means a complete reindenting of the block, that is, editors can't do the smart thing, they don't have enough context. This is a waste of the engineer's time. Delimiters were figured out in Lisp, a very long time ago.
[3] This was figured out long ago as well.
[4] But not others. Object design is a bit funky.
[4.5] This is a general design 'con' in dynamic languages. It's partially solvable with a sufficiently smart compiler, most compilers aren't that smart.
[5] This is why serious Python programs (that don't come bundled with their own version of Python) are written to target Python 2.4, released in 2004.
[6] A 'lambda' function in Python can not have statements. Most interesting functions have statements.
[7] Python (similar to Java) relies on a very specific directory structure for a given program to be able to import libraries. This means that if you are doing anything remotely exotic with layouts (e.g., libraries are in a peer directory, not a child directory), you have to commit hackery.
[8]This avoids the fact that the end result has to be emitted in some fashion.