Java Annotations

This post was killed by user flags.

What is the point of this article? To vent about how much they dislike Java? It's clearly not to educate, as the least they could do is try researching how to do repeating annotations in JDK 8:

http://softwarecave.org/2014/05/20/repeating-annotations-in-...

And it's clear from reading the annotation documentation that null is not a valid value. It might be surprising to some developers, but it was a conscious decision made by the spec designers. It also shouldn't be a surprise to the author that Java is smart enough to forbid you to set a null value regardless of whether it was specified directly or they used a constant:

http://stackoverflow.com/questions/1178104/error-setting-a-d...

"I hate X" piece like this do nothing to advance the discussion on language features. They only add a bunch of noise and ramp up the flamewars on both sides.

Comparing C# and Java is so last decade. I don't use Java because of the language, but because of its enormous toolset and awesome community.

If there is something I can't do well with Java, then I have Groovy. I will most likely waste time trying to implement the same thing with C#. In fact I would probably just use Python or C instead.

And C# can't (directly) run on anything not built by Microsoft. For those of us focused on shipping products to cross platform users, there are handfuls of languages better than C# in that regard. There are things every language does poorly and well, but you also don't see us making whycsharpsucks websites because we're probably too busy building things.

I just don't see the need for this kind of negativity. If a language wasn't designed for a certain way of using annotations (or any feature), maybe another method should be tried to get similar results. It may not be ideal and may not fit the paradigms of what you're used to, but it's a completely different language for heaven's sake.

It's like asking why a Honda Accord isn't faster than a Lamborghini... But at least the Accord holds 4 people and has useable trunk space. They're built for different needs, nobody expects an accord to race well, and nobody expects a lambo to be good for soccer moms and off-roading. So why the hate?

As of Java 8, repeated annotations are allowed (and are backwards compatible). Also, Java 8 annotations now serve as the basis for Java's pluggable type systems[1].

One of the available pluggable type systems adds physical units, something that, AFAICT, is certainly not trivial even in Haskell[2].

So the author may not like the decision not to allow null values in annotation arguments, but Java annotations have actually become a very powerful tool.

[1]: http://blog.paralleluniverse.co/2014/05/01/modern-java/#adva...

[2]: http://www.haskell.org/haskellwiki/Physical_units

I'm not sure if annotations are designed for this kind of usage.

Most if this is just praising or criticizing syntactical sugar. And it's a weird and manipulative writing style to tell the reader "this is how you need to do it" followed by examples that don't even compile - simply to include some oh so bad compiler errors.

Why does the author seem surprised when his code doesn't compile after adding a non-optional parameter? It's arguable whether parameters should be optional by default or mandatory by default. Not really knowing much about c# I guess anything besides primitives will be `null`, which doesn't seem like you gain much.

I'm not sure I have ever seen annotation used like in this `whenType` example. Besides that the whole approach looks suspiciously complex (why not just create `@DefaultPriority` which you can add to your type?), annotations are supposed to be simple meta data and you shouldn't be trying to implement some kind of logic with them. Any logic like this should be done when processing the annotation in my opinion.

Java annotations sure are limited and it's does seem kind of weird that you can't use null as default value. But I never encountered any real problems that couldn't be handled by inspecting annotations using reflections or annotation processors.

Like Roman Empire, Java will take a long time to become irrelevant despite continuing stream of hindsight rants.

Annotation in itself is not bad IMO. Used carefully as language-level extension mechanism like it is being used by Swift, it's useful.

What I disliked when annotation was first introduced is User-defined Annotation because the feature in-effect turns code into magic.

Annotations in Java cannot inherit from other annotations. This has been known for a long time:

http://stackoverflow.com/questions/1624084/why-is-not-possib...

Not sure why it is a surprise to the author.

Could be worse...PHP uses comments for annotations..how do you like them apples?

I left Java around 2010 for a role that let me focus on data and PostgreSQL for a while, and I don't like the language anymore. I've probably been spoiled by Clojure and Python.

Comparing Java and .NET is unfair. Java was created in the 90's. .NET is way younger than that. .NET was created with Java in mind, and of course it's a better language.

Each language has its strengths.