A Stored Program Architecture such as Von Neumann Architecture stores programs in computer memory and if not using an interpreted or JIT programming language the memory and data for programs can be treated the same. This methodology made programming in previous generations a lot easier as it meant the computer could be programmed using punch tape or cards.
The first ‘Fully’ stored programming computer was the Manchester Mark 1 which was first operational in April 1949.https://en.wikipedia.org/wiki/Manchester_Mark_1
However there is some dispute as to the true ‘first’ stored program computer.
Before the use of punch cards or tape, computers could be programmed in a similar method using wires. This meant a lot of re-wiring and ‘patching’ was difficult on complex systems as the wires would encompass whole rows of machinery and in some cases could take many miles to complete a program.
In Addition to the ‘Von Neumann’ architecture, there is also the ‘Harvard’ architecture which keeps data and program (memory) registers independent.
Programming Order of Succession
- Early computers were not re-programmable. They were hard-wired.
- Then punch tape and punch cards were developed to feed into computer memory to be computed.
- Then programs started to use machine code, although complex for a human to develop they were one of the first innovations that allowed for easy computer programming and rapid development.
- After machine code, a new symbolic form of machine code was created whereby complex hardware instructions could be reduced to line by line instructions. Hence the first machine code compiler was created in order to turn assembly code into machine code.
Machine code could be considered a modern-day programmers’ lowest level of access to a computer’s processor. Machine code provides basic instructions that are logical or mathematical to store, move or load instructions. It is possible on modern hardware to virtualize machine code and some modern programming languages like Java can compile programs into byte code where the initial program can be computed on many platforms.
Due to the complexity of Machine Code, the need for a language that was human-readable (and later developed into high-level programming languages) birthed Assembly, an easy to use (comparably) way to program the computer in a methodology and symbolic sense designed for human readability. Instead of numeric OPCODES, the new syntax allowed for easily identifiable instructions (MOVL, JMP, ADDL). Embedded software and real-time systems may still use machine code as its primary source code today.
As high-level languages and capslock languages were adapted, interpreted languages were developed (the 1950s onward) by using the computer to virtualize itself and process instructions as a ‘virtual machine’ (in the literal sense) that could aide the use in porting the language to other computers as the language syntax could be a defined standard and the compiler could compile the program to many forms of machine code for different models and modes of computer. Interpreted Languages have the added benefit of allowing the programmer to debug their program at a more granular level where programs could be inspected line by line before translation (compilation and then execution).
Byte code such as Java byte code can be interpreted or compiled just in time (JIT) whereas the program is running, it is also translating the byte code into machine code. However, this additional workload has a performance toll on the program.
High Level Programming Languages
High-level programming languages reduce the learning curve and frustration that comes with debugging a program as the syntax and grammar of the language are much easier to understand for the reader because it is based on a more natural approach to human interpretation. However, the benefits can cause programs to be compiled in a way that does not optimize performance or utilize capacity fully because the language could be interpreted in a way that the programmer did not intend or was not aware of.
However, the development of High Level Programming languages allowed for much more rapid development than its predecessors which meant performance hits to compiled machine code programs did not exceed the increased development performance (The programmers were able to do their job easier, which made the programs better) in the 1950s.
Example Early High Level Programming Languages
- FORTRAN (Formula Translation)
- COBOL (Common Business Oriented Langauge)
- ALGOL (Algorithmic Language)
- LISP (List Processing)
- BASIC (Beginners All Purpose Instruction Code)
Sometimes called the Capslock Programming Languages.
Programming Languages could be classified by their approach to programming paradigms such as statements or methods, functions or object-oriented. Most modern-day programming languages are fit for general purpose.