...where most modern systems are written to work around user error in
one way or another.
No. They either don't bother to verify, most common. or they simply
list a set of errors after the user has entered a formful of data.
What I was doing was informing the user on the very keystroke of any
error, and as soon as an assertion could be computed otherwise.
The user could navigate around failed assertions by rekeying erogenous
fields (the assertions have an error messing in English that explains
the problem), by changing inputs so that the flow of fields keyed
change, thus bypassing the assert.
The program guide you by the hand through only the fields it wants you
to key. What you key can be used to influence what you key next.
A simple example would be skipping over state and zip if you said
earlier you lived in Canada.
It is not like a form where you have to key everything, or skip fields
manually.
In theory a user could attempt to sneak around a programming bug that
manifested as a failed assertion by keying different data. This has
never happened to my knowledge, but in theory it is possible.
The failed assertion messages are often of the form, "If you key A you
also have to key B, or leave both blank". "No such zip code in that
state."
In pseudo java you code them like this:
assert( a.blank() == b.blank(), "If you key a, you also have to key
b");
assert( stateCrossZip( state, zip ), "No such zip code in that state."
)
Literally they would be coded:
CLEAR? a CLEAR? b = " If you key a, you also have to key b" MUST
FROM state zip STATExZIP " No such zip code in that state." MUST
They are much like Java assertions, except they have an English
explanation. When they fail, the action is to back the user up and
let him rekey the previous field, or back up even further if the user,
(or the programmer) requests, using the CULPRIT verb to indentify the
most likely culprit FIELD, not place in the code where that field was
keyed. Where you back up to could be in a routine miles away. You
don't just jump there, your restore the state you had when you were
there. You even jump back to a method YOU called, not that called YOU.
This is how jaunting differs from an exception.