Component 2

Component 2

1. 2.1

   • 2.1.1
     • abstraction
       • filtering out the characteristics of problems that are not needed in order to concentrate on those that are needed
     • decomposition
       • breaking down a complex problem or system into smaller parts that are more manageable and easier to understand
     • algorithmic thinking
       • take a complex problem, understand what the problem is and develop possible solutions
   • 2.1.2
     • start/end
       • process
       • decision
       • parallelogram - input/output
     • tarce table
     • Character set - all of the characters a computer can use
   • 2.1.3
     • search algorithms
       • Binary
         • Split the array in half. Initially, it will look at the item in the middle of the array and compare it to the search terms, which leads to three possible scenarios: if the search criteria is met by middle item: Item Found; if the search criteria is less than middle item, search the first half of the array; if the search criteria is larger than middle item, search the upper half of the array. The process of dividing the array continues until the middle item meets the search criteria.
       • Linear
         • Starting at the beginning of the data set, each item of data is examined until a match is made. Once the item is found, the search ends.
     • sort algoithms
       • Bubble
         • Start at the beginning of the list. Compare the first value in the list with the next one up. If the first value is bigger, swap the positions of the two values. Move to the second value in the list. Again, compare this value with the next and swap if the value is bigger. Keep going until the there are no more items to compare. Go back to the start of the list.
       • Merge
         • The list is repeatedly divided into two until all the elements are separated individually. Pairs of elements are then compared, placed into order and combined. The process is then repeated until the list is recompiled as a whole.
       • Insertion
         • An insertion sort compares values in turn, starting with the second value in the list. If this value is greater than the value to the left of it, no changes are made. Otherwise this value is repeatedly moved left until it meets a value that is less than it. The sort process then starts again with the next value. This continues until the end of the list is reached.

2. 2.5

   • 2.5.1
     • Languages
       • High-level
         • High-level programming languages are close to natural language spoken and written by humans. E.g. python
       • Low-level
         • Assembly language uses mnemonics to represent instructions.
         • Machine code consists of only 0s and 1s which are binary numbers.
     • Translators
       • Translates source code to machine code
         • Compiler
           • Translates all in one go
             • Adv. - run quickly, can be shared as an executable file, can be shared without source code so its not easily modified, optimises code so it takes up less memory
               • Disadv. - has to be re-compiled whenever its changed, source code can't run on a computer with different architecture
         • Assembler
           • Assembly language into machine code
         • Interpreter
           • Translates one instruction at a time
             • Adv. - instructions execute as soon as they're translated, errors are quickly spotted
               • Disadv. - runs slowly, has to be translated every time it's run, source code has to be supplied and could be modified without permission
   • 2.5.2
     • IDEs
       • Integrated Development Environment
         • An application used to make software
           • Editor - bracket matching, auto-completion, syntax checks
           • Run-time environment - execute one line at a time
           • Translator
             • Auto-documentation
               • Libraries
                 • Build automation
                   • Debugger

3. 2.2

   • 2.2.1
     • Constant - data item that can't change value during execution.
     • Variable - data item that can change value during execution
     • Operators
       • Addition +
       • Subtraction -
       • Multiplication *
       • Division /
       • Integer division DIV
       • Remainder MOD
     • Inputs - data taken in during execution
     • Assignments
       • Assignment =
       • Equivalence ==
       • Less than (or equal to) <(=)
       • Greater than (or equal to) >(=)
       • Not equal to =!
     • Constructs
       • Sequence - the order in which instructions occur and are processed.
       • Selection - determines which path a program takes when it is running.
       • Iteration - the repeated execution of a section of code when a program is running.
     • Boolean operators
       • AND
       • NOT
       • OR
   • 2.2.2
     • Data types
       • Integer - whole numbers
       • Float/real - decimals
       • Boolean - TRUE/FLASE
       • Character - a single alphanumeric character
       • String - one or more alphanumeric characters
       • Casting - changing the data type of a variable
   • 2.2.3
     • String manipulation
       • Length - finding the length of a string
       • Concatenation - combining strings into one
       • Upper/lowercase - making a string entirely upper/lower case
       • Character position - finding what character is in (a) certain position(s)
     • File manipulation
       • Opening - file = open(‘scores.txt’,’r’)
       • Closing - file.close()
       • Reading - file = openRead("scores.txt") score = myFile.readLine()
       • Writing - file = open('scores.txt','w') file.write('Hello')
     • Records - a collection of data items arranged for processing by a program. Multiple records are contained in a file or data set
     • SQL - Data can be retrieved using the commands SELECT, FROM and WHERE, for example:
     • Using subprograms can help with code structure because it is easier to write, test and debug than a whole piece of code, and its easier to understand

4. 2.3

   • 2.3.1
     • Defensive design
       • authentication - verifying the identity of a user
       • Anticipating misuse - predicting what could go wrong with a program when taking an input from a user
       • Input validation
         • Range check
         • Length check
         • Presence check
         • Format check
         • Type check
       • Maintainability
         • Use of sub-programs
         • Suitable variable names make programs easier to understand
         • comments to make the code easier to read for other people
         • Indentation helps to see where subroutines end
   • 2.3.2
     • Testing
       • Purpose - to help the programmer remove such bugs and to ensure that the program functions as intended.
       • Iterative testing happens throughout development
       • Terminal testing happens after development
       • A syntax error occurs when code written does not follow the rules of the programming language
       • A logic error is an error in the way a program works when the program doesn't do what it should do
       • suitable test data
         • Normal - within the correct range
         • Invalid- incorrect type
         • Boundary - only just within range
         • Erroneous - not within range

5. 2.4

   • Notation
     • AND ∧
     • OR ∨
     • NOT ¬

Images and files in the map