Debugged, modified, maintained and customized incremental assembler software on an HP1000 and provided CM and user support and education.

• From the days when it took many mainframe hours to assemble and load the complete radar application program, the incremental assembler accepted a list of source code updates, as well as special files from the full assembler. The incremental assembler's output is a set of object code patches, including branches to special spare patching areas, new code, branches back, as well as branches around "deleted" code. Using the patch assembler, small changes to the radar application program could be loaded and tested in only a few minutes (until too many changes accumulated).
• I became responsible for maintaining this program just after it was delivered. It was mostly written in HP1000 assembly language. As there were still a few adjustments to be made, I quickly became skilled at deciphering the intent of assembly code and debugging.
• I made many enhancements over time:
• Proper handling of multiple patching areas with various overlay rules.
• Enlargement of the symbol table capacity, which required virtualizing it to use "extended memory area", while it was previously accessed from register pointers.
• Proper handling of multiple module/file updates from multiple source code updates. This required a fair amount of update file pre-processing and checking, as well as the addition of many command line options and some utility programs.
• Handling intermediate level updates, where enough changes had accumulated to prevent practical direct usage of the patch assembler, but not enough updates to justify going back to the mainframe for a full source code re-assembly. This involved having the incremental assembler accumulate information, which it used to update the special files received from the assembler. Additional updates would be made to a special revision of the object code, which was already partially patched. The idea was to create the illusion that an actual source code update and re-assembly had occurred, so that the incremental assembler only had to process newer updates. This program was apparently a little too successful. Fortunately, after about a decade, the mainframe build process came to take only a few minutes. At that point the patch assembler was only needed in remote locations where radar application program changes had to be tested without convenient mainframe access.