Link Details

First: The link is actually referencing this link: http://www.javacoffeebreak.com/articles/toptenerrors.html
Second: The additional errors mentioned are not too useful since the compiler catches most of these anyway.
Third: The originating link is wrong about pass by reference. Java does not pass by reference. It passes a copy of the object pointer. Not the same thing. In C++ for example a method can null an object which affects the calling method - in Java

in Java (stupid dzone doesn't let you edit your reply) - that can't happen as you'd be only nulling out the copy of the reference.

In short, Java reference == C pointer

I think C has the same issue as C++. A function can destroy the struct pointed to in a parameter if you're not careful. I haven't coded C in like 18 years so I can't give an example. :(

The whole pass by reference/copy argument/confusion would not exist if programmers quite making the number one mistake, "writing methods with side effects".

I'd happily write my programs in a functional language if I only had a stateless database.

Agreed - most of the errors are compiler errors.

i think its not funny,but very stupid. its like always misspelling your name.but to be fair it happens all the time to people that have name longer than 10 chars, so i heard(i just copy and paste mine).

-vraeman
-raveman(sorry, i dont know how to delete the line above, can someone help? i cant remember what button to press, its so hard).

continue; (ups, again i wrote it not inside the loop)

P.S. topic should be top ten errors that idiots make. (i dont even try to be mean, its just very sad and offensive to java programmers). I make mistakes, but its not like i would bite my hand when i eat.

The original "Top Ten" list is a list of errors that only beginners make. The errors jsugrue added in his post are only marginally more complex. Perhaps the lists should have been called "Top Ten Mistakes Java BEGINNERS Make".
I also object to the description of argument passing. Everything in Java is passed by value. When you pass an object, you just happen to pass a reference to it, not the object itself; that reference, however, is passed by value and cannot be changed. Perhaps some might consider this as nitpicking, but it describes another relatively common mistake of beginners, namely changing the value of a parameter and expecting the change to be visible outside the method.
The most dangerous error in both lists combined is misspelling a method when overriding. That actually happens quite frequently, even to seasoned programmers, and contrary to most errors in the lists this one cannot be caught by the compiler.

You're right. Misspelling an override is not caught by the compiler. Good reason to follow the advice of favoring composition over inheritance when possible.