Structured Approach Advantages (AQA GCSE Computer Science): Revision Notes
Structured approach advantages
What is the structured approach to programming?
The structured approach to programming is a way of writing code that breaks large programmes into smaller, manageable pieces called subroutines. Instead of writing one massive programme, you split it into separate modules that each handle specific tasks. This approach focuses on using well-organized subroutines, clear interfaces between different parts of the programme, and making good use of return values.
Think of it like building with LEGO blocks - instead of trying to create one giant piece, you build smaller sections that fit together perfectly to make the final product.
Understanding local variables in subroutines
Before diving into the advantages, it's important to understand local variables. When you create variables inside a subroutine, these variables have local scope. This means they only exist within that specific subroutine and cannot be accessed by the main programme or other subroutines.
For example, if you have a subroutine called circle_area() that calculates the area of a circle, any variables you create inside this subroutine (like area or pi) can only be used within that subroutine. If you try to access these variables from outside the subroutine, your programme will produce an error.
This might seem restrictive, but it's actually a powerful feature that helps keep your code organised and prevents accidental interference between different parts of your programme.
Key advantages of structured programming
1. Reduces programme size and eliminates repetition
One of the biggest benefits of using subroutines is that you don't need to write the same code multiple times. Instead of copying and pasting similar code throughout your programme, you can write it once as a subroutine and then call it whenever needed.
Programming Comparison: With and Without Subroutines
This comparison perfectly demonstrates the power of subroutines. Example A shows repetitive code where the same calculation (multiplying by 1.2) is written out multiple times with different variables. Example B shows how a single subroutine can handle all these calculations, making the code much shorter and more efficient.
2. Makes code much easier to maintain and understand
When your programme is broken into smaller subroutines, each one has a clear purpose. This makes it much easier to:
- Read and understand what each part of the programme does
- Find and fix bugs when they occur
- Make changes or improvements to specific functions
- Work as part of a team, where different people can work on different subroutines
3. Speeds up development and testing
Writing structured programmes is actually faster in the long run because:
- You can test each subroutine individually before putting them together
- Debugging is easier because problems are isolated to specific subroutines
- You can reuse subroutines in other programmes, saving development time
- Pre-written and pre-tested subroutines can be used as building blocks
4. Enables code reuse across different programmes
Once you've written a useful subroutine, you can use it in multiple programmes. For example, if you create a subroutine to calculate tax on a price, you can use this same subroutine in a shop system, an accounting programme, or any other application that needs tax calculations.
Functions vs procedures
It's important to understand the difference between two types of subroutines:
- Function: A subroutine that performs a calculation or task and then returns a value back to the main programme
- Procedure: A subroutine that performs an action but doesn't return any value
For example, a function might calculate the area of a circle and return the result, while a procedure might print a message to the screen without returning anything.
Exam tips for structured programming
Essential Exam Strategy for Structured Programming Questions
When answering exam questions about structured programming advantages:
- Focus on the benefits: Always mention how subroutines reduce code repetition, improve maintainability, and speed up development
- Use specific examples: If possible, explain how a subroutine could solve a real programming problem
- Remember the terminology: Make sure you can distinguish between functions and procedures
- Think about teamwork: Structured programming makes it easier for multiple programmers to work on the same project
Key Points to Remember:
- Structured programming breaks large programmes into smaller, manageable subroutines
- Local variables only exist within their specific subroutine and cannot be accessed from outside
- Main advantages include reducing code repetition, easier maintenance, faster development, and code reuse
- Functions return values while procedures don't return anything
- Code reuse means you can use the same subroutine in multiple programmes, saving time and effort