Thanks for that explanation Durgadas. As a past H200 programmer I would probably get in too deep to the different style of working necessary on this type of machine, but I'll do it anyway.
Unlike register machines the great advantage of a two address character machine is that fields can be any length. If you want to do maths to hundreds of significant digits then you just make the fields that big, but the instructions are just the same because they process whole fields no matter how large they are. That is why the word marks are so important, because the processing of a single instruction doesn't stop in the right place if one is missing. It is true that the basic instructions reference the right hand end of fields, i.e. words, but the advanced instructions include the Extended Move instruction that can process from left to right or right to left and terminate on a word mark, item mark or record mark. Hence it is possible to construct and process a four level data structure containing characters, words, items and records entirely within the hardware without any software iteration being necessary. I will have my work cut out just building the hardware for the basic instruction set though.
That method for writing subroutines illustrates one important point about the simplest programming techniques, that the machine code can be self-modifying. Register machines tend to hold all variable working data in the stack or data segments and the executable portion of a programme does not change, following the Harvard architectural model, but with the Von Neumann architectural model the code is also regarded as data and therefore can change itself while running. This may be regarded as bad practice by modern control freaks but is actually extremely versatile and the key to how it was possible to write tiny programmes such as my
Pi Factory demonstration programme. There is so much self-modification there that it is very difficult to work out what is happening without the assistance of the clues given in the comments and my notes.
Modern programmers seem to consider the "Go To" instruction to be the work of the devil and bound to result in chaos, but here it is necessary and normal to modify GoTo instructions while the programme is running. Oh horrors! How could any programme possibly run reliably using code like that? The truth is that nowadays programmers only write the easy high level code as the more critical low level code with its naughty but essential GoTo's has already been built by more experienced system programmers. In fact nowadays that low level code is microcoded into the central processor's hardware during design. In the case of the H200 almost all the register handling was similarly hard coded, so the programmer didn't seem to need to think about it because the data was put back into main memory by the hardware automatically.
Although the programmer didn't have to use data registers directly they needed to understand what the machine was doing with address registers behind the scenes in order to return from subroutines and take full advantage of instruction chaining. This latter technique involved leaving the addresses out of instructions because the right ones were already in the registers following execution of the previous instructions. You have to understand instruction chaining to be able to comprehend what the assembled code in a typical programme is actually achieving. The H200 programmer's reference manual explains how each instruction uses and alters address registers so that a programmer can use this important feature effectively.
Another programming trick was making instructions temporarily disappear from the code. This usually involved placing a NOP (No Operation) immediately before the instruction during assembly. To disable the instruction, code elsewhere removed the word mark from its first character. As a result the NOP treated the instruction as its own parameters, which it always ignored, and passed control to the next instruction along. The hidden instruction could be reinstated simply by putting the word mark back on it. This technique allowed any instruction to be switched on and off as required. There are examples of it in my Pi Factory programme. Such techniques required very clear thinking on the part of the programmer to be reliable. This is where the idea of a programme being a "finite state machine" rather than a predefined procedure is essential to grasp. At all times the whole programme had to be in a valid meaningful state.
The style of programming used on these old character machines was very much aimed at minimising the memory space and machine cycles used because memories were small and expensive and the processors were slow by modern standards. Nowadays memory is dirt cheap and processors incredibly fast, so the code doesn't have to be so efficient and it can be designed to permit rapid reliable programming by relatively inexperienced programmers. My Pi Factory programme is tiny, but it took me two solid weeks of intense decision making to make it work to my very demanding specification. I also subscribe to an online writer's forum and am in fact now a staff member there, which explains why I don't post here very often. We discuss how much thought can go into a very effective piece of writing and how people can spend so much time reading, analysing and discussing famous works such as those of Shakespeare and much-loved poems by the great poets. However, back in the early days of computing just as much thought had to go into writing code that would fulfil the requirements. A clever piece of code that speeded up a long process could result in the computer operators going home an hour or two earlier at the end of each evening shift. In those days that was like poetry to all concerned.
