Trends in Programming Languages

Before the high level programming languages we know today, computers were programmed one instruction at a time using binary, octal or hexadecimal code. It was very difficult and expensive to program this way.

This led to the development of assemblers and assembly languages that made programming somewhat easier but this was still the domain of computer specialists.

Later, with the widespread use of computers, individuals wished to solve larger application problems. Assembly and low-level methods were rather inadequate in the resources. As a result a number of `high-level' programming languages began to appear from the mid 1950s, each supporting facilities and control structures for specific fields of application. Since the required resources were not supported in hardware, high level languages had to be developed to support them.

Learning Intentions and Success Criteria

Learning Intentions

Success Criteria

In this tutorial I am going to learn :
  • how to ...
By the end of the tutorial I will be able to :
  • ...

Machine Code

The first code used to program a computer was called machine language or machine code. Machine code could also be called the oldest programming language dating back in the early 1950s.
Machine instructions were in binary form consisting of opcodes, short for operation codes and addresses.

A 16 bit instruction may have the following structure depending on the machine architecture:

0 0 0 1   0 0 0 1 0 0 1 1 0 0 0 1
0 0 1 1   1 1 0 0 1 0 1 1 1 0 1 0
1 0 1 0   0 1 1 0 0 1 0 0 1 1 1 0
Op Code   Address

While they actually ran very fast, low level programs demanded a large expenditure of time on the part of the programmer.

The main problems associated with machine code programming were:
  • Programs would only run on specific machine architectures - they were not portable.
  • Low level programs were by no means easy to read and, as a result, maintaining and adapting them was difficult.
  • Programmers found it difficult to remember the opcodes and looking them up in the system manual was tedious.

Assembly Language

Assembly language programming addressed the problem of programmers remembering all the opcodes and addresses of machine level programming by using symbolic code. The symbols represented a mnemonic that corresponded to the type of operation involved such as ADD, MOV, JMP, etc.

A typical assembly program to add two numbers might look like:

LDA X  {load the value in the X register to the A register
ADD Y  {add the value in the Y register to the contents of the A
STA Z  {Store the result in the Z register

This made writing and debugging programs a good deal easier.

However there was an extra overhead in that the mnemonics had to be translated into native machine code before the processor could carry out the instructions. This was achieved using an assembler.

Like machine code programs, well-written assembly language programs have fast execution times and make efficient use of computer resources; each assembly code statement has a 1:1 relationship with the machine language statement - not portable.

Given a certain specification, a programmer can easily take ten or more times as long to write an appropriate program in assembly level language, compared with one of the higher level languages that are now available.

Assembly language is therefore still used today in embedded systems and device drivers where there might not be much memory available and where the programmer has to make the best possible use of the given architecture.

High Level Language

The early 1960s thus witnessed the evolution of several high level, imperative languages, each designed for a specific area of use. These programs were block-structured (procedures) and the lines of code resembled English sentences and mathematical expressions so were much easier to read and debug. In fact COBOL was designed to be easier to read than assembly code. Each line of high level code now translated to roughly ten to twenty lines of low level code thus allowing programmers more flexibility in constructing programs.
For example, COBOL statements would look like:


Critics said that they would yield programs with unacceptably slow execution times since they would have to be translated to machine code using compilers, which were fairly complex programs in their own right, but supporters argued that a significant reduction in coding and debugging time would result.

Both statements turned out to be true! In the case of FORTRAN the slow compilation speed was offset by the reduced time to program the application.

The use of languages such as ALGOL started the programming revolution and offered programmers many advantages including:
  • The use of statements and keywords using English words
  • Access to high level control structures, such as selection and iteration
  • The use of high level data structures, such as arrays, records and files
  • The capability of defining types and dynamic data structures such as stacks and queues.


The first 4GL language was Forth, developed in 1970 for use in scientific and industrial control systems. 4GLs were typically developed to meet the special needs of data processing, with such applications as databases, spreadsheets and graphics applications. They were non-procedural and designed in such a way that users could specify the nature of the problem in a simple manner without having to understand the computer processing involved.
A typical database command in 4GL would take the form


and the database would be queried until either a match was found or not found.
If, on the other hand, a list of values had to be arranged in numerical order, it is evidently much easier to use the command 'SORT' from the application rather than writing the code in an imperative language to achieve the same objective.

Most 4GLs were written for specific purposes and incorporated the following features:
  • database application tools (dBase, PARADOX, ACCESS macros)
  • end-user tools like query languages (SQL (structured query languages), Postscript)
  • report generators (RPG);
  • application generators, sometimes referred to as RAD (Rapid-application development)

4GLs have evolved into such languages as SQL for Oracle Applicaltions and are responsible for many of the powerful in-built features that can be accessed from a menu or by clicking on an icon in present-day GUI systems.


Considering 5GLs there are various threads that exist:
  • they are natural language systems involved in artificial intelligence and expert systems;
  • 5GL is programming that uses a visual or graphical interface to create source code that can be compiled using a conventional high level language compiler;
  • they encompass event driven, object-oriented programming and GUIs.

In the 1980s vast efforts were being put towards two large projects in artificial intelligence, namely:
  1. the ADA language development in America and
  2. Prolog development - the Japanese "Fifth Generation" Computer Project

It was thought that these two languages would dominate programming language development well into the 21st century. This is partly true but other developments took centre stage.
With the advent of GUIs:
  • event driven, visual programming languages (Visual C, Visual Basic, Visual FoxPro) emerged to take advantage of these powerful interfaces;
  • object-oriented languages (C++, Turbo Pascal, Java, Visual COBOL) also flourished under GUI environments.

Also with the rapid use of the Internet and the WWW, web-based languages were developed to enhance existing software or as languages in their own right. These include scripting languages (JavaScript) and markup languages (HTML, XML) and many more.

  • The language should be available to run on a wide variety of hardware
  • It should be easy to learn
  • It should be simple to implement
  • Require modest computer resources
  • Its code should be efficient at running any program of varying complexity

Additional Videos

Embed video here

Exam Questions

Embed Document here


  • Please make a list of essential key-points here


  • upload files here