Computer Science
Grade 8
20 min
Breaking Down Problems
Breaking Down Problems
Tutorial Preview
1
Introduction & Learning Objectives
Learning Objectives
Decompose a large programming task into a list of smaller, manageable sub-problems.
Identify potential objects and classes from a problem description by finding the key 'nouns' and 'verbs'.
Apply the Top-Down Design strategy to outline the structure of a program before writing code.
Create pseudocode for individual functions that handle specific sub-tasks.
Explain how breaking down problems makes code easier to debug, reuse, and understand.
Map the flow of data (inputs and outputs) between different components of a program.
How would you build a massive video game like Minecraft or a complex app like TikTok? 🤔 You wouldn't start by coding the first pixel; you'd start with a plan!
This lesson teaches you the most important s...
2
Key Concepts & Vocabulary
TermDefinitionExample
DecompositionThe process of breaking a complex problem or system into smaller, more manageable parts that are easier to understand, solve, and create.Problem: 'Build a car.' Decomposition: Break it down into building the engine, building the frame, building the wheels, and building the electronics separately.
Top-Down DesignA problem-solving approach where you start with the overall goal and progressively break it down into smaller and smaller sub-problems.Goal: 'Make a user profile page.' Sub-problems: 1. Get user data. 2. Display profile picture. 3. Display user's posts. 4. Add a 'Follow' button.
AbstractionHiding the complex details of how something works and only showing the essential features. In programming, this means using a...
3
Core Syntax & Patterns
The Single Responsibility Principle (SRP)
Every class, object, or function in a program should have responsibility for only one part of the program's functionality.
Use this when designing your classes and functions. If a function is named `calculateScoreAndDisplayLeaderboard`, it's doing two things. You should break it into two separate functions: `calculateScore()` and `displayLeaderboard()`.
Top-Down Decomposition Strategy
1. Start with the main goal. 2. Break it into 3-5 major sub-systems or steps. 3. Break each of those sub-systems into smaller, more specific functions or tasks. 4. Continue until each task is small enough to be coded easily.
This is your main strategy for tackling any new, large project. It helps you create a roadmap before you start coding, p...
4 more steps in this tutorial
Sign up free to access the complete tutorial with worked examples and practice.
Sign Up Free to ContinueSample Practice Questions
Challenging
How does strictly following the Single Responsibility Principle (SRP) for functions like `addContact()` and `displayContacts()` in the Contact List app directly improve code reusability?
A.It doesn't; SRP is only for making code easier to read
B.Because if you need to display the contacts in another part of the app (e.g., a summary widget), you can call the exact same `displayContacts()` function without any modification
C.Smaller functions run faster, so they are more desirable to reuse
D.SRP requires using global variables, which makes functions easier to access and reuse
Challenging
For the 'Monster Battle' game, a student proposes creating a `BattleManager` object instead of putting all the game loop logic in the main program. What would be the primary responsibility of this `BattleManager`, and why is its creation a good example of decomposition?
A.Its responsibility is to control the turn-based flow of the game (e.g., whose turn it is, checking for a winner). This separates the game *rules* from the *participants* (Player/Monster)
B.Its responsibility is to store the Player's health. This is good decomposition because health is important
C.Its responsibility is to draw the monster on the screen. This separates logic from graphics
D.Its responsibility is to create the Player and Monster objects. This is not good decomposition because it adds an unnecessary object
Challenging
Imagine you must add a "Search" feature to the 'Contact List' app. Following Top-Down Design and SRP, which of the following represents the most logical new function and its place in the data flow?
A.Modify the `displayContacts()` function to include a search bar and filtering logic all in one
B.Add a new property to the `Contact` object called `isSearchResult`
C.Create a new function `searchContacts(searchTerm)` that takes the user's query, filters the main contact list, and returns a *new* list of matching contacts to be displayed
D.Create a new `search()` method inside the `Contact` object itself
Want to practice and check your answers?
Sign up to access all questions with instant feedback, explanations, and progress tracking.
Start Practicing Free