P rogramming concepts Revision Notes

In programming, a variable is a named storage location that can hold data which may change during the execution of a program. For example, a variable named score might store a player's current points and update as the game progresses.

A constant is similar in that it is a named storage location, but its value is fixed once set and cannot be altered during program execution. For instance, a constant named MAX_PLAYERS might hold the value 4 to represent the maximum number of players allowed in a game.

• Variables store data that can change.
• Constants store data that remains fixed throughout the program.

Before using variables or constants, they must be declared. Declaration involves specifying a name (identifier) and often a data type that defines what kind of data the storage location can hold, such as integer, real number, or string.

For example, in pseudocode: `DECLARE age AS INTEGER` creates a variable named age that can hold whole numbers. To declare a constant, the syntax might be: `DECLARE CONSTANT PI AS REAL = 3.14159` which sets PI as a fixed real number value.

Proper declaration helps the program manage memory and prevents errors by ensuring data is used consistently.

• Declaration includes naming and typing the storage location.
• Constants are declared with a fixed initial value.
• Variables can be declared without an initial value but must be assigned before use.

Variables are used when data needs to be stored and updated, such as counters, user inputs, or calculations. Constants are used for values that should not change, like configuration settings or fixed limits.

For example, a program calculating the area of a circle might use a constant for PI and a variable for the radius entered by the user:

`DECLARE CONSTANT PI AS REAL = 3.14159` `DECLARE radius AS REAL` `INPUT radius` `area = PI * radius * radius` `OUTPUT area`

• Use variables for data that changes.
• Use constants for fixed values to avoid accidental modification.
• Using constants improves program readability and maintainability.

Names given to variables and constants should be descriptive to make the program easier to understand and maintain. For example, `totalScore` is clearer than `ts` or `x`.

Good naming conventions help prevent confusion and errors, especially in larger programs or when working in teams.

• Use clear, descriptive names for variables and constants.
• Avoid single-letter or ambiguous names unless used in very limited contexts.
• Follow consistent naming conventions throughout the program.

Always initialise variables before use to avoid unpredictable behaviour. Constants must be assigned a value at declaration since they cannot be changed later.

Be aware of the scope of variables and constants—where in the program they can be accessed. This affects how and where you declare them.

Use constants to represent values that might need to be changed in one place only, such as tax rates or maximum limits, making programs easier to update.

• Initialise variables before use.
• Assign constants at declaration.
• Consider scope when declaring variables and constants.
• Use constants to simplify program updates.

In programming, data types define the kind of data a variable can store. Choosing the correct data type is crucial because it affects how data is stored, processed, and interpreted by the computer. The fundamental data types form the building blocks for all programming tasks and include integer, real, char, string, and Boolean.

• Data types specify the nature and size of data.
• Correct data type selection ensures efficient memory use and accurate operations.
• Fundamental data types are universal across programming languages.

An integer represents whole numbers without any fractional or decimal part. Integers can be positive, negative, or zero. They are commonly used for counting, indexing, and performing arithmetic operations where decimals are not needed.

For example, the number of students in a class (25) or the number of pages in a book (300) are integers.

When declaring an integer variable, it can only hold whole numbers; attempting to assign a decimal value will cause an error or truncation depending on the language.

• Stores whole numbers only, e.g., -3, 0, 42.
• Used for counting and discrete quantities.
• Operations include addition, subtraction, multiplication, and division (result may be truncated).

The real data type represents numbers that can have fractional parts, including decimals. These are also called floating-point numbers because the decimal point can 'float' to any position within the number.

Real numbers are essential when precision is required, such as measurements, financial calculations, or scientific data.

For example, 3.14 (approximate value of pi) or -0.001 are real numbers.

• Stores numbers with decimals, e.g., 2.5, -0.75.
• Used for measurements, averages, and precise calculations.
• Operations include arithmetic with decimal results.

A char data type holds a single character, which can be a letter, digit, symbol, or whitespace. It is typically stored as a numeric code internally (such as ASCII or Unicode).

For example, 'A', '7', or '?' are valid char values.

Char is different from string because it can only store one character at a time.

• Stores exactly one character.
• Represents letters, digits, punctuation, or control characters.
• Useful for processing individual characters in text.

A string is a sequence of characters grouped together to form text. Strings can include letters, digits, spaces, and symbols.

Examples include names like "Alice", sentences like "Hello, world!", or numeric strings like "12345".

Strings are used for storing and manipulating text data such as user input, messages, or file contents.

• Stores sequences of characters, e.g., "Hello".
• Used for text processing and display.
• Operations include concatenation, slicing, and searching.

Boolean data types represent logical values and can only be one of two states: true or false.

Booleans are fundamental in decision-making, controlling program flow with conditions and loops.

For example, a Boolean variable might indicate whether a user is logged in (true) or not (false).

• Stores true or false values only.
• Used in conditional statements and logic operations.
• Enables control flow such as if-else and loops.

Programs need to interact with users or other systems to be useful. This interaction happens through input and output operations. Input operations allow a program to receive data, such as numbers or text, from a user or an external source. Output operations allow the program to display or send results, messages, or data to the user or another system.

Without input and output, a program would simply run without any interaction, limiting its usefulness. For example, a calculator program needs input numbers and must output the result of calculations.

• Input: Receiving data from users or external sources.
• Output: Sending or displaying data to users or other systems.

The most common input method is through the keyboard, where users type data that the program reads. Another input method is reading data from files stored on a disk. In some cases, input can come from sensors or other devices, but these are beyond this scope.

In programming, input is often implemented using specific commands or functions. For example, in pseudocode, the statement 'INPUT age' prompts the user to enter a value that is stored in the variable 'age'. In Python, the equivalent is 'age = input()'.

Input data must often be converted to the correct type. For example, input from the keyboard is usually read as text (string) and may need conversion to an integer or real number before calculations.

• Keyboard input is the most common method.
• File input allows reading stored data.
• Input commands store user data in variables.
• Data type conversion may be necessary after input.

Output usually involves displaying information on the screen, such as results, messages, or prompts. Another output method is writing data to files for storage or further processing.

In pseudocode, output is often done with the 'OUTPUT' or 'PRINT' statement, for example, 'OUTPUT "Result is", total'. In Python, 'print("Result is", total)' displays the message and value.

Output can be formatted to improve readability, such as including labels, line breaks, or formatting numbers to a certain decimal place.

• Screen display is the primary output method.
• File output saves data externally.
• Output commands display or send data.
• Formatting output improves clarity.

Consider a program that asks the user for two numbers, adds them, and displays the result.

Pseudocode example: INPUT number1 INPUT number2 SET sum TO number1 + number2 OUTPUT "The sum is", sum

This program uses input statements to get two numbers, stores them in variables, calculates their sum, and outputs the result with a descriptive message.

• Input two numbers from the user.
• Calculate the sum of the numbers.
• Output the sum with a message.

When implementing input and output, it is important to validate input data to ensure it is sensible and prevent errors. For example, if a program expects a number, it should check that the input is numeric.

Clear prompts and messages improve user experience. For example, 'Enter your age:' is clearer than just 'Input:'.

Programs should handle unexpected input gracefully, such as prompting again or showing an error message rather than crashing.

• Validate input data to avoid errors.
• Use clear prompts and messages.
• Handle invalid input gracefully.

Sequence refers to the order in which instructions are executed in a program. Each statement runs one after another unless the flow is changed by selection or iteration.

Maintaining correct sequence is vital because computers follow instructions literally and sequentially. For example, if you input a number and then print it, reversing these steps would cause an error or unexpected output.

Example: To calculate the area of a rectangle, first input length and width, then multiply, then output the result. Changing this order breaks the logic.

• Sequence ensures predictable and logical execution.
• Errors often arise from incorrect ordering of statements.
• Every program starts with sequence before selection or iteration modifies flow.

Selection allows a program to choose between different actions based on conditions. It uses Boolean expressions to decide which path to follow.

Common selection structures include IF, IF-ELSE, and CASE statements.

Example: If a student's mark is 50 or above, print 'Pass'; otherwise, print 'Fail'. This decision-making controls program behaviour dynamically.

• Selection introduces branching in programs.
• Conditions must be carefully constructed to avoid logic errors.
• Nested selections allow multiple layers of decision-making.

Iteration repeats a block of instructions while a condition remains true or for a set number of times.

Loops such as FOR, WHILE, and REPEAT-UNTIL implement iteration.

Example: To print numbers 1 to 5, a FOR loop runs from 1 to 5, printing each number in turn, avoiding code duplication.

• Iteration reduces code repetition and increases efficiency.
• Loop conditions must be correctly defined to prevent infinite loops.
• Loops can be nested for complex repetition patterns.

Totalling involves adding values together, often within loops, to compute sums such as totals or averages.

Counting tracks how many times an event occurs, such as counting valid inputs or occurrences of a character.

Example totalling: Summing exam scores entered by a user to find the total marks obtained. Example counting: Counting how many times the letter 'a' appears in a string.

• Totalling uses an accumulator variable updated each iteration.
• Counting uses a counter variable incremented when conditions are met.
• Both require initialisation before loops and careful updates inside loops.

Strings are sequences of characters used to represent text. Handling strings involves operations like concatenation (joining), measuring length, extracting substrings, and searching.

Example: Concatenating first name and last name to form a full name, or counting vowels in a word.

String handling is essential for user input processing, formatting output, and data validation.

• Strings are manipulated differently from numbers.
• Common operations include concatenation, length measurement, and character access.
• Understanding string functions helps solve text-based problems efficiently.

In programming, a nested statement occurs when one control structure is placed inside another. This can be a selection statement (like an if statement) inside another selection, or a loop inside another loop. Nesting allows programs to handle complex logic by combining multiple conditions or repeated actions.

For example, an if statement inside another if statement lets a program check a condition only if a previous condition is true, enabling multi-level decision-making.

• Nested statements increase the complexity and capability of programs.
• They are commonly used in decision-making and repetition.
• Proper nesting requires careful attention to syntax and logic.

Nested selection means placing one selection statement inside another. This allows checking multiple conditions in a structured way.

For instance, consider a program that checks a student's grade and then checks attendance:

If the grade is above 70, then check if attendance is above 80%. If both are true, print 'Pass with good attendance'. Otherwise, print 'Pass but poor attendance'. If the grade is 70 or below, print 'Fail'.

• Nested if statements enable multi-level condition checks.
• They help handle complex decision trees.
• Each inner condition is only evaluated if the outer condition is true.

Nested iteration involves placing one loop inside another. This is useful when dealing with multi-dimensional data or repeated processes within repeated processes.

For example, to print a 3x3 grid of stars, an outer loop can iterate over rows, and an inner loop can iterate over columns, printing a star each time.

Example pseudocode: For each row from 1 to 3: For each column from 1 to 3: print '*' without newline; after inner loop ends, print newline.

• Nested loops allow handling of multi-level repetition.
• They are essential for working with arrays, matrices, or grids.
• Care must be taken to avoid infinite loops by ensuring correct loop bounds.

When nesting statements, proper indentation is crucial for readability and to avoid logical errors. Indentation visually separates blocks of code, showing which statements belong inside others.

Most programming languages require consistent indentation or use braces to define blocks. Poor indentation can lead to confusion and bugs, especially in nested code where multiple levels exist.

Example: In Python, indentation defines blocks, so nested statements must be indented further than their parent statements.

• Indentation improves code clarity and maintainability.
• It helps identify the start and end of nested blocks.
• Consistent style reduces errors and aids debugging.

Start by clearly understanding the logic you want to implement. Break down complex conditions into smaller parts.

Use comments to explain each nested block's purpose.

Test nested statements carefully, as errors can be harder to spot than in simple statements. Use trace tables or print statements to follow the flow of execution during debugging.

• Plan nested logic before coding.
• Comment nested blocks for clarity.
• Test thoroughly to ensure correct behaviour.

Procedures and functions are reusable blocks of code designed to perform specific tasks within a program. Using them helps avoid repetition and makes programs easier to read and maintain.

A procedure is a set of instructions executed when called but does not return a value to the calling code. For example, a procedure might display a message or update a variable.

A function is similar but always returns a value after execution. For instance, a function could calculate the area of a rectangle and return the result for further use.

• Procedures perform tasks without returning values.
• Functions perform tasks and return a value to the caller.

Parameters are variables listed in the procedure or function definition that receive values when the procedure or function is called. They allow the same procedure or function to operate on different data each time it is used.

For example, a function to calculate the area of a rectangle might have two parameters: length and width. When called, specific values are passed in, and the function returns the calculated area.

Parameters enable modular and flexible code by avoiding hard-coded values inside procedures or functions.

• Parameters act as inputs to procedures/functions.
• They allow dynamic data to be processed within reusable code blocks.

Local variables are declared inside a procedure or function and exist only during its execution. They cannot be accessed outside that procedure or function.

This limits their scope and prevents unintended interference with other parts of the program. For example, a variable used to store a temporary calculation inside a function is local to that function.

Once the procedure or function finishes, local variables are destroyed and their memory freed.

• Local variables exist only within their procedure/function.
• They help avoid conflicts by limiting variable scope.

Global variables are declared outside any procedure or function, usually at the start of a program. They can be accessed and modified by any part of the program, including all procedures and functions.

While useful for sharing data, overusing global variables can make programs harder to debug and maintain because changes in one place affect others.

For example, a global variable might store a program-wide setting or counter that multiple procedures update.

• Global variables are accessible everywhere in the program.
• They persist for the program’s entire runtime.

Consider a function that calculates the area of a rectangle:

It takes two parameters: length and width (both local to the function).

Inside the function, a local variable area stores the product of length and width. This variable is not accessible outside the function. The function returns area to the caller.

• Function definition: function area(length, width)
• Local variable: area = length × width
• Return value: area
• Caller can use the returned value without accessing local variables directly.

In programming, division can produce both a quotient and a remainder. The MOD routine returns the remainder after division, while DIV returns the integer quotient, discarding any fractional part.

For example, consider dividing 17 by 5: 17 DIV 5 equals 3 because 5 fits into 17 three whole times, and 17 MOD 5 equals 2 because 2 is left over after subtracting 3×5=15 from 17.

Using MOD is useful for tasks like determining if a number is even or odd (a number MOD 2 equals 0 means it is even). DIV is helpful when you need to know how many times one number fits completely into another without fractions.

• MOD returns the remainder of integer division.
• DIV returns the integer quotient, ignoring the remainder.

The ROUND routine approximates a real (decimal) number to the nearest whole number. If the fractional part is 0.5 or greater, ROUND increases the integer part by one; otherwise, it leaves it unchanged.

For example, ROUND(4.3) results in 4, while ROUND(4.7) results in 5. This is useful when you need to convert floating-point results to integers for indexing or display.

ROUND helps avoid errors from truncation and makes results easier to interpret when decimals are not needed.

• ROUND approximates a real number to the nearest integer.
• It rounds up if the decimal part is 0.5 or more, otherwise rounds down.

The RANDOM routine produces a pseudo-random number, often within a specified range. For example, RANDOM(1, 10) generates an integer between 1 and 10 inclusive.

Random numbers are essential in simulations, games, and testing programs where unpredictability is required.

Programmers must understand that RANDOM generates pseudo-random numbers based on algorithms, which appear random but are deterministic if the seed is known.

• RANDOM generates a number within a given range.
• Useful for simulations, games, and randomized testing.

Example 1: To check if a number N is divisible by 4, use: if N MOD 4 = 0 then it is divisible.

Example 2: To find how many full weeks are in D days, use: weeks = D DIV 7.

Example 3: To round a calculated average score avg to the nearest whole number: rounded_avg = ROUND(avg). If avg = 78.6, rounded_avg = 79; if avg = 78.3, rounded_avg = 78.

• Use MOD to test divisibility or cycle through repeating patterns.
• Use DIV to count whole units from totals.
• Use ROUND to convert decimals to integers appropriately.

Always ensure that the arguments passed to these routines are of the correct data type (usually integers for MOD and DIV, real numbers for ROUND).

Be aware that DIV discards the fractional part without rounding, which differs from ROUND.

When using RANDOM, specify the range clearly and understand that repeated calls produce different values, but the sequence can be repeated if the seed is fixed.

• Check data types before using routines.
• Understand differences between truncation (DIV) and rounding (ROUND).
• Use RANDOM carefully to avoid predictable patterns.

Identifiers are names given to variables, constants, procedures, and functions in a program. Using meaningful identifiers means choosing names that clearly describe the purpose or content of the item. For example, naming a variable 'totalScore' is more informative than 'x' or 'a'. This practice helps anyone reading the code to understand what each element represents without guessing.

Meaningful identifiers reduce confusion and errors during development and maintenance. They also make it easier to locate and update parts of the program when requirements change.

• Choose descriptive names that reflect the role or data stored.
• Avoid vague or single-letter names except for simple counters (e.g., i, j).
• Use consistent naming conventions, such as camelCase or underscores, to improve readability.

Comments are notes written within the code that explain what the code does or why certain decisions were made. They do not affect program execution but are vital for human understanding.

Good comments clarify complex logic, describe the purpose of variables or functions, and outline the overall program flow. For example, before a loop that calculates the average score, a comment might say: 'Calculate the average score from all test results'.

Comments should be concise and relevant, avoiding obvious statements that restate the code. They are especially helpful when the logic is not immediately clear or when using non-trivial algorithms.

• Use comments to explain the purpose of code blocks or complex statements.
• Avoid redundant comments that simply repeat the code.
• Update comments when code changes to keep them accurate.

Procedures and functions are blocks of code designed to perform specific tasks. Using them helps break down a program into manageable parts, making it easier to understand, test, and maintain.

A procedure performs actions but does not return a value, while a function returns a value after processing. For example, a function 'calculateArea' might take length and width as inputs and return the area of a rectangle.

Structuring code with procedures and functions avoids repetition, promotes code reuse, and isolates changes to specific parts without affecting the whole program.

• Define procedures for tasks that perform actions without returning values.
• Define functions for computations that return results.
• Use parameters to pass data into procedures and functions, and return values where appropriate.
• Keep procedures and functions focused on a single task for clarity.

Programs developed with meaningful identifiers, clear comments, and structured procedures/functions are easier to debug, update, and extend. This reduces development time and errors when modifying code.

Maintainable code also facilitates collaboration among programmers, as others can quickly understand the program's logic and structure.

For example, if a program calculates student grades, using descriptive variable names like 'studentName' and functions like 'calculateFinalGrade' makes it straightforward to add new grading criteria later.

• Improves readability and understanding for current and future developers.
• Simplifies debugging and testing processes.
• Enables easier updates and feature additions.
• Supports teamwork and code sharing.