Abstraction and Automation

Abstraction is the process of removing unnecessary detail to focus on what is essential for the task at hand. It is one of the most important ideas in computer science.

A map is a classic example: a road map removes buildings, topography, and irrelevant details to show only roads, junctions, and distances. The abstraction is useful precisely because of what it leaves out.

In computing, abstraction allows programmers to work at a higher level without needing to understand every implementation detail below them.

The problem-solving process in computer science follows four stages:

1. Define the problem — understand what needs to be solved; identify inputs, outputs, and constraints
2. Abstract — represent the problem as a model, removing irrelevant detail
3. Design an algorithm — devise a step-by-step solution to the abstract model
4. Automate — implement the algorithm as a program that a computer can execute

AQA identifies seven types of abstraction:

Type	Meaning	Example
Representational	Remove unnecessary detail from a model	London Underground map — distances distorted, surface geography removed
Generalisation / classification	Identify common properties and group similar entities into a class	A Shape class generalises Circle, Rectangle, Triangle
Information hiding	Conceal implementation details; expose only the interface	sort(arr) — you call it without knowing the sorting algorithm used
Procedural	Represent a process as a named subroutine, hiding the steps	printReceipt() — the caller does not know what it prints or how
Functional	Treat a subroutine as a pure mapping from inputs to outputs, ignoring side effects	sqrt(x) — known only by its input/output contract
Data	Hide the implementation of a data structure behind its interface (ADT)	A stack — exposed as push/pop/peek; implemented as array or linked list
Problem reduction	Transform an unfamiliar problem into one with a known solution	Shortest path on a map → single-source shortest path in a weighted graph

Decomposition means breaking a large problem into smaller, more manageable sub-problems that can each be solved independently.

Problem: Build a library management system
    ├── User authentication
    ├── Book catalogue (search, add, remove)
    ├── Loan management (issue, return, overdue)
    └── Reporting (stock levels, popular books)

Benefits of decomposition:

• Sub-problems are simpler to design, implement, and test
• Different team members can work on different sub-problems in parallel
• Sub-solutions can be reused in other projects

Composition is the reverse: combining the solutions to sub-problems to produce the solution to the whole problem. The sub-solutions must have well-defined interfaces so they can be connected.

Decomposition and composition are core practices in structured and object-oriented programming. A function that calls other functions is an example of composition: processOrder() composes validatePayment(), updateStock(), and sendConfirmation().

Information hiding (also called encapsulation in OOP) separates the what of a component from the how. External code depends only on the interface — it has no knowledge of the internal workings.

Example — a Stack ADT:

Interface (what):    push(item)  pop()  peek()  isEmpty()
Implementation (how): could be array-based or linked-list-based

Switching from an array implementation to a linked-list implementation does not affect any code that uses the stack — only the internal implementation changes.

Abstraction layers stack on top of each other in real systems:

Application software  (Python program)
Programming language  (Python interpreter)
Operating system      (file I/O, memory management)
Hardware              (CPU, RAM, disk)
Physics               (transistors, electrons)

Each layer hides complexity from the layer above. A Python programmer does not need to understand transistor physics to read a file.

Automation is the implementation of an abstract model as a program that a computer can execute. The model (algorithm) was designed at the abstraction stage; automation brings it to life in a programming language.

Three key ideas in automation:

1. The model must be computationally tractable — it must be expressible as an algorithm that terminates in a reasonable time
2. The program is a running instance of the model — not the model itself; the same model can be automated in many languages
3. Bugs often indicate a gap between the model and the implementation — the algorithm is correct but the code does not faithfully implement it (or the model does not correctly represent the problem)

Example — sorting as automation:

• Problem: given an unsorted list, produce a sorted version
• Abstract model: a comparison-based algorithm (e.g. merge sort) operating on abstract elements with a defined ordering relation
• Automation: a Python or pseudocode function implementing merge sort on a concrete list of integers

Problem reduction transforms an unfamiliar or hard problem into a known problem with an existing solution.

Examples:

New problem	Reduced to	Solution
Shortest route between two towns	Single-source shortest path in a weighted directed graph	Dijkstra's algorithm
Matching students to universities	Stable matching problem	Gale-Shapley algorithm
Scheduling tasks with dependencies	Topological sort of a DAG	Kahn's algorithm
Searching a sorted list	Binary search on an array	Binary search algorithm

The power of problem reduction is that once a problem class has a known solution, any problem reducible to it is also solved. This is the foundation of algorithm design and also of complexity theory (P vs NP).

1. Confusing abstraction with simplification

Abstraction is not simply "making things simpler." It is selectively removing irrelevant detail while preserving the properties needed for the task. The same real-world entity might be abstracted differently for different purposes (e.g. a road for navigation vs. a road for traffic flow modelling).

2. Describing information hiding as "deleting information"

Information hiding means making internal details inaccessible to external code — not destroying them. The implementation still exists inside the module; it is just not exposed.

3. Confusing decomposition with abstraction

Decomposition is the act of splitting a problem into sub-problems. Abstraction is the act of removing detail from a representation. They are complementary but distinct concepts.

4. Omitting automation from the problem-solving process

AQA specifies four stages: define, abstract, design, automate. Omitting automation (or describing it as just "writing code") misses the point that automation converts an abstract model into an executable program.