When I started my career as a programmer things were a lot different than they are now. Computers were just becoming less expensive but they were still being designed and operated as if they were the expensive behemoths that required huge air conditioned data centers and a small army to operate. The era of the temple of the computer was waning.
For those of you too young to remember, the temple of the computer had an outer vestibule where the unwashed masses were allowed and an inner sanctum with a counter separating it from the outer vestibule. There was a kind of priesthood of operators that intervened for the mere mortals who brought their offerings of decks of punched cards to be submitted to the great and powerful machine.
Then, after some passage of time, you would learn whether the gods had smiled upon you and run your program or whether you had a mistake in your deck. In either case you received a printout that contained the results, be they the output from a successful run or the core dump from an unsuccessful run. You also typically received a report of how many seconds your run had taken that was directly related to how much your account would be charged for the run.
All this changed with the advent of the microcomputer. The problem was, most people that were programming these modern marvels had learned at the temple of the computer. Consequently, things were oriented to be more convenient for the computer than the user. This was particularly true when it came to how you entered your program into the computer.
Early microcomputers had two types of languages, compiled languages and interpreted languages. Compiled languages were rare at first because most of the early microcomputers did not have much if any secondary storage. They typically had paper tape readers or cassette tapes hooked up to load programs from. Consequently, interpreted languages like Basic were the norm.
Basic programming had two modes of operation. In immediate mode you would type in a command, hit return, and the computer would run the command immediately. In programming mode you would type a line number followed by a command, hit return and the computer would store that line for execution later.
The line numbers were used to sequence the program with the lowest number being the beginning of the program and proceeding upward until you reached the highest line number. When you were through entering the entire program you would type the immediate command “run” and the computer would start running the program that you had entered starting at the lowest line number.
This was what happened in the best of cases. What typically happened the first time that you ran a program is that the computer would print an error message like “Syntax error in line 2215”. Then you would type “list” to get the computer to display the program on the screen so that you could try to figure out what was wrong with line 2215.
To fix the problem you would have to retype the entire line in error, including the line number, with your corrected instruction. This was labor intensive but I loved it. I was making the computer do my bidding like a genie in a bottle. Somehow though, I knew there had to be an even better way to enter the program.
There was a better way. It was a program called a text editor. It allowed you to create a program that you then saved, either to tape, a floppy disk, or, if you were extremely lucky, a hard drive. The first text editors were line oriented and were little better than the Basic interpreter. They had commands that allowed you to make corrections to a line without having to retype the whole line. There were even some commands that would allow you to change every occurrence of a particular word or phrase to another word or phrase in the entire file.
The next innovation in programming was the screen editor. It was similar in operation to modern word processors except it didn’t allow bold facing or underlining or any other kind of styling. This wasn’t required for programming. Screen editors allowed you to use the cursor keys to move around in your program and correct it by deleting the errors and inserting the corrections directly.
Keep in mind that these innovations were taking years to come to pass. Life was getting better all the time for programmers. At this point we even had character based games that drew maps of dungeons on our screens using dashes and vertical bars and represented monsters with single letters that would move around the screen and attack the single letter that represented you in the game.
But life got better still with the introduction of the programmable editor. This allowed the user to create their own custom sequences of commands to reduce tedious repetitive corrections to a single command. For instance, suppose you had a file that contained a hundred lines that had all consisted of some arbitrary text with the unique string “$$” on each line followed by a number. You need to change the number so that it has a decimal point and two zeroes appended to it. A programmable editor would allow you to create a custom command that would look for the string “$$”, find the end of the number after that point and append “.00” to it. This saved countless tedious hours.
That was not the end of improvements in the programmers lot by a long shot. It is however the end of this blog post. I may revisit the topic and bring you up to date with the innovations that came after this point if there is any interest.