Abstraction and decomposition

Welcome to Program Design!

In this chapter, we are going to look at the two most important "mental tools" a computer scientist uses: Abstraction and Decomposition. Don't let the big words scare you! At their heart, these are just fancy names for things you already do every day to solve problems. By the end of these notes, you’ll see how these techniques turn a "mission impossible" coding project into a set of easy, bite-sized tasks.

1. Abstraction: Focusing on What Matters

Imagine you are looking at a map of a city to find a bus stop. Does that map show every single blade of grass? Does it show the color of everyone’s front door? Of course not! If it did, the map would be too cluttered to read.

Abstraction is the process of removing or hiding unnecessary details from a problem so that you can focus on the important parts. In computer science, we use abstraction to reduce complexity and make it easier to design a solution.

Real-World Analogy: Driving a Car

When you drive a car, you use abstraction. You interact with a steering wheel, pedals, and a gear stick. You do not need to know exactly how the pistons move in the engine or how the fuel injection system works to get to the grocery store. Those details are "abstracted away" because they aren't necessary for the task of driving.

Why is Abstraction Important?

1. Simplifies the Problem: It makes the core logic easier to see.
2. Saves Time: You don't waste energy on details that don't affect the outcome.
3. Better Design: It allows you to create models (like a weather map or a flight simulator) that actually work.

Did you know? The famous London Underground (Tube) map is a classic example of abstraction. It doesn't show the actual distances or curves of the tracks; it only shows the connections between stations because that's all a passenger needs to know!

Quick Review: Abstraction

• Definition: Hiding unnecessary detail.
• Goal: To simplify the problem.
• Example: A car dashboard or a simplified map.

2. Decomposition: Breaking it Down

If someone told you to "Build a House," you might feel overwhelmed and not know where to start. But if they told you to "Lay the bricks for the front wall," that feels much easier.

Decomposition is the process of breaking a large, complex problem into smaller, more manageable sub-problems. Each of these sub-problems accomplishes a specific, identifiable task. These smaller tasks can then be broken down even further until they are simple enough to solve easily.

Step-by-Step Example: Making a Cup of Tea

If we decompose the task of "Making Tea," it might look like this:

1. Boil Water: (Fill kettle, plug in, wait for click).
2. Prepare Mug: (Get mug, add tea bag).
3. Brew Tea: (Pour water, wait 3 minutes, remove bag).
4. Finish: (Add milk/sugar, stir).

Each of these steps is an identifiable task. If you can do these four small things, you have successfully solved the big problem of "Making Tea."

Decomposition in Programming

In the world of 9645 Computer Science, decomposition is achieved through the use of subroutines (also known as functions or procedures). Instead of writing one giant block of code, we write small subroutines that each handle one part of the program, like calculateTax() or validatePassword().

Memory Aid: Divide and Conquer

Think of Decomposition as "Divide and Conquer." You divide the giant enemy (the problem) into a tiny army that you can conquer one by one.

Quick Review: Decomposition

• Definition: Breaking a problem into smaller sub-problems.
• Goal: To make a complex task manageable.
• In Code: We use subroutines to represent these sub-problems.

3. How They Work Together

Don't worry if these two feel similar at first! They are two sides of the same coin. Here is how to tell them apart:

• Abstraction is about DETAIL. (What can I ignore?)
• Decomposition is about STRUCTURE. (How can I break this into pieces?)

Example: Creating a Video Game
You use abstraction to decide that a "Player" is just a character with a "Health" number and a "Position"—you ignore their eye color or what they ate for breakfast.
You use decomposition to break the game into tasks: "Handle Input," "Update Physics," and "Render Graphics."

4. Common Mistakes to Avoid

• Mistaking one for the other: Remember, if you are deleting info, it's Abstraction. If you are chopping the problem into parts, it's Decomposition.
• Over-decomposing: Don't break a task down so far that it becomes more work to manage the pieces than to just do the task! (You don't need a separate subroutine to add 1 + 1).
• Forgetting the Goal: The goal of both is to make the Program Design phase easier for the human programmer.

Summary Key Takeaways

1. Abstraction makes problems simpler by removing unnecessary details.
2. Decomposition makes problems manageable by breaking them into smaller sub-tasks.
3. Using both techniques is essential for structured programming.
4. Subroutines are the primary way we implement decomposition in our code.

Great job! You've just mastered the foundation of program design. These concepts will make every other chapter in your Oxford AQA syllabus much easier to understand!