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.

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.