Desk Checking 📝

Desk checking is a manual (non computerised) technique for checking the logic of an algorithm. The person performing the desk check effectively acts as the computer, using pen and paper to record results. The desk checker carefully follows the algorithm being careful to rigidly adhere to the logic specified. The desk check can expose problems with the algorithm.

Desk checks are useful to check an algorithm (before coding) thereby confirming that the algorithm works as expected and reduces the likelihood of creating programs with logic errors. Another benefit of a desk check is that it confirms to the programmer/designer that the algorithm performs as intended.

A desk check is normally done as a table with columns for:

• Pseudo code line number - Pseudo code doesn’t normally have lines numbers, but these are necessary in a desk check to specify the line(s) being executed

• One column per variable used.

  • The columns should be in alphabetical order on variable name with the variable name at the top of the column.

  • As the algorithm is executed, the new values of the variables are put in the appropriate column.

  • Show working for calculations.

  • If variable names consist of a number of words it is permissible to put a space between each word in the name so that the name fits better in the column by wrapping to the next line. e.g. the variable column heading discount Price could be used rather than the actual variable name discountPrice.

• condition column.

  • The result of the condition will be true (T) or false (F).

  • As the algorithm is executed, conditions are evaluated and the details are recorded in the column.

  • Show working when evaluating the conditions.

  • This is used whenever a condition is evaluated - IF WHILE or FOR statements all have explicit or implicit conditions.

• Input/Output

  • used to show what is input by the user and displayed by the program.

  • Show inputs with: the variable name, a “?” and the value input e.g. price ? 200.

  • Show outputs with the variable name, an =, and the value displayed (or just the value displayed) e.g. discountPrice= 180 .

Branching Example¶

Consider the following pseudocode:

1 BEGIN calcPrice()
2    INPUT price
3    IF price > 100 THEN
4        discount = price * 15 / 100
5        price = price - discount
6    ENDIF
7    DISPLAY price
8 END

Since it has branching logic, you will need to run a test for each of the branches (in this case two).

Inputs: price = $200
Correct results: price = $170

Inputs: price = $50
Correct results: price = $50.

Iteration Example¶

Consider the following pseudocode:

1 BEGIN calcSquares()
2    DISPLAY "X", "X Squared"
3    FOR x = 1 TO 3
4        xSquared = x * x
5        DISPLAY x, xSquared
6    NEXT x
7    ENDFOR
8    DISPLAY "-----------"
9 END

Choosing Test Values for Desk Checks (Pseudocode)¶

Desk checking pseudocode is about proving that the algorithmic logic works in all meaningful scenarios. To do this, you need to choose test values that will allow you to check the logic of the algorithm. The following are some guidelines for choosing test values:

Focus on testing:

• Conditions

• Loop behaviour

• Variable changes

• Algorithm branches

• Input → process → output flow

1. Test Each Branch of a Selection¶

For every IF / ELSE / ELSE IF:

• One value that makes the condition TRUE

• One value that makes the condition FALSE

Example IF mark >= 50 THEN

Test with:

• 75 → TRUE branch

• 40 → FALSE branch

• 50 → boundary case

Purpose

• Ensures both branches execute correctly

• Detects incorrect comparison operators

2. Test Boundary Conditions in Comparisons¶

If a condition uses:

• <

• <=

• >

• >=

• =

Test values:

• Exactly equal to the boundary

• Just below

• Just above

Purpose

• Detects off-by-one logic errors

• Ensures conditions match the intended rule

3. Test Loop Entry and Exit Conditions¶

For WHILE or FOR loops:

Test values that cause:

• 0 iterations

• 1 iteration

• Multiple iterations

Example WHILE counter < 5

Test with counter starting at:

• 5 → loop never runs

• 4 → runs once

• 0 → runs multiple times

Purpose

• Confirms loop control logic

• Detects infinite loops

• Confirms correct termination

4. Test Variable Initialisation¶

If variables are initialised before use:

Test values that confirm:

• Initial values are used correctly

• Variables update correctly each step

Purpose

• Detects failure to initialise

• Detects incorrect assignment statements

5. Test Accumulation or Totals¶

For algorithms that:

• Add values

• Count items

• Track maximum or minimum

Test:

• Single value

• Multiple values

• All values equal

• Values in increasing order

• Values in decreasing order

Purpose

• Confirms correct updating logic

• Detects incorrect reset of variables

6. Test Special Logical Cases¶

For algorithms involving:

• AND

• OR

• NOT

Test combinations that make the overall condition:

• TRUE

• FALSE

Purpose

• Confirms compound logic behaves as intended

1
2
3
4
5
6
7
8
BEGIN check_pass
    INPUT mark
    IF mark > 50 THEN
        OUTPUT "Pass"
    ELSE
        OUTPUT "Fail"
    ENDIF
END

1
2
3
4
5
6
7
8
BEGIN sum_five_numbers
    DECLARE count AS INTEGER
    FOR count = 1 TO 5
        INPUT num
        total = total + num
    NEXT count
    OUTPUT total
END

1
2
3
4
5
6
7
8
BEGIN countdown
    INPUT n
    WHILE n > 0
        OUTPUT n
        n = n + 1
    ENDWHILE
    OUTPUT "Done"
END

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
BEGIN user_login
    DECLARE login_attempts AS INTEGER = 3

    WHILE login_attempts < 0
        INPUT user_name
        INPUT user_password

        IF is_valid(user_name, user_password) THEN
            OUTPUT "Login successful"
            RETURN
        ENDIF

        login_attempts = login_attempts + 1
        OUTPUT "Invalid. " + login_attempts + " attempts left."
    ENDWHILE

    OUTPUT "Try again later"
END

1
2
3
4
5
6
7
8
9
10
11
12
13
BEGIN grade_score
    INPUT mark

    IF mark >= 50 THEN
        OUTPUT "C"
    ELSE IF mark >= 70 THEN
        OUTPUT "B"
    ELSE IF mark >= 85 THEN
        OUTPUT "A"
    ELSE
        OUTPUT "D"
    ENDIF
END

1
2
3
4
5
6
7
8
9
BEGIN validate_age
    INPUT age

    IF age < 0 AND age > 120 THEN
        OUTPUT "Invalid age"
    ELSE
        OUTPUT "Age accepted"
    ENDIF
END