here i finish up my thoughts on italics, by myself...

as i said earlier, to get accuracy through the book,
it's almost a necessity that more than one person
go through the book.  it would be silly to assume
that a sole producer, no matter how dedicated or
skilled or tenacious, had located _every_ instance.

(i am not saying it cannot be done; i'm saying that
it would be silly for us to _assume_ that it was so.)

so, then, a different sort of question poses itself:

how do you motivate additional volunteers to do
the job the second, third, or fourth time around?

it's usually easy enough to find someone to do it
the _first_ time, because it's virgin territory, and
every find is a new hit, and _feels_like_progress._

it's the second, and subsequent, times through it
that the job gets unfulfilling, because most of the
instances -- 80% or 90% -- are _already_ marked,
so there are fewer cases where you get the "rush"
of finding a new one.  (and fixing a false-positive,
although valuable, is rare, and even less thrilling.)

***

but there _is_ a way to get the best of both sides.
and that's to _hide_ the visibility of current italics,
so the person can "have the fun" of finding them.

then, because we do know about the presence of
many of the instances, we can reward the person
with _recognition_ that they "found" what we "hid".

and we can also show them any that they missed.

so we're both (1) rewarding their successes, and
(2) training them, by showing any shortcomings.

this keeps 'em motivated, and makes 'em better.

***

moreover, we can give them _extra_credit_ when
they find an instance that we didn't already know.

after all, that's why we do the additional checks;
so people find new cases we didn't know about...
so that's what we're gonna give good rewards for.

in my "italics game" demo, if the italics you clicked
had a blue bounding-box, it meant, "hey, good job!
you found one of the instances that we had hidden."

in our game, this "find" might earn you one point.
(or 1000 points, given the point-inflation today.)

but if the italics you clicked had a _red_ bounding,
it meant that you'd _discovered_a_new_instance_...

(this isn't just something arbitrary that i made up;
the words with red bounding-boxes are instances
that were _actually_ missed by either david or jim,
and usually both, in their digitizations of "huck".
so, according to them, you _did_ find a new one.)

so in our game, this "discovery" of a new instance
might earn two points, or five, or 2000, or 5000.

(a nice twist might be to base it on the number of
rounds so far; it'd be 2 points in the second round,
and 3 points in the third, 5 in the fifth, and so on.
thus, the more people who'd missed it before you,
the higher the reward you'll receive for finding it.)

we could have other game-play considerations too.

as one, of course, there would also be _penalities_
-- _deducted_ points -- for any missed instances.

we could decide how heavily we wanted to charge
people for such missed instances, but i'd say that
it should be at least _twice_ as much as we reward
them for "re-finding" a known instance, since the
whole purpose of this exercise is to find new ones,
so we want subsequent checkers to be _vigilant._

and we might want to base this penalty, too, on
the round, to balance the increased "reward" for
finding new instances.  so you'd lose 2 points in
the second round for misses, 3 in the third, etc.

as another wrinkle, we might want to plant some
"false misses" in the mix.  here, we would _say_
the person had "missed" an instance, but we will
then point to an _unitalicized_ word.  this would
be the equivalent of a "false positive", and thus
we'll want the person to _appeal_ the judgment.

that way, if round 2 incorrectly italicizes a word,
then round 3 will be penalized for not finding it,
but the player in round 3 will see that the word
is _not_ supposed to be italicized, and _appeal_.
and our referee will come and uphold the appeal,
thus _removing_ the incorrect mark from round 2.
(and yes, retroactively penalize the round 2 player.)

so the false penalties teach the players to appeal,
and that benefits us by removing false-positives...

***

like any social game, you'd post the "standings",
and give players a message-board to chat, boast,
trashtalk, bellyache, and just generally have fun...

***

so, would this kind of "game" thingee work?

i dunno.  don't care, really.  i'm just a coder,
building a tool to help automate a dull task...

if you want an example of a non-game use of it, see:
>   http://zenmagiclove.com/misc/italicscheck241.html
>   http://zenmagiclove.com/misc/italicscheck258.html
>   http://zenmagiclove.com/misc/italicscheck271.html
>   http://zenmagiclove.com/misc/italicscheck303.html
>   http://zenmagiclove.com/misc/italicscheck313.html
>   http://zenmagiclove.com/misc/italicscheck320.html
>   http://zenmagiclove.com/misc/italicscheck326.html

these are the same 7 pages i had set up as a game,
but here we just have the interface of the tool itself.

you'll see that each instance of italics is _highlighted_
by a colorized box in both the left and right margins.
(lines with multiple instances display multiple boxes.)

these highlights are created by analyzing the text for
the page, and seeing which lines have italics marked,
then putting the margin-highlights at the appropriate
place on the scan where we computed that line to be.

or -- if people think it works better -- we can also
mark each of those words themselves, with borders,
the same way we did with the "game" version earlier.
(to see this, click the "turn them on" button up top.)

what the checker is checking for, then, is congruence
with an italicized word in a line and a highlight for it.

any noncongruence -- italics without a highlight, or
highlight without italicized word -- needs attention.

also note that, new in this version, i've included a
_button_ in the right margin, for each line of words.
when a line "needs attention", you'll click its button.
this will send a report that that line needs attention.

this is for when the text is sufficiently correct that
changes will be rare, and we would want 'em to be
confirmed by someone before they are committed.

***

now let's recall how i described the current workflow:
>   look at the pagescan and note
>   where there are italics, then
>   check each instance in the text,
>   and mark it in the event that it
>   hasn't already been marked.
>   and then, just to be safe,
>   make sure that every italics word
>   that _is_ marked in the text
>   is actually an italics in the scan.

so there are 2 entities in front of you on your screen.
one is the pagescan, and the other is the text-file...

and most of what you're doing is shifting between
one and the other, and then back to the first one...

look at the scan, then the text, then back to the scan.
repeat, repeat, repeat.  like watching a tennis match...

haha!  my goodness: "like watching a tennis match."
sometimes i'm so funny i crack _myself_ up!      ;+)

now look at how this tool makes that more efficient.

first, the text-file is removed from the picture entirely.
all edits could be registered automatically by the tool.

(however, i suggest instant review by an administrator,
so that false-positives will not even get a toehold, and
to address anomalies such as don's partial-word italics.
this is the "confirmation" that i was mentioning earlier.)

still, a person who's _checking_ doesn't mess with text.

this means there's no loss-of-attention involved in the
task-switch from examining-the-scan to text-editing.

moreover, it is unnecessary to look at the text-file to
see if an italicized word is marked, because the mark
is shown _right_on_the_scan_itself_, where it's needed.

you _know_ if a word's marked, or if it still needs to be.
so if you see an italic _with_ a mark, you know it's fine.
if you see one _without_ a mark, you know to mark it...

and if there is a false-positive, you can see that as well,
because there is a mark, but no italic-word alongside it.

so all that tedious back-and-forth-and back movement
of your eyes and attention from the scan to text to scan
is eliminated.  your eyes and attention stay on the scan.

this is the essence of a _huge_ boost in task-efficiency.

and that's why we build tools in the first place.

are there any questions?

-bowerbird