Programming

A programming paradigm is a fundamental style or 'way of thinking' about programming. It's not a specific language, but rather an approach to structuring code to solve problems. Different paradigms are suited to different types of tasks. The main paradigms you need to know are:

• Imperative: This is the most common paradigm. It uses statements that change a program's state. You write a sequence of commands for the computer to perform. High-level imperative languages include Python, Java, and C++.
• Declarative: Instead of describing *how* to do something, you describe *what* you want to achieve. The language itself figures out how to get the result. SQL (for databases) and Prolog (for logic programming) are key examples.
• Object-Oriented (OOP): An extension of imperative programming. It organises code into 'objects' which bundle data (attributes) and the methods (procedures) that operate on that data. This promotes code reuse and helps manage complexity in large systems.
• Low-Level: This programming style is very close to the computer's own machine code. It deals directly with memory addresses and processor registers. Assembly language is the primary example. It gives the programmer fine-grained control but is difficult and time-consuming to write.

Structured programming is an approach that aims to improve the clarity and quality of code by breaking a large program down into smaller, self-contained modules. The two main types of modules are procedures and functions.

• Procedure: A subroutine that performs a specific task but does not return a value. You 'call' a procedure to execute its code. For example, a procedure might print a menu to the screen.
• Function: A subroutine that performs a task and *must* return a single value. Because it returns a value, a function call is always used within an expression, for example, being assigned to a variable or used in a print statement.

Both use a 'header' which defines their name and any parameters they accept. This header is also known as the 'procedure/function interface'. Using procedures and functions promotes modularity and code reuse, making programs easier to write, test, and debug.

When we call a procedure or function, we often need to pass data to it. The values we send are called 'arguments', and the variables in the subroutine that receive these values are called 'parameters'. There are two main ways to pass this data:

• Pass by Value: The subroutine receives a *copy* of the argument's data. Any changes made to the parameter inside the subroutine do not affect the original variable in the calling code. This is the default method in many languages and is safer as it prevents accidental modification of data.

• Pass by Reference: The subroutine receives the *memory address* of the argument. This means the parameter becomes an alias for the original variable. Any changes made to the parameter inside the subroutine *will* change the value of the original variable. This is necessary when you want a procedure to modify its input arguments.

Simple variables can hold one piece of data, like a number or a string. Arrays can hold many pieces of data, but they must all be of the same type. Often, we need to group related items of *different* types. For this, we use a record. A record is a composite data structure that groups a collection of related fields under a single name. For example, to store information about a student, you might want to group their ID (an integer), name (a string), and date of birth (a date). A record allows you to do this. You first define the 'template' or 'type' for the record, then you can declare variables of that record type.

Variables and data structures like arrays and records exist in RAM, which is volatile. When the program ends or the power is turned off, all that data is lost. To store data permanently, we must write it to a file on a secondary storage device like a hard drive. This is called persistent storage.

There are three main types of file access:

• Serial: Records are stored one after another, in the order they were added. To find a specific record, you must start at the beginning and read every record until you find it.
• Sequential: A special type of serial file where the records are sorted into order based on a key field. This can make searching more efficient.
• Random: Records can be accessed directly using their position or a key field, without reading through the preceding records. This is much faster for non-sequential access.

Basic file operations include:

• `OPENFILE <filename> FOR <MODE>`: Prepares a file for use. Mode can be `READ`, `WRITE` (overwrite), or `APPEND` (add to end).
• `READFILE <filename>, <variable>`: Reads a line or record from an open file into a variable.
• `WRITEFILE <filename>, <data>`: Writes data to an open file.
• `CLOSEFILE <filename>`: Closes the file, saving changes and freeing up resources.

An exception is an error that occurs during the execution of a program (a run-time error). Examples include trying to divide by zero, accessing a file that doesn't exist, or a user entering text when a number is expected. Without any special handling, an exception will cause the program to crash, which is not user-friendly.

Exception handling is a mechanism that allows a programmer to write code to deal with these errors gracefully. Instead of crashing, the program can detect the error, display a helpful message, and either continue or terminate in a controlled way. The standard structure for this is a `TRY...CATCH` block (sometimes called `TRY...EXCEPT`).

• TRY: You place the code that might cause an exception inside the `TRY` block.
• CATCH: If an exception occurs in the `TRY` block, the program immediately jumps to the `CATCH` block. The code in the `CATCH` block is the 'plan B' - it handles the error, for example by printing a message like "Invalid input, please enter a number."