One of the problems is that for Java the task is underspecified: Flatten a list of what? Sure this one is integers, is that always the case or should the list take <object>?

Leaving out that information from the question is going to disorient novices who in a high stress situation at the short end of an asymmetrical relationship. I suppose if the interviewer lets them Google, then it is a fair test (and objectively, not Googling before writing code is probably the best criterion for failing miserably).

What the question really measures is how lucky the candidate was in their education. If they were taught in Racket rather than Java:

  (flatten '((1) ((2 3 ((4) (5 6)))))

and if they were taught the JVM rather than Java

  (flatten [[1] [[2 3 [[4] [5 6]]]]]

and with J

  flatten =: [: ; <S:0

I'd bet that the interviewer would not know if it was wrong or right. Which is the same issue of open endedness that the candidate faces.

> is going to disorient novices who in a high stress situation at the short end of an asymmetrical relationship.

> What the question really measures is how lucky the candidate was in their education.

Yes! Exactly! This is the other point I wanted to make[1], thanks for doing it for me :)

> flatten =: [: ; <S:0

Nice, I was playing with J quite a lot but somehow missed the spread word (for the curious: http://code.jsoftware.com/wiki/Vocabulary/scapco)

[1] In my comment here: https://news.ycombinator.com/item?id=13725095

I played with J and have it loaded on an old Android phone...but I copy pasted the code from Rosetta Code after Googling 'flatten a list in Java' which is where I became aware of the <object> issue {racket I knew and clojure I suspected}.

> One of the problems is that for Java the task is underspecified: Flatten a list of what? Sure this one is integers, is that always the case or should the list take <object>?

Well, I don't Java much, but I think that even if the result List is just integers, the source list has to be (invalid syntax) List<Integer | List<Integer>>, which is somewhat problematic to type as anything but List<Object> given Java's lack of sum types.

More precisely List<Integer | List<Integer | List <Integer | List<Integer | ...> :) That would be trivial in functional languages.

It would be trivial in languages with sum types and support for recursive signatures/constructors, which doesn't describe all statically-types functional languages. And there's no reason such a language would have to be functional, though most are.

Interfaces are (open) sum types. Or close enough for government work.

Yes, but Java (unless I missed a recent change) doesn't let you assign new interfaces to existing types, so short of either wrapping Lists and Ints in containers implementing a common interface and demanding that the input be in the wrapped form, that doesn't actually help.

Faced with this problem, I would precisely wrap Lists and Ints in containers implementing a common interface and demand that the input be in that form (actually, the input is text right? so I'd parse it into that form - assuming I couldn't get away with just manipulating the textual representation).

Note that in the genuine sum-type case you're wrapping, too.

I suppose a fair counter question would be how on earth the interviewer ended up with a couple of nested heterogeneous lists in Java, instead of a simple Tree data structure.

If you look at the actual, original question it was presumably a textual serialization of a simple data structure.

But...but Python is starting to become a Programming 101 language, and Python is awesome :( :(

The coming glut of Python devs is going to be a problem. Its an excellent language, I've used it for work for years, but its almost too powerful. A minimally skilled programmer can write mostly-functional Python programs while still not having the slightest notion of what they're doing, meaning the pressure for a developer to understand and improve their craft is often minimal.

If I were responsible for hiring developers into a Python post, I would only consider candidates to could show (ideally substantial) work in some other, strongly-typed, lower-level language. It hardly even matters if they haven't seen Python, a decent developer can become a useful Python programmer in a few hours. Python experience does not teach or demonstrate a decent understanding of software structure.

I have seen a fair bit of Python code in the style of Java (as well as some completely unreadable Python). Just because you can be useful in Python doesn't mean you are writing good idiomatic Python code. And if you aren't doing that, then what is the point in using Python?

To be fair, I probably still have a bit of C-stink in my python code. I don't know the idiomatic way to do everything, and I don't try to put everything into list comprehensions by default, but I still think it's an excellent, and fast, language, and have been using it for many years.