Python is pretty strongly typed, as is Java.

Tools like pylint and mypy can make Python practical for large projects.

Python is strongly typed. It's also dynamically typed.

You can easily catch Python bugs analogously to how you would with a statically, manifestly typed language, using an IDE (or editor with plugins n- I like vim+syntastic), using a whole-program static analyzer (like pylint), using gradual typing (like mypy) and using automated tests.

Actually, static analysis is pretty effective with python - see pylint.

Also, there's more than one JIT for Python - see Pypy and Numba, for examples.

Threading works fine on Jython and IronPython, but you're right that the threading in CPython is poor.

I'm a big Python fan, but I can't stop looking enviously at Rust. It sounds pretty promising at catching bugs up front. I wish I could rewrite Python's innermost loops in Rust instead of Cython or C.

With appropriate software engineering tools, Python can do pretty well at catching bugs up front, but it sounds like Rust takes it to a whole other level: beyond pylint and mypy, beyond C++, beyond Java.

Even a laissez faire bug checker like pyflakes can quickly and painlessly find most misspelled variable names in Python code.

I prefer pylint over pyflakes; pylint is more stringent. And I'm starting to like to like mypy, which adds gradual typing to Python.

Weakly typed languages are a little scary, and Untyped languages are even worse.

But Python is pretty strongly typed.

Agreed, but I'll point out that Python IDE's (or text editors with appropriate smarts like vim+syntastic), type inferencers (like pylint), gradual type systems (like mypy), and automated tests go a long way toward making it very cheap to catch Python bugs before deploying to test.

Combine that with the "fewer words per idea expressed" of Python, and you've got a winning combination.

Lines_of_code / number_of_bugs is roughly a constant across programming languages.

That's why programs written in VHLL's tend to have fewer bugs.

Static typing is good for improving machine efficiency. It's also good for replacing the innermost loop of some Python programs.

Python's IDE's (PyCharm, vim+syntastic, emacs+I_bet_something_exists), type inference (pylint), gradual typing (mypy or pytype), and automated tests are more than adequate replacements for a static type system at catching bugs.

Compilation with a static type system need not be slow.

If anything, the analog with Python's implicit compile step (the interpreter itself), type inferencing (pylint), gradual typing (mypy), and automated tests is slower.

Developer time is more expensive than machine time in the modern world, and a VHLL like Python (plus a reasonable assortment of tools and techniques) is the best way to optimize developer time.

Actually, I was forced to use PowerShell for about a year. It really was pretty poor - I compiled a list of the problems I found in it.

I suggested maybe using CPython or IronPython instead, but they wouldn't have it, because "nobody knows them".

LOL.

Static analyzers and gradual typing are available for Python.

Does't Haskell do this?

It's hobbled by a bad primary implementation though: The Glasgow Haskell Compiler. It's fast, it does impressive type inferencing, but the error messages from the compiler are rather poor.

A type inferencing tool for Python helps a lot with this. EG pylint.

Also, the gradual typing available in Python 3.x+mypy helps even more.

Strong typing is pretty useful, but it isn't the opposite of dynamic typing.

Strong typing just means that your language has few to no implicit type conversions. A 100% strongly typed language wouldn't even implicitly promote an int to a float.

Java allows you to add a number to a string; this is an small example of weak typing.

Python is kind of similar with multiplying a string by an integer.