Fundamentals of Computer Programming

A computer's processor understands only one thing: patterns of 0s and 1s. People, on the other hand, think in words and numbers. A programming language is the bridge between the two.

This lesson explains the kinds of programming language, the translator programs that turn what we write into what the machine runs, the three kinds of mistake every programmer makes and how to find them, three languages you will meet in school and beyond, and the basic building blocks of every program: constants, variables and data types.

Lesson 20 then puts all of it to work in Python.

19.1 Programming languages: low-level (machine and assembly) and high-level languages

Programming languages are divided into two groups according to how close they are to the machine.

Low-level languages

A low-level language is close to the hardware: each instruction does one tiny job inside the processor, and a program written for one type of processor does not work on another. There are two low-level languages.

Machine language (first generation, 1GL) is written entirely in binary — 0s and 1s. It is the only language the processor understands directly, so it needs no translation and runs fastest.

But it is almost impossible for people to read, very easy to get wrong, and different for every family of processors (it is machine-dependent).

The first computers were programmed this way, by setting switches or punching holes in cards.

Assembly language (second generation, 2GL) replaces each binary instruction with a short word called a mnemonic: MOV (move), ADD, SUB (subtract), JMP (jump).

It is easier to read than binary, but it is still machine-dependent and needs one instruction for each tiny step. A program called an assembler translates it into machine language.

Assembly language is still used where speed and size matter most, as in parts of device drivers and the tiny chips inside washing machines and remote controls.

High-level languages

A high-level language (third generation, 3GL, and later) uses English words and ordinary mathematical signs, such as print, if, input and c = a + b. One high-level statement may stand for many machine instructions.

High-level programs are easy to read, write and correct, and the same program works on many kinds of computer (it is portable, or machine-independent).

They must be translated into machine language by a compiler or an interpreter before they run. Python, C, C++ and Java are high-level languages.

Some books also name fourth-generation languages (4GL) such as SQL, used to ask a database for information, and fifth-generation languages (5GL) such as Prolog, used in artificial intelligence.

(a) FORTRAN card, 1957

(b) Grace Hopper, compiler

(c) The first real bug, 1947

(d) Dennis Ritchie, C

(e) Dev-C++ editor

19.2 Language processors: compiler, interpreter and assembler

Compiler. A compiler reads the whole source program, checks all of it, and translates it at once into an object program — on Windows, usually an .exe file.

If there are errors, it lists them all after it has finished reading, and no object program is made until they are corrected. Once compiled, the program runs on its own, without the compiler, as often as you like, and it runs fast.

C, C++ and FORTRAN programs are compiled; GCC (the GNU Compiler Collection) and the compiler in Microsoft Visual Studio are examples.

Interpreter. An interpreter takes the source program one line (statement) at a time: it translates that line, carries it out at once, and only then moves to the next line.

It stops at the first error it meets and reports it, which makes errors easy to find and fix — ideal for learning.

But no separate object program is made, so the interpreter is needed every time the program runs, and the program runs more slowly. Python programs are run by an interpreter.

Assembler. An assembler translates a program in assembly language into machine language, one mnemonic at a time into the matching binary instruction.

19.3 Syntax errors, logical errors and run-time errors; testing and debugging

An error in a program is called a bug.

The word was used by engineers long before computers, but it became famous on 9 September 1947, when operators of the Harvard Mark II computer found a moth stuck in one of its relays, taped it into their log book and wrote "First actual case of bug being found."

Program errors are of three kinds.

print("Namaste"

SyntaxError: '(' was never closed

total = 500
students = 0
print("Share =", total / students)

ZeroDivisionError: division by zero

Testing and debugging

Testing means running a program with chosen test data — inputs whose correct outputs you have worked out beforehand — and comparing the program's output with them.

Good test data includes normal values (a mark of 65), boundary values (0, 100, and exactly the pass mark), and wrong values (a negative mark, or a word where a number is expected), to see whether the program copes.

Debugging means finding where an error is and correcting it. Useful ways are:

1. Read the error message: it names the error and usually the line.
2. Dry run (trace) the program on paper with a trace table, as in Lesson 18.
3. Print the values of variables at different points to see where they first go wrong.
4. Step through the program one line at a time and watch the variables. IDLE has a debugger (Debug → Debugger) that runs one line at a time, and a breakpoint is a line where the program pauses.
5. Check one part at a time, and test again after every correction.

# average of the marks in English and Maths
e = float(input("Enter marks in English: "))
m = float(input("Enter marks in Maths: "))
avg = e + m / 2
print("Average =", avg

File "marks.py", line 5
    print("Average =", avg
         ^
SyntaxError: '(' was never closed

Enter marks in English: 60
Enter marks in Maths: 80
Average = 100.0

# average of the marks in English and Maths
e = float(input("Enter marks in English: "))
m = float(input("Enter marks in Maths: "))
avg = (e + m) / 2
print("Average =", avg)

Enter marks in English: 60
Enter marks in Maths: 80
Average = 70.0

19.4 Common high-level languages: Python, C and Java

Thousands of programming languages exist. Three are worth knowing by name at this level, and you will meet them again in later classes.

Python. Created by Guido van Rossum and first released in 1991.

It is run by an interpreter, its programs are short and easy to read, and it needs no declarations, so it is the language that schools around the world, and the grade 8 to 10 courses here, use to teach programming.

It is also used in professional work: websites, data analysis, science and artificial intelligence. Lesson 20 teaches it.

C. Created by Dennis Ritchie at Bell Laboratories, USA, in 1972. It is a compiled language that gives the programmer close control over the computer, so operating systems, device drivers and many other fast programs are written in it.

It is more demanding than Python: every variable must be declared with its type and every statement ends with a semicolon.

Java. Created by James Gosling and his team at Sun Microsystems and released in 1995.

It is compiled into an intermediate code that runs on any computer with a Java Virtual Machine, which is why it is called a "write once, run anywhere" language. It is used in Android apps, banking software and large business systems.

a = 25
b = 17
print("Sum =", a + b)

#include <stdio.h>

int main(void) {
    int a = 25;
    int b = 17;
    printf("Sum = %d\n", a + b);
    return 0;
}

public class Sum {
    public static void main(String[] args) {
        int a = 25;
        int b = 17;
        System.out.println("Sum = " + (a + b));
    }
}

19.5 Constants, variables and data types

A constant is a value that does not change while the program runs. A numeric constant is a number, such as 45, -7.5 or 3.2e4 (which means 3.2 × 10⁴ = 32,000).

A string constant is any group of characters inside quotation marks, such as "Kathmandu", "9841234567" or "2081". The two Boolean constants are True and False.

A constant can also be given a name: Python has no special constant type, so by custom the name is written in capitals, PI = 3.14159, to tell the reader do not change this.

Rules for naming variables in Python

1. A name may contain letters, digits and the underscore _.
2. It must begin with a letter or an underscore, never with a digit.
3. It must not contain spaces or special characters such as -, $, % or ..
4. It must not be a keyword (if, for, class, …).
5. Capital and small letters are different: age, Age and AGE are three different variables.

Data types

The data type of a value tells the computer what kind of data it is, how much memory to give it and what can be done with it.

The two basic kinds are numeric data, used in calculations, and string (character) data, which is text: letters, digits and symbols treated as characters, not as amounts.

Python works out the type from the value, so you never declare it.

name = "Anita Rai"
age = 14
height = 1.52
population = 29164578
is_monitor = True

print(name, "is", age, "years old and", height, "m tall.")
print("Population of Nepal (2021 census):", population)
print("Class monitor:", is_monitor)
print(type(age), type(height), type(name), type(is_monitor))

Anita Rai is 14 years old and 1.52 m tall.
Population of Nepal (2021 census): 29164578
Class monitor: True
<class 'int'> <class 'float'> <class 'str'> <class 'bool'>

Practice questions

Group A — Objective (1 mark each)

1. Machine language is written using [1]aEnglish wordsbmnemonicsc0s and 1sdflowchart symbols
2. The translator that converts assembly language into machine language is [1]aa compilerban interpretercan assemblerdan editor
3. Which translator converts the whole program at once and makes an object program? [1]ainterpreterbcompilercassemblerddebugger
4. Python programs are run by [1]aan assemblerban interpretercan operating systemda modem
5. Which of these is a low-level language? [1]aPythonbJavacassembly languagedJavaScript
6. Dividing a number by zero while a program is running causes [1]aa syntax errorba logical errorca run-time errordno error
7. A program runs to the end but prints a wrong answer because of a wrong formula. This is [1]aa syntax errorba logical errorca run-time errorda hardware fault
8. Python was created by [1]aDennis RitchiebJames GoslingcGuido van RossumdJohn Kemeny
9. In Python, the value "25" written inside quotation marks has the data type [1]aintbfloatcstrdbool
10. Which of these is a valid Python variable name? [1]a2nd_markbfirst namectotal_marksdfor
11. What is the value of 17 // 5 in Python? [1]a3.4b3c2d4
12. A program written by a programmer in a high-level language is called [1]aobject codebsource codecmachine codedbytecode

Group B — Short answer (2 marks each)

1. Write any two differences between a low-level and a high-level language. [2]
2. What is a language processor? Name its three types. [2]
3. Write any two differences between a compiler and an interpreter. [2]
4. What is assembly language? Why does it need an assembler? [2]
5. Define syntax error and logical error with one example each. [2]
6. What is a run-time error? Give two examples. [2]
7. What is debugging? Write any two ways of debugging a program. [2]
8. Define constant and variable with one example of each. [2]
9. Write any four rules for naming a variable in Python. [2]
10. Name the four basic data types of Python with an example of each. [2]

Group C — Long answer (4 marks each)

1. What is a programming language? Explain machine language, assembly language and high-level language, giving one advantage and one disadvantage of each. [1+3]
2. Explain compiler, interpreter and assembler. Which translator is used for Python programs and which for C programs? [3+1]
3. What are testing and debugging? Explain the three types of programming error with one example each. [1+3]
4. Write short notes on any two of these languages: Python, C, Java. [2+2]
5. Study the program below. Find the errors, name the type of each, and write the correct program and its output when the length is 12 and the breadth is 5. [4]

CLS
INPUT "Enter length and breadth: ", L, B
A = L + B
PRINT "Area ="; A
P = 2 * L + B
PRNT "Perimeter ="; P
END

CLS
INPUT "Enter length and breadth: ", L, B
A = L * B
PRINT "Area ="; A
P = 2 * (L + B)
PRINT "Perimeter ="; P
END

Enter length and breadth: 12, 5
Area = 60
Perimeter = 34

Group D — Extended answers (10 marks each, for deeper revision)

1. Differentiate between low-level and high-level languages, and explain the language processors. [10]
2. Explain the types of programming errors and the testing and debugging of a program. [10]
3. Explain constants, variables and data types with examples. [10]

Model answer D1: programming languages and language processors (10 marks)

Introduction. A programming language is a set of words and rules used to write instructions for a computer. Languages are of two levels, low-level and high-level (Plate 19.H).

Low-level languages. Machine language is written only in 0s and 1s, the only language the CPU understands directly. It is very fast but hard to write and different for each computer.

Assembly language uses short codes (mnemonics) such as ADD and MOV instead of 0s and 1s. It is easier than machine language but still depends on the machine.

High-level languages. They use English-like words and are easy to learn and write, and the same program can be used on different computers. Python, C and Java are examples.

Language processors. A computer understands only machine language, so a program in any other language must be translated by a language processor.

1. Assembler: translates assembly language into machine language.
2. Compiler: translates the whole high-level program into machine code at once, and shows all errors together. The compiled program runs fast and can run without the compiler. C is compiled.
3. Interpreter: translates and runs the program line by line. It stops at the first error and is slow, but easy for testing. Python is interpreted.

Conclusion. Humans write in high-level languages, and processors translate them into the machine language of the computer.

Model answer D2: errors, testing and debugging (10 marks)

Introduction. A mistake in a program is called an error or a bug. The word came from 1947, when a real moth was found inside the Harvard Mark II computer (Plate 19.H). Debugging is finding and removing errors.

Types of errors.

1. Syntax error. A violation of the rules (grammar) of the language, such as a missing bracket or a misspelt keyword. The translator finds it and the program does not run. Example in Python: pront("Hello") instead of print("Hello").
2. Logical error. The program runs but gives a wrong answer because the logic is wrong. No error message is shown, so it is the hardest to find. Example: writing AVG = A + B + C / 3 instead of AVG = (A + B + C) / 3; with 6, 9 and 12 the correct answer is 9, but the first gives 6 + 9 + 4 = 19.
3. Run-time error. An error that appears while the program is running, such as dividing by zero or opening a file that is not there. The program stops with a message. Example: PRINT 10 / 0.

Testing and debugging.

1. Testing: run the program with sample data whose answer is already known, including a very small, a very large and a wrong input.
2. Dry run: follow the program by hand with a table of variables to see the values at each step.
3. Debugging: read the error message, locate the line, correct it and run again; print the values of the variables to see where they go wrong.

Conclusion. Errors are natural in programming; careful planning, testing with known data and patient debugging produce correct programs.

Model answer D3: constants, variables and data types (10 marks)

Introduction. A program works with data. The data are held in constants and variables, and each has a data type.

Constant. A value that does not change while the program runs. A numeric constant is a number such as 25 or 3.14. A string constant is text in quotation marks, such as "Nepal".

Variable. A named place in the memory whose value can change. Rules for a name: it must begin with a letter, may contain letters and digits, has no spaces, and cannot be a reserved word such as print.

Example marks, name.

Data types in Python.

Example.

name = "Asha"
age = 13
print(name, age)

The output is Asha 13 (print separates the items with one space).

Conclusion. Constants give fixed values, variables store changing values, and the data type tells the computer how much memory to use and what operations are allowed.