Java is for better or worse more verbose than Python, which means more lines of code which means more opportunity for bugs. It is hardly nonsensical. That opinion is a product of language-centric parochialism with no regard for actual fact.
Ditto for the "just work" line being a "delusion." Like it or not, Python does indeed "just work" in most cases. This isn't unique to Python of course, but I do think that is a fair opinion of the author to hold.
So if i write unit tests, that increases the number of lines of code, thus increasing the bug count right? The static type information in java is more akin to unit tests than actual programming logic - they decrease the bug count, not increase it.
Whether they decrease the bug count enough to make up for the productivity loss is the part that is debatable
In my experience, done right it's a bit of a wash. There's more potential cases to test in python.. but the tests are easier generally to write, and the code is more concise and easier to read.
With pretty extensive experience at this point in both languages I wouldn't say I've experienced a significant difference in bug trends at all, frankly.
I don't believe it is a simple linear relationship otherwise we'd all be using Perl or APL. More likely there is a "sweet spot" in the verbosity/terseness spectrum that is occupied by languages like Python.
This is not the case for Perl & APL: each line can contain a multitude of clauses and the relationships between them can be complex to unravel.
Conversely some languages (e.g. at the extreme end assembly language) require multiple lines to express a complete clause.
Complex manually expressed type systems can be similar in effect to both cases. A single line can become complex to unravel e.g this kind of thing:
int (*(*vtable)[])();
We seem naturally drawn to using lines as logical delimiters: code is maybe similar to poetry in this respect. Also, in similarity to poetry, single clause lines allow us to annotate our thinking on the same line by way of a comment.
One clause per line is probably a natural sweet spot.
If my theory is correct then the relationship between lines and bugs will still be linear but APL would have a multiplier greater than one while assembly's multiplier could be a fraction (e.g. 5 vs 1/5).
Does that apply cross-language, or just within a given language?
Getting normal things done with static type checking is not always simple; sometimes code gets skewed toward satisfying the type system. This is not completely unlike the way some people pepper their code with statements that serve no purpose except to shut up a lint tool, or make their test code simpler by making their solution code more complex.
Assertions are an interesting case, as the programmer controls what gets verified and when, rather than being forced to code around an inflexible static checking system that inserts itself into language syntax.
it doesn't add to solution complexity
First, there are objective aspects to that perception. For example, Python affords trying stuff immediately through its REPL. When you commit it to “real” code, it just works. Opening an UTF-8 file is just `codecs.open`. Alas, there is Zope/Plone to serve as a counterexample.
Second, emotional reactions do affect how we, human programmers, perform. If I feel nice coding in Python, I am very probably more productive. If I hate XML configuration files, I'll be on my nerves when I write them and might perform poorly.
The relationship between a programmer and code is not (just) a mathematical thing and we really should stop seeing emotion as a cognitive defect and appreciate it as the evolutionary improvement that it indeed is.
(Sorry for ranting. I'm hungry.)
Tom Pinckney: Why I gave up on Java and switched to Python
The author is not arguing that Python is better than Java. (It's 2011, why would he do that?) He's telling his reasons for switching. We can disagree with all of them, but we cannot say any of them are invalid because they are “emotional” or “subjective”.
P.S Even though within the article the python the he explains what he means (with type bugs) such issues won't be by moving to python.
1)"No more XML config files" XML configs are slowly disappearing
2)"by omitting the type info a python program has fewer opportunities for bugs" this reason was just nonsensical
3)"It's free software and easier to hack on", go check the openJDK
4)"Things in the python world seem to "just work"" that's just a self delusion caused by an emotional reaction not a valid argument
5)"I can still relive the good old scheme days" ok so maybe this one is not BS