Paper 2 Revision

Paper 2 Revision

1. Abstraction

   • Removes unnecessary detail to make problems less complex

2. Decomposition

   • Break down problems to make them easier to solve

3. Algorithmic thinking

   • Logical steps to solve a complex problem.

4. Computational thinking

5. Syntax/logic errors

   • Syntax error
     • Error in the rules of the language For example: (spelling of a command word)
   • Logic error
     • Code runs, just not as you expect it to.

6. IDEs: The TREE!

   • Translator: Compiler and interpreter
   • Run time environment: Runs the code to allow you to test the program .
   • Editor: Write/edit code, autocomplete keywords
   • Error diagnostics: Find and suggest ways to fix errors

7. Translators

   • Compiler
     • Translates entire source code at once, creates an exe file.
   • Interpreter
     • Translates source code one line at a time, good for testing during development.

8. Testing

   • Used to find defects before releasing a program
   • Used to check that the program works as intended.
   • Two types of testing Final testing (after development) Iterative testing (During development)

9. Test data

   • Normal data: Data which the program should accept.
   • Erroneous data: A data type which the program should not accept
   • Invalid data: Data which is the correct data type, but an unacceptable value.
   • Boundary data: Data at the limits of what the program is able to handle.

10. Sub programs

    • Allow you to reuse in other programs
    • Avoids repetition - therefore less lines of code
    • Allows you to break down problems into smaller parts
    • Functions return a value, where a procedure does not.

11. Storing data

    • Variable: Data can change when the program is running
    • Constant: Data cannot change when the program is running.

12. Bubble sort

    • Simple algorithm, good for shorter lists, less memory needed
    • Inefficient, not good for long lists

13. Insertion sort

    • Good for shorter lists, add items easily
    • Not good for long lists, more complex than bubble sort.

14. Merge sort

    • Good for large lists, consistent running time
    • Complex algorithm, takes more memory, slower for smaller lists.

15. Linear search

    • Can be used for unordered and ordered lists, simple algorithm
    • Inefficient, not good for large lists

16. Binary search

    • Good for large lists
    • More complex, can only be used for ordered lists.