My microcomputer career began in the late 1970s while attending university, where a friend and I built and programmed a small 8080 based system.
One of the first "substantial" bits of code I wrote was a tiny editor and assembler which fit into a 2K (2716) EPROM, and allowed you to enter assembly text in memory and assemble into a working binary program elsewhere in memory. This was very primitive: the editor worked with hexidecimal line numbers and supported only 255 lines. The assembler had no directives other than EQU, DB, DW and END however it did support the entire 8080 instruction set.
This little package marked the very beginning of my career in embedded systems development tools.
Source code to this system was cross developed on the university mainframe. When I acquired my Altair with a floppy disk system, I wrote newer and better disk based utiities, and never did move the original source code over to the Altair - when I left the university and my student computer account was closed, the original tiny editor and assembler were completely lost, no source code or binaries remained of it (or so I thought).
During my university years, I met and became friends with Henry "Chuck" Colford. Chuck was a few years ahead of me, and was building an 8085 based system called P.I.M.P.S. (Personal Interactive MicroProcessor System) as part of his graduate thesis. Chuck liked my editor/assembler, and with my permission, incorporated it in his project.
When Chuck left the university, the PIMPS system stayed behind. What I didn't know at the time was that after he left, he built a second system on his own. Identical to the first design, it included copies of the original ROMs and my little editor/assembler.
Over 20 years went by and I had all but forgotten about my first software project, when Chuck stopped in to drop off some other equipment he was donating to my collection, and said "I brought something else that I want you to have"... and thats how I was reunited with my long lost code.
As soon as I had the chance, I fired it up, and found myself immersed in memories of my early computing years. It took a little while, but I figured out how to use the long forgotten commands to edit and assemble a small program.
I liked the write-up of the PIMPS system. Well done. I have a bit more info for you... I used an STD bus chassis for my thesis (not a SBC kit as I told you). I really liked the STD bus - simple, standard and easy to expand. It was newer than the S100, but more Intel'ish (i.e. synchronous) and lighter weight than the VME bus that followed. The university had chassis, processor, memory and I/O cards, but they were not really as well used as they could have been, largely because they lacked an environment and toolset to do more. While most folks beat their brains out working on IEEE-488 (or back then called HPIB, GPIB) bus projects, everyone suffered the slings and arrows of long edit-assemble-download-burn-test cycles.
I took a different approach and scrounged the STD buss hardware and built a ROMulator card that emulated a 2716 or 2732 EPROM. This gave you the ability to load code into pseudo ROM that would plug into a target without the hour+ long process of UV erase, wait for the DataIO programmer to burn to test an image (remember those days). My original design focused on the hardware and a monitor that would allow the user to talk to the mainframe to store and retrieve images and to map those into RAM that could be connected to a target via umbilical cables. To make this work stand alone, on the ROMulator card, I included a programmable register that allowed the code to be mapped to a desired STD bus RAM address space, even though it would be seen as absolute address $0000 when the umbilical was plugged into a target system. When I ported the code over to my PIMPS board, those commands just came along, but obviously the ROMulator register and EPROM umbilical cables did not. The design actually allowed multiple ROMulator cards to be run from a single chassis so that you could provide code to multiple target ROMs or systems at once.
When I saw your software, it was so cool, I was glad you let me include it. Now instead of being dependant on the mainframe (which we talked to at no more than 300 baud), you could edit and assemble it right there on the STD system rather than having to go back to the mainframe and do an edit-assemble cycle, download to the DataIO, etc., all of which all took forever back then. This was way cool back then - No floppies to boot up, no drives. Just instant on, and go. You sure know how to build software small and fast! It worked and people used it!
Rather than just being some interesting look what could be done or a technology showcase, other people desperate to get their projects done against hard deadlines used your software and my hardware to complete their own work. They only burned the ROM after they had it working. Real problem solvers! I think we were ahead of our time.