See, fortunately for me we use Java at work, and these day long excursions turn into 40 hour weeks. ;)

Interesting. My experience with Java is that the only thing that gets in the way of programming in Java is the verbosity, which an IDE with powerful refactoring tools (eclipse, IDEA, eclim) gets around nicely. I would argue that in many ways, Java is easier to program in than a lot of other currently hot languages because there is so much tooling around it (although I would trade basically any python package manager for ivy any day), it is statically typed, and its behavior is generally boring but extremely predictable, and not hard to reason about, excluding the threading library which is not super fun. What have you found is frustrating about using Java?

Maybe because I'm not used to java anymore I constantly find myself wanting to do things that are "bad" in Java. I want my function to return more than one variable and then accept it on the other side like x,y = getCoordinates(); Yes I can do something almost like that in java with an array or collection but it's considered "wrong." Sometimes, I want to have a module with just functions, not an a class. Writing the long list of setters and getters that just return and set themselves is really frustrating to me, knowing that in other languages I would just have properties. And working around this in java by making them all "public" is considered "wrong."

And while I agree that java has excellent tools, the one tool that doesn't work as well or as easily for me is the interactive console. Perhaps it's java's verbosity, or maybe this tool hasn't been as fleshed out as it has been in python, javascript and even php (phpsh), but I haven't found one that works as easily for me.

I agree, writing Java without powerful refactoring tools is a bore--that's why it's great to use Eclipse's "Generate Getters and Setters based on Fields" refactoring tool.

Interestingly, I've never really felt the pain of not having a good REPL for java, although I often use it in other languages. Although Java isn't interpreted, unlike the other languages you mentioned, Scala is both interpreted and compiled, so it's not a great argument for why it doesn't have a good REPL. I think eclipse's very strong autocomplete somewhat obviates the need for it, because I know that I mostly depend upon bpython/ipython for the easy access to docstrings and information about arguments.

I wonder if part of the reason why I've never felt the need for a REPL in Java is simply because there isn't one built in, so it isn't a tool that I ever reach for. REPLs are great for prototyping, and for learning, but I've found that the more I learn about a language, the less I tend toward using the REPL, so perhaps it's simply that I got used to being able to edit my code instead of having to type it all in again.

If you'll be programming in a language like Java, it really helps to familiarize yourself with the tools. I don't remember the last time I had to write boilerplate getters and setters for member variables. In Eclipse, for example, you simply declare the member variables, click on Source -> Generate Getters and Setters, and viola, all the boilerplate code is inserted for you.

If you were writing this in C, you'd return a point as a struct. The Java equivalent of a struct is a class. Write a class to wrap those values and return an instance of that class. Yes, there's overhead there that a struct strictly avoids, but it's the way the language was designed, and it's a much better solution than indexing into an array or collection.

As for multiple return, I've never once seen a need for it that couldn't be solved by creating ad-hoc MethodReturnValue classes that wrapped everything I wanted to return multiply.

There's beanshell, but it really isn't all that great.

My big problem (I came to Java after learning Haskell) is NPEs.