Java must be stopped

Java has past its expiry date. It is no longer the only cross platform, fast language available. There are few examples of widely used Java applications. The few popular ones there are are noticeably slower and more resource intensive than native apps. And as a developer, I waste far too much time worrying about types in Java and generally writing out a lot of boiler plate code. Here are some examples of Java compared to Python (a more modern language):

converting an integer to a string in Java:

String aString = Integer.toString(aInt);

converting an integer to a string in python:

aString = str(aInt)

consider using a dictionary, or hash map in Java:

Map<String, Object> env = new HashMap<String, Object>();

in python:

env = {}

Notice how much cleaner the python implementation is? I don’t even need to care about types, actually, I don’t even need to worry about using semi colons. Python enforces nice looking code by forcing the developer to indent properly. How cool is that?

As a C++ programmer, getting past the concept of a dynamic typing language as easy to work with as Python was tough. But the reward so sweet. Using duck typing, I can make a function that takes in any sort of argument and all I need to ensure is that the argument has a certain interface.

For example, if i want to write a simple function that outputs a string or integer in Python, I could write the following:

def outputVariable( arg ):
    print str(arg)

To do the same in java, I would need a class and two functions (one for a string, one for an integer):

class Outputter {
    public void output(String arg) {
        System.out.println( arg );
    }	

    public void output(int arg) {
        System.out.println( Integer.toString(arg) );
    }
}

It seems to me that since punch cards computer languages have been evolving to be more easily read and less verbose. With each new generation of languages allowing developers to write one line of code that would be the equivalent of 10 lines of code had he used an older language.

There are two main reasons why Java and C/C++ are still the defacto standard languages: there is an existing large Java and C/C++ code base to maintain, and to replace it all would be a very expensive undertaking. And also, there are many Java and C/C++ programmers. Many of whom aren’t even aware that there are easier ways to write software.

There is an argument for learning Java: it’s more likely you will find work with Java. But if you are interested in just writing solid software quickly, you should consider using a language that is more congruent with “quickly” and “easy” than Java.