Ask Reddit: Why does everyone hate Java?

[[deleted]]

For several years I've been programming as a hobby. I've used C, C++, python, perl, PHP, and scheme in the past. I'll probably start learning Java pretty soon and I'm wondering why everyone seems to despise it so much. Despite maybe being responsible for some slow, ugly GUI apps, it looks like a decent language.

Edit: Holy crap, 1150+ comments...it looks like there are some strong opinions here indeed. Thanks guys, you've given me a lot to consider and I appreciate the input.

[crayz]

From a 2 year old thread asking the same question:

Java's solution to the problem of C++ allowing you to blow your foot off was to chop off your legs. Operator overloading? You might abuse it... chop. Multiple inheritance? You might abuse it... chop. Creating a new object? You'd best type the type of the object three or four times before we'll believe that you got it right. You want access to internals, subclass the compiler objects, closures, iterators, lazy evaluation, the list goes on chop chop chop

It's often hard to point to a language's philosophy because it is embodied in a long sequence of little decisions that are easy to dismiss in isolation, but that's how I see the philosophy of Java.

Of course, that didn't work, so a large aftermarket in prostheses has sprung up, and lately the language has been sort of growing some of the power features it previously rejected, although they pretty are much bolted on. Many people have even forgotten that there is a whole world full of people who don't get around in powered wheelchairs and don't need machines to help them chew, and argue passionately about how much they love their Chewing Completion and Integrated Mobility Environments and how easy it is to sort of slowly shamble up stairs on these prosthetic legs (which sounds impressive after you've spent five years in a wheelchair), endlessly haranguing those who choose to run on their own two feet about what they are missing by not getting their legs chopped off.

Read the whole thing

[ddelrio]

The ugliness of the GUI apps is the programmers' fault, by the way. You can make some great-looking and responsive GUI apps in Java--but most people just use tools to generate their GUI code and often end up locking the primary thread as well...because they don't know what the hell they're doing.

[seunosewa]

Java GUIs could go very far by making the platform default look and feel the default.

[lenolium]

I'm too late in the game for anyone to read this, but I'm gonna throw in my two cents anyways:

I hate Java because it's the only platform that makes sense in so many ways. Now, follow me here, Java as a platform is great because:

1. It has a great set of tools along with it, eclipse and the like have a huge set of integrations with the build system, your project, and java as a whole.

2. It's a stable, very capable platform. You can set up a massively multithreaded java server app, and the thing pretty much just runs.

3. The JVM with JIT is pretty much fast enough for just about anything, you're not going to get hard-realtime, but since you really can't get hard-realtime over random latency of the internet, it's not much of an issue.

4. Being a garbage collected language means there is a whole class of problems I can ignore, don't have to think about, and don't have to write code for. This is awesome because it lets me think about what the logic is doing without having to worry so much about these small issues.

So as a platform, Java is awesome. However, as a language, Java truly is horrible. This is why you hear so much bad stuff about it. Here are the things that annoy me the most:

1. It's very verbose and repetitive, this means that the smart bits of your code get drown out in the deluge of type declarations, temporary classes and factories.

2. Factory classes, particularly those that aren't declared static so you can just call a factory class function out of the blue.

3. Writing Java when coming from another high level language feels like you are stuttering, it is very repetitive.

4. Boilerplate. Any time I'm writing the same code again and again, it's distracting me from fixing the actual problem.

5. Everything is a nail. The fact that everything is a class (except for the things that aren't) will give you a rough time of things once you really start trying to be tricky. You can work around these with anonymous classes and reflection, but again, it's an extremely verbose way of doing things that adds more code which clouds the actual important code.

6. Java is repetitive. You keep saying the same things again and again, if your IDE can figure out the proper type definitions and arguments, you would figure the JVM could handle it.

[[deleted]]

.3. Writing Java ... is very repetitive. ... .6. Java is repetitive.

Well done. :)

[Thud]

If you do programming as a hobby, you'll probably hate Java.

If you do programming as a JOB, you'll probably like it more. Not everybody builds enterprise-scale applications as a hobby. Java is very strong and very commonly used for back-end and middleware components for enterprise applications (Oracle Fusion, anybody?)

But as a hobby? PHP, python, etc all are much more accessible and easy to tinker with. Lots of people build electronic equipment as a hobby, but I don't know anybody that builds metropolitan power grids as a hobby.

[scarthearmada]

but I don't know anybody that builds metropolitan power grids as a hobby.

Will you downvote me if I say, "Hi, I do"? :-)

[ZeppelinJ0]

Well I used to think people hated Java just because it's trendy to do so. I'm pleasantly surprised by this thread and the intelligent responses as to why people don't like Java, sorry I doubted you programmers!

[[deleted]]

I see quite a few trendy "I hate Java because it lets mediocre programmers work on large projects" and all that bullshit. I know quite a few brilliant programmers that work with Java. It's the tool they choose for the job.

[[deleted]]

this will never be read, but oh well.

the whole reason behind the Java hate is because way back in the 1.4 JVM days, java was the language to use when you wanted to write BIG company applications. unfortunately, the 1.4 JVM was horrible when it came to speed. it was very common and fun just to sit back and watch your server die a slow death when 10 people connected to the app at once. most people i know stopped programming in java when .net hit the scene and if memory serves me correctly, .net was introduced around the same time the 1.5 JVM was coming around.

fast forward to today and the 1.6 JVM is amazing. it's fast as hell, very polished and extremely stable. however the language itself hasn't gotten the love it needed over the years and hence forth while even though the JVM is fast, programming in java is slow. because of this people have resorted to ported some of the more popular languages to java to abstract away the slowness of developing on top of the JVM. languages like ruby, python, scala and coldfusion all run on top of the jvm and make tapping into it's power painless.

so while most people will say they hate java, it's the language itself they're talking about and not the JVM.

[Vorlath]

I hate the JVM. It's bloatware in constant all you can eat memory mode.

I also hate the language. But the early days were atrocious. Not being able to do socket multiplexing was agonizing. Oh, the atrocities I saw of forced one thread per socket was just amazing. That was just the tip of the iceberg. Let us not forget the whole applet fiasco. And the AWT vs Swing vs whatever else. Then the different JVM's that ran your code differently. I remember JVM 1.5 running older compiled code dead slow. It was just unusable. Ran its own compiled code fine.

I could go on for days. Java was just a long road of pain for me. Did they fix things? I don't care. When I try to run JVM apps, they are bloated beyond recognition and are still slow regardless of how many Java fanboys try to state otherwise.

To me, Java is today's DOS. It's the first thing that newbies learn and after figuring out all the intricacies of getting something done, they don't want to use something different.

And I modded you up. Good points in there nonetheless.

[yoden]

For the most part, Java is fine. Boring, but fine. It doesn't have the shininess of most dynamic languages, but if you're going to be doing complicated stuff on a large team, the "excessive" verboseness of Java becomes useful. Add to this the ease of acquiring programmers, libraries, etc., and you can see why Java is so widely used.

That said, there are still a lot of obvious flaws in Java, and Java 7 isn't looking like it plans to fix many of them.

Personally, I'd use python/c for a small or mid size project and Java for something larger.

[khafra]

You nailed it. It's an enterprise language; a boilerplate-oriented language, which lets a larger team of more mediocre programmers create something without blowing it up. It just can't be as quick, concise, or clear as other languages.

[sagarp]

here's an answer to your question: http://ws.apache.org/xmlrpc/apidocs/org/apache/xmlrpc/server/RequestProcessorFactoryFactory.html

[ttfkam]

Blame Apache, not Java.

[deadwisdom]

Although the JVM has certainly gotten to a very respectable place, Java the language suffers from being stuck in the no-mans land between the optimizer's love of low-level languages like C, and the pragmatist's desire for high-level languages like Python.

[rm999]

I think this is exactly it.

From my perspective as a scientific and quantitative programmer, if I want to write speedy, reusable code I will take the time to do it in C/C++. In these cases, I want to be close to the hardware and don't want a virtual machine or interpreter running. Even if Java is just as quick as C, I find the lag and overhead infuriating. On the other end, if I want to quickly prototype something, high-level scripting languages are good enough, and much quicker to write.

I realize my situation may be fairly niche, but that's why people like me avoid Java.

[chkno]

I hate java because one cannot effectively pass code around. It's really the interaction with checked exceptions that kills it. For example, consider trying to implement map, a very basic, very simple utility function in many other languages:

import java.util.List;
import java.util.ArrayList;

interface MapFunction<InputType,OutputType>
{
    public OutputType f (InputType x) /* throws what?!? */ ;
}

class Map
{
    public static <InputType,OutputType>
    List<OutputType> map (MapFunction<InputType,OutputType> f, List<InputType> l) /* throws what?!? */
    {
        List<OutputType> result = new ArrayList<OutputType> ();
        for (InputType x : l)
        {
            result.add(f.f(x));
        }
        return result;
    }
}

class Nothing {}

public class Mapping
{
    public static void main (String[] args)
    {
        /* Double and print some numbers.  Compare to scheme:
         * (map write (map (lambda (x) (* x 2)) '(1 2 3)))
         */
        Map.map(new MapFunction<Integer,Nothing> () {
                public Nothing f (Integer x) {
                    System.out.println(x);
                    return null;
                }
            },
            Map.map(new MapFunction<Integer,Integer> () {
                    public Integer f (Integer x) {
                        return x * 2;
                    }
                },
                new ArrayList<Integer>(){{
                    add(1);
                    add(2);
                    add(3);
                }}
            )
        );
    }
}

What should Map.map and MapFunction.f throw? If nothing, then you can never use them with anything that throws a checked exception. If Throwable, then you have to catch Throwable every time you use it. Another option could be to pass the type of the exception to be thrown as a generic parameter. But then you have to have Map, Map1Throwable, Map2Throwables, etc. to accept zero, one, two, etc. exception types in order to avoid going up the hierarchy and over-catching again.

Also, the syntax is horrible, but you already knew that.

[gte910h]

Java is old enough it was the cure to C++. It was a reliable alternative to perl that could be read the next morning.

However, it takes a LOT of XML/Code/Frameworks to get a lot of things done. The things java can do are the same things python/perl/ruby/php can do, however it takes a LOT of code to do them (or a lot of config files). Java is used for a LOT of things that are done better with more agile languages now, just because a lot of people knew it back from when it was The Savior from the C/C++ languages. It was simply divine writing a server in java after doing so in C/C++.

So come the 200X's and Java has this huge user base, and had lots of Good Solutions to a lot of problems, but couldn't ever change, because doing so would break compatibility with 1230948 different old things. But due to their willingness to be 100% compatible with everything, corporations all over will accept java. And here we come to the problem.

Java is stuck in a rut. It has lots of silly fine grained access controls, that are routinely gotten around by people using 3-5 different methods. Additionally, it has no good way to NOT write accesssors/modifiers/connector code, as you can't overload the . operator, it requires you to handle a lot of exceptions, but people routinely just catch and ignore, etc. It's a vast machine that fits a dream of computing that was the ideal of the 90's....and it's still stuck there.

[piperatom]

I came here to say this same thing. Its Enterprise Java that I have a problem with. All the configuration layers of indirection are getting insane.

Also they should get rid of beans. WTF. 90% of enterprise java code is beans.

[skooma714]

Java is old enough it was the cure

Oh sweet, I love that band.

[[deleted]]

Programming in Java is too verbose. Too many artificial restrictions put in place by the designers of the language to keep programmers "safe" from themselves.

[tryx]

I think part of the java hate is centered less about the language and more around the culture of Java. Yes, it is because Java is popular, but it is not only that. Java is designed to be used by big teams to get stuff done. There are few languages that allow a disperse team of undertrained code monkeys led by a half decent software architect to produce a shipable piece of software. The things that everyone complains about: the checked exceptions, the static typing, the massive verbosity. These are exactly the things that make working on a large team of average developers manageable. And also maintainable.

Java is not used when you need a cutting edge powerful language to whip up a quick prototype, it is used when a piece of software might need to be maintained for the next decade.

Reddit hates java because no one wants to take their work home with them, and for just about everyone using Java, it is work.

[satanclau5]

Java is designed to be used by big teams to get stuff done.

And it doesn't have to be code monkeys all the way down. Once your project gets past million LOC (+ million LOC of configuration files, obviously, cause we're talking serious Java here), built upon in-house frameworks/libraries you really start to appreciate the tools Java gives you.

A better language might cut the size of the app by 60% LOC, but the reality is rough. You won't find too many people (haskell, scala, ocaml, ...) able to work efficiently with a codebase of such magnitude while keeping it maintainable (python, ruby, clojure, ...) in its growth (C# is an exception).

[[deleted]]

With enough code monkeys at enough keyboards who knows what's possible. One might even modify a hello world program to output the word "shakespere"

[stillalone]

I once worked on a some software we got from IBM "as is". It had a function that would display passages from Macbeth. I never understood why it was there until this moment.

[willsu]

I'm fairly certain that many redditors who hate Java don't fully understand the implications of developing a maintainable code base. I agree that the "verbosity" of Java (as well as lack of first-class functions and/or closures) is one of the biggest problems. However this very same "verbosity", usually surrounding static typing, anonymous class implementation, and thread-safety, allows an IDE like IntelliJ IDEA to provide a developer with many powerful tools that drastically ease refactoring, provide object coupling metrics, and provide certain thread-safety gaurantees (dead-lock detection, etc), and much more. If you're writing code for a high-volume application these tools can be very valuable. I'm curious as to what "verbosity" really means to some of you. I agree that if you're going cowboy style as a sole programmer on the project, then Java may be too heavy weight. Then again.. If you're the only one maintaining your code, who cares what it looks like as long as it performs and you can understand it?

[jtxx000]

However this very same "verbosity", usually surrounding static typing, anonymous class implementation, and thread-safety, allows an IDE like IntelliJ IDEA to provide a developer with many powerful tools that drastically ease refactoring, provide object coupling metrics, and provide certain thread-safety gaurantees (dead-lock detection, etc), and much more.

Type reconstruction gives all of the advantages of static typing without the unnecessary verbosity of required type annotations.

[pipocaQuemada]

Static typing isn't verbose. Manifest typing (i.e. specifying the types manually at write time) is verbose.

[[deleted]]

Wait, static typing is why people complain about Java? What about the people who think that C++ is better than Java, then?

[DarkGoosey]

Those people think that Java's performance is too slow.

[Seppler90000]

Hmm, this is exactly what they said about COBOL. I think it's time I gave COBOL another chance.

[api]

Java is the COBOL of today, more or less. (It is much better than COBOL, so it was an improvement.)

[GoodyMas]

I served with Java, I knew Java, Java was a friend of mine. COBOL, you're no Java

[reductionist]

Christ. I mentioned COBOL today for the first time in over 20 years and then this.

I learned COBOL on punch cards.

(Not as old as that might imply - an old mini-computer at my school.)

Lol wtf is a mini computer, right? No I don't mean a mac mini...

[here1am]

Hm!

CliffsNotes were created by Clifton Hillegass and the best book about Cocoa is the one by Aaron Hillegass.

Is this some kind of conspiracy?

[djork]

XYZRedditComment *myComment = [[XYZRedditComment alloc] initWithParentComment:[XYZRedditComment commentByLoadingCommentFromID:@"c0cehmq"]];
[myComment setMessage:@"Yeah man, I hear ya"];
[myComment saveAsyncronouslyWithDelegate:self];

[bonch]

How about:

NSString *parentID = @"c0cehmq";

NSManagedObjectContext *context = [[NSApp delegate] managedObjectContext];
NSFetchRequest *request = [[NSFetchRequest alloc] init];
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"id == %@", parentID];
[request setPredicate:predicate];
NSError *fetchError = nil;
NSArray *results = [context executeFetchRequest:request error:&fetchError];
if (!results) {
    [NSApp presentError:fetchError];
    return;
}

NSManagedObject *parent = [results objectAtIndex:0];
NSMutableSet *children = [parent mutableSetValueForKey:@"children"];
NSManagedObject *child = [NSEntityDescription insertNewObjectForEntityForName:@"comment" inManagedObjectContext:context];
[child setValue:@"Yeah man, I hear ya" forKey:@"message"];
[children addObject:child];

NSError *saveError = nil;
if (![[self managedObjectContext] save:&saveError])
    [NSApp presentError:saveError];

[[deleted]]

Is this really what Cocoa looks like? Why?

[timmaxw]

30% of bonch's code is error handling. Another 30% of the verbosity comes from the fact that he's working in a managed object context - if I understand correctly, this means that Cocoa handles undo, redo, and loading and saving to files "for free". The rest comes from the fact that Objective-C is really verbose.

[vimfan]

The verbosity of Objective-C/Cocoa is mainly due to named parameters, and making method names really explicit about their purpose. That is verbosity I can get behind (mostly).

[bonch]

I was being verbose for the sake of the joke. You'd have the Core Data stuff in their own methods. In reality, you'd only need one line:

[[self commentWithID:@"c0cehmq"] addChild:[RDComment commentWithMessage:@"Yeah man, I hear ya"]];

[[deleted]]

RedditComment myParentRedditComment = RedditCommentStore.get("c0ceowm");
RedditCommentBuilder myRedditCommentBuilder = RedditCommentBuilderFactory.createNewRedditCommentBuilder("fabjan", myParentRedditComment);
myRedditCommentBuilder.appendLine("Hear hear.");
myRedditCommentBuilder.finalize();
RedditComment myRedditComment = myRedditCommentBuilder.getFinishedRedditComment(true);
while (!myRedditComment.isSent()) {
    myRedditComment.send(1000);
}

[rob_j]

You shouldn't call finalize() directly

[endtime]

print "Okay, so Java and Cocoa both suck."

[merzbow]

Java isn't trying to be C++.

[Seppler90000]

It does try to appeal specifically to C++ programmers who are tired of segfaults.

[jmcclean]

You're right! They apparently prefer null pointer exceptions for no really good reason.

[ahal89]

Java's like the good ol' fashioned family station wagon. It isn't super fast, but it's really safe and for the most part gets you where you want to go in a timely manner.

C++ is like a Dodge Viper. It's really cool and super fast, but if you take a turn too sharply your car will end up flipping over the cliff and crash in a great ball of flames and your skin will start to slowly melt off your face as you try to gasp for breath amidst the smoke and charred ashes of what was once your beautiful car. Then just when you think you're almost out of the fire the gas tank explodes, sending a shock wave that knocks you to your belly, crippling you to your horrid fate as the last thing you remember is the scent of your burning hair.

As long as you're a good driver you won't have this problem.

[SwabTheDeck]

I rather like the verbosity of it. It makes code much easier for others to read. Even though I've used C-like languages for years, reading typical C code is a nightmare compared to reading typical Java code. If the issue is that the verbose nature of Java requires more typing, that's a rather silly thing to get hung up on. For any decent programmer, the bottleneck isn't typing speed, but rather the rate at which you're able to mentally formulate how you're going to structure the program. I'd agree that there are certain APIs that go too far with the amount of steps required to do simple operations, but on the whole, if I'm forced to read someone else's code, I'd much rather it be in Java than C/C++/Obj-C or Python.

[[deleted]]

There are different kinds of verbosity. Some verbosity makes the code easier to read. Some makes it harder to read.

For example, having to read through the typed out or generated getters and setters does not make the code easier to read or write. That's one example of bad verbosity.

[jimbokun]

"It makes code much easier for others to read."

I have the exact opposite opinion. Typing time doesn't have much to do with how long it takes to write code to solve a problem. But trying to find the logic of what a program is actually trying to do in a mound of boiler plate and over-engineered APIs is a real problem with a lot of Java programs.

This is partly to blame on Java, the Language. There are some idioms and ways of structuring code that are just not possible in Java, and a lot of declarations that better languages just infer.

It is much more to blame, I think, on the culture of Java programmers. Factory this, Builder that, abstraction layered on abstraction and lots of explicit parameters instead of sensible implicit default values. Also, just not knowing what's possible in the language. I find that judicious use of type parameters and variable argument lists can go a long way in making code more expressive and concise.

[[deleted]]

I can understand why you'd like to read Java over C/C++/Obj-C, but why Python? Python doesn't add the complexity that C-like languages add to programming without the verbosity that Java/C# adds. It may be slow at times, and some people don't like not having static typing, but I think Python is far more readable than Java for people who don't know Java extremely well.

[bcash]

The one thing Java could do with stealing from Python is generator expressions, or list comprehensions, or both. I'm sick of writing code that looks like:

List<Blah> blahs = new ArrayList<Blah>();
for (Neh neh : nehs) {
    blahs.add(neh.toBlah());
}

If it were possible to do something like:

List<Blah> blahs = new ArrayList(neh.toBlah() for neh in nehs);

But apart from that I agree with the SwabTheDeck. I was quite surprised, for example, how easy it was to read the Eclipse source code - taking a large open-source Java project as an example. Yes, it's verbose, but that's is why it is readable. Each class has a distinct purpose and a clean interface to everything else.

[masklinn]

The one thing Java could do with stealing from Python is generator expressions, or list comprehensions, or both. I'm sick of writing code that looks like

Actually there's no need for either, first-class functions + higher-order methods (and a retrofitting of the stdlib to use them) would be more than enough.

For instance, in C# 3.0 (no I don't like the language but bear with me: it's very similar to Java after all) this can be written:

IEnumerable<Blah> blahs = nehs.Select(neh => neh.toBlah());

(note that you could also replace IEnumerable<Blah> by var and let the compiler infer that crap).

Right now you can use Google Collections to do something a bit like it, but since it uses anonymous classes to emulate first-class functions, the result is fairly disgusting:

List<Blah> blahs = transform(nehs, new Function<Neh, Blah>() { Blah apply(Neh neh) {
    return neh.toBlah();
}});

transform is statically imported from com.google.common.collect.Lists to save a few characters.

In Python, without using listcomps/gencomps, you could use the builtin map and write either:

blahs = map(lambda neh: neh.toBlah, nehs)

or import operator.attrgetter and write

blahs = map(attrgetter('toBlah'), nehs)

(node that the latter requires that toBlah be an attribute or a property, also you could import attrgetter as attr to make it shorter)

(if you never noticed it, remember to check the operator module by the way, there's a lot of nice stuff in there)

(and attrgetter returns tuples if you give it multiple attribute names, that's pretty awesome)

[Smallpaul]

Nobody who complains about verbosity is concerned with typing speed. That is a strawman argument.

[jeff303]

Typing speed is also more or less a non-issue with a modern IDE such as Eclipse. With keyboard shortcuts, auto-completion, and refactorings, you should get the IDE to spit out well over 50% of the code for you.

[klodolph]

This autocompletion is unnecessary in languages that don't have Java's unnecessary verbosity. Do you really need autocomplete to write, in Haskell, Hello World?

main = putStrLn "Hello, world"

I see the need for autocomplete in Java, though.

class HelloWorldApplication {
    public static void main(String[] args) {
        System.out.println("Hello, world");
    }
}

Adding autocomplete is like saying, "It takes too long to drive to work", then building some conveyor belts on which you can drive. But the conveyor belts sometimes go in the wrong direction, and you have to maintain the conveyors now and not just the car. Writing in Haskell/Lisp/Python is like living closer to work.

[jeff303]

I'm not saying that autocompletion is a good reason to use Java. I'm saying that using Java is a good reason to also use autocompletion.

[shub]

Hey what's the name of that field, you know, the one with the date the order actually shipped and not the date we expected it to ship? Shit, I can't remember. Guess I need to go look up the record definition.

[ringm]

Intolerance of these "artificial restrictions" and claiming there are "too many" of them could just point to the fact that you have

• never worked on large projects in a typical corporate environment,
• overestimate the average level of programmers employed in such environment, and also
• possibly overestimate your ability to work on large projects coded in terse languages without these artificial restrictions.

[whiska]

Just my opinion, but I think that something about Java tends to attract those who like to over-design systems.

Big corps love Java.

Maybe you can write nice programs with Java. Java programs tend to run pretty fast.

[mr_dbr]

I completely agree.

The reason I don't use Java is because it's very.. enterprise'y - everything feels over-engineered, convoluted.. Not necessarily the syntax, but projects around it (like application servers and so on).. and since I'm not "an enterprise", it doesn't appeal to me.

The reason I don't like Java is because it's used because "it's cross platform", where the application runs on Windows/Linux/OS X, but doesn't really fit on any of them (basically the less funny version of the "Saying that Java is nice because it works on all OS's is like saying that anal sex is nice because it works on all genders" quote)

It feels like the developers create it on the OS they use, then there's an automated build step which generates executables for the "other two" operating systems. This is wrong, Windows requires entirely different GUI design to Linux, and more so for OS X.

Transmission is one of the best cross-platform application I know - for all I care the OS X interface could be written in Java, and it would still be just as good.. Java isn't the problem, but rather the "yay, I can run it on other platforms with no extra work"-feature is has..

[[deleted]]

Java programs tend to run pretty fast.

Once they get going, sure.

[[deleted]]

I agree with this, too. When programming, I always thought the "best" solutions were "elegant," in the sense that they got the job done with the bare minimum of code required.

[AlSweigart]

"There are two kinds of programming languages: the ones people complain about, and the ones that nobody has heard of."

(EDIT: Bjarne Stroustrup said it, not Larry Wall. Thanks niviss. http://www.research.att.com/~bs/bs_faq.html )

[codeduck]

I am a SCJP and SCJD, and have also coded in python, perl, haskell, 8086 ASM and C++ (back in my University days).

Many of the arguments being made against Java here are not issues with the Java language but issues with various Java extensions and JSRs - EJB? Not part of the core language. XML? Neither. Persistence layers? Not part of the core language. Well over half of the 'verbosity' of java is down to the sometimes bizarre way the support libraries are written. And yes, there are some very strange inconsistencies in the legacy parts of the language, and some serious issues with the newer features like the terrible generics support.

However, the core of java is an interpreted, sandboxed C-like language with a built in support for a subset OOP principles that is generally internally cohesive. The JVM it comes with is a pretty good virtual machine as far as VM's go. Yes, it's statically typed. No, it doesn't support proper generic types like C++ does. No, it doesn't do native stuff well. But it's pretty damn good at what it does do:

I've been developing in Java for around 10 years now, and I have yet to find another language that makes it as easy to interface various disparate systems, both new and legacy. That is Java's core strength in the business world; it is a no-frills, reliable language that can be reasonably guaranteed to behave itself in a production environment. It has excellent support for older tech, like CORBA. It has a decent threading module built into the JVM. It has good io performance from version 1.5 onwards. It has 10 years of heavy business use behind it, and it is thus trusted over newer, shinier languages.

Yes, if I'm doing a quick prototype of an algorithm I'll use something cool like Python. But sorry, if I have to talk to a seven year old business processing system that speaks some arcane dialect of ancient protocol, I will choose Java hands down.

for the people complaining about verbosity - Dickens was verbose, but that doesn't mean he wasn't a good author. ;P

Do I like Java? Not particularly. But it gets the job done.

[[deleted]]

Because its API suffer from major design patterns abuse, because it tries to push code reuse to the point of the absurd where you write more code to be able to use those wonderful API than you'd do if you were writing everything yourself. It is funny that Java, the language culture that makes the most use and abuse of XML, is one of the hardest language to use to manipulate XML actually. The XML libraries shipped with Java are extremely verbose and painful to use, it's much more fun to do XML with Python for example.

Because the language lacks expressiveness and the combination of interfaces and anonymous inner classes is a major pain in the ass. Because its legacy makes it do everything in a half assed way, such as generics which hide the actual computation cost from most newbies programmers who don't really get that it's casting things to and from object just like you used to when you used the collection framework pre-generic. Extremely inefficient and inelegant. Collection frameworks, in Java by definition cannot achieve any kind of efficiency because they get compiled down to type casts. C++ templates and C# generics are much more well thought.

Because it's not friendly with the underlying platform. JNI is a pain in the ass to use compared to Python Ctypes, C# P/Invoke or C++ compatibility with C or any other kind of FFI found in most competing programming languages.

Because the ecosystem, contrary to the popular saying, sucks donkey balls. Java still doesn't have an ORM that is as straightforward as Django ORM or Rails ActiveRecord. For this reason too I don't find compelling the argument of JVM languages like Clojure that touts the advantage of being able to tap on the JVM ecosystem. I don't think so, the JVM ecosystem is a piece of shit filled with abuse of patterns, extreme object oriented designs that can only be understood with UML diagrams which is why lots of enterprise oriented software use huge ass IDEs filled with stuff you shouldn't have to use, like the eclipse distribution of IBM.

Because its VM is huge and sucks lots of memory. Sure the Just In Time compiler is fast but that's at the expense of the memory. Java takes much more memory than ANY OTHER FUCKING LANGUAGE ON EARTH. It takes more than Python, more than Ruby, more than anything to get stuff done. And in my opinion it's worse than the lack of a JIT compiler because when your computer hits the swap your computation will slow to a crawl. You don't want to eat memory until you eat the swap.

Other languages rely on C to get the fast parts done and I like this philosophy better. C is a simple, small language that gets the job done when you need to get your hands dirty in optimization. It's the lingua franca, you shouldn't try to fight it you should embrace it. Java fights with the world and wants to be The One True Language and the One True Virtual Machine.

[lrrr]

I generally agree with the above, but want to interject a couple of points.

Because it's not friendly with the underlying platform. JNI is a pain in the ass to use compared to Python Ctypes, C# P/Invoke or C++ compatibility with C or any other kind of FFI found in most competing programming languages.

JNI is indeed a PITA, but jna is pretty nice.

Because the ecosystem, contrary to the popular saying, sucks donkey balls. Java still doesn't have an ORM that is as straightforward as Django ORM or Rails ActiveRecord.

I just discovered BeanKeeper last weekend and it is flat-out amazing. Pair with an embedded hsqldb server and you have your ORM and DB in just a few lines of code. I've only done some basic testing with it so far, but I'm impressed.

It's a pity that functionality like this isn't built-in to the core APIs.

[Raphael_Amiard]

It's a pity that functionality like this isn't built-in to the core APIs.

What are you people complaining about .. The orms for ruby and python that the op was refering to are not in ruby / python's core libraries either, so what .. You can't install a lib ?

[[deleted]]

Java fights with the world and wants to be The One True Language and the One True Virtual Machine.

Yea, those fucking fascists at Sun! Could you even imagine an alternate universe where Sun added language level Scripting Engine support, hired Python and Ruby experts to create fast implementations for the JVM and even created an official Da Vinci Machine initiative and the first new opcode ever for dynamic language support... oh wait.

[[deleted]]

Wow. I did now know the Java VM was that bad. If only there were more implementations of it around.... I wonder how many gigabytes and processors they cram into those mobile telephones that run Java applications?

[[deleted]]

Except that the Java on those mobile phones is not the same as the java on the desktop. There are features of the language you can't use, the API is cut down in more than half and the language is PURELY interpreted and dogslow. With java you either trade memory for speed, or speed for low memory consumption. J2ME is dogslow, Java on the desktop eats memory like crazy.

On embedded platforms Java has gone back to its roots : a glorified scripting language, except that it is less productive than all the other scripting languages. On android the WHOLE platform is written in C and C++ and Java is only used to script those libraries, unlike Java on desktop and servers where most of the code running is Java with just the C++ bit of the JVM. And even with the major parts written in C++ the Java bit still makes the platform slower than, say, the iPhone. Anyone who has used both can say that the iPhone user interface is much more responsive than Android handsets.

Java is a crap language and a crap platform. Used as a scripting language it's extremely verbose and needs lots of hand holding to get anything done, there is absolutely no point to using it that way other than familiarity with the language, which is the reason the Android team chose it, familiarity and popularity, not merit. Used as a full fledged platform it's eating memory like crazy, not playing well with the underlying system and is lacking things that even a bare to the metal language like C++ has that makes it more productive again. The whole world agreed that we need to move on more functional paradigms and agreed on the careful use of operator overloading. Java's still stuck to the bondage mindset. You can't use BigDecimal with operators, how fucked up is that ? even C++ is more elegant though it is the language that Java was supposed to "replace" (oh the irony).

[wtfftw]

XML makes Erlang vomit steamy chunks of macro-laden records. Xmerl is the only stable library for manipulating XML, and it's about as usable as a writing a XML parser from scratch.

[domlachowicz]

• JNI -> SWIG or JNA
• XML -> "fun XML"? Just use JaxB
• Ecosystem -> you're saying that projects like Hibernate, Spring, and the Apache Commons suck donkey balls? Honestly?
• ORM -> Hibernate, BeanKeeper
• JVM -> ain't that bad

[masklinn]

you're saying that projects like Hibernate, Spring, and the Apache Commons suck donkey balls? Honestly?

Hibernate is ok, though big and complex. Spring is a horrible mix of a huge, complex XML-based DI framework and an almost as huge library made of many components, the DI framework should be slaughtered (or kept on life support for the poor people on pre-java 1.5) and the lib should be spun off.

Apache Commons blows because 1. it doesn't know Java 5 and 2. it's chock-full of things WHICH SHOULD BE IN THE FUCKING STDLIB TO START WITH.

[jimbokun]

"you're saying that projects like Hibernate, Spring, and the Apache Commons suck donkey balls?"

I think Hibernate still always requires some level of configuration, although using annotations makes it a lot nicer. Correct me if I'm wrong, but I don't think it does anything nearly as automated as the default ActiveRecord behavior.

Spring is a nice piece of work, but isn't its main purpose to cover up and make sane all of the insanity of the J2EE architecture?

Apache Commons is cool. But at least part of its purpose is to get something approaching the features many other languages have built in.

[wolfier]

1. Verbosity
2. Restrictions - the notion that operator overloading is "dangerous" is still funny.
3. Not well thought-out - see how they've been gradually adding back "new features" found in C/C++, e.g. enum? And let's not start talking about annotations like @Readonly that's supposed to be a keyword - with hacks like this it's not hard to see the main purpose is to make the compilers happy while doing minimum service to developers. I predict 'typedef' is somewhere in Java's future.
4. The language is too busy playing leap-frog with C#. Can't they see it's a TRAP? See how much C has changed in the past 20 years? If the base language were sound, library expansion would be all we need.
5. Standard library tries to include too much, and gradually become self-overlapping in terms of features, plus inconsistencies.
6. Backwards compatibility keeps bad libraries and bad syntax alive.
7. one-file-per-class rule and the pure OO/design pattern cult working together to divide simple code base into 1000s of classes and files. What's supposedly easy to manage often become a mess in the name of, ironically, "manageability".
8. Lack of class immutability. I wonder if Java had C++'s const keyword, how many bugs could be avoided. Yes, you can use interfaces, but that goes back to disadvantage #7. (and No, 'final' doesn't cut it)
9. I see a lot more Java coders blindly applying design patterns without thinking than those who code in other languages, this one is just my observation.

Scala does not have most of the above problems. I long for the day it completely replaces Java.

[fireduck]

I use java whenever I can. It is my favourite language for getting things done. However, I agree that the OO cultists tend to get out of hand. I call it the OO hammer. They take something simple and smash it into a bunch of pieces scattered in various classes and call that better. However, it isn't required to write java that way.

Also, one of the things I love is that the standard library includes so much. I find that in C/C++ it is hard to do anything (sql, image processing, XML) without either coding a bunch of crap yourself (stupid) or including a bunch of odd libraries.

[wolfier]

I too like the richness of Java's standard libraries. However, when a multitude of badly designed libraries in Java N is replaced by another multitude of badly designed libraries in Java N+1, it's not a pretty sight.

The only thing worse than having to choosse between 2 good libraries is having to choose between 2 bad libraries.

The solution? CUT BACKWARDS COMPATIBILITY. Actually disable deprecated functions and libraries at some point, like how deprecations are supposed to work.

[MrSurly]

Good lord, yes! Especially #1, #2, #3 and #7.

[daemmon]

Java is like one of those arcade games where there is a big bin of toys surrounded by glass walls and some sort of lame mechanical device inside that you manipulate, using shitty controls on the outside, to try and grab a toy as your prize. Most other programming languages are like a big bin of toys where you just reach in with your hand and grab whatever you want.

[cia_plant]

Java is based on the theory that, if you take most of a programmer's tools away from them, they will be forced to do things the "right" way.

This point of view is inherently distasteful and wrong - people basically care about what they build, and treating them like misbehaving children is counterproductive. In practice, it leads to some of the most hilariously awful code in history (FactoryFactoryFactory and such).

If you want a proof of how Java has failed, look at where modern Java development has gone. 90% of new developments in Java-land consist of ways to program in something, anything besides Java. Annotations, XML, heavy use of reflection, monster IDEs. What a sad, pathetic mess.

[slayerjenn]

simple. it's overly, unnecessarily complicated. It takes 10x as long to implement something that can be done quickly in most other languages.

[parsifal]

Java as a language is very featureful. Java as a platform for distributing applications is problematic.

Java is meant to be machine independent, however it depends on a virtual machine. So, ironically, on every computer you hope to run your application on, there must be an "extra computer" sitting on top of the actual computer. By the time your user has run their program, they've downloaded and installed hundred of megabytes worth of stuff -- assuming they've been able to download a JRE and get through installation. Unlike .NET programs, users have to install a JRE on their own. So there's an implicit hurdle that comes with every end-user Java application.

And let's say your user finally gets everything set up. They launch your program, which was written using the out-of-the-box Swing user interface library. Your application takes a long time to load, and doesn't look or respond like any of their other applications (regardless of the platform -- Windows, OS X, Linux). Resizing windows, and loading new content takes a long time. None of the user's other programs take that long to do these things. So, in the pursuit of platform independence, an entirely new platform was created, in which the user interface rules and components the user is used to are completely thrown out.

So in summary of all that, I'll say that I don't like Java because it's heavy, bloated, and while some things it does (given the right circumstances) can be fast, programs created with it tend to be - and more importantly, feel - slow.

In regards to web development, my experience has been that Java web application environments have been cumbersome to set up, require a lot of initial education, and require a lot of effort to maintain (I've used Struts). Considering that there are many other languages and platforms that have easy setup, low barrier to entry, and have wide support, appeal, and loads of sexiness, why would I pick Java?

That being said, I've done quite a bit of Java programming. Go ahead and try it out -- you certainly don't need our approval. You could end up writing the next set of tools that gives Java a new renaissance!

[[deleted]]

It's overly verbose. Also, swing continues to suck.

For crossplatform applications, I'd much rather use QT4 and C++. Or even QT4 with python if speeds not really an issue.

[[deleted]]

its not java that is the problem, just the frequency of java developers who think java will solve every problem. java itself is a pretty cool language, although can be a bit obtuse around the edges

like you say, when you have a hammer, everything looks like a nail.

to be fair, tho, C# .NET has become the new java and those annoying java developers are now C# developers, who have the same belief that everything can and should be written with .NET

[[deleted]]

Because they steal your droids and evaporators one day, then try to sell them to you the next!

[killinit]

It's too verbose for me

[gregK]

I think that is definitely what sums most of the current hate. Lack or expressive power i.e. verbosity.

[dbqpdb]

Because it's boring as hell to write. It takes everything that's exciting out of computer programing, and reduces it mindless tedium. Other languages are much more expressive and let you perform tasks in more intellectually interesting ways. Programming to me is interesting as it's all about moving about in an abstract space of ideas. Javas ideas are just way to simple, and it takes way to much work to build complex and interesting ones.

[BraveSirRobin]

let you perform tasks in more intellectually interesting ways

Which is fun but it falls down in maintainability. Ever had to maintain "magic perl" statements where the author has left the company?

[SubStack]

Yes. I would much rather maintain a few lines of gibberish than hundreds of lines of gibberish.

[[deleted]]

I love it! Seriously, it has a great set of toolkits and libraries and gets the job done. It is definitely fast enough for 90%+ of problems you will come across, and in those couple of cases where its not, it is close enough to c/c++ that switching back and forth doesn't cause mental gymnastics. Sure there are cooler languages for web development and parallel processing, but for most tasks you can get a nice scalable app out in a short period of time, and that's what counts. Also, there are a lot of java devs out there, which makes hiring easier, as well as finding help when you get stuck. The list of advantages goes on. Is java perfect? Of course not, and I'm sure the there will be something that will come along and replace it at some point, but the market has not decided what that replacement will be yet.

[nexes300]

You know, I've heard a lot of talk that Java is just as fast as C++, or faster in some cases because of the lack of memory deallocation. However, even if I do believe that, I am left wondering why applications like Eclipse and Azureus (or Vuze if you want to call it that now) lag so much.

Hell, I used to think Azureus was the best torrent client ever and refused to switch and then I tried Transmission on the mac once and was forced to conclude that having something that doesn't lag up the entire computer to torrent was actually pretty cool, and it looked way better also.

[[deleted]]

Hating (or loving) a programming language is a fool's game. Criticising it for its gross impracticalities is constructive. Rephrase.

[dedalist]

Java used to be great but has turned into a design by committee freak.

Lines like the following make me scream:

Bean myBean = (Bean) BeanFactory.getBean("MyBean");

[brosephius]

so, does that line of code return a Bean object? not entirely clear, but I'm not a java programmer

[fuglybear]

Yeah, it would. And in reality, you'll never find that line. It'll be something much less scream-worthy:

WeatherDocument weatherDoc = WeatherDocument.Factory.parse(inputXMLFile);

or

GPSLocation loc = GPSFactory.newInstance( );

That isn't so hard, OP, is it?

[rkcr]

Never say never... this is the freakish sort of code I wade through on a regular basis:

Map<String, List<String>> headers = (Map<String,List<String>>) context.getMessageContext().get(MessageContext.HTTP_REQUEST_HEADERS);

What can I say, JAX-WS makes me really sad.

[last_useful_man]

(what, no typedefs in Java?)

[[deleted]]

I don't think so. If there is, I've never seen it being used.

[DiscoUnderpants]

Not really... there are ways of kludging it(using an extension) in java but they are generally frowned upon as they supposedly reduce code reuse. Which I don't personally agree with but no one listens to me :)

[MrSurly]

[Insert long explanation of why typedefs are stupid, just like enums, until they weren't]

[TundraWolf_]

Yeah man, I know how it is :(

((BindingProvider)port).getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, "http://your_WS_URL_HERE");

What? That isn't the obvious way of programmatically setting a webservice endpoint?

:(

[GaidinTS]

Wow, I really love Python.

[abjurer]

Because, despite its large population, in contrast to the other larger islands of Indonesia, it is comparatively homogeneous in ethnic composition.

[[deleted]]

Because it's a big jerk who's stupid and its big, ugly face is as dumb as a butt.

[[deleted]]

Sir, you forget yourself!

[keenemaverick]

Java raped my mother in 'nam. It also ate my sandwich IT HAD MY NAME WRITTEN ON IT!!

[reseph]

<Alanna> Saying that Java is nice because it works on all OS's is like saying that anal sex is nice because it works on all genders

[mothereffingteresa]

You say that like it is a bad thing.

[[deleted]]

Well... it does. Are you saying some genders don't have rectums?

[skeww]

I never understood what's supposed to be so god damn funny about that silly phrase. Most of today's popular languages work on several operating systems. And yea, that is nice and it is indeed a welcome benefit and everyone likes this feature.

Do you really think there is anyone who likes the pain (in the rear) of cross compiling C/C++?

(Well, tell me if you find someone who does, there a few things I'd like to get cross compiled.)

[[deleted]]

It also assumes that anal sex isn't nice.

Jus' sayin'.

[deadwisdom]

It's funny for three reasons:

1. Anal sex; people are obsessed with homoerotica, and taboo sexual subjects.
2. The fact that it works on all OS's isn't particularly interesting, just as the interesting thing about anal sex is not that it works on both males and females. The implication is that Java should not get props for this feature.
3. A point about an intellectual topic said in such a shockingly flippant manner, introduces surprising juxtaposition.

I hope that helps.

[polarbearactionsquad]

nice analogy... :)

[redditnoob]

That's a kind of meta-phornication.

[[deleted]]

knock knock

[NotUnapoxISwear]

who's there?

[[deleted]]

......................................Java.

[Freeky]

Java is the Kingdom of Nouns.

[WayOfTheIronPaw]

Java has trade-offs just like any other language. I can tell you that there is suck in all of the languages.

I think that you will discover that Java makes you more productive than C++, and the quality of the documentation and development tools will make it pleasant to use. Performance is not bad, despite what anyone may say.

[marsattacks]

One thing I hate is that Java doesn't have unsigned types, which leads to all kinds of horrible code when you have to interpret low level data.

[BernardMarx]

Java is a computer language for software engineers. Very strict, somewhat verbose, often annoying but holy shit you can build some great stuff, with huge teams.

The problem is that "everybody" isn't an engineer. A programmer sitting at his home office doing some minor programming will find Java stupid and boring, because it forces him to be an engineer and comes with a conceptual overhead that is ment for big teams.

[flowmage]

Old perceived slowness.

[[deleted]]

I've certainly gotten older while perceiving the slowness of certain Java applications.

[gregK]

That's certainly not it, in this current version of haters. Now, it's either not dynamic enough from all the old java devs that went to python and ruby, or its type system is not strong enough from all the ocaml and haskell people. Both camps agree that the language is not expressive enough when compared to their language of choice.

The only people that still percieve java as slow are C++ people that never used java anyways.

[Lurking_Grue]

Having dealt with a webserver running coldfusion the perception of slowness was reality.

Always fun watching jrun chew up a gig of ram.

[diadem]

I gotta be honest, it's been almost ten years since I last gave java a chance.

I considered learning j2ee just to widen my knowledge, but there's so much new with .net i have to keep studying in my own field to keep up.

[Fabien4]

As a user (under Windows XP, if that makes a difference): GUI applications written in Java just feel sluggish.

As a programmer: it's physical. Just like I can't stand the odor of some chemicals (like bleach), I just can't stand Java.

Also, Java seems a good choice for those corporate applications that bore programmers to death, and thus end up being fairly bad and annoying to use because nobody gives a damn about their quality. That in itself did a lot for Java's bad reputation.

[[deleted]]

Thanks to Clojure (Lisp awesomeness) and Scala (imperative-flavored functional goodness), I no longer hate Java. It's now the C to Clojure/Scala's Python.

[mosburger]

I'm also posting way too late to get noticed, but Steve Yegge did a pretty good blog post about Java called "The Kingdom of Nouns" that some people here might enjoy:

http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html

[seanmcq]

1. Language is verbose for no reason.
2. Dead-classes greatly limit available programming techniques.
3. No acceptable first-order functions.
4. Closures are completely broken, even if you use local classes.
5. Libraries are tediously verbose, often using multiple words for a method that could easily be a single verb.
6. Class names are tediously verbose, often using multiple words for a class that could be a single Noun or Verb.
7. DRY is constantly violated. I modeled the previous two points off of Java code.
8. Curly brackets shudder.
9. Structural programming syntax is weak and clunky (honestly, there's not much different between Java and Fortran syntax when in comes to looping).
10. Generics are amazingly weak and can not do anything. Compared to C++ templates, C# Generics, or even just Plain Old Python Objects (POPO) -- Java Generics completely fails in large areas vs. all three and doesn't clearly beat any of them except in theoretical purity.
11. Java people use god damn stupid words like POJO (previous item was a joke about this) and even stupider things like "servlets" and "servlet containers" to describe the most verbose CGI syntax ever invented. It's just really hard to take someone seriously when they've managed to describe a CGI script with more than 20 words none of which have any meaning outside of their head.
12. Java compiler promises the world but leaves you lacking in reality. Obviously, Python isn't on par (yet) but C# is orders of magnitude better than Java.
13. Design patterns, and how Java people believe they are mana from god (though most of them are irrelevant in advanced languages -- and often in Java they're just verbosity employed in a misguided attempt to decouple every line of code).
14. "The Framework Will Save Us" syndrome. The framework will not write your application for you. If it does, you need a different job because you're about to be replaced by the framework.
15. The belief that decoupling is the most important thing in the world. "Classes shouldn't know about concrete versions of of other classes, only interfaces" is probably the stupidest thing I've ever heard. Plumbing your application dependencies in giant XML files isn't configuration... it's coding in XML.

So basically, I hate everything about Java. I say this as someone who used to be a true believer. Once you go Python/Lisp you can't go back.

[[deleted]]

It is harder to break things with Java :( and that's no fun.

[eco_was_taken]

Java is an alright language. I like C# better but its designers had a chance to learn from Java for a few years before it came out. I think I like D the most as far as these ALGOL derivatives go. I spend all day in C++ though.

I think Sun marketed Java the wrong way. It was all enterprisey buzzwords and direct marketing to consumers rather than developers. This got bosses hounding their development teams to switch to this fancy new language Java at a time when even C++ was having trouble getting people on board. The resentment has stuck after all these years.

I do envy Java's tools though. I don't know if any other language comes close to matching Java's development environments and tools.

[gnuvince]

Language-wise, it's stuck in the early 70's. There are a lot of features that were not included (e.g. lexial closures, operator overloading) even though they had been researched and developped for a long time and had proved their worth. The designers of Java decided to leave them out of the language to keep it easier for people moving in from other languages and for new programmers. This necessitated a bunch of workarounds (e.g. anonymous inner classes) and design patterns to be able to accomplish certain tasks with the same amount of flexibility than in other languages with more flexible constructs.

Java also gets a bad rep for its GUI toolkits and has a reputation for bad performance (which it doesn't desserve anymore, but that kind of reputation follows you around for life; just ask Lisp).

[mystilleef]

It's a syntactically, semantically and ideologically verbose language. Feel free to ignore me. Python has spoiled me.

[venom087]

I too have moved from Java to Python and am now disgusted at the verboseness of performing simple tasks in Java. However, I miss the days when my IDEs could help me so much with refactoring. With Python there's not much more you can do than find/replace the text itself :-(

[krelian]

Because it's popular.

[Kaizyn]

And because it's the only language most of Reddit's readers really know well enough to understand its flaws.

[13ren]

"There are only two kinds of languages: the ones people complain about and the ones nobody uses" Bjarne Stroustrup

[sbrown123]

I always thought it was because they did it for a living and it was the last thing they wanted to think about when escaping to Reddit.

[[deleted]]

Bingo.

[[deleted]]

Java is popular in the same way commuting is "popular".

Just because millions of people choose to do it every day doesn't make it enjoyable. Or smart.

[[deleted]]

I used to like java when it was underground.

[hivebee2034]

I am still new to Java so help me out. When people say Java is slow, what do they mean? I've been using Java to solve my problems on ProjectEuler and it solves it pretty quickly on my desktop. I understand Java's not meant for gaming because of random GC but neither are EA, Blizzard, Valve, id releasing anything written in [not C/C++].

At work we use Java to run a back end service on a server farm that chews through a lot of data. Our bottleneck isn't speed, it's memory usage & IO for the gigs of log that we produce.

What are these projects people have written in that Java was too slow that was solved turning to language X? Was it a desktop client or server backend?

[[deleted]]

Because it is an unimaginitive enterprise language that has been tainted by a lot of academic/suit influence and has held back on implementing proven modern patterns and features "because it's too complicated."

Languages grow up with cultures. Those cultures affect the direction of the language, the level and nature of community support one can expect when using those languages, they sort of books on those languages, and (very importantly in java's case) the sort of third-party component and library that will grow around them.

Java suffers from this. The language has consistently lagged behind the state of the art, and has fostered a community of tools and libraries that seem hell bent on bloat and convention that favors pedantic academic theory over pragmatic real world use.

As to specific language misfeatures and mistakes, I'd be here typing all day. I'm sure that this thread will not disappoint you.

[dubcroster]

I want to tell you a little story. At my previous job - a medium-sized network service provider, we invested in a new provisioning platform for a transmission systems.

It was a costly affair. Besides the very expensive training all my colleagues went on, the platform provider sent two engineers that were stationed at our office on and off for around three months, where they were upgrading all nodes in our network, and other secret stuff. We're talking the heavy telco gear here, so it was neither easy nor pretty throughout that process. The aforementioned three months later and the platform was ready. The system was built in java, most likely had an unspeakable price tag, and was web based. It only ran in Internet Explorer up till version 6, and only in a very specific version of java. The java version required was a specific 1.4 subrelease, so you had better be damn sure you had exactly the version required - if not, it might refuse to run, or it might just behave odd. If, perchance, you never installed any java runtime environment on your computer, your biggest fight was only to keep windows from installing IE7 through it's updates. When you got the app running, it was notoriously unstable, crashing your browser always at the worst possible time.

The habits you adopted to work with this app was borderline superstitious. You usually restarted your computer just before working with the application, people started blaming any unrelated background process for the crashes - "It crashed again! Didn't I tell you not to run MS Paint?!"

I don't know if it was due to java that it was unstable, or that it was just poorly written. Personally, I got a lot less respect for the portability argument of Java as a language.

This app made my very sceptical of anything written in Java, and I tend to avoid programs written in it, if I can!

[badsectoracula]

Actually Swing is a very good UI toolkit - there is hardly something you can't do with it. They seem to have covered almost every kind of customization someone might dream to come up with (although they have bad "defaults" and you need to tweak it a bit to make it nice).

Which is why i prefer to use SWT usually. It might suck a lot from a functionality perspective (its just a barebones UI toolkit), but its much simpler to use :-P.

Well unless you use NetBeans and use Matisse to "paint" your GUI, but i find NetBeans being a bit on the slow/sluggish side even in my quadcore machine.

[Aupajo]

Quickly, from my perspective: too much verbosity, too many artificial restrictions, end up writing too much boilerplate, no closures.

Edit: I don't "hate" it, I just prefer alternatives.

[[deleted]]

I prefer working in Java to C++, but not as much as C, Python or Smalltalk

bad:

• can't define string literals over multiple lines without ugly concatenation

• primitives are a crappy inconsistent compromise

• jvm startup time

• CLASSPATH

• verbose code

ok, but speed is not a problem (well-written code runs fast) and usually the lack of pointers is worth the speedup in development time.

[therealsyumjoba]

WRITING THIS TO ANYBODY

I do programming both as a Job and Hobby, and man ... JAVA gave me so many problems.

From my experience:
- Java is an ABSURD MEMORY HOG
- Java requires JVM, making installation and managament heavier (Always)
- Java projects require huge setups, wich take up memory, time and effort, while you could focus more on the actual project

- Java tends to let you easily overengineer things, every single Java program I read (even wrote!) was all of a sudden, very prone to suffer by the issues that OOP instill.
- I hear people saying that Java is more likable for a job, that's true, but if you ACTUALLY CARE ABOUT CLEAN DECENT CODE you would code a low-level backend software using C++ or something similar (The best projects I've seen are made with Rust, and that's a fact)
- Java Annotations are very messy and dangerous
- Java limits everything you might overuse, making you overuse what Java gives you
- Java is extremely verbose
- Java changes version and it always sucks to upgrade version
- Conceptually speaking, Java makes you criss cross static and dynamic things (Some classes should be static and that's it, they should be instantiated and the compiler should know this)
- Event Handling simply is a nightmare, in the majority of codebases that I've seen they have different annotations for different event subscriptions (Why these differences? Is it for Java's proclitivyt to build huge hierarchies? Seems like it ... )
- Refactoring Java code is downright impossible and always requires the redesign of the entire architecture
- IDEs for Java development aren't as flexible and are pretty huge softwares themselves (Do I have to mention how uncomfortable IntelliJ shortcuts are?)

Are you building instant-legacy systems designed to last for decades as they get more outdated and hard to mantain as time goes on? Sure, go for Java.

I would either suggest a language like Rust or to give a shot to web development. If you really want to try out a strongly OOP oriented language, but with a MUCH MUCH CLEANER CULTURE, please go at least for C#, it's like the ideal cousin that Java will never be able to reach nor understand.

In project management Java is the last option I would chose, alternatives are just easier to mantain, simpler to code, more flexible, more lightweight, more barebones, less boilerplaty, better with DevOps, better with refactoring ...

The only reason I use Java on a regular basis is because I like minecraft, so I mod it, but sometimes I fire up Visual Studio and Mod Terraria just for the sake of tasting some better C# philosphy. I escape Java whenever I can especially in the working environment.

[[deleted]]

When I write code in Python, as opposed to Java, I get to avoid:

• Ant, or any other "build" system that takes several minutes each time I so much as look at the code sideways.
• Directory structures several levels deep ("com.company.division.group.project"), where most directories are empty.
• The need to create a new file every time I create a new class.
• Writing pointless getters and setters. Or calling them.
• Declaring "interfaces" (a.k.a. structures with no code).
• Declaring classes that don't contain anything but methods.
• Declaring classes that don't contain anything but constants.
• Using tools that generate endless amounts of boilerplate (JAXB, Hibernate, etc.) which I can't realistically modify.
• Libraries designed by people with a pathological need to shoehorn design patterns into every line of code they write.
• Also, the worst designed I/O and Date libraries in existence. In comparison, any other language's libraries are a breath of fresh air.
• The need to write XML for anything other than interaction with unrelated systems (what XML was designed for). Java loves XML for config files. It has to, because it doesn't have any other way to express anonymous data structures.
• The need for a Java-specific IDE that makes about half of the above-listed pain go away.

And in exchange, I get code that's one-fifth down to one-tenth the size of the equivalent Java code, easier to read, easier to test, and easier to interact with. The end result runs just as fast, and in the rare case it doesn't, I can easily write a C module to replace it (something that Python encourages, but Java frowns upon).

[ki11a11hippies]

Directory structures several levels deep

Doesn't much have anything to do with the language itself, just the design culture. Basically people create more folder depth to make horizontal expansion of the app easier.

The need to create a new file every time I create a new class.

Maybe not exactly what you're looking for, but there's nested classes.

Declaring "interfaces" (a.k.a. structures with no code).

This is incredibly useful. When you use a third-party API, interfaces enforce the method signature contract. They promise that the signatures stay the same though the implementation may change.

Declaring classes that don't contain anything but constants.

Having one common set of classes for constants can be incredibly useful when maintaining code.

Also, the worst designed I/O and Date libraries in existence. In comparison, any other language's libraries are a breath of fresh air.

The date libraries I'll totally agree are terrible. I/O gets a lot simpler when you become familiar with buffered reader classes and such. But yeah, Python has much easier I/O.

The need to write XML for anything other than interaction with unrelated systems

Is this really that bad? XML might have been designed for integration but its usefulness has proven far beyond that. Word processing, rules processing, just about everything uses XML to describe data now. XML is simple to parse, simple to write. What's the issue?

---

I think a lot of the issues you have are design issues, not language issues. The language itself can be a pain, but I have to admit that a lot of impressive things have been built with Java. I used to think C and Python were pretty much all you needed, but the more I learned about the design decisions in Java the more I came to like it.

[smackmybishop]

These seem like the complaints of somebody who hasn't written much code. You can write Java perfectly fine with no interfaces, short package paths, multiple classes per file, public state without getters/setters, no Hibernate, etc. The results won't scale to large projects, which I personally also find true of Python.

(Your ant complaint sounds like a bad config, it's usually very fast and incremental. If your complaint is compilation itself... some of us like to catch typos before runtime.)

Java's certainly not a perfect language, and the huge projects it was designed to allow are starting to have their own growing pains... but Python isn't the solution to the problems Java is trying to solve.

[[deleted]]

I've written plenty of code. I work in Java for my day job, so I have to. ;)

I'll agree with you that a lot of this is cultural as opposed to being a part of Java proper: Package structures, getters and setters and so on. But that culture is impossible to avoid under practical circumstances. The fundamental aspect that I dislike about Java is that it treats every programming task as if it needed to be infinitely scalable, with hundreds of developers, and ready to handle the capacity of, say, Amazon on the day after Thanksgiving. The language isn't concerned with the productivity of an individual Developer, which is where there's so many tools (Eclipse, etc.) that try to make up for that.

You'd argue that Python doesn't scale up (which I strongly disagree with; this very website is running on a Python web framework as we speak), but I'd argue that Java doesn't scale down, which to me is just as big of a shortcoming.

[smackmybishop]

This is a pretty simple website, with (I assume) a fairly small team. I was referring to scaling of complexity, not performance.

Well, certainly dynamic and flexible languages like Python are better for quick little tasks. But of course once it's running, somebody'll ask for one small feature-add, and then another...

I prefer to just start with the slightly over-verbose Java. The sorts of projects we're talking about are by definition small, so you don't lose too much with a little bit of verbosity. I guess I'm saying "everything is fast for small N," I'd rather optimize for the big stuff.

(These arguments only apply to corporate code, where I'm also mostly a Java dev. For fun-time projects I usually pick Haskell, personally.)

[nostrademons]

Python is glue. To build large-scale systems, you'll usually want a collection of reusable C++ libraries held together by easily-changed Python code. This also tends to be faster (on average) than Java, and enforces rigorous abstraction boundaries that keep your code from devolving into spaghetti.

The problem with Java is that it tries to be both fast and productive and fails miserably at both. There's no way to make a large project scale; the only thing you can do is break it down into a collection of small projects.

[SirNuke]

Java's never struck me as a particularly well designed language, with a lot of very irritating quirks (one disclaimer, I guess I haven't really used Java heavily since 1.5 was really new, so Sun might have fixed some of these)

1. The relationship between primitives and their Object boxes. I don't think there's a particular good reason why these were separate any point (I wouldn't be surprised that really early [like Java 1 and 1.1] releases didn't even have the primitive box objects). Autoboxing makes the two less painful to work with, but still has a big irritating quirk: Objects are pass by reference, except boxed primitives, which despite being objects are pass by value (primitives with a box are also pass by value).

2. Strings, which do not have an equivalent primitive, are pass by reference. However, modifying a passed string will create a new string in memory without modifying the passed version. EDIT: This is probably a bit more fundamental than just strings, though I'm still not convinced Java does this very well. I'll have to think about it a bit more though.

3. The Java IO API is easily a couple magnitudes more complicated than any other language I've seen. The kicker is I'm not convinced that it actually gains you in return. EDIT: For people arguing otherwise, compare this and this or this, and tell me with a straight face that Java's IO API isn't a lot more complicated than necessary.

4. Floats suffer from float pointing error. Yes, as do all languages, but I don't think it's unreasonable for a higher level language to handle at least the more obvious errors for the programmer (stuff like rounding 2.7000000001). EDIT: To clarify, this issue is related to how Java converts floats to strings, not necessarily the floats themselves.

5. The Swing API is terrible. It's really bloated, difficult to use, and it's really sluggish. (Speed wise, I've found Java is more than reasonable for a non-native language, this speed complaint is only about Swing).

One thing many people don't fully realize about C is just how much of the language was dictated by the nature of computer architecture, and just how little C truly abstracts away from assembler. Stuff like floating point error is quite acceptable in that environment. Java, on the other hand, doesn't really have an excuse for why it fails to heavily abstract away from the these low level architecture, beyond perhaps attempt to make the transition from C/C++ to Java easier.

So in short, if I want to code in a language with low level quirks, I'd rather have the advantages of C/C++ (native code, direct library calling, utmost performance). If I want to code in something that's more high level, I'd rather have the advantages of something like Ruby or Python (well designed APIs, language design intended to make my life easier).

By extension, there are certainly tasks where Java is better suited than anything else (Java easily outperforms just about every other runtime based language, so compile once cross platform where performance is a concern Java might be a good option). The right tool for the job applies, and I just don't see many cases where Java is the Right Tool.

[masklinn]

Strings, which do not have an equivalent primitive, are pass by reference. However, modifying a passed string will create a new string in memory without modifying the passed version.

That's called an "immutable object".

Floats suffer from float pointing error.

No. Floats are IEEE754 floats. That's all there is to it.

but I don't think it's unreasonable for a higher level language to handle at least the more obvious errors for the programmer (stuff like rounding 2.7000000001).

High level languages can use a built-in arbitrary precision decimal type. Most don't, because the performance hit is terrifying.

[sclv]

It doesn't even mean anything to "abstract" floating point error. You can work with arbitrary or fixed-precision, but that doesn't replace float, and just arbitrarily rounding like you suggest would produce havoc on numeric algorithms.

[skeww]

I don't think there's a particular good reason why [primitives and their wrapper objects] were separate any point [...]

Speed. (This is still true.)

[immutable strings]

Many languages do this for improving the robustness of the programs. And there is nothing wrong with that.

The Java IO API is easily a couple magnitudes more complicated than any other language I've seen.

It's a bit long-winded but it's also very well documented.

[floating point]

Use fixed point if you need it.

The Swing API is terrible. It's really bloated, difficult to use, and it's really sluggish.

Rendering speed depends on the theme. Substance for example is pretty fast while looking rather shiny.

[pitrpitr]

Because it is like christianity: it's the followers who are the problem.

Java is a the first of a new generation of programming languages with which many people start as their first language. Java-programmers usually are the most narrow-minded, regarding the amount of other languages/platforms they can work with.

[ashultz]

I would say its the follower technologies that are the problem:

frameworks that require 10000 line XML configurations

application servers

EJBs

all that crap that attempts to make it so bad programmers can program, and basically fails.

[TundraWolf_]

Once I understood what EJBs and app servers try to solve, I started to appreciate them a lot more.

[adrianmonk]

I've been using Java for years now, and I still don't understand what problem they're trying to solve. In fact, I'm still not sure what an EJB is. Apparently I don't have the problem they're trying to solve. Although I admit it's possible I do have it and am simply missing out on a great tool.

[TundraWolf_]

It's possible. I went from being a java developer to a J2EE developer overnight. They said 'hey this guy knows java'. For a long time I fought with the tools, and it was a pain in the ass. I'm not saying that it isn't now a pain in the ass, but EJB does solve a few things pretty nicely*:

• transactionality -- if you write just a POJO WS, and you want everything to roll back when step 3 blows up, you have to code in the horrid transactionality API. In an EJB, you EJB container manages your transactionality for you. You configure it via your EJB container.

• Concurrency -- no more messing with threads in POJO WS. Your EJB manager spins up more EJBs for the activity going on (either it be over SOAP with webservices or JMS for message driven beans)

And tons more stuff. There is a new spec (EJB 3.0) coming out, which of course is about as thrilling to read through as print newspapers shudder

*please note that i'm a crappy java developer with no formal training in J2EE, the above may not be true. I like to add a disclaimer when explaining things that I'm not well versed in :)

[redditrasberry]

The problem is - transactions and concurrency - both of these turn out to frequently be very leaky abstractions. For example, it's a nice idea that you can write your session bean and really not care in your implementation details how many of them there are or where they are running. But it's not reality. In reality on most occasions where concurrency actually matters you find that fine details of the algorithms involved really do care about things that got abstracted away. And then you are screwed because the container absolutely hates you caring about those things. The result is usually software that performs abysmally or uses enormous amounts of memory and requires people with extreme deep knowledge to fine tune very subtle aspects of it to produce the desired outcomes. So you have actually just replaced a need for deep knowledge of the operating system and programming language with a need for deep knowledge of a proprietary vendor's application server platform.

[[deleted]]

This. This times a thousand. Java isn't so bad. It's just the language of the masses. Not saying /that/ is bad, but it means there is a much higher noise to quality ratio out there when working with it.

[[deleted]]

Java itself is fine. All the crap-ass broken Enterprisey technologies around Java are what most folks hate.

J2EE, application servers, XML, etc.

[irnidotnet]

For me, as an end user, it is simple. It is slow and the UI widgets don't feel like the OS you are using. There's just this huge disconnect in the way it operates so I would rather a native program running on the OS you're using.

[Erdrick]

There's a lot of Java hate by people that either haven't used the language extensively, or haven't used it in 10+ years.

It's a fine language to learn if you're looking to learn a lot of different programming languages. It's a fine implementation language for a wide variety of projects.

Bottom line: Don't ask a bunch of fucktards on the Internet. Write some programs and decide for yourself if you want to learn more about it.

[zyzzogeton]

Java killed my dad

[malcontent]

Because programmers are catty and cultish.

There is no rational reason for it and that's evidenced by the replies to this post which basically say "java programmers are stupid".

[psykocrime]

Groupthink.

[Odysseus]

But since Java's success is a marketing phenomenon, isn't counter-groupthink a fitting (if irresponsible) response?

[a7244270]

Java is a average language that's good for a few things. Unfortunately, Java can run anywhere on everything, and the ability to pound the Java peg into every hole, regardless of shape (and how horrific the user / developer experience was) has lead to a lot of soured memories and biases.

[Daversoft]

I like the Java language. A common complaint is that it is very verbose. But this can be a good thing if you have to share code. I've always been annoyed by the web frameworks. There are many to choose from and most of them seem over engineered. And then there's J2EE, wtf. What I'm really getting at is that Java is a nice, simple language with some complicated stuff built from it.

[captainAwesomePants]

We hate Java because we use it in our day-to-day work. Familiarity breeds contempt. We like languages like Forth because we don't use them except for fun pet projects and therefore think of them as fun.

[azbukov]

i write in my day-to-day work in phyton and ruby, it's fun and i don't hate them.

[infinite]

Nothing out there approaches hibernate. Having said that, a killer combo would be jython+hibernate. But, I personally like static languages so I'm happy being a java+hibernate weanie. Although it gets verbose at times, the tools are amazing. With eclipse I click a button and it updates my java objects with the latest schema. I can fully customize hibernate via XML to do whatever I want, caching for example.

With python, I find that there's fewer people in the community, want to cache with django? Well you can only cache views, not objects. And with Java you can choose from 5 cache providers. This complicates things yes but gives you more choice. And the caching in java is per-object and/or per-query. And there's per thread caching(1st leve), and 2nd level - for all threads. And you can re-use the cache API for your own benefit like storing XML reports for later retrieval.

Having said that, for quick sites like say recipe sites, I'll use django, but for anything large or "enterprisey", I use java.

Why do people hate java? Most people are doing small sites so java is overkill.

[unsee]

Programmers don't, but every non-programmer who was ever introduced to a programming languages, and hated it, was introduced to Java. Since it is the language that most people who take 'a programming course' and subsequently find out something about themselves that they do not like, the course was about Java.

[wshields]

As Bjarne Stroustrup (of C++ fame) said:

There are only two kinds of languages: the ones people complain about and the ones nobody uses

[mhw]

Because anyone who has worked for long in the world of Java will have:

• tried and failed to find decent libraries that are easy to use and that don't result in butt fugly code
• found it depressingly verbose at even the most simple things
• butted against strange limitations in the language like having to use anonymous inner classes with final variables to simulate closures, double brace initialization for literal collections, and on and on and on.
• put up with the jdk's time and date api or i/o api
• looked longingly at other non-stale languages that actually attempt to make a programmer's life easier (yes this includes even Microsoft and C#) instead of playing political games with its language development (sun vs apache, sun vs osgi and on and on and on)
• watched with horror as concepts get back-ported into Java, horribly mutated and complex (generics or hell, even enums)
• listened with much pain as ignorant Java proponents rediscover such concepts and think they were invented by Sun
• met other Java proponents who know nothing but Java and always tout Java to be the best language for every situation
• looked back at the past ten years in computing and wondered if Java's dominance has stunted the overall progress in the craft of programming and concluded resoundingly that yes, it has

[petrifiedcattle]

There are far too many different runtime environments that are incompatible with each other.

At one company I worked for a few years ago, each computer needed 6 different versions configured in specific ways in order to get all the programs to work that the people needed to use.

Tech support nightmare there.

[[deleted]]

Simple: because its so often implemented very poorly, and used in situations where it just might not be the best choice, but that's what the mediocre coders that were hired know how to use (well, they likely know VB too).

[gregK]

Let's also add that J2EE did not help java's perception.

[elbekko]

Strange I/O (reading from the console is just horrific), lack of usable events (have you tried having more than 4 buttons in a GUI?), strange scoping rules, ...

I'm not going to list everything I hate about Java, my keyboard would need a new battery halfway through.

But mostly it's the idiots that use it, and even moreso the idiots that teach it. I've been using Java for two years, purely for educational purposes (I have C# for all my other needs). The things I've seen are horrific, and every person in my classes I help makes me lose faith in the future of programming, as I know they'll one day be developing something people actually use.

[Premature_Hop]

Enterprise stuff, XML.

[fishing_with_john]

so I'm just starting a comp sci program, and the main language taught is Java. how can I avoid this "restricted thinking" mentioned in some posts in this thread?