On Wed, Mar 30, 2022, 5:34 PM Undiscussed Horrific Abuse, One Victim of
   Many <[1]gmkarl@gmail.com> wrote:

   So, this isn't really using a programmer at the moment, but spamlogging
   this kind of perception can often resolve it.
   I'm trying to write assembler so that my bios post codes are written to
   my serial port.
   I spent many days fixing things to try to debug it. I presently have
   two implementations. One works, the other doesn't.
   However, it seems the two implementations are exactly identical, as far
   as I can tell.
   The working one was slowly migrated from code that worked already.
   The failing one was copied over by me earlier.
   I've mutated them to be identical, and the failing one is still
   failing, while the working one is still working.
   I had the working one preceding the failing one, and only one character
   was output.
   When I duplicate the working one, there are two characters. When I
   remove it, there is one.

   *when I remove it, there anone.

   But get this: when I copy-paste the failing one to come before the
   working one, I get an additional character from that.
   You'd think it would be something after the working one, and before the
   failing one, but they appear completely identical.
   Since writing your own bios is an unlikely task to complete in a timely
   manner without experience, it seems to make sense to try to
   troubleshoot this further.
   I'm not planning on investigating the per-clock-tick behavior of the
   cpu. But I am interesting in finding a property of the source code that
   distinguishes whether or not it works when run. If that property is
   where its source code bytes came from, that would be interesting. In
   such situations one can seem very likely to experience a delusion,
   which are also helpful to sort out.
   I'm logging the terminal output of the development and run system, and
   the serial system accessing it, and both systems are airgapped. So
   there's something to check what is real at least a little bit more.

   0539
   I copied the working block below the failing block.
   The blocks are now:
   1 copied from failing
   2 working blocks
   1 original failing block
   1 working block
   This is producing 4 characters of output, from 5 identical blocks. A
   working theory is that only the original failing block is failing,
   which can be tested by removing it. An alternative theory could be that
   only the last block is failing. A tertiary theory could be that a
   different block is failing each time, or that it the unexpected output
   is unrelated to failure of a block.
   As I type this I will likely make errors from my perception issues.

References

   1. mailto:gmkarl@gmail.com