Chapter 4 — Program Coding

What is programming? Programming is the activity of creating a set of instructions a computer can follow to perform tasks. These instructions must be precise, unambiguous and ordered. A program is the written form of these instructions in a language the computer can interpret. Programming teaches you to think logically: break a problem into smaller steps, decide what information is needed, and tell the computer exactly how to use that information.

What is an algorithm? An algorithm is a clear and finite sequence of steps to solve a specific problem. It does not depend on a particular programming language. Instead, it explains the logic of the solution. An algorithm should be correct, clear, and terminate after a finite number of steps. Writing an algorithm first helps catch mistakes before writing code.

Why start with algorithms? Designing an algorithm before coding makes development faster and less error-prone. It is easier to check logic in plain steps or with a flowchart than to correct errors in source code later. Algorithms are also reusable: once you have a method to find the largest of three numbers, you can apply the same logic in many programs.

Characteristics of a good algorithm A good algorithm is:

• Correct: it solves the problem for all valid inputs.
• Efficient: it uses reasonable steps and resources for the task size.
• Simple: steps should be easy to understand and follow.
• Finite: it must finish after a limited number of steps.

How to express an algorithm You can write algorithms in simple numbered steps, in pseudocode that looks like programming statements, or show them as flowcharts. For school problems, choose the method your teacher prefers. Always test an algorithm with sample inputs by doing a dry run on paper: write down the values that change at each step and check that the final result is what you expect.

Flowcharts are diagrams that show the flow of control in an algorithm using standard symbols. Standard symbols include an oval for Start/End, a parallelogram for Input/Output, a rectangle for Process or calculation, and a diamond for Decisions that branch into two or more paths. Arrows show the order in which steps happen. A flowchart makes it easy to visualise choices and loops and to spot mistakes such as missing steps or incorrect branching.

Pseudocode is a way to write the logic of a program using plain language mixed with common programming words like READ, WRITE, IF, WHILE, FOR and CALL. It is more detailed than a high-level algorithm written in sentences, but it avoids strict language syntax. Pseudocode should be precise enough for someone to convert it into actual program code without guessing the logic.

When to use each Use a flowchart when you want a clear picture of branching and looping, which helps during class explanation or presentation. Use pseudocode when you are about to write the program because it maps closely to code structure and is faster to write than a detailed flowchart. Both methods support testing: you can walk through them with sample inputs to ensure correct behaviour.

Good practices Keep flowcharts tidy: limit crossing arrows and group related steps. Label decision branches clearly (Yes/No or True/False) and use consistent symbol sizes. For pseudocode, use clear indenting and meaningful names for variables and procedures. Include comments or short notes explaining assumptions such as whether input numbers are positive or whether arrays are 0-based. Teachers often ask for both flowchart and pseudocode for the same problem to show complete understanding.

Variables are named containers that hold data values while a program runs. Imagine each variable as a labelled box where you store a piece of information: a number, a name, or a true/false answer. Variables let a program remember and change values. Use meaningful names such as totalMarks, studentName or counter so that the purpose of each box is clear when reading the code.

Data types describe what kind of value a variable can hold. Common types taught at this level are integers (whole numbers), real or float (numbers with decimal parts), strings (text), and boolean (true or false). Choosing the correct type helps prevent errors: for example, dividing two integers in some languages may give an integer result by truncation, while using real types keeps decimals.

Declaration and assignment Some programming environments require declaring a variable with its type before using it, e.g., INTEGER age. Other environments let you assign a value directly, e.g., age = 12. Assignment uses the equals sign to store a value: marks = 85. You can update a variable with expressions, for example: count = count + 1 increases the stored value by one.

Naming rules and conventions Variable names should start with a letter and may include letters, digits or underscores, depending on language rules in class. Avoid single-letter names except for counters like i or j in loops. Consistent naming style, such as camelCase (totalMarks) or snake_case (total_marks), makes code easier to follow. Add short comments to explain any non-obvious variable purpose.

Common mistakes Using a variable before assigning a value leads to undefined behaviour. Mixing types without conversion (for example adding a number to a string) causes errors in many languages. Be careful with array indices which are also variables: using an out-of-range index causes runtime errors. Always initialize variables where necessary, and document expected ranges or units (for example, marks out of 100).

Input allows a program to receive data from a user, a file, or another system. Typical input statements use words like READ or INPUT followed by variable names. A good input prompt explains what is expected, such as "Enter number of students:" so the user provides the correct type and number of values. When writing programs, think about the order of inputs and validate them where necessary.

Output displays results or messages to the user. Output statements use words like WRITE, PRINT or DISPLAY and can combine text with variable values. For clarity, include labels when printing values: instead of printing 72, print "Average = 72". Formatting matters when printing lists or tables; align columns and use clear headings when required.

Type handling and conversion Input is often read as text and may need conversion to numbers. Some teaching languages convert automatically; others require explicit conversion functions. Watch for invalid inputs such as letters where numbers are expected. Include checks and helpful error messages so the program does not crash or produce misleading results.

Input order and default values Ensure that every READ statement appears before the code that uses that value. For optional inputs or menu choices, provide default values or instructions. When reading multiple values, decide whether to read them on one line separated by spaces or on separate lines. For exams, follow the input/output style shown in examples or teacher instructions.

Testing I/O Test with normal inputs, boundary cases such as zero or maximum values, and invalid inputs to see if the program handles them gracefully. Check output formatting and messages so a user unfamiliar with the program can understand the results without extra explanation.

Operators are the building blocks for forming expressions that perform calculations or tests. At this level we use three main groups of operators: arithmetic, relational and logical. Arithmetic operators like +, -, *, / and % perform mathematical calculations. Relational operators compare two values and return true or false, using symbols like =, !=, <, >, <= and >=. Logical operators combine boolean results and include AND, OR and NOT.

Expressions are combinations of variables, constants and operators that evaluate to a single value. For example, total = price * quantity + tax is an arithmetic expression. A condition such as age >= 18 is a relational expression that evaluates to true or false. Logical expressions combine such conditions: (age >= 18) AND (hasID = true).

Operator precedence determines the order in which parts of an expression are evaluated. Multiplication and division are done before addition and subtraction; relational checks come after arithmetic; logical operators are evaluated after relational operators. Use parentheses to make the intended order explicit and improve readability. For example, (a + b) * c forces addition before multiplication.

Integer vs real operations Be aware that dividing integers may produce integer results in some languages (discarding the fraction), while using real types preserves decimals. The modulus operator (%) gives the remainder of integer division and is useful for checking even/odd numbers or cycles. Logical operators short-circuit in many languages: an AND stops evaluating if the first part is false because the whole expression cannot be true.

Common mistakes Mixing types without conversion, forgetting parentheses, and misunderstanding operator precedence cause wrong results. When writing complex expressions, break them into smaller steps or use temporary variables for clarity. Always test expressions with values that reveal precedence or type errors.

Sequence is the simplest control structure in which statements execute one after another. Most programs begin as a sequence: read inputs, perform calculations, and display outputs. Each step must be in the correct order so that values used in a statement have already been assigned.

Designing small programs Start with a clear problem statement: what inputs are needed and what outputs are expected. Write an algorithm in numbered steps or pseudocode and then map each step to program statements. Keep the program short and focused on one task. Simple programs are ideal for practicing correct use of variables, input/output and expressions.

Structure of a simple program A typical small program contains: a start point, input statements, processing statements, output statements and an end. Use comments to describe the purpose of the program and the meaning of key variables. Test parts of the program independently. For example, test the input routine separately from the calculation routine to find errors quickly.

Examples of simple programs Friendly examples are calculators for two numbers, temperature converters between Celsius and Fahrenheit, area or perimeter calculators for shapes, and small grade calculators that compute total and average marks. These programs use sequence to perform their steps and reinforce basic skills.

Checking and testing Always dry-run the program with sample inputs and list variable values step by step. Test normal cases, boundary values such as zero or negative inputs if allowed, and large values to ensure no overflow or incorrect formatting. Good testing at this stage prevents more complex errors when you add selections and loops later.

Selection statements allow a program to choose different actions depending on conditions. The basic form is IF condition THEN action ENDIF, used when an action should run only if a condition is true. IF-ELSE extends this to provide an alternative action when the condition is false: IF condition THEN action1 ELSE action2 ENDIF. These constructs are essential for decisions like pass/fail, eligibility checks, and menu choices.

Writing clear conditions Conditions use relational and logical operators to compare values and combine subconditions. Make conditions readable by using parentheses and descriptive variable names. For example: IF (age >= 18) AND (hasID = true) THEN ... checks two requirements clearly.

Nested IF and multiple choices Sometimes you need to check several conditions in sequence, such as grading ranges. You can nest IF statements inside others or chain conditions using IF...ELSE IF...ELSE (if your pseudocode style allows it). Keep nesting shallow because deep nesting makes code harder to read. For more than two branches, a CASE or SWITCH structure is cleaner if available.

Common pitfalls Off-by-one errors in ranges (for example using > instead of >=) lead to incorrect branching. Forgetting an ELSE path can leave the program without guidance for some inputs. Also be careful to use correct logical operators: using OR where AND is needed changes the logic.

Testing selection Test each branch with inputs that make the condition true and false, and test boundary values that are exactly on limits. Include tests for unexpected input, such as negative numbers or empty strings, to ensure the program responds sensibly and does not crash.

Loops let a program repeat actions multiple times without writing the same code again. They are used when a task must be performed repeatedly, like summing many numbers, processing each item in a list, or responding to user input until a condition is met. Two common loop types are WHILE (repeat while a condition is true) and FOR (repeat a known number of times).

WHILE loops check the condition before running the loop body. They are suited to situations where the number of iterations is not known beforehand. For example, reading numbers until the user enters 0 uses a WHILE loop. Remember to update variables used in the condition inside the loop so it eventually becomes false and the loop terminates; otherwise you risk an infinite loop.

FOR loops are used when you know how many times you want to repeat an action. A FOR loop typically sets a counter to a start value, repeats until the counter reaches an end value, and updates the counter each iteration. Use FOR to iterate over array indices or to perform an action a fixed number of times.

Loop control and nested loops Some languages provide statements like BREAK to exit a loop early or CONTINUE to skip to the next iteration. Nested loops are loops inside loops and are useful for working with two-dimensional data, such as tables. Be cautious with nested loops: they multiply the number of iterations and may slow the program if sizes are large.

Testing loops Test loops with zero iterations, one iteration, and many iterations to check boundaries. Trace the loop by listing the counter and relevant variable values after each pass to ensure the correct behaviour. If a loop is not finishing, inspect how the condition depends on variables and whether they change appropriately within the loop.

Functions and procedures are named blocks of code designed to perform a single, well-defined task. A function usually returns a value to the place where it was called; a procedure performs an action but may not return a value. Using functions and procedures helps divide a program into smaller, manageable parts that are easier to write, test and reuse.

Design and purpose Each function should have a clear purpose and a small footprint: do one thing and do it well. Describe required inputs as parameters and define what the function will return. For example, a function calculateAverage(marks, n) might take an array and its size, and return the average. Writing a function header and a brief comment describing expected inputs and outputs is good practice.

Calling and parameters Call a function by using its name and providing arguments. Parameters are the names used inside the function; arguments are the actual values passed. At this level, focus on passing values (call by value), where the function cannot change the original variable outside its scope. Some languages allow passing by reference, but that is an advanced topic.

Benefits Reusability: write once, use many times. Testing: you can test functions individually with sample inputs. Readability: the main program becomes a set of high-level calls, making the overall logic easier to follow. Maintainability: fix or improve the function and all callers benefit immediately.

Examples and testing Write small functions like square(x) returning x*x, or isEven(n) returning true if n%2=0. Use functions in loops or decision statements. Test functions with typical, boundary and invalid inputs to ensure they behave correctly. Document any assumptions such as non-negative input or non-empty arrays so callers know how to use the function safely.

Arrays or lists are structures that store several values of the same type under one name. Each value is stored in a position or index. Arrays make it easy to represent collections such as marks for a class, a series of temperatures, or a list of names. Using arrays avoids needing many separate variables like mark1, mark2, mark3, which are hard to manage.

Declaration and use Depending on the teaching convention, arrays may start at index 0 or 1. When declaring an array, specify its size if required. For example, declare marks[5] to store five values. To access an element, use the array name with an index: marks[2] refers to the third element if indexing starts at 0. Always ensure index values stay within the valid range to prevent errors.

Common operations Reading values into an array is done with a loop: FOR i = 0 TO n-1 READ arr[i] ENDFOR. Traversing with loops lets you compute totals, find the largest or smallest element, count elements satisfying a condition, or copy values to another array. Sorting arranges elements in order; simple methods like bubble sort compare adjacent elements and swap them repeatedly until the array is ordered.

Searching Linear search checks each element sequentially and stops when the target is found or the end is reached. For small arrays this is simple and sufficient. Record the index of the found element or a sentinel like -1 if not found. For larger arrays, efficient methods exist but are beyond the current class level.

Edge cases and testing Test with arrays of size zero (if allowed), size one, and typical sizes. Watch for off-by-one errors: loops should match the chosen index range. Use clear variable names like n for size and i for index and comment whether your array starts at 0 or 1.

Debugging is the process of locating, understanding and fixing errors in a program. Errors can be syntax errors (mistakes in the code that prevent the program from running), runtime errors (problems that happen while the program runs, such as division by zero), or logical errors (the program runs but produces incorrect results). The goal of debugging is not only to fix the visible symptom but to understand and correct the underlying cause.

Tracing is a useful debugging technique where you follow the program step by step and record the values of variables at each point. You can do this manually on paper or include temporary output statements in the program to print variable values during execution. Tracing helps you see where a value differs from what you expect and narrows down the place to search for the mistake.

Practical debugging steps First, reproduce the error consistently with a test case. Read any error messages carefully because they often indicate the line number or type of problem. Insert prints or use a trace table to capture variable values at important steps. Simplify the code to isolate the part causing the issue, and test each part separately. After fixing, rerun all relevant tests to ensure the change did not introduce new errors.

Common mistakes to look for Off-by-one errors in loops, wrong operator precedence, using the wrong variable name, forgetting to initialize variables, and index out-of-bounds for arrays are frequent sources of bugs. Logical errors such as using <= instead of < can lead to wrong outputs without crashing, so careful testing with edge cases is important.

Good habits Write small programs and test frequently, keep code well commented, and use meaningful variable names to make tracing easier. Maintain a simple log of test cases and their results so you can check that fixes remain correct over time.

Program design is the planning phase where you think through a problem and decide how the program will work before writing code. Good design begins with a clear problem statement: specify inputs, outputs and any constraints. Then write an algorithm or draw a flowchart and prepare pseudocode. Decide on data structures such as variables or arrays, and identify functions or procedures for repeated tasks. Planning reduces errors and makes coding faster.

Modular design Break a program into modules where each module does one job, for example input handling, processing, or output. Use functions for tasks that recur, and keep each function short and focused. This makes testing easier because you can test each module independently before combining them into the main program.

Documentation Document both inside and outside the code. Header comments should give the program name, purpose, author, date and brief instructions for running it. Inline comments explain tricky parts or the intention behind particular choices. External documentation, such as a short user guide and a list of test cases with expected results, helps teachers and classmates understand and run your program.

Naming and style Use meaningful variable and function names, consistent indentation, and readable formatting. Follow any style rules your teacher gives. Consistent style not only makes your code easier to read, it also earns marks in assessments where clarity is evaluated.

Testing plan Prepare test cases that include normal inputs, boundary cases and invalid inputs. Record expected outputs and compare them to actual outputs. A simple test table shows input, expected output, and actual output, and notes whether the test passed. This demonstrates a careful approach to development and helps in debugging.

Class project asks you to use the techniques learned in this unit to build a small, complete program. The project should show your ability to analyse a problem, design a solution, write working code and document it. Choose a manageable task such as a student marks manager, a small calculator, a number-guessing game, or a contact list. The goal is to demonstrate clear logic, correct use of variables, selection and looping, arrays where needed, and at least one function or procedure.

Planning the project Begin with a short problem statement describing what the program does and who will use it. List inputs and expected outputs. Draw a flowchart for the main workflow and prepare pseudocode for each module. Decide on function names and what parameters they need. Plan test cases that include typical inputs, boundary values and invalid inputs. A project plan showing tasks and estimated time is useful for group work.

Implementing the project Code module by module, and test each piece before integrating. Use clear variable names and include comments explaining main steps. For user interaction, provide friendly prompts and validation messages. If the project has a menu, ensure each choice calls the correct function and there is a way to return to the menu or exit cleanly.

Documentation and presentation Prepare a short user guide with instructions to run the program, sample input and output, and descriptions of any assumptions. Include the algorithm or flowchart, the pseudocode or code listing, and a table of test cases showing expected and actual outputs. During assessment, be ready to explain design choices and to run the program for the examiner.

Assessment focus Teachers look for correct working logic, readable and well-documented code, appropriate testing, and a clear demonstration of understanding. A small well-tested project with good documentation is better than a large incomplete one. Practice presenting the program and discussing how you tested and debugged it.