You now know how to design an algorithm. Section 8 is about turning it into a working program. First we look at the different types of programming languages, and then at the steps from typing the code to running it.

Build on what you learned in Forms 1–3

These Lower School ICT posts cover the basics of this topic:

• Introduction to Scratch Programming – your first programming language
• Configuring Flowgorithm for CSEC / CAPE / CXC /NCSE – running flowcharts as programs

In this post:

• Low-level languages: machine language and assembly language
• High-level languages
• Translators: compilers, interpreters and assemblers
• The steps in implementing a program

Low-level languages

A low-level language is close to what the computer’s hardware understands.

• Machine language – instructions written in binary (0s and 1s), e.g. 10110000 01100001. The CPU can run it directly, but it is very hard for people to read and write, and it is different for each type of processor.
• Assembly language – uses short codes called mnemonics, e.g. MOV, ADD, LOAD. It is easier than binary but still tied to one type of processor, and must be changed into machine code by an assembler.

Image source: File:FortranCardPROJ039.agr.jpg

High-level languages

A high-level language uses English-like words and normal maths symbols, so it is easier to learn, read and fix. Examples: Python, C, Pascal, Java, Visual Basic. The same program can run on different types of computers (it is portable), but it must be translated into machine code first.

Here is the same tiny program in two high-level languages:

print("Hello, Caribbean!")

#include <stdio.h>

int main(void)
{
    printf("Hello, Caribbean!\n");
    return 0;
}

Both print Hello, Caribbean! – C needs a little more structure (the main function, semicolons and return 0).

Video: The First Programming Languages: Crash Course Computer Science #11 – https://www.youtube.com/watch?v=RU1u-js7db8

Translators

• Compiler – translates the whole high-level program into machine code (object code) before it runs; the result can then be run many times. C uses a compiler.
• Interpreter – translates and runs the program one line at a time, and stops at the first error it meets. Python normally uses an interpreter.
• Assembler – translates assembly language into machine code.

Steps in implementing a program

1. Create the source code – type the program in a high-level language using an editor or IDE (e.g. IDLE, Thonny, VS Code, Code::Blocks). The program you type is called source code.
2. Translate (compile) – the compiler checks for syntax errors and converts the source code into object code (machine code).
3. Link – the linker joins the object code with any library code it uses (e.g. the code for printf) to make one executable file.
4. Execute (run) – the computer runs the executable program, and you test it with test data.
5. Maintain – after the program is in use, it is corrected, updated and improved (e.g. when the VAT rate changes or users ask for a new feature).

For example, to run the C program above in a terminal you type gcc hello.c -o hello (compile and link) and then ./hello (execute).

Related

Related: The Real Context of Program Implementation & Programming languages – 2025-10-08_09-30-23

Paper 1 practice (multiple choice)

Choose the best answer for each question. Try them all before you check.

1. Which of the following is a high-level language?
(A) Machine code
(B) Assembly language
(C) Python
(D) Binary

2. A program that translates the whole of a source program into machine code before it is run is
(A) an interpreter
(B) a compiler
(C) an assembler
(D) a linker

3. Assembly language uses
(A) English sentences
(B) mnemonics such as ADD and MOV
(C) only 0s and 1s
(D) pictures

4. Which step joins object code with library routines to make an executable program?
(A) Editing
(B) Linking
(C) Maintaining
(D) Testing

5. ONE advantage of a high-level language over a low-level language is that it is
(A) harder to read
(B) machine-dependent
(C) easier to learn and portable
(D) always faster

Paper 2 practice (structured question)

A programmer in Georgetown writes a program in C to keep track of a shop’s stock.

(a) Distinguish between a low-level language and a high-level language. (2 marks)

(b) Name TWO types of low-level language. (2 marks)

(c) Describe the following steps in implementing a program:

(i) compiling (1 mark)

(ii) linking (1 mark)

(iii) executing (1 mark)

(d) State ONE difference between a compiler and an interpreter. (2 marks)

(e) Explain why maintenance is a step in implementing a program. (1 mark)

Total: 10 marks

Next: Program Errors, Testing and Debugging: Syntax, Logic and Runtime Errors

Syllabus link: This post is relevant to the CSEC® Information Technology Syllabus (CXC 30/G/SYLL 17), Section 8: Program Implementation, Specific Objectives 1 and 2 (“distinguish between low-level and high-level programming languages” and “describe the sequence of steps in implementing a program”).

Attributions to media used in this post:

• FortranCardPROJ039.agr.jpg – Arnold Reinhold – CC BY-SA 2.5 (via Wikimedia Commons)

© 2026 Vedesh Kungebeharry. All rights reserved.