[snip]

   What I was getting at is that short circuiting happens rarely (I believe
it only happens for the ?:, || and && operators), and so a beginning
programmer might (wrongly) assume that it does not happen for the ternary
operator.

   As such, the programmer might expect all three expressions to get
evaluated. If the intention truly was to ensure that everything gets
evaluated, it might have been clearer to write the code as:

<code>
int result1 = getMaleBorderAge();
int result2 = getFemaleBorderAge();
if (isMale) {
 int borderAge = result1;
} else {
 int borderAge = result1;
}
</code>

   In other words, I think a higher percentage of Java programmers will
correctly determine what this code does:

<code>
int borderAge;
if (isMale) {
 borderAge = getMaleBorderAge();
} else {
 borderAge = getFemaleBorderAge();
}
</code>

than this code:

<code>
int borderAge = isMale ? getMaleBorderAge() : getFemaleBorderAge();
</code>

   - Oliver

Monique Y. Mudama coughed up:

Objectively, I think you're wrong.  There is far less clutter to express the
same thing.  The only reason I can see that someone might think that

       int borderAge = isMale ? 65 : 60;

is somehow less clear than

       int borderAge;
       if (isMale)
           borderAge = 65;
       else
           borderAge = 60;

is simply because they are less familiar with :? or otherwise somehow
spooked by it.

You've got to be a bit careful here.  There are (at least) two aspects to
clarity.  One is how well does the programming construct capture the intent of
the programmer, the other is how clearly is that construct expressed in the
concrete syntax of the language.

In this case I think these two aspects work in different directions.

First off, if the concept is something like (for instance):

   if the person is female then the retirement age is 60, otherwise
   it's 65.

Note two things about that: (1) we are covering /all/ the possibilities (2) we
are using the two values (60 and 65) for the same purpose (as signified by the
fact that we don't -- and in normal English shouldn't -- repeat the phrase
"retirement age").

Now we can translate that concept into Java code using an if statement:

   if (person.isFemale())
       retirementAge = 60;
   else
       retirementAge = 65;

but that doesn't capture the concept particularly well.  There is nothing to
stop us missing off the else (either syntactically or logically); and there is
nothing to hint that the important thing is that the same variable,
retirementAge, is assigned on both branches.  So the notation is an /indirect/
expression of our intent.  It works, but it's not as clear as it should be.

Using an ?: operator, OTOH, is a very direct expression of our intention:

   retirementAge = person.isFemale()
                               ? 60
                               : 65;

The reader doesn't have to /notice/ that the same variable is assigned to in
each case -- there is only one assignment.  Similarly there is no possibility
of forgetting to cover the cases.

So, as far as that goes, the ?: operator (if used correctly) is significantly,
and objectively, clearer than an if statement.

But that's only half the story.  /Given/ that a conditional expression is to be
preferred over conditional execution of different statements, does Java's
concrete syntax convey the underlying semantics well ?  Now there, I agree, the
answer is an objective "no".  It's something that you just have to get used to.
It belongs in the long tradition of punctuation abuse, which has been a central
feature of programming language design, more-or-less from the very beginning.

The syntactic unclarity is something that you /can/ get used to (especially if
you use decent layout conventions), and with experience you find the syntax
more and more transparent.  But the unclarity in the other department is
inherent -- it's not something that goes away as you get used to it.  If
anything it's the other way around -- as your sensitivity develops you find it
more and more off-putting.

   -- chris

One benefit the ternary operator offers over the if-else is the ability
to declare the result "final" in one line:

final int borderAge = isMale ? 65 : 60;

If you do it this way, you have compiler-checks to ensure your code
doesn't change the value of borderAge within the current scope. If you
want to achieve a final result using an if-then, you have to leave a
temporary variable dangling in order to do it, and the result is
messier:

int temp;
if (isMale) {
 temp=65;
} else {
 temp=60;
}
final int borderAge = temp;

   Agreed. I was surprised when Roedy opened his post with "Objectively,
this is clearer" (Less surprised when Monique and Thomas used it, as I
assume it was to point out the absurdity of describing the clarity as being
objective in the posts they were responding to).

   This is just my opinion, but I think people are allowed to form judges
about what is or isn't clear even if they haven't had training on the
subject matter. In fact, perhaps as a "true" test that a concept is a clear,
we can see if people who have NOT been trained are able to grasp the
concept. If so, then that concept must be extremely clear.

   If we agree to this definition (and I'm not saying we have, this is just
a theoretical situation here), then I think, objectively, most English
speakers will find the "if-else" form clearer than the ternary operator.

   That is, even non-programmers can guess what will happen with respect to
the "if-else" form; that's an indication of how clear it is.

   Of course, Chris Uppal made an extremely good argument (in my opinion)
for the clarity of the ternary operator; namely that it makes it clear that
the same variable is being assigned to in both branches of the condition.

   So, like so many things, it all depends on your definition of "clear"
(as Verdrengh pointed out).

   - Oliver.