Programming

Variables, constants and data types

A variable is a named store whose value can change while the program runs. Every variable is declared before it is used, with an identifier and a data type: DECLARE Score : INTEGER. The data type tells the computer what kind of value the variable holds and what can be done with it.

The five basic data types are integer, real, char, string and Boolean. An integer is a whole number, a real is a number capable of containing a fractional part, a char is a single character, a string is a sequence of zero or more characters, and a Boolean holds either TRUE or FALSE. Choosing the wrong type causes an error rather than a wrong answer: an average of 67.5 cannot be stored in a variable declared as an INTEGER.

A constant is a value that is set once and never changes while the program runs. It is declared with the keyword CONSTANT, for example CONSTANT HourlyRate ← 6.50. Only a literal can be used as the value of a constant, never a variable, another constant or an expression. Constants make a program easier to maintain, because the value appears in one place and can be updated once instead of being hunted down in every calculation that uses it.

Identifiers are the names given to variables, constants, arrays, procedures and functions. Cambridge pseudocode uses Pascal case, so NumberOfPlayers rather than number_of_players: letters and digits only, starting with a capital letter, with no underscore and no accented characters. Identifiers are case insensitive, so Countdown and CountDown must not be used as two different variables, and a keyword must never be used as an identifier.

The name should say what the value is. TotalScore and PupilName tell the next person what is being stored, which is part of what makes a program maintainable. T and P do not.

Input, output and sequence

Values are read into a program with INPUT and written out with OUTPUT. The identifier given to INPUT must be a variable, and it may be a single element of an array. OUTPUT can send several values at once if they are separated by commas, which is how text and values are mixed on one line: OUTPUT "You have ", Lives, " lives left".

An INPUT statement on its own gives the user no idea what to type, so a user prompt is placed immediately before it. OUTPUT "Enter the pupil's score" followed by INPUT Score is the standard pattern, and prompts, inputs and outputs are the three things an examiner looks for when you are asked to write or amend an algorithm.

Sequence means the statements are carried out one after another, in the order in which they are written. The order matters. Setting a total to 0 before a loop gives a correct total, while putting the same statement inside the loop wipes out the running total on every pass.

Data is checked as soon as it is entered. A validation check placed straight after the INPUT statement rejects data that is not sensible before the rest of the program tries to use it, which is why a program can tell you that the age you typed is not valid instead of crashing a few lines later.

• INPUT <variable> reads one value into a variable.
• OUTPUT <value(s)> writes one or more values, separated by commas.
• Put an OUTPUT prompt immediately before every INPUT so the user knows what to type.
• Statements run in sequence, so moving one statement changes the result of the whole program.

Selection: IF and CASE statements

Selection lets a program choose between paths. An IF statement tests a condition and carries out the statements that follow it only when the condition is TRUE. A condition is always an expression that evaluates to a Boolean, such as Score >= 50, and it must never be written as a sentence.

The THEN and ELSE clauses are indented by two spaces, because they are continuations of the IF statement rather than separate statements, and every IF is closed with ENDIF. The ELSE clause is optional: without it, nothing at all happens when the condition is false.

A CASE statement compares one variable with several fixed values, and it is clearer than a long chain of IF statements. Each case clause holds a single value and a single statement, the clauses are indented by two spaces, and the whole statement ends with ENDCASE. An OTHERWISE clause, which must be the last case, runs when none of the other cases apply.

The cases are tested in order. As soon as one applies, its statement is carried out and the remaining cases are skipped, so control passes to the statement after ENDCASE. That is why the order of the cases matters whenever more than one of them could match.

Statements can be nested: an IF inside another IF, or a loop inside a loop. Cambridge will not ask you to write more than three levels of nesting, and each level is indented a further two spaces so that the structure can still be read.

Iteration: count-controlled, pre-condition and post-condition loops

Iteration repeats statements, and there are three loops to choose between. Picking the right one is part of the answer.

A count-controlled loop repeats a known number of times: FOR Index ← 1 TO 10, with NEXT Index at the end. The counter must be an INTEGER, both end values are included, and if the first value is larger than the second the statements are not carried out at all. A STEP can be added to change the increment, and the increment may be negative.

A pre-condition loop (WHILE ... DO ... ENDWHILE) tests its condition before the statements are run, so it runs zero or more times. A post-condition loop (REPEAT ... UNTIL) tests its condition after the statements have run, so it always runs at least once. A WHILE loop repeats while the condition is TRUE, whereas a REPEAT loop repeats until the condition becomes TRUE, which is the opposite of each other.

Totalling and counting are the two standard uses of iteration. Totalling sets a total to 0 before the loop and adds Total ← Total + Value inside it. Counting sets a count to 0 before the loop and adds Count ← Count + 1 inside it. Both variables must be set before the loop and never inside it, or the running value is wiped out on every pass.

Loops can be nested, with one loop inside another, and the inner loop runs right through for every single pass of the outer loop. That is how a table of values is worked through row by row.

Operators, string handling and library routines

Arithmetic operators carry out calculations: +, -, *, / and ^ for a power. The integer operators DIV and MOD work on whole numbers. DIV returns the quotient with the fractional part discarded and MOD returns the remainder, so DIV(10, 3) returns 3 and MOD(10, 3) returns 1. Multiplication and division are worked out before addition and subtraction, and it is good practice to use brackets to make the order explicit in a long expression.

Relational operators compare two values and always produce a result of data type BOOLEAN. The six used are =, <, <=, >, >= and <> for not equal to.

Logical operators combine Boolean values, and only AND, OR and NOT are used. AND is TRUE only when both sides are TRUE, OR is TRUE when at least one side is TRUE, and NOT reverses a value. They let one condition test two things at once: IF Age >= 11 AND Age <= 18.

String handling uses four library routines. LENGTH returns the number of characters in a string, SUBSTRING returns a section of a string given a start position and a length, and UCASE and LCASE return the string or character in upper case or lower case. The first character of a string can be position zero or one depending on the system, so state which position you are counting from.

Library routines are ready-made operations you can call. ROUND(Value, 2) rounds a value to two decimal places, and RANDOM() returns a random number between 0 and 1 inclusive, which can be scaled when a whole number is wanted. ROUND(RANDOM() * 6, 0) gives a whole number from 0 to 6.

The routines are worth memorising with their results. LENGTH("Happy Days") returns 10, SUBSTRING("Happy Days", 1, 5) returns "Happy", UCASE("Happy") returns "HAPPY" and LCASE('W') returns 'w'.

Procedures, functions and writing a maintainable program

A procedure is a named block of code that carries out a task. It is defined once and called whenever it is needed, using the keyword CALL, and it ends with ENDPROCEDURE. Writing the same instructions once inside a procedure rather than repeating them keeps a program short and leaves one place to correct when something changes.

A function works in the same way as a procedure except that it also returns a single value to the point at which it was called, and its definition states the data type of that value. The RETURN statement gives the value back. Because a function produces a value, it is called as part of an expression, such as OUTPUT ClassAverage(Total, Count), and CALL is never used with a function.

Parameters are the values passed into a procedure or function when it is called. They are named and given data types in the definition, and they are used as variables inside the routine. Cambridge will not use more than three parameters. Parameters make a routine general: the same procedure draws a line of any length if the length is passed to it.

Local variables are declared inside a procedure or function and exist only while it runs, so the rest of the program cannot see them. Global variables are declared outside and can be used anywhere in the program. Local variables are safer, because no other part of the program can change them by accident, and they keep routines independent of each other.

A maintainable program is one that somebody else can understand and change without breaking it. That means meaningful identifiers for variables, constants, arrays, procedures and functions; comments, written with // on their own line above the code they describe and at the same level of indentation; procedures and functions that each do one job; and consistent indentation so the structure is visible. A comment should explain why the code does something, not repeat what the line already says.

Arrays: one-dimensional and two-dimensional

An array is a fixed-length structure of elements that are all of the same data type, and each element is reached by its index number. An array is declared with its lower and upper bounds: DECLARE StudentNames : ARRAY[1:30] OF STRING. It is good practice to state the lower bound, because the first index can be 0 or 1 in different systems, and in Cambridge pseudocode a lower bound of 1 is generally used.

A two-dimensional array has two indexes, which is how a table of values is stored: DECLARE NoughtsAndCrosses : ARRAY[1:3, 1:3] OF CHAR. In the main statements only one index value is used for each dimension, so a single square is NoughtsAndCrosses[2, 3].

Arrays are used with iteration, because an index can be a variable. FOR Index ← 1 TO 30 with StudentNames[Index] ← "" inside it sets every element to the empty string, and the same loop with an INPUT statement fills the array from the keyboard. That is the whole point of an array: one loop processes every element instead of thirty separate statements.

Nested iteration works through a two-dimensional array, with an outer loop for the rows and an inner loop for the columns, so that every element is visited exactly once. A seating plan, a table of marks with one row per pupil and a game board are all handled in this way.

File handling

Data held only in variables is lost as soon as the program stops. Storing data in a file means it can be read back the next time the program runs, so a list of club members survives between sessions and can be used by other programs as well.

A file is opened before it is used, and the mode must be stated: OPENFILE "Members.txt" FOR READ, or OPENFILE "Backup.txt" FOR WRITE. A file should be opened in only one mode at a time. Opening a file for WRITE creates a new file, so any data already stored in that file is lost.

Data is read with READFILE "Members.txt", NextName, which reads one item of data and assigns it to the variable, and written with WRITEFILE "Backup.txt", NextName. A single item of data or a whole line of text can be read or written in this way. When the program has finished with a file it must be closed with CLOSEFILE "Members.txt", so that the data is saved and the file is released for other programs to use.

Reading a file normally uses a loop, because the number of items in a file is rarely known in advance. Opening a file for READ when the file does not exist causes an error, so a well-written program checks before it tries.

• OPENFILE <file identifier> FOR <READ or WRITE> opens a file, and the mode must always be stated.
• READFILE <file identifier>, <variable> reads one item of data and assigns it to the variable.
• WRITEFILE <file identifier>, <variable> writes one item of data into the file.
• CLOSEFILE <file identifier> closes the file so that the data is saved and the file is released.
• Opening a file for WRITE creates a new file and destroys any data already in it.