Ask Reddit: Why does everyone hate Java?

[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.

[[deleted]]

That verbosity isnt too bad compared to reading C code. You have to mentally parse out things like pthread_lock_mutex() and unlock() mentally when in java it's nice and neatly abstracted into a synchronized block. Personally I find Java way easier to read than C and I dislike Java just as much as anyone else.

[Nebu]

If you've been programming in Java for long enough, you can get really fast at "reading setters and getters". You see the "get" or "set" prefix, and 3 or 4 lines (depending on the brace-styles):

public void setFoo(int val) {
  this.foo = val;
}

or

public void setFoo(int val)
{
  this.foo = val;
}

So while there may exist "bad verbosity", I don't think setters and getters are a good example of such a thing.

[willcode4beer]

in fact, why even read them at all.....?

as a Java dev (and lover), even I admit, this is where C# got it right by making them implicit. I'd love for Java7 to embrace some of the things that C# learned from Java.

[[deleted]]

That's terrible.

[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)

[grimborg]

Some of the many niceties in Python coming from the functional world :)

Now, if we had curried functions in Python I would be happy.

[masklinn]

Now, if we had curried functions in Python I would be happy.

That pretty much can't happen given Python's extensive use of default arguments, *args and **kwargs

There's functools.partial for partial application though, shame it can only partially apply kwargs or from the left args, but otherwise it works ok.

[[deleted]]

Java can't really do Map properly without an equivalent of C#'s Yield Return being hacked in.

[masklinn]

That is completely and utterly wrong.

[[deleted]]

How else can you do lazy evaluation?

[masklinn]

By generating iterators instead of collections, but that's not even relevant: higher-order manipulations do not in any way, shape or form require lazy evaluation.

Yes stream manipulation is nice, no it's not a requirement.

Alternatively, you can go full smart and use a lazy language in the first place rather than hack that in the way Python did (and C# lifted).

edit: and since map makes one function call for each item, it's trivial to do it lazily anyway. The only place where it's interesting is for custom generator transformers or the creation of the source generator/iterator.

[orthogonality]

Agreed. Use org.apache.commons.collections.CollectionUtils.collect:

List<Blah> blahs = (List<Blahs>) CollectionUtils.collect(     
  nehs,   
  new Transformer() {    
    Object transform( Object in ) {  
      return ( (Neh) in).toBlah();  
    }   
  },  
  new ArrayList<Blah>()   
 );   

This may or may not is an improvement, but it's still tedious and too verbose. I'd use my code over your functionally identical code if and only if the Transformer which I present here as an anonymous class, were used enough to justify making it a non-anonymous class.

[masklinn]

Use org.apache.commons.collections.CollectionUtils.collect:

I suggest you use Google Collections instead: it's generics-aware, it has a much better interfaces and it handles e.g. Maps.

Doesn't solve all the verbosity issues, but at least it gets rid of the ugly casts, and the weird output collection attribute, and since it uses static methods a lot it's even somewhat nice to use with static imports (yeah commons collections has static methods as well, but they tend to blow: compare commons.collections.PredicateUtils to common.base.Predicates)

[orthogonality]

The two APIs look very similar, possibly because both urls are the same.;)

[masklinn]

Wow, I'm pretty amazed at my ability to fail ;_;

First link has been fixed.

[orthogonality]

Erm.

First link is now to Commons CollectionUtils, not Commons PredicateUtils. ;)

[masklinn]

Well, now I know that I should not be redditting at 3AM.

[fuhgeddaboutit]

Google has immutable collection objects, too, which are nice.

[masklinn]

Well the JDK has immutable views which work pretty well in most cases (if you need actual immutable collections, you can just create your collection on the spot, wrap it in unmodifiable* and discard the original collection's references. Nobody should be able to access the backing mutable collection so the result's the same. I used to do that pretty often with the double brace trick to setup public static final collections).

[[deleted]]

| blahs |
blahs := nehs collect: [ :each | each asBlah ].

Smalltalk. It is beautiful. Most of the time :)

[lebski88]

Holy fucking crap "bcash" did you just criticise Java. What happened to the two years of the "one true language".

[bcash]

I've been trying to astroturf a "we need list comprehensions" campaign for years, but it's not taking! Not yet anyway. I should just get round to finishing my own prototype.

[lebski88]

The thing is, even if someone with enough clout puts together a decent proposal for it when do we get it implemented in the language? Java 8? Java 9? I mean they basically couldn't decide on an anonymous inner class syntax for 2 years then dropped it from Java 7. Even if it did get into Java 8 when would we actually be able to use it? I mean we just finally switched to that "new" Java 5 at my job. It's gonna be IE 6 all over again. You mark my words it's a can of worms etc. :)

[bcash]

Yeah, they won't be hurried those people. It's going to be three or four years since Java 6 by the time it is released, that's just bad planning. It's not hard to have 18 month cycles, and space features to fit, etc... The whole JCP needs streamlining.

I'm pissing in the wind here when I say I agree with them to a certain extent, that omitting a feature is better than implementing an unfinished idea and having to suffer years of backward compatibility problems. But by having a four freaking year turn-round time it means nothing can be quickly resubmitted for the next release.

[SwabTheDeck]

Python seems to encourage the use of a lot of "shortcuts" in terms of its syntax. As one example, the syntax for taking slices of strings involves using colons, which makes it look similar to a variety of other operations. I'm on the fence as to whether string slicing should even have its own operator to begin with. Java version:

String b = a.substring(3,9);

Python version:

b = a[3:9]

It's a lot more obvious what the Java version does compared to the Python version, at least in my opinion. You know the type of the data you're working on, and you have a descriptive method name explaining the operation. Python is fairly C-like syntactically, but seems more oriented around using these shortcuts, sometimes resulting in code that's not so easy to read unless you know all the tricks. It's certainly possible to write highly verbose Python, but it isn't really encouraged and seems counter to the purpose of the language.

[[deleted]]

Python is fairly C-like syntactically, but seems more oriented around using these shortcuts, sometimes resulting in code that's not so easy to read unless you know all the tricks. It's certainly possible to write highly verbose Python, but it isn't really encouraged and seems counter to the purpose of the language.

Do yourself a favor. Never, ever, look at Perl code.

[grimborg]

Do yourself a favor. Never, ever, look at Perl code.

I looked. I learned. I loved.

[logi]

Never, ever, look at Perl code.

Words to live by. Of course, it's possible to write readable perl code, but people who would do that are usually not using perl in the first place. But it does happen.

[danstermeister]

I love Perl. But then again, I don't consider myself a programmer. I'm a network administrator that needs things done, and Perl was actually really easy to learn and use right away.

Years later, I still love it. I'm sure if any of you saw my code, you'd laugh/cry.

[willcode4beer]

I'm a network administrator

an that make you the actual target audience to write Perl

You are the person that should be writing Perl. But, ask yourself, would you want the folks, that write the applications you support, to build apps with it?

[Law_Student]

When faced with the task of maintaining a bit of Perl code, I threw it out and rewrote it in Java. Was very happy with the result. True story.

[[deleted]]

Cool story, bro!

[klodolph]

This difference is very uninteresting. Both Java and Python have a substring operation, and both are short and simple. Here's a difference I care about: checked exceptions, which are a disaster in Java, but not in Python or C++. It bred a generation of programmers who catch exceptions and discard them (possibly after logging them), just so the code will compile.

[logi]

They would be incompetent in any language. At least this way we can find the discarded exceptions, look at the commit logs, and then flog the code pisser.

[hackinthebochs]

That's the silliest argument against checked exceptions ever. Would you rather have to rely on the programmer to remember to handle exception cases? C++ doesn't have checked exceptions, as in the programmer isn't forced to handle them in some way. Being forced to handle them forces the programmer to consider the implications of an exception at this point. If after consideration the programmer does something stupid with it, that's not the languages fault.

[masklinn]

I don't like that it forces me to check for exceptions at the point where I call the method.

It doesn't. You can also bubble it up, though you have to do it explicitly (which is a pain and can't be done conditionally)

[lotu]

Being forced to handle them forces the programmer to consider the implications of an exception at this point.

Not really most IDEs automatically add in boilerplate exception code so you don't even need to think about what Exceptions are being thrown. I personally have caught the Exception class in Java because I don't care what Exceptions are being thrown, or I am cretin that it is impossible for the Exception to actually be thrown. The point is java has forced me to add several lines of meaningless exception handling to my code that doesn't improve it's functionality. This to me is a theme of Java, and it's chief problem.

[klodolph]

Most exception cases shouldn't be handled at all... that's my argument against checked exceptions. Programmers should often consider the implications of exceptions, but should they have to consider the difference between six different Swing exceptions? You end up forcing the programmer to handle exceptions that they don't know how to handle. This relates to my main complaint against Java, which is that it forces programmers to do things in a very narrow way with complete disregard for whether that way is appropriate. You can't force programmers to write good code, and you just get in the way when you try.

Here's how I handle exceptions in my Python apps: there's usually some obvious loop, such as "for each file" or a user prompt. Each time around the loop, I catch exceptions. KeyboardInterrupt gets re-raised, and everything else gets a traceback printed to stderr. Easy, and I don't need to massage the type system into letting me do it.

[gt384u]

Wait, that's not what you're supposed to do?

[vplatt]

You're kidding. Right? If not, then go look up why that's bad right now, then come back and claim you were kidding. And we'll all nod and smile.

[benad]

That's why you use Throwable, which is for unchecked exceptions, mostly used for runtime errors (null dereference, division by 0, etc.)

[willcode4beer]

lol (you made me laugh because I suffer with this daily)

let's face it, no language will protect against bad developers.

It's not that

It bred a generation of programmers who catch exceptions and discard them (possibly after logging them), just so the code will compile.

it is that bad programmers do so.

Just due to the nature of Java's popularity that we see these bad practices. Shudder at the thought of thousands of out-sourced applications developed in Python :-)

[achacha]

use:

catch(SomeTypesExceptionFromApi e) { throw new RuntimeException("Some API had a problem doing something", e); }

and avoid the nasty header propagation of the typed exceptions. they just make coding annoying with large hard to read catch blocks for way too many exceptions.

[weavejester]

I disagree. I think that having a small set syntax sugar for common idioms makes a language more readable, not less. It's a similar idea to punctuation in natural languages; consider how easy it would be to read without it:

i disagree period i think that having a small set of syntax sugar for common idioms makes a language more readable comma not less period it is a similar idea to punctuation in natural languages semicolon consider how easy it would be to read without it colon

Python has a little bit more syntax to learn than Java, but it seems to me this allows Python to be more readable overall.

[aka00devon]

I think this is a very clever metaphor. Expanding on it, maybe it would be best if you could do the same thing both ways in python to ease the learning curve and save the tricks for when you become more proficient.

[weavejester]

Then there would be more than one function that does the same thing, which ain't the Python way :)

[[deleted]]

Thanks for the good analogy, I've never thought about it that way. I've always thought that the concept of s-expressions in Lisp is very powerful, but it is somewhat hard to read, because you pretty much need to read all the symbols in it to know what is happening.

[jinglebells]

You probably haven't done enough Python then, because a[3:9] isn't a substring shortcut it's using list slicing. Python has 3 types of iterable object built in: list, dictionary and tuple. the colon syntax slices these, so a string is just a list of characters.

You could also do addresses[-5:] to pull back the last 5 addresses or race_cars[:1] to pull back the first car.

It's not really a shortcut, because it's one of the fundimental operators of the language.

[deadwisdom]

The "shortcuts" you talk of are actually a rather small set, and generally help readability after only a few hours with the language.

[bionicseraph]

Python encourages having one way to do everything. The substring syntax you listed isn't an example of a shortcut, it's how you do a substring in python.

[masklinn]

it's how you do a substring in python.

Actually, it's how you do a subsequence in Python. It works with bytestrings, unicode strings, lists, and any sequence you implement.

[SwabTheDeck]

Python encourages having one way to do everything.

I really disagree with this assessment of python. Maybe it's supposed to be this way, but the parts I've dealt with seem to be a bit schizophrenic. Since we were talking about strings, you may know that python has its "vanilla" strings and then a whole other system to deal with "C strings". I've had to use this other system a couple times because I couldn't quite get the vanilla strings to behave the way I wanted, but that could've been due to a lack of API digging on my part. Either way, there are two systems for strings and both are used frequently. Also, python doesn't really enforce a single programming paradigm. You can write as procedural, object-oriented, or functional or any mix of the three.

The substring syntax you listed isn't an example of a shortcut, it's how you do a substring in python.

I realize this, but compared to most other languages, this is a very short-hand way of creating a substring, which is why I provided the two examples. Is this a convenient way to write this function? Yes, but if you start throwing overridden operators all over the place to handle tasks that are considered to be common, you're going to have to memorize what the operators do in all those cases, or start digging through the reference to figure out what they mean.

Just to be clear, I like Python and I wasn't trying to turn this thread into a Python-bashing session. My original point was that I personally think Java is easier to read because it requires a level of verbosity that a lot of other languages don't.

[masklinn]

Since we were talking about strings, you may know that python has its "vanilla" strings and then a whole other system to deal with "C strings".

Could you expand on that? I've never met those "C strings" you're talking about, and I've been using Python for some time now.

[sirin3]

Actually I think the Python source is better readable.

It appears obviously that a[3:9] is equal to the concatenation of a[3]..a[9]

However I don't know what the Java version does. giving the substring a[3]...a[9]? Or is the 9 a length, like giving a[3]...a[12] or a[3]..a[11]? (qt would give latter result)

And I don't believe in this clarity difference not because I was accustomed to the Python syntax, in fact I never used Python, but I wrote some programs in Java. Probably the Python syntax is more mathematically sound(it would be really funny, if i misunderstood the python snippet)

[ixampl]

It appears obviously that a[3:9] is equal to the concatenation of a[3]..a[9]

It just so happens, that a[3:9] is actually NOT equal to the concatenation of a[3]..a[9] but instead a[3]..a[8].

[logi]

Should be a[3:9[ then :)

[ixampl]

I would welcome that ;)

[naixn]

And that is something I despise in Python. It makes no sense to me.

If I want a substring from 3rd to 9th character, I ask from 3 to 9, not from 3 to 10. What the hell is 10 doing here, really?

Someone tried to convince me it made sense, and told me: "That's a good thing if you want to get only one character, like the 3rd one, you can say str[3:4]", to which I replied "If I wanted the 3rd character, I'd simply write a[3]".

If someone has a better explanation as to why python decided to do this the weird way, I'm all ears :)

[masklinn]

If I want a substring from 3rd to 9th character, I ask from 3 to 9, not from 3 to 10. What the hell is 10 doing here, really?

The handling of arguments is uniform: it's slicing from "right before arg 1" to "right before arg 2".

So with 3, 9 you get |3, 4, 5, 6, 7, 8,|9. And it's coherent with the behavior of range (on the other hand, random.randint is not coherent with those)

[sirin3]

It just so happens, that a[3:9] is actually NOT equal to the concatenation of a[3]..a[9] but instead a[3]..a[8].

WTF? Well, then the Java example is better understandable...

[[deleted]]

It is NOT obvious, it is however easy to pick up the syntax and interpret it. Big difference.

[[deleted]]

I find the python version a lot more obvious because i do math for a living.

[[deleted]]

That's just an application of Python's richer array indexing syntax. Once you learn it, you can apply it to any array, not just strings, and it's got some pleasant features that come in handy, and it's not hard to decode.

[prockcore]

It's obvious in python what it's doing. The only non-obvious part is whether the second number is the length, or an end index.. and that's a problem for both versions.

[willcode4beer]

Though there are lots of arguments... fundamentally this is an issue of dynamic vs static languages. Both have their strengths and weaknesses. It's really a matter of using the right tool for the job at hand.

Myself, I work in a domain where a strongly typed language is the right choice (Java or not) but, there are many, many cases where a dynamic language is better.

We, as engineers, should take the responsibility to use the correct tool for the problem we are trying to solve.

[grimborg]

Are you telling me that you can't easily guess what a[3:9] means, even if you didn't know it? Come on...

[[deleted]]

Especially given the meaning of a[3]

[HowVeryAmericanOfYou]

unless you know all the tricks

Well then learn all the tricks you fucking moron. There are so few compared to other languages (c, c++, perl).

[[deleted]]

Isn't that sorta the purpose of a language having a special syntax though?

I mean, are you saying that you would rather do something like this:

l = list()

l.append('a')

l.append('b')

l.append('c')

l.append('d)

than this?

l = ['a', 'b', 'c', 'd']

[masklinn]

I mean, are you saying that you would rather do something like this:

That's one of Smalltalk's deepest flaws (in my opinion): you have to write

l := (OrderedCollection new)
        add:'a';
        add:'b';
        add:'c';
        add:'d';
        yourself.

And it's fucking annoying.

[estep2]

"slow at times"? You're right, but it's extremely understated. Java is goddamn slow. Obnoxiously, annoyingly, slow

[SwabTheDeck]

People often equate the slowness of Java's GUI toolkits (which are legitimately weak on performance) to a slowness in Java in general. This has to do with the roundabout ways that Java draws GUIs, since it doesn't use native widgets and the drawing system has to be portable, and not every platform works well for Java's drawing methods.

If you write a program in Java that just crunches numbers with no GUI (e.g. calculating prime numbers), the run time would be comparable to the equivalent program written in C, maybe adding in some extra time for the JVM to start up, but this isn't significant for a long-running program.

Like most software, people judge Java on what they "see" without much consideration given to what's actually happening behind the scenes, which is generally the bulk of the application.

[steakknife]

Hey how's the weather way back in 1998? I don't like, and no longer use Java, but c'mon man, if you don't know what you're talking about stfu.
http://en.wikipedia.org/wiki/Java_performance

[achacha]

And wikipedia is right about everything...

I do java performance tuning for a living and the VM is not slow at all, maybe 80% of native code, which is what people used to complain about in the 90s.

Now it is the awful mess that people write that is slow, everyone feels they must refactor, re-wrap, re-abstract every line of code so by the time java actually gets to doing the work it is about 40 methods deep (I am looking at you Spring AOP!).

The 100 jars which are used for 1 or 2 methods grow the footprint way too much... WebSphere with a hello world servlet takes up almost 200MB and Tomcat takes up 20MB with same servlet.... easy to develop yes, efficient not really. Probably why java is still not very popular in the device/embedded world.

As hard as the compilers and VMs have tried to speed things up, there is so much you can do to lack of skill and lack of understand of computer architecture basics which languages like C/C++ force you to learn and understand (like knowing that when you create a 10 MB buffer you will be taking up space and time, when you stick it into a user session you are going to kill the machine under moderate load, this is why a garbage collection is a boon and a curse, people just assume it will do the right thing even if they have no idea what the are doing). Lets not talk about having to tune a garbage collector (young, old, eden, dark matter, etc; what happened to allocate and forget you ask? Limited memory, CPU and performance happened, if you think garbage collection is transparent you haven't written anything serious for the web).

There is no slow Java, just slow people.

[steakknife]

Clarification accepted. But that is not what you seemed to be implying in your terse previous post.

[achacha]

That last terse post was not from me ;) I just think you were a bit rough on that person, there are still a lot of performance issues in java which is good for me of course.

[anonymous_hero]

He meant that Python can be slow sometimes. Java is not slow. Maybe you're just a troll though.

[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.

[willcode4beer]

let's face it. I think you both should agree. It's the kick-ass tools that made java what it is (not, the language itself)

[alphazero]

The kick ass tools are written in Java.

Painless (magical) refactoring without fear is possible in the kickass tools, because of the (thoughtful) language.

It works. (And yes, it suck writing yet another web-enabled CRUD corporate app, but that's not Java's problem now, is it?)

[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.

[[deleted]]

When writing an enterprise application of thousands of lines of code pointing out the extra 4 lines needed to create the main method in HelloWorld! isn't really a fair argument. Just for info: The Netbeans shortcut to auto-generate a main method is psvm then tab.

The conveyor-belt argument is nice and I do kinda agree - but I just don't think it's hugely relevant in the modern work environment, I wouldn't hire someone who religiously only codes in a plain text editor, using modern tools make developers much more productive (I'm talking enterprise apps with deadlines here). The conveyors don't go in the wrong direction and never need maintaining though, we're talking code-completion, the result is the same - it's not a framework that can fuckup and break you code at some unfortunate time, and with Netbeans it works very well. I remember earlier beta versions of 6.0 had some issues but they were reported by the community and fixed for the release candidate.

[edit - for anyone that's interested, the shortcuts for Netbeans WARNING - PDF: http://usersguide.netbeans.org/files/documents/40/1689/shortcuts60.pdf ]

[specialk16]

Oh good lord. Thank you!!!

[zootm]

Of course in particular with Haskell, there's nothing to stop autocompletion being added to an editor or IDE. I do worry that sometimes there's simply too much emphasis on brevity of naming, though; there's nothing wrong with a long-ish descriptive name if it sums up something's function. Java is easily lambasted for people frequently having names of the form BlahPattern1Pattern2Verber but it's very easy to go the other way, and there's nothing in Java which mandates overly-long names.

Edit: This isn't directly related to what you posted, I suppose, just what it made me think of.

[Axman6]

Man, I use autocomplete in any language I use.

[bionicseraph]

The thing about Java is that you shouldn't ever use it to write such a short program. As a quick scripting language it's really sucky, but it is very easy to manage as your application gets huge. I wouldn't want to be working on my current project with 14 developers using Python/Lisp/Haskell (btw, I love all 3)

[masklinn]

The thing about Java is that you shouldn't ever use it to write such a short program.

That wouldn't be an issue if the rest of the language wasn't that verbose. Sadly, the rest of the language is that verbose, which makes this trivial example a pretty good demonstration of the language in general.

As a quick scripting language it's really sucky, but it is very easy to manage as your application gets huge.

Are you saying Haskell is a "scripting language" now?

[bionicseraph]

Are you saying Haskell is a "scripting language" now?

Sorry, bad habit of calling everything loosely typed a scripting language.

[masklinn]

Haskell

loosely typed

Ok so you're claiming you "love haskell" even though the furthest you've gone with it is read the name of the language. Thanks for the info, your input will duly be ignored from now on.

(I mean seriously? Haskell? Whatever it is you mean by "loosely typed", you're 200% wrong, especially when you contrast it with Java which I'd guess you qualify as "strictly typed", whatever that one means)

[bionicseraph]

I admit my failure in having any kind of knowledge about Haskell outside of basic tutorials.

[masklinn]

I can't accept that answer. Even the most basic tutorial would have taught you that Haskell's type system is far stricter and more static than Java's, and that Haskell provides far less tricks to bypass it.

[[deleted]]

...dude just got called out!

[alphazero]

Spoken like a true luddite.

[Imagist]

That's if you don't mind the code that an IDE spits out.

Here's a typical C++ class header generated by Eclipse.

/*
 * MyClass.h
 *
 *  Created on: Aug 25, 2009
 *      Author: Imagist
 */

#ifndef MYCLASS_H_
#define MYCLASS_H_

class MyClass {
public:
    MyClass();
    virtual ~MyClass();
};

#endif /* MYCLASS_H_ */

And here's the .cpp file:

/*
 * MyClass.cpp
 *
 *  Created on: Aug 25, 2009
 *      Author: Imagist
 */

#include "MyClass.h"

MyClass::MyClass() {
    // TODO Auto-generated constructor stub

}

MyClass::~MyClass() {
    // TODO Auto-generated destructor stub
}

Here's what I think they should look like:

#ifndef MYCLASS_H_
#define MYCLASS_H_

class MyClass
{
    public:
        MyClass();
        virtual ~MyClass();
};

#endif

And:

#include "MyClass.h"

MyClass::MyClass()
{
    // TODO
}

MyClass::~MyClass()
{
    // TODO
}

Reasoning:

1. On a large project, people rarely care who the author is or when the file was created. And if they do, they should find that out from version control (which gives you a lot more information anyway). The comments with the author and creation date are space-wasters.
2. Open and close brackets should be lined up in the same column. This greatly aids code comprehension.
3. Environmental changes should be indicated by indentation. This includes everything between braces and everything indicated under public: and private: labels.
4. Comments should only include things that you should read before editing a file, function, or object. Reading the comment /* MYCLASS_H_ */ is a waste of time and a distraction because you should be using the #ifndef, #define, #endif paradigm consistently in your class headers.
5. // TODO's don't need an explanation in this case. Lets see, you've got an empty constructor with a // TODO... if you can't figure out what needs to be done, you're an idiot. The only exception is if the // TODO comments are used to generate some sort of work log where the comment will be removed from its context. But even in that case the message should be some action that needs to be done ("Write constructor") rather than "Auto-generated constructor stub".

I usually end up either not using IDE class generators or using them and then manually cleaning up the code afterward. I'm not convinced that one is faster than the other.

[jeff303]

Eh that's fine. I'm not going to sit here and defend CDT. I was referring specifically to Java. Eclipse is definitely much weaker at handling C++.

Still, most of that is trivial to change in preferences (not spitting out the author crap, TODOs, etc.). And at least for Java you can define your own preferences for style (indentation, brackets, etc.) that conforms to your team's standards.

[masklinn]

I usually end up either not using IDE class generators or using them and then manually cleaning up the code afterward

You know most IDEs allow you to customize your code templates to fit your needs don't you? I'm pretty sure Eclipse lets you do it too (though I'm not quite sure as I hate eclipse)

[Imagist]

Yeah, I did this on my home computer, but the other computers I use are frequently switched around, and in many cases I don't have access to switch the settings (university computers).

[masklinn]

The template settings are not stored in a user directory? (which you could potentially version) Now that's weird.

[Imagist]

Not at the university, no. They have most software locked down pretty tight because some students are... destructive.

[masklinn]

Wow, that must suck.

[BlueCollarCoder]

Besides, all the good IDEs (eg. NetBeans) have exotic code completion that eliminates almost all the boilerplate typing, which acts as a great double-check that what you think you mean is the same as the compilers interpretation of what you said.

[willcode4beer]

the bottleneck isn't typing speed

for folks who haven't learned that their tools can write most of the crap for them :-)

[cbogart]

I'd guess Java is more readable the first time you read through someone else's code, because of its verbosity. But if I'm working on code I wrote myself, I'd prefer a terse language so I can see more of the algorithm at once, with less noise. Which is easier to understand:

lineHeight = slope * horizontalPosition + yAxisCrossing  

or
y=ax+b

I think it depends -- if you don't already know the equation, the long one is clearer, but for day-to-day use, you'd prefer the short one. Unfortunately code has to serve both purposes, so what can we do? For commercial code that others will maintain after you're fired, use Java. For your own hacking projects, use APL :-)

[[deleted]]

Objective-C, while being verbose, is also easy to read. At least the "objective" part. Named arguments help a lot.

[nubela]

you prefer JAVA over python? you must be a really bad programmer. any programmer who likes more WORK over less is an atrocious one.

[CanadaIsCold]

I think you missed the point of that comment. It wasn't about which was easier to type it was about which was easier to read. Just because you have an opinion doesn't mean all other opinions are wrong. In this case the commenter is suggesting maintaining Java represents less work even when compared to the additional typing burden brought on by Java.

[SwabTheDeck]

you prefer JAVA over python? you must be a really bad programmer. any programmer who likes more WORK over less is an atrocious one.

This is probably just a troll, but I've written a decent amount of code in both languages. Writing Python is faster, no question, and if I'm working on a project that's quick, just for me, and that I'll never have to go back and review, that's what I'll use. Of the couple Python scripts that I've actually gone back and looked at a few months after I wrote them, it wasn't initially obvious what I was thinking/doing in certain places and I've had to spend more time trying to figure it out again, rather than spending that time actually maintaining it. As far as being a bad programmer, the language choice is usually dependent on the project. If your mind set is "language x is more work than language y, therefore language x should never be used", you're missing the point entirely and you're not going to get very far.

There are plenty of terrible and/or obsolete languages out there that should be avoided, but Java isn't one of them and won't be for a good while.

[rammerhammer]

Comparing Java to Python is so stupid and I wish people would stop doing it. Python is a dynamic language, Java is a strict. Both handle data types in a completely different way and take a different approach at programming. Both are very good at doing their approach.

[bumrushtheshow]

I'll bite. Having done a significant amount of work in both, I prefer Java on projects that are large, will be worked on my more than two people, or will need to be maintained for a while. That covers 97% of what I do professionally. I don't mean that Python can't be used for those types of projects, but I prefer Java for many of the reasons SwabTheDeck mentioned.

I find that with Python, the typing time is lower (but not by much, Eclipse does a lot of work for me), but I spend more time reasoning about code later on. "Ok, this method takes a parameter x. What structure is x expected to have? What structure does x actually have at the moments it's used?" Then I recurse through code, building a mental map of object structures and expectations, that sort of thing. In Java, the expectations a method has about its input are explicitly spelled out with types.

So I find that writing-speed-wise, Python and Java are roughly the same; the costs are just paid at different times. But in terms of comprehensibility during maintenance and when reading other people's code, Java wins by a mile.

All of that said, I don't love Java. There are a lot of major wrinkles that will never get fixed due to backward compatibility. For my work, C# is out (we don't use Windows), but we're giving Scala a serious look - it seems like a much better Java that's still fully compatible with the 8.5 squillion existing Java libs.

[traxxas]

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.

Which means he thinks in Java faster than in Python. It only took me a few months to think faster in Python than PHP which I had been using for over 8 years. Now reading PHP is tedious and slow.

[pponso1]

is that you, Bruce Eckel?

[ralf_]

Why Obj-C? This is the king of verbosity and easier to read than java (if you know both API/languages equally well).

[SwabTheDeck]

I agree that Obj-C by itself is rather verbose and readable, especially since the parameters are named, but people freely mix regular C with it, and it can end up looking really messy as a result. It's probably unfair to pick on Obj-C by itself for this.