Robust software (Edexcel GCSE Computer Science): Revision Notes
Robust software
What is robust software?
Software is considered robust when it can cope with unexpected situations without breaking down or crashing.
Think of robust software like a well-built house that can withstand storms - it can handle unusual inputs, user errors, or unexpected events without falling apart.
A robust programme has two main qualities:
- It doesn't crash or produce wrong results when something unexpected happens
- It's secure and protected from people who might try to exploit weaknesses in the code
Example: Calculator App Robustness
If you accidentally type letters into a calculator app that expects numbers, robust software would show you a clear error message rather than crashing completely. This demonstrates how robust software gracefully handles unexpected input.
Understanding code vulnerabilities
Code vulnerabilities are like hidden weak spots in a programme that criminals or hackers might exploit. These weaknesses can allow unauthorised access to sensitive information or cause damage to systems.
Known vulnerabilities
Some programming languages have known vulnerabilities - these are documented weaknesses that programmers should be aware of. For instance, programmes written in the C programming language can sometimes allow direct access to computer memory, which creates opportunities for hackers to implement "backdoor" entries into systems.
A language-specific vulnerability is a particular weakness in how a programming language handles certain operations, which hackers can take advantage of.
Bad programming practices to avoid
Critical Programming Mistakes to Avoid
Programmers can accidentally introduce vulnerabilities through these poor coding habits:
- Poor planning - Not thinking through potential security issues before starting to code
- Quick fixes - Using temporary solutions instead of properly solving problems, which can create new vulnerabilities
- Messy code structure - Writing code that doesn't follow agreed standards, making it harder to spot problems
- Insufficient testing - Not checking the programme thoroughly before release
Making programmes more robust
There are three main strategies programmers use to create robust software:
Following good programming practices
This means writing clean, well-organized code that follows industry standards and best practices for security.
Regular code reviews
Code reviews involve other programmers or special software checking the code to ensure it meets quality standards and doesn't contain vulnerabilities.
Maintaining audit trails
An audit trail is like a detailed logbook that tracks all changes made to the software during development, helping with accountability and problem-solving.
Code reviews explained
Code reviews serve three important purposes:
- Checking standards - Ensuring the software follows agreed-upon coding standards and practices
- Finding inefficiencies - Spotting parts of the code that could run better or use fewer resources
- Identifying vulnerabilities - Discovering potential security weaknesses before the software is released
Code reviews can be done by other programmers (peer review) or by specialised software tools that automatically scan the code. These tools can detect bugs and security issues while suggesting improvements.
Critical Rule for Code Reviews
If a code review finds serious problems, they must be fixed before the development process continues. Never ignore issues found during review.
Audit trails and version control
An audit trail helps improve accountability during software development by keeping detailed records of who made what changes and when. This is crucial because if a problem is discovered later, developers can track it back to its source and undo problematic changes.
Version control software works alongside audit trails, especially useful when teams of programmers work on large projects. It uses a database to track every single change made to the code. If someone makes a mistake, programmers can easily revert to an earlier, working version.
Understanding Version Control
Think of version control like having multiple saved versions of a document - if you accidentally delete something important, you can go back to a previous save. This provides a safety net for development teams.
Exam Tip: Understanding Quick Fixes
One common exam question asks why "quick fix" solutions can introduce vulnerabilities. Here's the key point: when programmers rush to fix a problem without properly understanding it or considering the broader impact, they might create new security holes or instabilities in the software. It's always better to take time to implement a proper, well-thought-out solution.
Key Points to Remember:
- Robust software handles unexpected situations without crashing and stays secure from attacks
- Code vulnerabilities are weaknesses that criminals might exploit to gain unauthorised access
- Code reviews help catch problems early by having others check your work before release
- Audit trails track all changes so problems can be traced back and fixed
- Quick fixes often create more problems than they solve - proper planning prevents vulnerabilities