Software development and programming paradigms

14.1 · Free notes

Programming paradigms and levels of language: procedural, modular, object-oriented, low-level and high-level

Key points

• The procedural paradigm builds a program as a sequence of instructions grouped into procedures/subroutines (functions) that are called in order. It uses sequence, selection and iteration, and is typical of C, Pascal and basic Python.
• Modular programming splits a large program into modules/subroutines, each with a single clear task. Modules can be written and tested independently, shared between team members and reused. They communicate through parameters and return values, and use local variables.
• The object-oriented (OO) paradigm models a program as objects that combine attributes (data) and methods (behaviour). A class is the blueprint and an object is an instance of it. Objects are created by instantiation.
• Encapsulation keeps attributes private and allows access only through public methods (getters/setters). This hides implementation detail and protects data from accidental or invalid changes.
• Inheritance lets a subclass (child) acquire the attributes and methods of a superclass (parent), which promotes code reuse. Polymorphism lets a subclass override a method so the same call behaves differently depending on the object type.
• Low-level languages are close to the hardware: machine code (binary opcode + operand) and assembly language (mnemonics such as ADD, LDR). They are machine/architecture-specific, so they are not portable.
• Assembly is translated by an assembler, usually one mnemonic to one machine instruction (one-to-one). Programmers can directly use registers and memory addresses.
• High-level languages (Python, Java, C#) use English-like statements, are portable and are easier to read, write, debug and maintain. One statement becomes many machine instructions, and a compiler or interpreter translates it.
• Low-level code gives fine control of hardware, speed and memory use. This suits embedded systems, device drivers and real-time systems, but development is slow, error-prone and hard to maintain. High-level languages give faster development at the cost of less hardware control.
• Exam tip: match the paradigm to the scenario. Use OO for large systems with many related entities (e.g. customers and accounts). Use procedural/modular for simple linear tasks. Use low-level for tiny, timing-critical devices. Always justify with a benefit and a drawback.
• An imperative high-level language gives instructions that are carried out in order and change the program's state (the values of variables). Procedural and object-oriented languages are imperative, unlike declarative languages such as SQL, which describe the result wanted.

In more detail

• Worked procedural: C programs are sequences of procedures that act on data.
• Worked object-oriented: a Java game models Player and Enemy classes, each with attributes and methods.
• Worked declarative: SQL says what data you want, not how to find it.
• Worked low-level use: device drivers and very speed-critical routines are sometimes written in assembly.
• Worked modular: splitting a program into a maths module and a display module lets different programmers work on each.