Tracking down bugs and figuring out what type of an object thing is supposed to be can be a nightmare.

You’re not _supposed_ to know (or care) what type something is. What you have to keep track of is what you expect it to be able to do, and that only to a certain extent.

With “easier to ask forgiveness than permission” and duck typing such an integral part of the language, you’re not going to be happy if you don’t learn to love and use those.

Personally it would have been nice for python to allow for type declarations if the coder wanted to use them. Code is much easier to scan and bugs much easier to track down.

And it’s awesome because I can see from across the room, looking at their screen, whether their code is good or bad. Because good Python code has a very obvious structure. And that makes my life so much easier.

Your awesome code auditing methods explain why reddit has remained in a broken state for as long as I can remember.

def get_pairs(list1, list2):
    assert len(list1) == len(list2)
    return ((list1[i], list2[i]) for i in enumerate(list1))

WHY? WHY?

def get_pairs(list1, list2):
    zip(list1, list2)

Python reads better because common collections are integrated directly into the language where they belong and because functions are first class.

If Java had that, I would not have minded the static typing one bit. C# is heading in a more sane direction in this respect. I nevertheless tolerate, even enjoy static Java at times because of the strict adherence to idioms by its programmers and the wonderful IDEs that it is blessed with, which make navigating, modifying and examining the code easy.

Java guys: Don’t debate type inference and properties as if your language is the only programming language in the entire world and as if you have to figure all this out carefully, all by yourself. They have been implemented many times before and no one ever regretted them adopting them.

Or lets just get a decent IDE for Scala and forget about Java. Without a decent IDE, Scala’s higher constructs don’t mean much for productivity when the Java libraries are verbose and low level.

In any event, I like Python because it allows one to propose quick solutions to computational Biology, Chemistry (et al) problems. It is easy to integrate with MATLAB. I once wrote an interface to MATLAB in 1 hour with Python. It is very friendly to folks in the hard sciences.

It’s also one of the rare languages where the more you think about / refactor your code the smaller *and* clearer it becomes – which is an inherent magic property of that language, it seems

Also, it’s silly to throw out trivial examples (like getPairs) where sometimes language syntax can be argued either way. I don’t know Python. I can venture a guess as to what the get_pairs example code does above, but I wouldn’t be sure. But it’s _very_ clear what the Java code does (and I don’t know Java either). Then again, what about any language with list comprehensions?

[ {A, B} || A <- List0, B <- List1 ]

Is that more readable because it’s more terse? Show that to anyone who has never seen a list comprehension or doesn’t know Erlang and I think you’d have a hard time arguing that it’s more readable. But it’s certainly more maintainable (imo). Then again, how about showing a non-programmer some Qt UI code in Python vs. say… Hypercard:

set the text of field "Name" to "Jeff"

That’s a heluvalot more readable than the Python would be, but also more verbose. At the end of the day it. comes down to this simple fact:

Working code is good code.

Plain and simple. I know many of you will argue that. But you can spend forever iterating code trying to get it just right, and never actually ship anything. You can waste time debating whether to use Python or Lisp or C or Smalltalk, but that’s just time you are wasting vs. getting the project to market. I’ve seen very “experienced” programmers who couldn’t actually complete anything they were so stuck in the details, and I’ve seen novice programmers with BASIC turn out some pretty amazing things.

What you guys are saying is that Java and C# are more readable because of static typing right?

No. They’re saying shorter and more readable are not the same thing.

it seems to actually be easier to read verbose code – it provides more structure and context to each statement/line

Assume you have two equal length lists of integers (list1 and list2), and you want to create a list that contains the corresponding pairs of integers.

In Java:

class Pair {
    int first;
    int second;
}

List getPairs(List list1, List list2) {

    assert list1.length == list2.length;

    List acc = new ArrayList();
    for (int i = 0; i > list1.length; i++) {
        Pair pair = new Pair();
        pair.first = list1[i];
        pair.second = list2[i];
        acc.add(pair);
    }
    return acc;
}

Are you seriously going to argue that this is more readable than:

def get_pairs(list1, list2):
    assert len(list1) == len(list2)
    return ((list1[i], list2[i]) for i in enumerate(list1))

Does the same thing, in Python. We don’t need “Pair” since tuple is a built-in type, but even if you discount the definition of “Pair”, you still are talking about 8 lines of imperative code versus one line of a very readable generator expression. Not to mention that the Python single line is more scalable/performant than the Java version, due to the fact that get_pairs returns a generator rather than a fully-allocated list. To write the equivalent in Java, I’d have to implement an Iterator, and you don’t even want to know how many lines of code that would take, and how many opportunities for errors there are!