Am 26.06.21 um 16:11 schrieb Ævar Arnfjörð Bjarmason:
>
> On Sat, Jun 26 2021, René Scharfe wrote:
>
>> Am 21.06.21 um 22:08 schrieb Ævar Arnfjörð Bjarmason:
>>>
>>> On Mon, Jun 21 2021, René Scharfe wrote:
>>>
>>>> Before an item is done, it should be reported as not done. After an
>>>> item is done, it should be reported as done. One loop iteration
>>>> finishes one item. Thus the number of items to report at the bottom of
>>>> the loop is one higher than at the top. i is the correct number to
>>>> report at the top of a zero-based loop, i+1 at the bottom.
>>
>>> Anyone with more time than sense can go and read over our linked back &
>>> forth thread where we're disagreeing on that point :). I think the pattern
>>> in commit-graph.c makes sense, you don't.
>>
>> Thanks for this comment, I think I got it now: Work doesn't count in the
>> commit-graph.c model of measuring progress, literally. I.e. progress is
>> the same before and after one item of work.
>
> The progress isn't the same, we update the count. Or do you mean in the
> time it takes us to go from the end of the for-loop & jump to the start
> of it and update the count?
>
>> Instead it counts the number of loop iterations. The model I describe
>> above counts finished work items instead. The results of the two
>> models differ by at most one despite their inverted axiom regarding
>> the value of work.
>>
>> Phew, that took me a while.
>
> For what it's worth I had some extensive examples in our initial
> thread[1][2] (search for "apple" and "throughput", respectively), that
> you cut out when replying to the relevant E-Mails. I'd think we could
> probably have gotten here earlier :)
Perhaps, but the key point for me was to invert my basic assumption that
a work item has value, and for that I had to realize and state it first
(done above). A mathematician would have done that in an instant, I
guess ("Invert, always invert").
> I'm a bit confused about this "value of work" comment.
Progress is a counter. The difference of the counter before and after
a work item is done is one in the count-work model, but zero in the
count-iterations model.
> If you pick up a copy of say a video game like Mario Kart you'll find
> that for a 3-lap race you start at 1/3, and still have an entire lap to
> go when the count is at 3/3.
>
> So it's just a question of whether you report progress on item N or work
> finished on item N, not whether laps in a race have more or less
> value.
These are linked. If you want to know which lap you are in, the answer
won't change until you start a new lap:
for (i = 0; i < 3; i++) {
display_progress(p, i + 1);
drive_one_lap();
display_progress(p, i + 1);
}
If you want for know how many laps you finished, the answer will
increase after a lap is done:
for (i = 0; i < 3; i++) {
display_progress(p, i);
drive_one_lap();
display_progress(p, i + 1);
}
> To reference my earlier E-Mail[1] are you eating the first apple or the
> zeroeth apple? I don't think one is more or less right in the
> mathematical sense, I just think for UX aimed at people counting "laps"
> makes more sense than counting completed items.
The difference between counting iterations and work items vanishes as
their numbers increase. The most pronounced difference is observed when
there is only a single item of work. The count-iterations model shows
1/1 from start to finish. The count-work model shows 0/1 initially and
1/1 after the work is done.
As a user I prefer the second one. If presented with just a number and
a percentage then I assume 100% means all work is done and would cancel
the program if that status is shown for too long. With Git I have
learned that only the final ", done" really means done in some cases,
but that's an unnecessary lesson and still surprising to me.
>>> Anyway, aside from that. I think, and I really would be advocating this
>>> too, even if our respective positions were reversed, that *in this case*
>>> it makes sense to just take something like SZEDER's patch here
>>> as-is. Because in that file there's some dozen occurrences of that exact
>>> pattern.
>>
>> The code without the patch either forgets to report the last work item
>> in the count-work-items model or is one short in the count-iterations
>> model, so a fix is needed either way.
>
> It won't be one short, for a loop of 2 items we'll go from:
>
> 0/2
> 1/2
> 1/2, done
>
> To:
>
> 1/2
> 2/2
> 2/2, done
>
> Just like the rest of the uses of the progress API in that file.
Yes, just like I wrote -- the old code is one short compared to the
correct output of the count-iterations method.
For completeness' sake, the correct output of the count-work method
would be:
0/2
1/2
2/2
2/2, done
> Which is one of the two reasons I prefer this pattern, i.e. this is less
> verbose:
>
> start_progress()
> for i in (0..X-1):
> display_progress(i+1)
> work()
> stop_progress()
>
> Than one of these, which AFAICT would be your recommendation:
>
> # Simplest, but stalls on work()
> start_progress()
> for i in (0..X-1):
> work()
> display_progress(i+1)
> stop_progress()
>
> # More verbose, but doesn't:
> start_progress()
> for i in (0..X-1):
> display_progress(i)
> work()
> display_progress(i+1)
> stop_progress()
>
> # Ditto:
> start_progress()
> display_progress(0)
> for i in (0..X-1):
> work()
> display_progress(i+1)
> stop_progress()
>
> And of course if your loop continues or whatever you'll need a last
> "display_progress(X)" before the "stop_progress()".
The count-work model needs one more progress update than the
count-iteration model. We could do all updates in the loop header,
which is evaluated just the right number of times. But I think that we
rather should choose between the models based on their results.
If each work item finishes within a progress display update period
(half a second) then there won't be any user-visible difference and
both models would do.
> The other is that if you count laps you can have your progress bar
> optionally show progress on that item. E.g. we could if we stall show
> seconds spend that we're hung on that item, or '3/3 ETA 40s". I have a
> patch[3] that takes an initial step towards that, with some more queued
> locally.
A time estimate for the whole operation (until ", done") would be nice.
It can help with the decision to go for a break or to keep staring at
the screen. I guess we just need to remember when start_progress() was
called and can then estimate the remaining time once the first item is
done. Stalling items would push the estimate further into the future.
A time estimate per item wouldn't help me much. I'd have to subtract
to get the number of unfinished items, catch the maximum estimated
duration and multiply those values. OK, by the time I manage that Git
is probably done -- but I'd rather like to leave arithmetic tasks to
the computer..
Seconds spent for the current item can be shown with both models. The
progress value is not sufficient to identify the problem case in most
cases. An ID of some kind (e.g. a file name or hash) would have to be
shown as well for that. But how would I use that information?
René
