Birth of High-Level Languages
Lab: Evolution of Computing
Video Runtime: 06:02
Throughout this era, machines became more powerful and programmers sought the means to abstract (hide away) the machine code into a form that was more easily written, expanded, and controlled. Programming all day in binary or hex codes at the machine level was not efficient. There had to be a way to invent a translator, which converted some language into the binary that the computer needs.
Incrementally throughout this period and even today, computer scientists strive for more efficient and powerful forms of language to push the computer.
Short Code (or Short Order Code) was the first “translated” language. Developed in 1949 by John W. Mauchly, it included commands such as the IF/THEN. Short Code was used on Colossus.
Assembly Language
Then came the Assembly Language, which is also called assembler. In this language, programmers wrote mnemonics to represent the machine code, meaning they used more human-readable symbols to represent the binary codes. The instruction symbols and process are a one-to-one relationship from machine code to assembler. When the code executes, the assembler converts your code into machine code, which is the binary digits of 1s and 0s.
Let’s use the previous example of computing the addition of two numbers represented by A = B + C, where the numbers (data) for B and C are stored in memory.
If you recall, there are four individual steps or tasks the computer must do in order to compute the result and store it away for reuse later.
Step 1: Load B
The first step is to load B out of stored memory and into a working memory location. In machine code, it could look like this:
0010 1011 0001
where:
- 0010 is the Load instruction
- 1011 (decimal value 11) is the working memory location of where to store B
- 0001 (decimal value 1) is the storage memory location of B, i.e. where it is stored.
In assembler, you would write it something like this:
LOAD R11,B
where:
- LOAD is the Load instruction
- R11 is the working memory location of where to store B, or the register.
- B is a symbol representing where the storage memory location of B is located.
Notice how much more readable this is compared to binary code.
Fast Forward to the Code
Let’s look at the comparison of assembler to machine code.
LOAD R11,B
LOAD R12,C
ADD R13,R11,R12
STOR R13,A
0010 1011 0001
0010 1100 0010
1010 1101 1011 1100
1100 0011 1101
You can imagine what an improvement programming in assembler was over writing in binary code for machine code. As a side note, both machine code and assembler are used today.
Second-Generation Languages – High-Level Languages
As machines became more powerful, programmers needed more powerful languages. The need to move further away from machine level code grew. We needed more powerful instruction sets. This is the birth of the high-level language era.
In 1954, John Backus, IBM, developed FORTRAN (FORMula TRANslator), which was released in commercial form in 1957. This language was designed for numerical applications. Instead of thinking specifically in computer instructions, programmers finally had a more natural, meaningful language. We no longer had to think about computer machine steps, such as load from memory and store back in memory. The code instead is converted down to the machine code we saw earlier.
For example, let’s look at our previous example of A = B + C.
program arithmetic
a = b + c
end program
LOAD R11,B
LOAD R12,C
ADD R13,R11,R12
STOR R13,A
0010 1011 0001
0010 1100 0010
1010 1101 1011 1100
1100 0011 1101
High-level languages like FORTRAN, allow us to focus on problem-solving instead of problem solving and machine instructions. Throughout this period, other languages emerged which are still in use today, such as:
- Lisp in 1958
- COBOL (Common Business-Oriented Language) in 1960
- BASIC (Beginner’s All-purpose Symbolic Instruction Code) in 1964
These languages brought new processes such as the compiler, which is the translation software to convert a human-readable language into machine code. In the early days, these high-level languages were actually converted first into assembly language and then into machine code.
New Breed of Software Professional
The development of high-level languages further defined our role in the market. In this era, we saw a division in responsibilities from low-level languages to high-level languages and functionality. Systems programmers wrote software for the tools such as the assemblers and the compilers. Applications programmers wrote the code in high-level language to solve various problems.
Your functions are bloated. Put them on a diet. Think "skinny" and "as few lines as possible."
Episodes
Total Lab Runtime: 01:07:56
