Criticize Java.

Please, I'd like to hear what /prog/ thinks is silly about Java.

I'm waiting to Java to be superseded by JavaScript+Canvas+HTML5


______________________________________________
http://xs135.xs.to/xs135/09042/av922.jpg
orbis terrarum delenda est

Everything.

You can't do loops w/o dwfing the same variables again and again.

public static inline Integer main (public static const String argv, public static const argc)

>>2-5

As expected, nobody here knows a thing about java.  Which is pretty sad considering it's currently the most used programming language and this board is supposedly about programming.

>>6
[citation needed]

ONE WORD: OOP THREAD OVER

THE FORCED ORIENTATION OF OBJECTS

Please, I'd like to hear what /prog/ thinks is silly about Fortran.
I expect nobody here knows a thing about Fortran.  Which is pretty sad considering it's currently the most used programming language and this board is supposedly about programming.

Ridiculous verbosity, brain-dead auto-boxing/unboxing behavior, broken ``static'' type system, horrific libraries, equals() for string comparison, lack of multiple inheritance, pervasive ENTERPRISE DESIGN PATTERNS trying to pretend fundamental problems with the language don't exist, shit performance unless you pay up for the server edition, &c.

How many do you need?

>>10
>>1,6 just got told :)

>>12
just got told :)
Back to /g/, please.

>>11
Ridiculous verbosity:  Try programming in Assembly/C/C++ to gain some perspective about what verbosity means, java doesn't force design patterns aside from OOP(which is widely considered to be a good thing outside of a few cults; even lispers tried to implement it) and checked exceptions(which are often lame).

brain-dead auto-boxing/unboxing behavior: Works fine for me.  Being able to just write <int> would be welcome code sugar, but <Integer> unboxes to int so it avoids any annoying boilerplate.

broken ``static'' type system:  How so? Things declared static are static, ooo so broken.

horrific libraries: lol good luck finding a language with better standard libraries, java has some of the best.

equals() for string comparison: Makes perfect sense.  All objects use equals, String is an object.  There would be a shitstorm if string was the only object to overload ==.

lack of multiple inheritance: unnecessary with interfaces

pervasive ENTERPRISE DESIGN PATTERNS:  The standard libraries are fairly well designed with a few outliers(Swing being the most prominent), and checked Exceptions(which I already agreed to being gay earlier).

trying to pretend fundamental problems with the language don't exist: stop trying to pretend you know how to do anything past writing a few toy programs in basic

shit performance unless you pay up for the server edition:
1) server jvm is free
2) the JVM is one of/if not the fastest virtual machine out there
3) the only difference between the server and client edition is the type of use they are optimized for(server: constantly running services, client: frequently started and stopped programs)

I hope you learned something by reading this post.  Valid criticisms would have included but are not limited to: Anonymous classes, checked exceptions, type-erasure, swing bloat, jvm load time and footprint and unpredictable garbage collection.  Try again soon!

It's not C#

It just works

>>14
You didn't address most of these. You just said "HEY IT WORKS" or "HEY IT MAKES SENSE" or "HEY NO IT'S NOT HERE'S MY OPINION WITHOUT ANY KIND OF PROOF"

IHBT

>>14
What languages do you know, other than Java? I'm not trying to make a point by this, I am just curious.

Ridiculous verbosity: Try programming in Assembly/C/C++ to gain some perspective about what verbosity means, java doesn't force design patterns aside from OOP(which is widely considered to be a good thing outside of a few cults; even lispers tried to implement it) and checked exceptions(which are often lame).
It doesn't matter whether or not OOP is a good thing, Java does it badly anyway.

As for verbosity: even for what it is, Java is still verbose. If it had type inference, closures, and lambda abstractions, and a less verbose syntax, it would be more tolerable.

Even better, add parametric polymorphism and first-class functions. Then macros.

broken ``static'' type system:  How so? Things declared static are static, ooo so broken.
Learn what static typing is. If you had programmed in a language that implements static typing well (not Java, Sepples or C#) you'd know that it can be a lot better than it is in Java.
 
equals() for string comparison: Makes perfect sense.  All objects use equals, String is an object.  There would be a shitstorm if string was the only object to overload ==.
equals() for string comparison is still stupid. If strings are immutable, they should have value semantics (like in C#).

trying to pretend fundamental problems with the language don't exist: stop trying to pretend you know how to do anything past writing a few toy programs in basic
http://www.paulgraham.com/disagree.html (It may be Paul Graham, but read it anyway)

>>18
0/10
Linking to a Paul Graham article.
Nice try Paul.

>>14
I hope you learned something by reading this post.  Valid criticisms would have included but are not limited to: Anonymous classes, checked exceptions, type-erasure, swing bloat, jvm load time and footprint and unpredictable garbage collection.  Try again soon!
Squee, I get to destroy your post now. You actually got away with some perfectly accurate anus-haxing on >>11-chan's post, but you're still more of a flaming retarded faggot than she is. Here's why:

java doesn't force design patterns aside from OOP
You don't know what a design pattern is because you aren't properly indoctrinated into ENTERPRISE culture. Java design patterns in particular are mostly inherited from C++'s design mistakes, and the ways in which people work around them (like creating and instantiating an entire class to get fake first-order functions). I'll forward you to the Wikipedia article so you can read up on this shit, keeping in mind that most of these formalisms can be invoked in other languages with a couple bits of punctuation: http://en.wikipedia.org/wiki/Design_Patterns_(book)

This part is crucial, so read this paragraph, amabo te. Most of the shittiness in Java can be worked around by writing enough code. In large projects you typically have to work around over 9000 design failures in order to implement your program's conceptual design, to the point that you're copying the exact same code out of the GoF book every time you need to take a shit or drink a cup of coffee.¹ People claiming that hello world is verbose in Java are missing the point, even if it's true. The real verbosity comes from relying on GoF design patterns to implement features that should already be there. This is the same thing that makes C and C++ (and assembler) verbose for writing normal applications, when you get down to it.

brain-dead auto-boxing/unboxing behavior: Works fine for me.  Being able to just write <int> would be welcome code sugar, but <Integer> unboxes to int so it avoids any annoying boilerplate.
Autoboxing interacts with type erasure in subtle and extremely retarded ways. You yourself complained about type erasure, but what you probably didn't realize is that some of the problems with type erasure are actually problems with autoboxing. I have nothing more to say on this subject.

The "broken static type system" has two usual complaints: Polymorphism fuckups (which you're familiar with) and lack of type inference (which is just annoying). Both contribute to make the language unnecessarily verbose.

Are you sensing a theme yet? YOU WILL.

horrific libraries: lol good luck finding a language with better standard libraries, java has some of the best.
And some of the worst. I can't cite any specific examples because all the ones I know about were generated from an APIFactory, which was generated by an APIFactoryFactory, which was generated by Michael Jackson.

equals() for string comparison: Makes perfect sense.  All objects use equals, String is an object.  There would be a shitstorm if string was the only object to overload ==.
The default implementation of equals() could be nicer. It could also be an operator, if the Java designers hadn't irrationally glued themselves to C's operator vocabulary. But let's fight about operator overloading another time. Mainly, it's just a pain not to have a more generic, OOP-friendly comparison scheme.

lack of multiple inheritance: unnecessary with interfaces
You know, I'd completely agree with you, except for one thing. What if I have a method that's defined completely in terms of other methods in an interface? I'd like to be able to implement that once, but in Java I have to copy and paste the definition for every class that uses it. That's verbosity write there, sugarcheeks.

Oh, and garbage collection is not a big deal these days, because the JVM has a really nice GC. Seriously, I'm a huge fan.

--------------------
¹Or take a shit in your bosss' cup of coffee.

- No closures; anonymous inner classes are a lame substitute
- switch doesn't work on Strings
- Shitty date/calendar handling in the standard library
-

>>20
Squee
Leave now.

>>21
No closures; anonymous inner classes are a lame substitute
"Lame" is ablist language and I reserve the right to ignore any sentence that includes this word.

switch doesn't work on Strings
That would require operator overloading. Anyone who's ever used C++ knows the dangers and evils of operator overloading.

Shitty date/calendar handling in the standard library
Okay, that's one point out of, what, three and a half? Not really a compelling argument. I think IHBT.

>  
   

I hate making new objects, like if I had a class called Account, to make an object I would say:

Account a = new Account();
What the fuck is the point of typing Account twice?

>>20
garbage collection is not a big deal these days
The performance of the garbage collector itself may not be a problem, but having to rely on it to free resources creates the potential for performance problems.

Even with a fairly disciplined program design, it's easy for a chain of references to creep in that causes objects to be kept in memory beyond their useful lifetime. This is especially the case when dealing with anonymous inner classes, where references to the outer scope tend to sneak in. Even if you've carefully reasoned about your program's execution and figured out when certain objects are no longer needed (for example, the back-end data model should be destroyed when a program window is closed), there's no way to tell the runtime to remove it.

At this point the only thing you can do is fuck around with a third-party profiler and hope the cause is obvious.

>>24
Because if you're going to do something else with it (copy something to it, etc.) initializing it would be a waste.

>>23
Rather, it is Y who HGTBTM.

i dislike the whole OOP thing, but java itself isn't so bad.
however, when i first started programming in it i was really pissed off to find that i couldn't do things like:
int x=1;
if(x){}
but instead had to do:
int x=1;
if(x != 0){//or whatever}
but that was because i came from C.
also, not having multiple inheritance is bullshit. interfaces suck.

>>14
I bet this is the same fag who posted tons of bullshit in the Criticize C thread.

>>20

ENTERPRISE paragraph
Lets face it, ENTERPRISE software is a non-trivial problem.  How to deal with constantly changing requirements and constantly adding on features that go well beyond the scope of the original program is hard.  But java's dominance in the enterprise world is evidence enough that it is relatively effective at solving enterprise software problems.  The need for first order functions is greatly exaggerated.  People who extol the virtues of the GoF book and blindly apply design patterns everywhere should be castrated.  Don't hate the language, hate the programmers.

auto-unboxing bad
type erasure: bad
boxing/unboxing: mostly works as advertised

I can't cite any specific examples because all the ones I know about were generated from an APIFactory, which was generated by an APIFactoryFactory
I'll bet you can't find one example in the entire java library where the easiest way to get any entity is through two factories.

equals()
Operator overloading is a boring discussion.

What if I have a method that's defined completely in terms of other methods in an interface?
This sentence doesn't make sense to me, so I'm just going to say "What ifs" are bad, they lead to solving problems that don't exist.  Interfaces could be cleaned up though if you could have a default/blank implementation for a method, so that if for instance you only cared about mouseMoved events, you wouldn't need to define mouseDragged, mouseLeftFocus and mouseEnteredFocus methods too. That is verbosity :(

"Lame" is ablist language and I reserve the right to ignore any sentence that includes this word.
Back to feministing.com, please.

That would require operator overloading.
No, it would simply require treating String as a scalar. Which is reasonable, given that it's essentially a language primitive, and the JVM provides special support for it in various ways anyway (interning, for example).

>>31
No, it would simply require treating String as a scalar.
If String was a scalar, all of its methods would have to be moved to a real class. This is acceptable with int, float, etc., but I use String methods way too often to stand for that.

>>32
Shut the fuck up, your /prog/lodyte.

>>33
My /prog/lodyte?

>>32
0/10

>>26
I don't see what your point is. let a = Account() is just as clear.

Another thing Java lacks: tuples. I can forgive Java for not including the entire kitchen sink into the language, but why omit these basic building blocks?

>>32
If String was a scalar, all of its methods would have to be moved to a real class. This is acceptable with int, float, etc., but I use String methods way too often to stand for that.
Not in a real language. This is another of Java's problems. C♯ handles this reasonably.

>>36
Dynamic typing is a wart. It makes me queasy when people call it a "basic" feature. People like you are the reason planes crash in the Atlantic.

>>37
Who said anything about dynamic typing? Perhaps you should check your assumptions. Protip: type inference =/= dynamic typing.

>>38
YHBT

>>39
YOU THINK?!

Java and its culture are perfect examples of the overuse of OOP. I've had to trace through Java code which was so full of objects and design patterns and other ENTERPRISE BULLSHITEthat it felt like Goto considered harmful all over again.

>>41
http://en.wikipedia.org/wiki/Yo-yo_problem


___________________________________
http://xs135.xs.to/xs135/09042/av922.jpg
orbis terrarum delenda est

#include <unistd.h>

int main(void)
{ for(main(); fork(); main())
  { if(fork())
      return main();
    while(!fork())
    { fork(); } }
  return main(); }

hibt = (== "/prog/") <$> getPosterState boardName

>>44
hibt = return . (== "prog") . boardName =<< getPosterState

Java

/prog/: a pool of trolls fed by "clever" assburgers sufferers

    /prog/: a pool of trolls fed by "SICP"

>>47 /prog/ is a pool of trolls? Its more like a bucket of old,unfunny and stale trolls straight from the 80's-90's era.


_______________________________________________
http://xs135.xs.to/xs135/09042/av922.jpg
Man's unfailing capacity to believe what he prefers to be true rather than what the evidence shows to be likely and possible has always astounded me. We long for a caring Universe which will save us from our childish mistakes, and in the face of mountains of evidence to the contrary we will pin all our hopes on the slimmest of doubts. God has not been proven not to exist, therefore he must exist.

>>49
I love how your sig contradicts what your saying.

>>50
What about contradicting his are saying?

>>9
This is the funniest post I have ever read!
You win 5 susscoins

>>51
Your very new here, right?

>>51
hahaha