Subject: Re: [PATCH v4] git: treat "-C <treat>" as a no-op when <path> is empty

From: Junio C Hamano <[email-masked]>
Date: Sat, 07 Mar 2015 23:14:54 -0800

Eric Sunshine <[email-masked]> writes:

> On Sat, Mar 7, 2015 at 5:49 AM, karthik nayak <[email-masked]> wrote:
>
>> Also "*(*argv)[1]" seems more readable to me, maybe more of a perspective?
>
> I also had considered suggesting (*argv)[1][0] as more readable, but
> it is primarily personal taste, and I didn't want to bike-shed the
> issue.

I didn't mention that in earlier review rounds for the same reason,
but I saw Andreas Schwab also independently made the same comment,
so that makes three of us.

That does not change the fact that this is merely a matter of
preference; I wouldn't even call this one a "taste" (use of which
implies that there are judgement involved, as in "good taste" and
"bad taste").

But because it is "preference", the only time we can discuss is when
a new code is submitted and is under review.  Once it is in the
tree, it is not really worth extra patch noise to go and change.

As everybody knows, POINTER[0] and *POINTER are equivalent.  We have
quite a few places where we say "let's treat passing an empty string
the same as not passing an argument at all" with

	if (!POINTER || !*POINTER)
        	; /* no-op */
	else {
        	/* do something with POINTER */
                fn(POINTER);
	}

and we could say !POINTER[0] instead of !*POINTER, interchangeably.

We tend to prefer (again, I do not think this is particularly a
"taste" thing) *POINTER over POINTER[0] when POINTER is just a
single variable in the above pattern we often see in our code.

But when POINTER is an expression like (*argv)[1], where you unwrap
the operators according to their precedences, it often is easier to
read if you do not have to flip your eyes left and right too often.

You first look at "argv", then notice the prefix "*" (you have to
move your eyes to the left here) and know argv points at a location
that holds a pointer.  Then you notice the suffix [1] (now to the
right) and know that pointer points at an array and the expression
is talking about in its second element.

Now, you want to say that second element is actually a pointer to a
string and want to talk about the beginning of that string.  If you
express it as "*(*argv)[1]", it forces the reader to go back to the
left end once more.  If you write it as "(*argv)[1][0]", the reader
can keep going to the right, starting from the last thing the reader
read and understood (which is the "[1]" at the right end).

At least, that is how I analyze _my_ preference---the latter feels
easier on my eyes.

But as I said this is a mere preference thing.