Early High-Level Programming Languages

In the 1950s and 1960s, there was innovation in the field of computer programming and design. Computers were becoming commercially available and starting to gain widespread interest. In 1951 to Univac 1 was the first commercially available computer for example.

FORTRAN

In 1957 came about FORTRAN. FORTRAN was considered one of the first high-level programs to really gain popularity. Its design was suited for high performance when programmed and could perform code optimization to improve the performance of programmers’ instructions. It was ‘Formula Translating’ and its success saw it spread to other computers early on.

Fortran was built for number crunching and computing. Its implementations were widespread and its general-purpose capabilities saw use in many scientific fields of research. Fortran was produced over a series of years under different versions with compatibility for previous versions in many cases. It was by modern-day standards considered low level but no doubt was formulative for other modern-day languages, it included features like code comments, input-output handling and one of the first do loops. FORTRAN has many versions and is still used today.

ALGOL

ALGOL was developed around the same time as Fortran, it was designed for more ‘Algorithmic’ purpose. ALGOL 58 was considered a prototype version named IAL (International Algebraic Language) and was soon superseded by ALGOL 60. It was designed to be more human-readable and could be used to design algorithms and unlike Fortran, it was not designed to be hardware-specific to be the fastest but relied on the best implementations they thought were suitable. Although not as popular as Fortran, many modern languages have features present in ALGOL first, such as IF ELSE statements and dynamic arrays defined at run time.

Stored Program Computers

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.
https://en.wikipedia.org/wiki/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

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.

Assembly

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.

Interpreted Languages

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.