|
|
History of Computer-Programming |
|
At start-time of computers (for me this was around 1968), program was punched on cards as seen on IBM 360. 360 meant 360 kilobyte of memory. On one punch-card there were 80 characters (up to 8 holes for a byte), that is one line on a typing machine. The punch-cards could be changed in sequence. One ancestor of BASIC-language was the programming language FOCAL, a language very similar to BASIC, that was in a time, when for output of the computer there was no monitor, but a typewriter. The program was stored on punch tape and for changes at the program had to exist accordant editor-commands with code echoed on the typewriter, which were a part of the language, to manage this. And this was the essential difference to BASIC. Computer memory was extremely expensive and therefore the computer machine code had a zero-page addressing to save Bytes for addressing on zero-page, and the CPU had not all the internal registers as later CPU's, so the zero-page had to be used as a substitute of internal registers, because all byte movements had to run over the accumulator. The assembler-programmer had to write much code for getting little functions. The microprocessor 6502 was an image of these old Computers PDP8. But the entire BASIC interpreter was on punch-tape and found place in 8 kByte memory together with a long program. It seemed endless, when it printed out.
The programming-language BASIC was with line-numbers, GOTO's and GOSUB's. If the programmer wanted to change anything in a line of the program-listing, he had to extract the whole line out into an edit-line and move back the finished changes into program-listing. That was uncomfortable. But when he was adding later some more code into the program, what was the normal case, all program-lines had to be renumbered, and thereafter program and subroutines could not be found at the same line-number. The programmer wrote very quickly and not much went ahead.
Later there was one programming-language, that was Power BASIC for DOS, a big progress, which had a much more comfortable editor. The programmer could move the cursor up and down in the program-list and change characters at any position in the program. Further, line-numbers were abolished and replaced by names only for significant locations in the program and for subroutines and the programmer could move parts of the program within the entire code and change the sequence. GOTO's and GOSUB's were abolished. All program was put into subroutines, even the main-program and subroutines could be put into another page of the editor. The content of the main-program was only a listing of subroutines and the program had only the task to decide, which subroutine with which parameters were called. Well, it had no sense to jump with a GOTO within a subroutine to a location within another subroutine. And jumps could be replaced by if-instructions. It was valid the principle, that all program was running in loops, of which one was within another or outside of it, but never overcrossing. That was called conceited "structured programming". Certainly, it was another way of thinking to design a function, but it was simple and for powerful programming no other way was around. And the longer a program grew, the more overridden "structures" were introduced, which were invented by the programmer to handle huge program code in a clear way. In Power BASIC for DOS the programmer could write assembler code within the BASIC-code only by starting the line with an exclamation mark and after regarding some rules of determining the start address in the memory and saving some register-contents. Power BASIC for DOS had tools, that were bought subroutines, which could be implemented in different ways into the program and the compiler omitted unused subroutines, but in DOS the programmer had only a memory of 2 Megabytes and if he needed more, he had to write complicated program for memory-management, although he had Gigabytes of RAM.
The next step was BASIC for Windows. DOS was out of use and programming of Windows-functions had to be learnt, otherwise one could not even write A = B + C. In Visual BASIC the editor is even more comfortable, subroutines and functions, both together called procedures, can be clapped shut, so that only the name remains visible. And debugging is already performed while the programmer is writing code, so that programming errors and proposals are immediately displayed. The powerful programming means to set up from the long hand a collection of modules, which can be combined quickly - with adaptions - to powerful program-functions. It is valid the experience, that already simple functions need much code with many details to take into account and programming is so time-consuming, that it does not pay off, if code is not used more often.
|
|
Erich Foltyn
Vienna, Austria
July 10th 2011
|
|
|
