A2 Level Past Paper Questions

A two-dimensional array is a collection of values stored in rows and columns. A two-dimensional array can be thought of as a table of values or a matrix. Each value in a two-dimensional array can be accessed using two indices e.g. 2D[1][1] Example: storing a table of player scores in a game.

A three-dimensional array is a collection of values stored in rows, columns and layers. A three-dimensional array can be thought of as a cube of values or a tensor. Each value in a three-dimensional array can be accessed using three indices e.g. 3D[1][1][1] Example: storing the RGB colour channel values of a specific pixel in an image.

The value can be updated by setting july[5,6] = “X”

1 mark for correct array name ‘july’ and assignment of string “X” 1 mark for correct indices [5,6] or [6,5]. Accept [6][5].

The value can be updated by setting 2D[2][1] = 10

1 mark for correct array name ‘2D’ and assignment of integer 10 1 mark for correct indices [2][1] or [2,1]

Standardisation ensures that different systems can understand and communicate with each other using the same language.

Standardisation helps to avoid bugs and errors that can occur when different systems use the same language in different ways.

Standardisation enables interoperability, making it easier to develop software that works across different platforms and devices.

Standardisation makes the software development process simpler by providing a clear set of rules for writing and understanding code.

Standardisation makes it easier for developers to learn and use a language as they only need to learn one standard rather than multiple variations.

Standardisation enables developers to create secure and high-quality software across different devices.

Example: ECMAScript is the syntax standard used for JavaScript.

The process of developing a standard can be time-consuming and complex, involving multiple iterations and revisions.

There may be opposition from developers who are used to working with a different, non-standard version of the language.

Existing software systems may not be compatible with new agreed standards, leading to resistance for change from some companies.

There may be potential conflict or disagreement between competing business interests of companies.

Different companies may have different goals and priorities, making it difficult to agree on what should be included in a standard.

Example: HTML5 took several years and multiple development iterations led by the World Wide Web Consortium (W3C).

(1·X + Y̅·Y̅)·X̅ + X·Z

= (1·X + Y̅ + Y̅)·X̅ + X·Z [De Morgan’s]

= (X + Y̅ + Y̅)·X̅ + X·Z [Identity: 1·X = X]

= (X + Y̅)·X̅ + X·Z [Idempotent: Y̅ + Y̅ = Y̅]

= X̅·X + X̅·Y̅ + X·Z [Distribution]

= 0 + X̅·Y̅ + X·Z [Complement: X̅·X = 0]

= X̅·Y̅ + X·Z [Identity: 0 + A = A]

(A̅·A + A·A)·1 + B·C·0

= (A̅·A + A·A)·1 + 0 [Identity: B·C·0 = 0]

= (A̅·A + A·A)·1 [Identity: X + 0 = X]

= A̅·A + A·A [Identity: X·1 = X]

= A̅·A + A [Idempotent: A·A = A]

= 0 + A [Complement: A̅·A = 0]

= A [Identity: 0 + A = A]

declare i, j, length as integer declare myArray as string[] set i = 0 set length = len(myArray[]) - 1 for i to length if myArray[i] <> “X” then set j = i + 1 for j to length if myArray[j] <> “X” then if myArray[i] = myArray[j] then set myArray[j] = “X” end if end if next j end if next i output myArray

Marking: Declare and initialise variables (1), correct determination of length (1), use of outer loop (1), use of inner loop (1), correct starting condition for inner loop (1), correct condition to check for duplication (1), set duplicate values to “X” (1), output array (1).

Example test data (2 marks per row, 1 for data, 1 for correct outputs):

Message 1: “Password must be at least 8 characters long and contain at least one digit and one special character.” Message 2: “Password accepted.”

Accept any suitable response.

The solution should be easy to use and understand for the intended users.

Example: a website that has clear navigation and an intuitive design would be highly usable.

The solution should be able to complete tasks within an acceptable time frame and allocated memory usage.

Example: a software application that can process large data efficiently and quickly without slowing down would be high performing.

The solution should be able to adapt to changing usage and be able to scale up or down as necessary.

Example: an online ticket platform that can scale up and handle a sudden surge in traffic would be considered highly scalable.

The solution should protect data and be resilient to hacking and other security threats.

Example: an online banking system that uses two-factor authentication to protect users from unauthorised access would be considered highly secure.

<alpha> ::= a|b|c...x|y|z|A|B|C...X|Y|Z
<digit> ::= 0|1|2...8|9
<alpha-digit> ::= <alpha>|<digit>
<protocol> ::= "http" | "https"
<domain-char> ::= <alpha-digit> | "-" | "."
<domain> ::= <domain-char> | <domain-char><domain>
<path-char> ::= <alpha-digit> | <alpha-digit><path-char> | "/"<path-char> | "/"
<optional-path> ::= "/"<path-char> | ""
<url> ::= <protocol> "://" <domain> <optional-path>

1 mark for correct definition of alpha and digit.

1 mark for each correct definition up to a maximum of 5 marks.

Max 5 marks if BNF notation used incorrectly.

Program version management or version control systems (VCS) is the process of managing different versions of a software program throughout its development lifecycle.

It involves tracking changes made to the program’s source code and managing different versions or releases.

Version control systems help developers keep track of changes over time and collaborate with other developers on the same project.

VCS can help prevent conflicts or overwriting of code and allows developers to revert to earlier versions if necessary.

It typically involves creating a repository for the source code where all changes and versions are stored, such as GitHub.

Developers can make changes in their own working copies and then commit those changes back to a repository.

The VCS keeps track of the changes and allows developers to view the entire history of the codebase.

It also allows for the creation of different branches or forks of the code, which can then be merged back into the main codebase.

Local version control stores all changes on the local computer, whereas centralised version control has a single central repository.

An example of a VCS tool is Git.

Different sorting algorithms have varying time and space complexities. Depending on the size and type of data, different algorithms need to be chosen.

Recursive sorting algorithms:

• Operate by dividing the dataset into smaller sub-datasets and then recursively sorting those datasets
• Have good time complexity for larger datasets
• Are often easier to implement
• Can have higher space requirements given they make use of recursive calls
• Examples: Merge Sort, Quicksort

Non-recursive sorting algorithms:

• Operate by iteratively rearranging the dataset until all elements are sorted
• Usually faster than recursive algorithms for smaller datasets
• Usually have lower space requirements
• Examples: Insertion Sort, Bubble Sort

Apply an AND mask with 10000000₂:

00001111₂ AND 10000000₂ = 00000000₂

The state of the sign bit is 0, which means the integer is positive.

1 mark for using an AND (or XOR) mask. 1 mark for correct result. 1 mark for determining the state of the sign bit.

The i loop will execute n times.

The j loop will also execute n times, giving 2n total iterations.

There are 3 instructions executed (declarations/initialisations).

Total operations: 2n + 3.

The order will be dominated by n.

The growth rate for time performance in Big O notation is O(n).

The algorithm uses three data structures — three one-dimensional arrays.

Two input arrays of size n are combined to create a third.

Total storage requirements = n (proportional to input size).

The growth rate for memory is O(n).

Linear Complexity O(n)

Graph: A straight line from the origin going up and to the right. X-axis: Size of data Y-axis: Time to complete

1 mark for correctly labelled axes. 1 mark for correct gradient of line (straight diagonal line).

A shortest path algorithm is a method used to find the shortest path between two nodes or points.

It achieves this by calculating the distance/weight between nodes and selecting the path with the lowest total distance/cost.

It calculates a value for the distance from the starting node to each adjacent node.

The distance value is then updated if a shorter path is found.

This process is repeated until the destination node is reached.

A shortest path algorithm can be used in network routing or transportation (GPS) to find the most efficient path.

Example: Dijkstra’s algorithm.

Benefits:

• Natural language interfaces enable communication with computers in a more intuitive and user-friendly manner
• They can facilitate communication for individuals with disabilities (motor or visual impairments)
• They reduce the need for training and technical expertise, making technology more accessible
• They simplify complex tasks like data analysis by allowing users to express intentions in natural language
• They can improve efficiency by reducing the need for manual input
• They enable more natural communication in virtual and augmented reality applications
• They provide seamless integration of voice and text-based channels (smart speakers, phones)
• They improve accuracy of information retrieval compared to keyword-based searches
• They can enhance personalisation by allowing users to express preferences naturally

Challenges:

• Words can have multiple meanings (e.g. ‘bat’ — flying mammal or sports equipment)
• Phrases can be interpreted differently based on context (e.g. ‘bank’ — financial institution or river side)
• Different people may express the same idea in different ways using synonyms
• Idioms and colloquialisms are difficult to interpret
• Detecting sarcasm and irony is challenging
• Accents and dialects affect speech recognition accuracy
• Homophones (‘there’, ‘their’, ‘they’re’) cause confusion
• Cultural references require cultural knowledge
• New words and slang are constantly being created

Solutions:

• Machine Learning: using large datasets to train models (e.g. GPT-4)
• Contextual models that consider context to interpret language more accurately
• Continuous learning systems that adapt over time
• Multimodal inputs combining text with voice tone, facial expressions, and body language

1 mark for a correct component, 1 mark for an associated description (max 6 marks):

• ALU: Implements all the arithmetic, logical, and shift operations / decisions and calculations required by program instructions
• Control Unit: Fetches the instructions from main memory, decodes the instructions, and then executes them
• Register Set: Includes general-purpose registers that save temporary information needed by a program and special-purpose registers that execute various functions for the CPU
• Cache: A type of RAM within the processor which stores small amounts of frequently used data and instructions temporarily, reducing the time needed to fetch instructions from RAM
• Clock: Controls the timing and speed of the functions of different components of the CPU by sending out electrical signals

137524 MOD 1000 = 524

701924 MOD 1000 = 924

Product codes will hash to a small number (10 in a 1000) of memory locations because the last two digits are always the year ‘24’. This means many collisions will occur, resulting in overflow which will involve slow serial access to locate records.

Delete the last 2 digits (‘24’) and carry out MOD 1000 on the remaining 4 digits. This would spread records more evenly across available locations and reduce collisions.

• The CAD software produces large files to provide the printer with coordinate data needed to produce 3D objects

• A single memory buffer cannot accept data input and provide data output at the same time, which would result in a delay in the flow of data to the printer

• Such delays may lead to quality issues, such as surface pitting / imperfections / inaccuracies in the final product

• Double buffering minimises the delay between input and output operations

• The data in one buffer is sent to the printer controller to enable production to continue, while the other buffer is being filled with output data from the CAD program

P = 0.5:

• N = 2: Speedup = 1 / (0.5 + 0.5/2) = 1 / 0.75 = 1.33
• N = 20: Speedup = 1 / (0.5 + 0.5/20) = 1 / 0.525 = 1.90

P = 0.9:

• N = 2: Speedup = 1 / (0.1 + 0.9/2) = 1 / 0.55 = 1.82
• N = 20: Speedup = 1 / (0.1 + 0.9/20) = 1 / 0.145 = 6.90

• At 50% parallel processing, the benefit of increasing the number of processors is limited (1.33 to 1.90 — only a small improvement despite 10x more processors)

• At 90% parallel processing, the relative benefit of increasing processors is more significant (1.82 to 6.90)

• Whilst the number of processors used affects performance, the level of parallelisation achieved in the software is the most significant factor

• The serial fraction of the code limits the maximum speedup regardless of how many processors are added

1 mark for each limitation identified, 1 mark for associated description:

• Concurrency: It must be possible to divide an algorithm into groups of operations that can execute concurrently
• Dependencies: Dependencies between tasks intended to be carried out in parallel must be avoided; if one task depends on the result of another, it cannot run in parallel
• Data distributions / communication: Data transfer speeds relating to inputs/outputs, memory access and locality (where data is stored in relation to the processor accessing it) can limit performance
• Computational load: The total computation and communication time needs to be balanced so that the maximum execution time per processor is minimised
• Implementation: The coding of a parallel algorithm for a multithreaded process is complicated, and the program will be difficult to test and debug

Any two of:

• A hardware device has signalled that it has data to process / completed a task

• A software process needs a service to be provided / OS function to be performed

• An allotted amount of time has expired, and an action needs to be performed

• A hardware failure has occurred and needs to be addressed

• A priority level is assigned to the processor and is stored in the processor’s status register

• When the processor starts the execution of a program, its priority level is re-set to be equal to the priority of the program in execution

• When executing the current program, the processor only accepts interrupts that have a higher priority level

• When the processor is executing the resulting interrupt service routine, the processor priority level is again re-set to the priority of the interrupt

• The processor will only accept interrupts with higher priority and ignore interrupts with the same or lower priority

1. The processor receives the interrupt and completes the fetch-decode-execute cycle of the instruction it was running when it received the interrupt

2. The current contents of the processor registers (including the program counter) are saved to memory

3. The origin of the interrupt is identified so that the appropriate ISR (Interrupt Service Routine) is called

4. All other lower-priority interrupts are suspended to allow the ISR to finish running

5. The program counter is updated with the address of the first instruction of the ISR

6. The ISR / interrupt completes its execution

7. The processor registers are reloaded with the values that were saved to memory

8. The lower-priority interrupts that were suspended are re-established

9. The program counter is set to point to the address of the next instruction that needs to be executed in the program that was running when the interrupt was received

(i) A-D transmission speed = 50 Kbps (since 1000/50 = 20)

(ii) B-F routing cost = 12.5 (since 1000/80 = 12.5)

(iii) C-F routing cost = 2 (since 1000/500 = 2)

A-B-C-F (total cost: 4 + 10 + 2 = 16)

loop:  IN
       SUB 01A0
       JZE correct
       JMP loop
correct: OUT -1

Rounding is a method for expressing values to the closest value (higher or lower) allowed by the representation being used. Rounding is more accurate. Example: 4.85 in a 4-bit register would be rounded to 0101 (5).

Truncation is a method of approximating numbers by ignoring digits / fractions which are outside the representation being used. Example: 4.85 in the same register would be truncated to 0100 (4).

1A₁₆ = 00011010₂ 14₁₆ = 00010100₂ -14₁₆ = 11101100₂ (two’s complement)

Binary addition: 00011010

• 11101100 = 00000110₂

(Answer: 00000110₂ = 6₁₀, which is correct since 26 + (-20) = 6)

52.875₁₀ = 110100.1110₂

Normalise: 0.110100111(00) with exponent 0110₂ (6₁₀)

Mantissa (12-bit): 011010011100 Exponent (4-bit): 0110

Result: 011010011100 0110

Mantissa: 00100101 Exponent: 0101 = 5₁₀

Move binary point 5 places to the right: 0.0100101 → 001001.01

Denary value = 9.25

A data dictionary provides a record of the names, definitions and attributes of the data elements / metadata stored in a database. Further details may include: relationships between tables and key fields, data types, field lengths and any validation rules.

A DBMS enables a database administrator to:

• Organise files and control the stored data

• Set user permissions to control the addition, editing and updating of data

• Allow users to manipulate the data / run queries

• Control concurrency: concurrent access to the same database by multiple users

• Set security rules to prevent unauthorised access to data

• Utilise processes to back-up the data regularly and recover data if a problem occurs

• Set rules to verify / validate data input to improve the integrity of the data

• Monitor and optimise database performance / workflow / system resources

Any two of:

• Repetition of data stored in the database (‘data redundancy’)

• Data inconsistency where the same data exists in different formats in different locations

• Data corruption arising from writing or processing errors in repeating fields

• Increase in database size / longer load times

Four entities with relationships:

• Client (1) → (M) Valuation Request (one client can make many valuation requests)
• Valuation Request (1) → (M) Valuation (one request can have many item valuations)
• Expert Valuer (1) → (M) Valuation (one valuer can perform many valuations)

1 mark per correct relationship, 1 mark for 4 suitable table names.

erDiagram
    CLIENT ||--o{ VALUATION_REQUEST : makes
    VALUATION_REQUEST ||--o{ VALUATION : "results in"
    EXPERT_VALUER ||--o{ VALUATION : performs

Client (ClientID [PK], Name, Address, Telephone, Email) Valuation Request (RequestRef [PK], ClientID [FK], Items Description) Valuation (ValuationID [PK], RequestRef [FK], ValuerID [FK], Date) Expert Valuer (ValuerID [PK], Name, Mobile)

2 marks for 4 primary keys identified, up to 2 marks for correct foreign keys identified.

Query languages are used to create, access and modify data in and out of a database / database management system (DBMS).

SQL is a special purpose programming language designed for managing data stored in a relational DBMS.

SELECT Make, Model FROM Cars
WHERE Type = 'Electric'

Using a subquery:
SELECT Name FROM Members
WHERE MemberID IN (SELECT MemberID FROM CarHireMarch WHERE Date = '3 Mar 24')

Or using JOIN:
SELECT Name FROM Members JOIN CarHireMarch ON Members.MemberID = CarHireMarch.MemberID
WHERE Date = '3 Mar 24'

CREATE TABLE HirePayments (
  PaymentID Integer PRIMARY KEY,
  Date String,
  MemberID Integer,
  PaymentDue Double,
  Paid Boolean
)

Advantages:

• Cost saving as expenditure on hardware, hard disks etc is reduced
• Portability — all data available via the Internet from any device
• Remote updates and synchronisation — updating a cloud file means it looks the same on every device; sync apps update files instantly across devices
• File sharing — simply select a file and share a link for others to download or view
• Remote working — cloud technology enables working from any internet connection
• Unlimited storage capacity — additional storage can be made available as needed
• Zero-knowledge encryption — encryption key known only to the file owner, encryption takes place before files are sent to the cloud

Problems:

• Compromise of data integrity — data transmitted across the Internet could be intercepted and changed
• Unauthorised access — cloud files are outside private networks and directly accessible from the public Internet
• Cyberattacks — cloud resources contain sensitive data making them common targets
• Denial of Service attacks — attackers may demand ransom to stop attacks on cloud services
• Data loss/leakage — easy sharing creates concerns about data being leaked
• Data privacy/confidentiality — GDPR requires protection of data; placing data on the cloud has security implications
• Legal and regulatory compliance — demonstrating regulatory compliance for cloud data can be more difficult
• Misconfiguration arising from requirements to be user friendly
• Insecure interfaces/APIs
• Account hijacking due to weak password security
• Lack of visibility/ownership — limiting ability to monitor and protect cloud resources

• A hash table stores data using a key/index and a value

• A hashing algorithm is used to generate a key identifying at which location the data can be stored

• The MOD operation is commonly used in a hashing algorithm to generate the key

• Data can be retrieved using the key to return the value, which is direct access

• If the hashing algorithm generates a key that is already present, data collision occurs

• One solution is separate chaining where the hash table uses a dynamic data structure like a linked list to store values of the same key

• Separate chaining slows down retrieval as both the hash table and linked list need to be searched

• Another solution is linear probing which stores the data in the next available location and assigns a new key

Key → Value:

1001 → Apple

1002 → Berry

1003 → (empty/deleted)

1004 → Lime

1005 → Mango

1006 → Pear

1007 → Pineapple

1008 → Orange

Using linear probing — Peach is placed at the next available position (key 1003, which was deleted): 1001 → Apple 1002 → Berry 1003 → Peach (linear probing) 1004 → Lime 1005 → Mango 1006 → Pear 1007 → Pineapple 1008 → Orange

OR using separate chaining — Peach is linked from key 1006: 1006 → Pear → Peach

Procedural programming:

• Supports a logical step-by-step process such as implementing an algorithm
• Follows a top-down approach
• Allows the programmer to define precisely each step when performing a task
• Provides close control over the underlying operation of the hardware
• Programs are divided into functions
• Relies on the use of iteration, sequence and selection
• Examples include Pascal and C

Object-oriented programming:

• Programs are divided into objects, classes and methods
• Can use inheritance to reduce code duplication and increase flexibility
• Allows data to be encapsulated making data more secure
• Easier to expand programs; multiple developers can work on one project without affecting each other’s code
• Examples include C++ and Java

p = NOT(A).NOT(B).C + NOT(A).B.NOT(C) + NOT(A).B.C + A.NOT(B).C

Simplified: p = B.NOT(A) + C.NOT(B)

A.(1 + C) + NOT(B).(A + B)

= A.1 + A.C + NOT(B).A + NOT(B).B (distribution)

= A + A.C + NOT(B).A + 0 (identity: A.1=A, NOT(B).B=0)

= A + A.C + NOT(B).A (identity: A+0=A)

= A + NOT(B).A (absorption: A+A.C=A)

= A (absorption: A+NOT(B).A=A)

X.NOT(Y + Z) + NOT(Z).X

= X.(NOT(Y).NOT(Z)) + NOT(Z).X (De Morgan’s Law)

= X.NOT(Y).NOT(Z) + NOT(Z).X (distribution)

= NOT(Z).X.(NOT(Y) + 1) (factoring out NOT(Z).X)

= NOT(Z).X.1 (identity: NOT(Y)+1=1)

= X.NOT(Z) (identity: X.1=X)

Declare subprocedure QuickSort(myArray, indexLow, indexHi) Declare pivot, temp, low, high as integer set low = indexLow set high = indexHi set pivot = myArray[int((indexLow + indexHi)/2)] while (low <= high) while (myArray[low] < pivot and low < indexHi) set low = low + 1 end while while (pivot < myArray[high] and high > indexLow) set high = high - 1 end while if (low <= high) then set temp = myArray[low] set myArray[low] = myArray[high] set myArray[high] = temp set low = low + 1 set high = high - 1 end if end while if (indexLow < high) then QuickSort(myArray, indexLow, high) if (low < indexHi) then QuickSort(myArray, low, indexHi) End Procedure

Marking: 1 mark each for: declaring subprocedure with parameter, declaring variables, initialising pointers, setting pivot to midpoint, outer loop with terminating condition, comparing data with pivot, incrementing/decrementing pointers, swapping elements, recursion (x2)

• Validation and verification are used to minimise the risk of human error when inputting data

• Validation ensures any data entered by the user meets specific requirements / is reasonable / accurate

• Validation checks include format checks, range checks, type checks and presence checks

• Verification checks that the data entered by the user is consistent

• The main methods of verification are double entry and comparing the data to the original source such as proof reading

In-order traversal visits the left subtree first, then the root, and finally the right subtree. This method could be used when searching for a grocery item (as it outputs data in sorted order).

Post-order traversal visits the left subtree first, then the right subtree, and finally the root. This method could be used to delete all the grocery store data (as it processes children before parents, allowing safe deletion).

Pre-order traversal visits the root first, then the left subtree, and finally the right subtree. This method could be used to create a copy of the grocery store data (as it preserves the tree structure).

Example balanced binary tree: Cheese /
Apples Tomatoes / \ / Banana (-) Swede

(Any valid balanced binary tree with grocery items accepted)

flowchart TD
    C["Cheese"] -->|left| A["Apples"]
    C -->|right| T["Tomatoes"]
    A -->|left| B["Banana"]
    T -->|left| S["Swede"]

• Analysis and planning software tools are used in producing designs

• Planning a system structure can use flowchart software or UML software

• These allow developers to produce planning and design documents for individual cases such as the end user or another developer

• Analysis software tools can be used in requirements engineering and management — to record and monitor requirements, use cases and test cases

• Example: CASE development tools / Rational Rose

• Integrated Development Environments (IDEs) are typical pieces of software used in development

• IDEs can provide a wide range of tools including debugging such as automatic error checking and breakpoints

• IDEs also allow developers to produce test cases for their software as they develop

• IDEs can also be used to support multiple developers in the development of a single project

• Program version management software is used as a repository for different stages of code development

• Versions can be submitted to track and record the changes in projects

• Version management software is useful when multiple developers are working on a single project — it ensures one developer does not overwrite another’s code

• Version management software can be used to roll-back software if a program becomes corrupt during development

• Example: Git / GitHub

<upper> ::= A|B|C...Y|Z
<lower> ::= a|b|c...y|z
<digit> ::= 0|1|2...8|9
<special> ::= !|"|£...@|*
<letterdigit> ::= <upper>|<lower>|<digit>
<character> ::= <letterdigit>|<special>
<name> ::= <letterdigit>|<letterdigit><name>
<password> ::= <character>|<character><password>
<encryption> ::= WEP|WPA
<string> ::= WIFI:<encryption>:<name>:<password>

Translation errors — usually identified by a compiler where the instructions given cannot be translated to machine code:

• Syntax error: e.g. IF without ENDIF or punctuation/spelling errors
• Linking error: e.g. calling a standard function where the correct library has not been linked to the program
• Semantic error: e.g. variable declared illegally

Execution/Runtime errors — even though a program compiles and executes, it could unexpectedly crash or produce incorrect results:

• Logical error: e.g. division by 0 or use of incorrect logical/comparative operator
• File handling error: e.g. attempting to write to a file that does not exist

• Compilers and interpreters are examples of translators — software used to convert one type of programming language to another

• Compilers convert high-level programming language source code into object/machine code, run through a single executable file

• The compilation process can throw multiple errors which can make debugging more difficult than using an interpreter

• Many languages such as C++ and VB.Net are compiled and produce a single executable targeted to one platform/OS

• Once compiled, it is difficult to review the source code, making intellectual property easier to protect

• Unlike compilers, interpreters convert high-level source code line-by-line

• An interpreter translates a single line into machine code then executes it before moving to the next

• An interpreted application does not produce an executable file — source code must be interpreted each time the application is run

• To execute interpreted source code, the code needs to be freely available making intellectual property harder to protect

• Example of interpreted language: Python

• The i loop will execute n times

• There are 3 operations outside the loop (initialisation)

• The total number of possible operations is 7n + 3

• The order will be dominated by n

• The growth rate for time performance is O(n) — linear complexity

A graph showing:

• Y-axis labelled ‘Time to complete’
• X-axis labelled ‘Size of data’
• A straight line from origin going up at a constant gradient
• Line identified as O(n) — linear complexity

(1 mark each for: correct time axis label, correct size axis label, correct gradient/straight line, correctly identifying linear complexity)

Contemporary devices including smartphones and tablets now do not adopt traditional interaction technologies such as keyboard and mouse. Modern methods include:

Voice Input:

• Common in everyday smart devices including mobile phones and digital assistants
• Many voice-controlled devices use a trigger word to activate and can carry out operations such as playing a song or ordering items
• Ambiguity of spoken language can affect operation (accents, background noise)
• Homophones (to, two, too) can cause issues
• Privacy concerns — companies store phrases spoken to each device; people may overhear commands

Touch Screen:

• Now commonplace in everyday life
• Allows gesture-controlled operations such as pinch-zoom and swiping
• Simple and natural to use, can be learnt quickly
• Requires dexterity which may not be suitable for all users
• Can be fragile and expensive to replace; if broken, the device often becomes unusable

Virtual and Augmented Reality:

• VR allows full immersive experience using hardware such as omnidirectional treadmills, VR headsets, in-ear headphones and touch controllers
• AR allows the virtual world to be mixed with the real world
• Examples of AR include mobile games and mobile phone app filters
• Both technologies are growing exponentially within the computing industry

Example: Dictating a letter, essay or coursework; or recording findings/events whilst carrying out a manual process/procedure.

Description: Because of poor typing skills / lack of speed; as required due to injury/impairment or disability; to avoid repetitive strain injury; to dictate notes whilst working on other tasks by hand (e.g. during surgery, an autopsy, or whilst carrying out an experiment).

Example: Giving commands to a car entertainment/navigation system; giving commands to a home heating/lighting control system or digital assistant.

Description: Can reset radio channels whilst driving without need to look away or take hands off controls; convenience of operating home control system from a remote location.

Example: Voice operated door entry system; voice authentication for online banking.

Description: No need to remember password or entry code; improved security provided by unique voice print.

Task 3 cannot be carried out in parallel with Task 2 because it requires the result (d) from Task 2.

80% of 16 hours = 12 hours 48 minutes This time is shared between 8 processors: Parallel running time = 12h 48m / 8 = 1 hour 36 minutes

(Alternative using Amdahl’s Law: Tp = Ts(L + P/N) = 16(0.2 + 0.8/8) = 16 × 0.3 = 4.8 hours total)

loop:   IN
        SUB R
        JNG reject
        OUT 1
        JMP loop
reject: OUT 2
        JMP loop

Batch processing:

• A system in which a series of repetitive processing operations are carried out together
• Processing is carried out without user intervention
• May be carried out at times when a computer system is otherwise not in use, such as at weekends or during the night
• Example: payroll or billing system

Real time transaction processing:

• A system in which transactions are processed immediately as they occur
• Can avoid multiple bookings
• Transactions may be made simultaneously from different computer terminals (e.g. over the internet)
• The file should be locked during update to prevent corruption by simultaneous changes by more than one user
• Example: booking a hotel room or airline seat

Sign and magnitude: Has a sign bit (0 = positive, 1 = negative) followed by the unsigned number value. Example: 1000 0011 = -3

Two’s complement: The negative value of the most significant bit followed by the positive value of all other bits as necessary to achieve the required negative number. Example: 1111 1101 = -3

Mantissa: 0.110010101 Exponent: 000110 = 6₁₀

Move binary point 6 places right: 0110010.101 Fixed point value = 50.625₁₀

• In an arithmetic shift, the sign bit of a two’s complement number must remain the same

• For a right arithmetic shift, a binary 1 is inserted in the empty (second most significant bit) position for a negative number — the empty position is filled with a copy of the original MSB

• For a left arithmetic shift, the bit pattern moves one space to the left and a binary 0 is added in the position of the least significant bit

• The effect of the right shift is to halve the negative value; the left shift doubles the negative value

• Many storage locations in the sequential access file will be left empty; the direct access file takes up much less storage space

• Accessing a record in the direct access file will usually be quicker as it will not be necessary to search from the start of the file

• In the sequential access file, collisions cannot occur / every record has its own unique storage location. Collisions can occur in the direct access file if identification codes generate the same hash values

• Collisions will have to be handled by a separate overflow area (or progressive overflow), reducing the speed advantage of direct access

• If the number of products is increased, the direct access file may need to be reorganised with more memory locations and a new hash function. The sequential access file allows for an increase without reorganisation

• Ready: The process is loaded into main memory and waits to be allocated CPU time for execution. Processes that are ready are maintained in a queue for ready processes

• Run: The process is chosen by the CPU for execution and the instructions within the process are executed by any one of the available CPU cores

• Blocked/Waiting: Whenever the process requests access to I/O, it enters the blocked or wait state. The process continues to wait in main memory. Once the I/O operation is completed, the process goes to the ready state

Benefits:

• High production rates / increased productivity
• High levels of control / increased consistency / quality
• Efficient use of materials / less waste

Drawbacks:

• Worker displacement / redundancy
• Capital cost
• Lack of flexibility

Safety related control system: A system where the main purpose is not to ensure safety, but where failure can be hazardous. Safety related systems do not have full responsibility for controlling hazards but would only be hazardous in conjunction with failure of other systems or human error. Example: timer on microwave oven, cruise control, traffic lights.

Safety critical control system: A system where the main purpose is to ensure safety and where failure is likely to cause injury to persons or damage to property. Example: railway signalling, nuclear reactor controls, auto pilot, aircraft avionics.

SELECT Description, Price FROM Product
WHERE Price < 300.00;

Using subquery:
SELECT Customer, OrderDate FROM Order
WHERE ProductID IN (SELECT ProductID FROM Product WHERE Description = 'Cooker');

Or using JOIN:
SELECT Customer, OrderDate FROM Order JOIN Product ON Order.ProductID = Product.ProductID
WHERE Description = 'Cooker';

INSERT INTO Product VALUES (288, 'Refrigerator', 'Coolstore 2000', 150.60);

• Data redundancy: The company will need to repeat employee data for each project the employee is involved with. This will result in larger than necessary file size and slow down access

• Data consistency: Duplication of data and repeated input is likely to give rise to errors in content, affecting the integrity of the company’s data

Project (ProjectCode [PK], Title, Budget) ProjectTeam (ProjectTeamCode [PK], ProjectCode [FK], EmployeeNumber [FK], HourlyRate) Employee (EmployeeNumber [PK], Forename, Surname, DepartmentCode [FK]) Department (DepartmentCode [PK], DepartmentName, HeadOfDepartment)

Marking: 1 mark for four tables including ProjectTeam linking table, 1 mark for primary keys, up to 3 marks for correct foreign keys.

A database split into a number of parts, with each part stored in a different location / on a different computer. The computers are linked in a wide area network, so data can be accessed/shared from any of the locations.

Data and processing are distributed between the computers.

• Service records for a customer can be kept on a computer at their local dealership, so access could be faster

• Less requirement to transfer data over the internet, so data transfer is more secure

• System allows a customer’s records to be transferred to another dealership

• The central office can obtain data from all dealerships, e.g. to identify common faults occurring with vehicles

• If a failure occurs with a computer, only one workstation will be affected

• A large database can be shared out between a number of small low-cost computers, so hardware may be cheaper

• Improved performance as a single computer is not overloaded with processing requirements

• Single key encryption is simpler and faster to encrypt and decrypt messages
• Double key — not necessary to send the key to the person encrypting the message, so security risk is reduced
• Double key — the public key can remain in use for an extended period; single key may need to be changed regularly for security
• Simpler to write the program for a single key system
• Double key encryption provides a means of independently verifying a digital signature

Examples:

• Double key — secure file transfer
• Single key — encrypting personal files on a single computer

C (01000011) XOR key (01101010) = 00101001 (encrypted C)

A (01000001) XOR encrypted C (00101001) = 01101000 (encrypted A)

B (01000010) XOR encrypted A (01101000) = 00101010 (encrypted B)

• Wireless network card

• Wireless access point / wireless router

Any two of: Bluetooth, WiFi, WAP, WPA, WEP, 802.11

Lack of security arising from ease of interception of transmitted data.

Positive effects:

• Opportunity for health professionals to provide information to the public, e.g. recommending healthy eating, warning of dangers such as drug/alcohol misuse
• Opportunities for specialist charities to support particular patient groups, e.g. diabetes or cancer patients
• Opportunity for members of the public to obtain medical information based on symptoms
• Internet searches for particular diseases can provide information on developing epidemics

Negative effects:

• Risk of incorrect self-diagnosis and unnecessary worry
• No quality control on a website’s content, so incorrect health advice may be offered
• Doctors may find patients demand the latest/most expensive treatment after checking online
• Patients may seek ‘second opinions’ from websites rather than accept health professionals’ opinions
• Searches for health information may lead to breach of privacy (search engine providers keeping records)

Expert systems aspects:

• Can store more knowledge than one person
• Can be kept up to date
• Helps give a more accurate decision
• Available 24/7
• Lower cost than employing NHS staff
• Allows access to an expert where not available locally
• A good expert system explains its decision / gives probabilities
• Allows employees to learn from the system

A stack is a data structure of items that are added and removed according to the last-in first-out (LIFO) / first-in last-out (FILO) principle. Items can only be added and removed from the stack from the top. Push adds an item to the top of the stack, pop removes the item from the top. A stack can be used as a recursive data structure. Underflow occurs when an attempt is made to pop an empty stack / overflow occurs when an attempt is made to add to a full stack. Pointers are used to keep track of the top of the stack.

Award one mark for a correct example, e.g. storing webpages for a back button in a web browser.

The value ‘.’ can be updated by setting alphabet[6,3] = ‘!’ (or alphabet[3,6] = ‘!’). 1 mark for correct array assignment of char ‘!’, 1 mark for correct indices.

A suitable two-dimensional array with appropriate indices and structure, for example:

   0          1            2           3 0     ID      firstname    Surname     Class 1      1       Finn       Jackson       7b 2      2       Jakub      Kowalski      7b 3      3       Molly      Wilcox        7a

1 mark for suitable indices and structure of two-dimensional array. 1 mark for appropriate pupil data.

An algorithm is a step by step set of instructions or rules (1 mark) which provides a solution to a specific problem (1 mark).

One mark for identifying a method and 1 mark for a description. Examples:

• Flow charts can be used to define algorithms. Flow charts are a diagrammatic visualisation of the inputs, outputs and processes completed by an algorithm.

• Pseudocode can be used to define algorithms. Pseudocode is a generic programming language that cannot be translated into machine code but can be interpreted by a developer.

• Structured English can be used to define algorithms. Structured English breaks down a compiled algorithm into simple English words to help show a step-by-step solution.

One mark for each correct answer up to a maximum of four:

• Recursive algorithms are more elegant than non-recursive algorithms.

• Non-recursive algorithms are less complex than recursive algorithms to program.

• Recursive algorithms generally use less code than non-recursive algorithms.

• Recursive algorithms can be more difficult to debug than non-recursive algorithms.

(A + C).(A.C + A.C’) + A.C = (A + C).A.(C + C’) + A.C = (A + C).A.(1) + A.C = (A + C).A + A.C = A.(A + C) + A.C = A.A + A.C + A.C = A + A.C = A

Correctly applying identities to arrive at correct answer: 6 marks. Correctly applying identities but arriving at wrong answer: 1 mark for each correct application with a max of 5 marks.

X.Y’.(X + Y) + Z’ Apply De Morgan’s Law: NOT(X.Y’) = X’ + Y = (X’ + Y).(X + Y) + Z’ = X’.X + X’.Y + Y.X + Y.Y + Z’ = 0 + X’.Y + X.Y + Y + Z’ = X’.Y + X.Y + Y + Z’ But simplifying differently: = (X’ + Y).(X + Y) + Z’ = X + Y’.Y + Z’ = X + 0 + Z’ = X’ + Z’

Correctly applying De Morgan’s Law: 1 mark. Correctly applying identities to arrive at correct answer: 4 marks. Correctly applying identities but arriving at wrong answer: 1 mark for each correct application with a max of 3 marks.

declare searchChar as char declare first, last, m as integer declare myArray[] as char[] input searchChar set first = 0 set last = len(myArray[]) - 1 repeat set m = (first + last) DIV 2 if searchChar < myArray[m] then set last = m - 1 else set first = m + 1 end if until (myArray[m] = searchChar) output m

Marking points (1 mark each): Declare and initialise variables; Use of outer loop; Correct condition in outer loop; Correct use of DIV or INT (to force m into an integer); Correct calculation to identify midpoint; Set first using midpoint; Set last using midpoint; Output position.

Two test cases required (1 mark per row):

Input: Invalid input e.g. 99 or 1000 (but not ‘a’) Output: error

Input: 365 Outputs: 3, 6, 5, 14, 365

The purpose of the algorithm is to confirm the input (1 mark) and output the digit sum (sum of the digits) (1 mark).

One mark for each correct response up to a maximum of four:

• Developers draft the design of a system up front and it does not change.

• Only once the analysis and design stages are complete, developers cannot go back to make any changes.

• If the analysis or design of the project are inaccurate or incorrect in any way, the project will fail due to the rigidness of the waterfall methodology.

• Requires less communication between the client and the developer.

• Client input is only required during analysis and at times the design stage.

One mark for each correct response up to a maximum of four:

• Developers start with a simple project design and requirements.

• Iterative approach as analysis and design relies on each other.

• Analysis informs design and the design informs further analysis to be undertaken.

• Changes can be made after each phase of development, analysis can be revisited, and designs changed.

• Strong communication between the client and the developer should be regular.

• Clients are involved during all stages of development.

1 mark for name and 1 mark for description. Examples:

• Questionnaires: These should be undertaken by a variety of stakeholders to support the analysis of the existing system. These questionnaires should measure the effectiveness of the current systems from the viewpoints of various stakeholders.

• Observations: Formal observations should be undertaken by the analysis team. These observers should monitor the interactions stakeholders have of the current systems, making relevant notes.

• Requirements: After the analysis has been completed a formal set of requirements should be produced for any proposed changes of an existing system or implementation of a new system.

1 mark for name and 1 mark for description. Examples:

• Annotated code listings: To ensure effective maintenance of the source code for any developer. A complete list of the annotated source code is required to resolve issues or extend the system.

• Algorithm designs: A complete collection of all algorithm designs in pseudocode or flow chart format. These can aide a future developer in following the logic of a program for maintenance purposes.

• Data dictionaries: A data dictionary is a document that contains the structures of all databases, data types and the relationship between them. This is useful for maintaining, debugging and extending the data within the system.

<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<digits> ::= <digit><digit>
<pub> ::= <digit><digit><digit><digit><digit>
<prefix> ::= 978 | 979
<separator> ::= " " | "-"
<ISBN> ::= <prefix><separator><digits><separator><pub><separator><digits><separator><digit>

1 mark for each correct production rule. Answer not correct if BNF notation used incorrectly (max of four marks).

One mark for each correct response to a maximum of two and one mark for example.

• Functional programming uses a series of function definitions which are evaluated as a mathematical expression to solve a problem.

• Functional programming is a declarative language which uses when programmer code what problem they want to solve rather than how they are going to solve a specific problem.

• Functional programming is used in research and testing.

• An example of a functional programming language is Haskell or SQL.

One mark for each correct response to a maximum of two and one mark for example.

• Logic programming is used to solve programming problems using a specific knowledge base.

• Logic programming takes a problem or question and will produce a solution based on this knowledge base.

• Logic programming is used in expert systems, machine learning and artificial intelligence.

• An example of a logic programming language is PROLOG or Mercury.

Award one mark for each correct response up to a maximum of two:

• When new hardware or software is developed it needs to ensure it is compatible with existing hardware and software.

• Products developed by different companies need to meet standards to ensure compatibility across platforms.

• There must be interoperability between new products and with existing products to exchange and use data.

• Using standards ensures products can work as part of a larger system or network.

• Examples of standardised computer languages are HTML5, CSS3 and JavaScript which are maintained by W3C (World Wide Web Consortium).

Award one mark for each correct response up to a maximum of two:

• All standards must be very detailed to ensure consistency in their implementation which has high costs in terms of time and money.

• Companies and businesses will only agree to standards when they are in their own best interests.

• Many companies have different targets and goals, and this can cause difficulties when agreeing on unified standards.

• Standards need to be broad enough to ensure they meet the demands of a wide range of complex problems but specific enough that they are implemented correctly.

1 mark for identifying i loop will execute n times.

1 mark for identifying j loop will execute n^2 times.

1 mark for identifying k loop will execute n^3 times.

1 mark for determining that the order will be dominated by n^3.

1 mark for determining that the growth rate for time performance is O(n^3).

The algorithm only uses two data structures, 2 three-dimensional arrays. Therefore, total storage requirements = 1. As there is no change to the amount of data structures being used, the growth rate for memory will be constant O(1).

O(n^3) polynomial complexity. Time and Size axes labelled correctly (1 mark). Correct gradient of line showing cubic growth (1 mark).

One mark for each correct response to a maximum of four:

• Data can be recovered from back-up of data simply by copying the back-up data back to the original location.

• Temporary data can be searched to find an autosaved version of any files or data.

• Data may be recovered using specialist software to deep search for any deleted or lost data.

• Undergo a complete system restore to a previous point in time where the data is still available.

• Archived files kept off site could be used (e.g. after flood or fire).

• Returning to a previous version if data was lost during an update then running the update again.

Band 3 (9-12 marks): Sustained, coherent, logically structured response with clear understanding covering extensive indicative content, balanced discussion with examples, drawing together different areas across the course, using technical terminology confidently.

Band 2 (5-8 marks): Adequate line of reasoning with satisfactory knowledge, limited examples, drawing from a number of areas.

Band 1 (1-4 marks): Lacks sufficient reasoning and structure, superficial knowledge, limited technical terminology.

Indicative content:

• A code of conduct is a formal written document that outlines the acceptable workplace and ethical standards to which employees must abide.
• Each employee or stakeholder agrees to act according to the clear guidelines outlined in a code of conduct usually by signing a formal contract.
• A code of conduct may include standards on privacy, security, damage, access levels, copyright infringement, ethics and wellbeing.
• If an employee or stakeholder breaks a code of conduct, then action can be taken against them for breaching this contract.
• The British Computer Society outlines its own code of conduct for Computing and IT professionals to ensure integrity in their profession.
• The BCS code of conduct comprises four key principles: public interest, professional competence and integrity, duty to relevant authority and duty to the profession.
• Public interest standards include having due regard for public health, privacy, security, the environment and the wellbeing of others.
• Professional competence and integrity standards include only undertaking work that is in your professional competence, not claiming a level of skill you do not possess.
• Duty to relevant authority standards include avoiding any situation that may cause a conflict of interest and not disclosing confidential information for personal gain.
• Duty to the profession standards include upholding the reputation of the BCS and seeking to improve professional standards at all times.
• During the analysis stage, when dealing with external stakeholders, employees must act with due regard.
• During design and testing stages, employees must not disclose confidential information; many companies include non-disclosure agreements.
• Throughout all stages of the software development process it is essential to continually reflect on professional development and maintain recognised standards.

A computer program that helps the user to group related files into folders.

Common operations/uses include creating, opening, deleting, renaming, moving, copying, sorting and searching for files.

Other uses include modifying file attributes / file properties / file permissions.

A hashing algorithm is a calculation for transforming a string of characters into a usually shorter fixed-length value or key.

Hashing is used to index and retrieve items in a data structure / database.

It saves time as it is faster to find an item using the shorter hashed key than to find it using the original value.

It is also used in many encryption algorithms to provide data security.

It can deal with collisions should they arise e.g. overflow area.

Impending data loss

Impending hardware / software failure

Detection of imminent power failure

The O/S suspends current interrupt routine.

The O/S stores the address of the current interrupt.

It runs the new higher priority interrupt routine.

The O/S returns to original interrupt routine and continues.

Loop INP {input 4 digit number} STA X {store 4 digit number} LDA X {load 4 digit number} SUB Y {subtract stored code} JZE correct {jump to correct if result is zero} OUT 2 {output 2} JMP loop {loop} Correct OUT 1 {output 1} HLT {stop}

1 mark for input of number 1 mark for loop and JMP command creating a loop 1 mark for subtracting code value (Y) from input (X) 1 mark for JZE command jump to correct 1 mark for outputting 2 if incorrect 1 mark for outputting 1 if correct

Podcast: A series of digital media files (either audio or video) that are released episodically and often downloaded through web syndication. The mode of delivery differentiates podcasting from other means of accessing media files over the Internet, such as direct download, or streamed webcasting. A list of all content is maintained on the distributor’s server as a web feed. The user employs special client application software known as a podcatcher. Files are stored locally on the user’s computer or other device ready for offline use.

Blog: A type of web site usually maintained by an individual with regular entries of commentary, descriptions of events, or other material such as graphics or video. Entries are commonly displayed in reverse-chronological order. Most blogs reflect the thoughts, opinions, and biases of the individual or corporation that runs the blog. Most are also interactive, allowing visitors to leave comments.

Instant messaging: A form of real-time direct text-based communication between two or more people. Messages are usually encrypted to maintain privacy. More advanced instant messaging software clients also allow enhanced modes of communication, such as live voice or video calling. IM is based on clients that facilitate connections between specified known users whereas online ‘chat’ also allows communication between anonymous users.

Webcast: Broadcasting over the Internet. A media file distributed over the Internet using streaming media technology. Distribution of a single content source to many simultaneous listeners/viewers. May either be distributed live or on demand.

7.1875 = 111.0011

Mantissa: 01110011

Exponent: 00000011

The closest representation of 19.3 possible using the specified format is:

Mantissa: 01001101

Exponent: 00000101

This has a value of 19.25

Absolute error = original value - rounded value = 19.3 - 19.25 = 0.05

Relative error = absolute error / original value = 0.05 / 19.3 = 0.0026

Accept percentage values.

There is a set number of bits for mantissa and exponent / trade-off between accuracy v range.

A larger mantissa leads to greater accuracy.

A larger exponent leads to greater range of numbers being represented.

There will always be a trade-off between accuracy and range when using floating point notation.

Route A-C-D-F: 2 + 10 + 2 = 14

14 x (1.2 + 1.2) = 33.6

A – B – F (5 + 14) x 1.2 = 22.8

The upgrade will supersede the link from node B to node F.

The lowest cost route from A to F will become 21.6.

Link C to D is central to the network and therefore most costs will be reduced.

A path or means by which a hacker can gain access to a computer or network server in order to deliver malware or effect a malicious outcome, such as obtaining personal information.

Drive-by-download (Watering hole): Malware being inadvertently downloaded from a legitimate, but compromised website without any further action from the user.

Domain shadowing: Diverting requests to legitimate websites to bogus copies of the website that will offer what appear to be genuine links, but to malware downloads.

Malvertising: Malware downloads from infected adverts placed on popular websites.

Distributed Denial-of-Service: Flooding the targeted system with bogus requests to overload the system making it unavailable for its intended use.

SQL injection: Used to attack data driven applications where a malicious SQL statement is inserted into an entry field which, when executed, will transfer the data content to the attacker.

Penetration testing / ethical hacking is the process of testing a computer system, or network, to find vulnerabilities an attacker could exploit / test the effectiveness of an organisation’s security policies.

Targeted Testing: The internal IT team working with external professionals to determine the vulnerability of the company’s systems and find solutions to strengthening the systems to prevent potential attacks.

Internal Testing: Testing systems to establish the extent to which a dissatisfied employee may go to in accessing unauthorised information.

External Penetration Testing: Testing to establish the vulnerability to external attackers of an organisation’s external devices and servers such as firewalls, email-servers and web servers.

Blind Pen Testing: An authorised imitation of a real cyber-attack where an ethical hacker is tasked with gaining access to an organisation’s systems.

Double Blind Penetration Testing: Similar to blind testing, but to determine how fast and effective the security team is on identifying and responding to real attacks.

CREATE TABLE Customer
(
  customerID char(6) NOT NULL,
  surname char(20) NOT NULL,
  orderDate datetime,
  itemNo char(7),
  orderQuantity int,
  PRIMARY KEY (customerID)
);

1 mark for correct construct (CREATE TABLE with brackets in correct places)

1 mark for identifying PRIMARY KEY

1 mark for NOT NULL on key field

1 mark for correct data types and sizes for itemNo and customerID

INSERT INTO Item VALUES ('CT00111', 13, 'Earrings', 97);

1 mark for INSERT and VALUE

1 mark for all fields in correct order.

UPDATE Item SET price = 93 WHERE itemNo = 'CT00016';

A set of formally described tables from which data can be accessed or reassembled in many different ways without having to reorganise the database tables.

A complex data structure to hold variety of different data. Where data items are related to each other they are linked together by pointers (relations).

Powerful method of storing data in tables that makes no assumptions about how application programs will access the data.

Reduced data redundancy: In each level of normalisation data redundancy / duplication is reduced, decreasing the size (volume) of stored data.

Increased data integrity: Once the redundancy is removed, it is easy to change / limits errors as the data is present in only one place.

Normalisation splits an entity into a smaller number of entities, so you will have more smaller tables, so it is easier for sorting, indexing and searching.

Surgery 1:M Dentist

Dentist 1:M Patient

Patient 1:M Appointment

Accept Dentist 1:M Appointment

erDiagram
    SURGERY ||--o{ DENTIST : employs
    DENTIST ||--o{ PATIENT : treats
    PATIENT ||--o{ APPOINTMENT : books

Surgery (SurgeryID [P], HouseNo, Postcode, TelephoneNo)

Dentist (DentistID [P], SurgeryID [F], Name, Qualifications)

Patient (PatientID [P], DentistID [F], Name, Address)

Appointment (AppointmentID [P], PatientID [F], Date, Time)

P = 0.5, 10 processors: increase = 1.82

P = 0.5, 1000 processors: increase = 1.99

P = 0.9, 10 processors: increase = 5.26

P = 0.9, 1000 processors: increase = 9.91

At 50% the significant increase in the number of processors produces a relatively small increase in speed.

At 90% the same increase in number of processors provides a much greater relative increase in speed.

At a low % of parallel processing there is limited benefit in increasing the number of processors as the 50% serial fraction is significant and limits the potential of parallelisation.

At higher % of parallel processing the benefits are much greater, but there are practical limitations that will marginalise benefits arising from using very large numbers of processors.

The level of parallelisation achieved in the software is generally more significant than the number of processors used.

Modular Development: If the system needs to be expanded, the work simply requires adding new computers and local data for the new site and then connecting them to the distributed system, with no interruption in current functions.

More Reliable: In case of database failures, the total system of centralised databases comes to a halt. However, in distributed systems, when a component fails, the functioning of the system continues. Data may be replicated so that it exists at more than one site.

Better Response: If data is distributed in an efficient manner, then user requests can be met from local data itself, thus providing faster response.

Lower Communication Cost: If data is located locally where it is mostly used, then the communication costs for data manipulation can be minimised.

Local autonomy: Users have local control of the data, and they can establish and enforce local policies regarding the use of this data.

Asymmetric algorithms have two keys - a public key (sender) and a private key (receiver).

Asymmetric algorithms do not require a shared key to be exchanged over an insecure medium such as the Internet as it does in symmetric encryption.

Asymmetric encryption can be used to encrypt the key for a symmetric encryption to increase security.

Asymmetric encryption is best used for sensitive data such as keys, digital signatures, bank details.

In many cases, the public and private key pairs in an asymmetric system can remain intact for many years without compromising the security of the system.

Context: For medical laboratories, privacy is a paramount concern. Medical laboratories have a legal and ethical obligation to protect patients’ confidentiality.

Two biometric properties are used for authentication: Physical biometrics include DNA, fingerprints, facial recognition, and eye scans (iris, retina). Behavioural biometrics include voice recognition and handwritten signatures.

Stages: Measurement, signal processing, pattern matching, and decision making.

Accuracy: Not 100% accurate. A false reject (FR) error is the rejection of an authorised person. A false accept (FA) error is the acceptance of a person who is not who they claim to be.

Advantages: Improved security, better user experience, passwords cannot be forgotten, or access cards lost.

Disadvantages: The environment and usage can affect measurement, systems are not 100% accurate and require integration and/or additional hardware.

Types include: Fingerprint recognition (unique to each person, low error rate), Facial recognition (camera/sensor to match face to stored image), Iris scanners (high acceptance rate), Retinal scanners (highly effective, can authenticate blind users), Voice print recognition (behavioural based, subject to errors from background noise).

A stack uses the last in first out (LIFO) principle. In a stack the last or most recent item of data to be added to the stack is removed first.

Adding data to a stack is known as pushing, whilst removing data from a stack is known as popping.

A queue uses the first in first out (FIFO) principle. In a queue the last or most recent item of data added to a queue is the last to be removed.

A → C → E → G → L → Ø

1 mark for node in correct position.

1 mark for both arrows to and from correct nodes.

A → E → G → L → Ø

1 mark for node in correct position.

1 mark for both arrows to and from correct nodes.

A.A + A.B + A.B̄ + B.B

= A.B + A.B̄ + B.B (A.A = 0)

= A.B + A.B̄ (B.B = 0)

= A.(B + B̄)

= A.1

= A

(A.B)̄ + A.C + B

= Ā + B̄ + A.C + B (De Morgan’s Law)

= Ā + A.C + B̄ + B

= Ā + A.C + 1

= 1

01101001

AND 10000000

= 00000000

State of the most significant bit is 0.

1 mark for using an AND or XOR mask.

1 mark for correct result.

1 mark for determining the state of the most significant bit.

A natural language interface is where speech and linguistics is used (1) to interact and control a software application (1).

One potential use for a natural language interface would be in translation software. Natural language could be processed in real time to allow for a seamless translation service.

1 mark for suitable example, 1 mark for justification.

Colloquialisms and words can be interpreted differently regionally.

Accents could make it difficult for a natural language interface to identify the words being spoken.

Ambiguity in spoken language where a word may have more than one interpretation.

Background noise could cause problems.

Illness such as sore throat.

The algorithm sorts an array (1) into ascending order (1).

This is a recursive (1) algorithm that calls itself (1) and has a stopping condition (1).

Recursion has allowed for simpler design and for the original complex problem of sorting an array to be solved in a shorter time span than a non-recursive sorting algorithm.

The algorithm is very compact.

The algorithm uses a divide and conquer design where the main problem is recursively broken into sub problems.

The solutions of the sub problems are then combined to produce a solution for the original problem.

The purpose of a shortest path algorithm is to find the shortest path between two vertices on a graph.

Each path between adjacent vertices is weighted with a cost.

These weightings are used to calculate the total costs of different paths between two vertices.

The path with the smallest cost is the shortest path.

A 2D array (adjacency matrix) showing the costs between each pair of nodes:

A→B=3, A→C=4, B→D=12, C→D=10, D→E=6

With traversal cost of 2 added at each node.

Path p = {A,B},{B,D},{D,E} = 3 + 2 + 12 + 2 + 6 = 25

Path q = {A,C},{C,D},{D,E} = 4 + 2 + 10 + 2 + 6 = 24

Path q is the shortest with cost 24.

A programming paradigm describes the different types or approaches in programming languages (1) that are needed to solve different problems more effectively (1).

Procedural languages are those that solve a problem in a linear fashion through a sequence of step-by-step instructions and involve the use of selection, iteration and callable procedures. Procedural languages are more suited to problems that require a linear algorithm solution.

Event-driven programming is used to solve problems that require heavy user interaction through a graphical interface. Listeners are attached to objects i.e. buttons, which in turn will execute a subroutine based on the type of event triggered i.e. a single click. Event-driven programming languages are more suited to problems that require rapid application development and a graphical user interface.

Object orientated programming could be used for the development of a large distributed software application that requires a large team of developers.

Event driven programming could be used for the development of a graphical user interface software application.

Logic programming could be used for the development of artificial intelligence software.

Functional programming could be used for the development of software applications requiring complex mathematical transformations.

Procedural programming could be used for the development of command line interface software applications.

Each iteration in the loop halves the number of elements until you get 1 left.

For n values we halve the number until we get one value left which is log₂ n.

There are two instructions in the loop therefore 2log₂ n.

log₂ n dominates (1) therefore time performance is O(log n) (1).

1 mark for both correct axes (size of data vs time to complete).

1 mark for correct O(n) line (straight line).

1 mark for correct O(log n) curve (flattening curve below the O(n) line).

1 mark for correct overall graph showing O(log n) is more efficient.

O(log n) algorithms (Search_B / binary search) are more time efficient than O(n) algorithms when searching for a data item.

Data compression is reducing the amount of memory a file uses.

The level of file compression is measured using a compression ratio. A compression ratio is the size of the compressed file divided by the original file size.

Compression algorithms are used to employ different methods to reduce file size depending on the type of file.

There are two main types of file compression algorithms: lossy and lossless.

Lossy compression algorithms reduce a file size but some data is lost during this process and cannot be retrieved.

Lossless compression algorithms reduce a file’s size without the loss of any data and the original file can be retrieved.

A class is a template or blueprint for a specific object. It defines an object’s variables (attributes/properties) and behaviour (methods).

An object is an instance of a class.

1 mark for template/blueprint/contract.

1 mark for defines variables (attributes/properties).

1 mark for defines behaviour (methods).

1 mark for stating an object is an instance of a class.

A method is a programmed behaviour/subroutine that is included in an object of a class.

A method can only access data within its own object (encapsulation).

Start Procedure Sort declare myArray[] i, j, temp is integer set i = 0 while i <= len(myArray[]) set j = 0 while j <= len(myArray[] - 1) if myArray[j] < myArray[j + 1] temp = myArray[j] myArray[j] = myArray[j + 1] myArray[j + 1] = temp end if j = j + 1 end while i = i + 1 end while End Procedure

Corrections: set j=0, set i=0, i = i + 1, myArray[j+1] = temp (not temp = myArray[j+1]), comparison should be < for descending order.

Compilers, interpreters and assemblers are all examples of translators. Translators are pieces of software used to convert one type of programming language to another.

Compilers convert high-level programming language source code into object and machine code, run through a single executable file. The compilation process can throw multiple errors which can make debugging more difficult. Once software is compiled it does not need recompilation unless changes are made. One executable file produced by compilation can be executed many times. Many languages such as C++ and VB.Net produce a single executable targeted to one platform. Once compiled it is difficult to review the source code making intellectual property easier to protect.

Unlike compilers, interpreters convert high-level programming language source code line-by-line. An interpreter translates a single line of code into machine code then executes it before moving onto the next. An interpreted application does not produce an executable file, meaning source code must be interpreted each time the application is run. The same high-level source code can be interpreted on many different platforms, making the application highly portable. Interpreted code could be easier to debug as it will throw an exception at the current line being translated.

An assembler is used to translate low-level assembly language mnemonics into machine code to directly program the CPU. Each assembly language instruction has a one-to-one relationship with a machine code instruction unlike high-level languages where one instruction is translated into multiple machine code instructions. Assembly is faster than compiling and interpreting and allows greater control over memory usage.

Buffering is the temporary storage of data (1) during input, output or internal transfer of data in a computer system (1).

Buffering is required because components of a computer system operate at different speeds.

Fast components (such as the CPU) can carry out other tasks whilst waiting for data to be transferred through the buffer to a slow device (such as a hard drive).

A double buffer is more efficient than a single buffer.

One buffer can be filling whilst the other is emptying.

An interrupt is a signal to the CPU that attention is required.

Interrupts may be generated by hardware devices or by software processes.

Keyboard key press, causing the CPU to accept characters which may be transferred to a word processing document.

Mouse click, causing the program to activate a menu choice.

Printer completed processing data, causing the CPU to transfer the next block of data to the printer.

Disk drive completed transferring data, causing the CPU to initiate transfer of the next block of data.

A running process has completed, so the CPU can reallocate resources.

A process has timed-out, so can be terminated by the CPU.

A file error has occurred, so the CPU suspends the data transfer and displays a warning message on screen.

1 mark for each correct 1:n relationship up to a maximum of 3 marks:

JOB 1:M WORK SESSION

JOB 1:M ITEM USED

STOCK LIST 1:M ITEM USED

erDiagram
    JOB ||--o{ WORK_SESSION : "worked over"
    JOB ||--o{ ITEM_USED : uses
    STOCK_LIST ||--o{ ITEM_USED : supplies

JOB (JobNumber [P], Description) WORK SESSION (WorkSessionID [P], JobNumber [F], Date, HoursWorked) STOCK LIST (StockCode [P], Description, UnitPrice) ITEM USED (ItemUsedID [P], JobNumber [F], StockCode [F], Quantity)

1 mark for four tables, including a table ITEM USED linking JOB and STOCK LIST. 1 mark for each primary key field [P] suitably identified in JOB and STOCK LIST tables. 3 marks, 1 for each foreign key field [F] suitably identified in WORK SESSION and ITEM USED tables.

SELECT CourseTitle, Degree FROM COURSE;

SELECT ModuleTitle FROM MODULE WHERE CourseID = '427';

UPDATE MODULE SET YearStudied = '3' WHERE ModuleTitle = 'Freshwater Biology';
Accept: UPDATE MODULE SET YearStudied = '3' WHERE ModuleID = '1022';

SELECT ModuleTitle, YearStudied FROM MODULE WHERE CourseID = (SELECT CourseID FROM COURSE WHERE CourseTitle = 'Modern Languages' AND Degree = 'BA');

Alternative using JOIN:
SELECT ModuleTitle, YearStudied FROM (COURSE JOIN MODULE ON ModuleID) WHERE CourseTitle = 'Modern Languages' AND Degree = 'BA';

SELECT ModuleTitle, StudentsEnrolled FROM MODULE WHERE (StudentsEnrolled < 20) OR (StudentsEnrolled > 40);

5.75 = 101.11 in binary

Mantissa = 0101 1100 00

Exponent = 000011

Accurate answer: 25.5 × 5.75 = 146.625

Method 1: Round then multiply: 26 × 6 = 156, absolute error = 9.375

Method 2: Multiply then round: 147, absolute error = 0.375

Method 3: Multiply then truncate: 146, absolute error = 0.625

Method 2 is most accurate.

Method 1 is least accurate.

Method 3 is neither most nor least.

Rounding is always as good as truncating, and will often be better.

Greatest overall accuracy is achieved by completing all stages of a calculation to maximum available decimal places, with rounding or truncation only carried out after obtaining the final result.

+152 = 0000 0000 1001 1000

Obtaining the two’s complement:

-152 = 1111 1111 0110 1000

LOD R, 0 {initialise count of readings} LOD S, 0 {initialise total of readings} LOOP: IN T {input data value} JNG T, FINISH {end if negative rogue value} INC R {increase reading count by 1} ADD S, T {add reading to total} JMP LOOP {return to start of the loop} FINISH: OUT S {output total} OUT R {output count}

1 mark for initialising total and count to zero. 2 marks for correct operation of the loop. 1 mark for correct calculation of total. 1 mark for correct calculation of count. 1 mark for input of readings, and output of total and count.

Create a second level index block with entries from 3000 to 3900. Link to pointer from 3000 in the first level index to the start of this block.

Create a third level index block with entries from 3800 to 3890. Link to pointer from 3800 in the second level index to the start of this block.

Create a data block, for records 3890 to 3899.

Store the two records 3892 and 3893 in sequential order in that data block.

Link the pointer from 3890 in the third level index to the start of the new data block on disk.

Begin at the first level index, then follow the pointer from ‘3000’ to the second level index block.

Follow the pointer from ‘3800’ to the third level index block.

Follow the pointer from ‘3890’ to the data block on disk, then load the data block into the RAM memory. Extract the required record 3893 from the data block in RAM.

Each record will require 22 bytes.

File size = 6000 × 22 = 132,000 bytes

File size = 132,000 / 1024 = 128.9 KB

Accept 132,000 / 1000 = 132 KB

Records will have an average size of (7 characters + end marker) = 8 bytes.

File size = 6000 × 8 = 48,000 bytes

File size = 48,000 / 1024 = 46.9 KB

Accept 48,000 / 1000 = 48 KB

Data mining is the automated analysis of large amounts of data to identify patterns. The objective is to turn raw data into information which can be used for decision making. Data mining may involve the use of statistical / predictive analysis or artificial intelligence.

Examples: Insurance Company: Analysing car insurance claims, to predict different risks of accidents depending on age, sex, type of car, business occupation. Shop: Analysing the buying habits of customers, so that advertising can be focussed more effectively. Police: Analysing incidents of crime in a particular location. Health Authority: Analysing data on the outcomes for patients, to identify the most effective medical treatments or determine whether screening of the population for particular diseases will be effective.

Presence check: to ensure input has not been left blank.

Type check: to ensure data is of a set type.

Format check: to ensure the data contains a valid pattern of letters and digits.

Range check: to ensure data is within allowed bounds.

Lookup check: to ensure that a data item is a valid category.

Length check: to ensure that a field conforms to a specific field length.

Viruses: Programs that can replicate themselves and be spread from one system to another by attaching themselves to host files. Used to modify or corrupt information on a targeted computer system. Worms: Self-replicating programs that identify vulnerabilities in operating systems and enable remote control of the infected computer. Spyware: Installed by opening attachments or downloading infected software. Can be used to collect stored data without the user’s knowledge. Trojans: A program that appears to perform a useful function, but also provides a ‘backdoor’ that enables data to be stolen.

Protection measures: Virus and spyware checking software should be installed and kept up to date. A firewall can protect against unauthorised access to the computer system. E-mail attachments should not be opened unless from a trusted source. Users should be cautious of fraudulent e-mails asking for passwords. Password hierarchy, access levels, user policies.

Data sent over the internet may be intercepted. Sensitive data should be encrypted.

Data is particularly at risk if sent or received at public Wi-Fi locations. Password protection should be used.

Data sent by post (e.g. on a DVD or on a USB memory stick) may be intercepted. The storage medium should be password protected. Sensitive data should be encrypted.

Monitoring speed, then applying power or braking as necessary.

Monitoring geographical location, and applying brakes on entering a station.

Monitoring the track ahead, and applying brakes if an obstruction is detected.

Monitoring the state of the carriage doors, and not moving from the platform if doors are open.

Monitoring fire warning systems and taking emergency action if a fire is detected.

A safety critical system is one in which a malfunction or failure of computer hardware or software could potentially put persons at risk of injury.

Measures to ensure safety: Exhaustive testing of systems must be carried out before they are brought into service. Systems should have redundancy where possible (e.g. a backup computer can be brought into use immediately if the main computer fails). Systems should be designed to be fail-safe (e.g. a train will safely come to a halt if a malfunction is detected). Regular maintenance and testing should be carried out. High levels of security must be maintained, to guard against malicious attacks.

A single computer has a number of separate users, running separate processes from different terminals. Time-slicing: each process receives small amounts of processor time, repeated as necessary. Active processes may be running (currently receiving processor time), runnable (able to run when the processor is available) or suspended. Example of a suspended process: awaiting completion of data input/output, awaiting linking of a DLL code module.

Two different designs of scheduler: single queue with equal job priority, or multiple job queues (e.g. with small fast jobs given priority over large slow jobs). Use of polling, to check when suspended jobs are ready to re-join the job queue. Storage protection ensures that programs in RAM do not interfere with each other. Backing store disks provide virtual memory to extend the job queue. A separate spooling system handles input/output operations, with connections to individual terminals. A large mainframe computer will have multiple processors, and may run a number of process threads simultaneously.

Distributed processing is the technique of carrying out a large computing task by sharing the processing between computers in different locations. Each computer will run its own programs and have its own store of data, but will share data with other computers in the distributed processing network as necessary.

Example - A patient record system for a health authority: Computers will be located in health centres and hospitals, linked in a wide area network. Each computer will have the software necessary to carry out database operations on patient records. Patient records will generally be held locally at the GP surgery, but additional records may also be held in a hospital. Doctors and other medical staff may access and update information about a patient at any of the locations by means of the network. The overall system may provide summary data for the health authority. The system will be able to inform GPs of the outcomes of hospital treatments carried out on their patients.

1 mark for correct root node (Goat).

1 mark for correct structure with all nodes in correct positions.

flowchart TD
    G["Goat"] -->|left| D["Duck"]
    G -->|right| L["Leopard"]
    D -->|left| B["Bear"]
    D -->|right| F["Fox"]
    B -->|left| A["Ant"]
    B -->|right| C["Cat"]
    F -->|left| E["Emu"]
    L -->|left| I["Insect"]
    L -->|right| O["Owl"]
    I -->|right| J["Jaguar"]
    O -->|left| M["Mayfly"]

G D B A C F E L I J O M

Uses: Clone a tree, count the number of leaves, convert expression tree to prefix notation.

Note: the recorded mark scheme gives the last two nodes as “M O”. Mayfly is Owl’s left child, so pre-order (root, left, right) must visit Owl before Mayfly. The in-order and post-order answers for this tree both agree with the structure above, so the transposition is confined to this one line. The Summer 2018 Unit 3 mark scheme was not available to confirm whether the error is WJEC’s or the transcription’s.

A B C D E F G I J L M O

Uses: Sort/search a binary tree, traversing alphabetically.

A C B E F D J I M O L G

Uses: Deleting/undo a binary tree, stack-based programming, convert postfix notation to expression tree.

Functionality: the system must produce correct results for a given set of inputs.

Performance: the system must produce results within an acceptable timeframe.

A natural user interface relies on intuitive actions related to natural, everyday human behavior. Examples: Touch screens where users touch or tap graphic icons. Gesture recognition systems which track and translate user movements into instructions. Speech recognition systems that identify spoken words and phrases and convert them into instructions.

An immersive interface places one or more of the user’s senses into a computer generated virtual environment. Examples: Virtual reality headsets or HMDs (head mounted displays) which receive video from a computer, possibly with head tracking. Binaural or 3D earphones to filter out natural sound and replace with selected audio. Force feedback and touch controls provide sensation of using hands within a virtual environment.

(A.B)̅ + A

= Ā + B̄ + A (De Morgan’s Law: (A.B)̅ = Ā + B̄)

= (Ā + A) + B̄ (commutative and associative laws)

= 1 + B̄ (complement law: Ā + A = 1)

= 1 (identity law: 1 + X = 1)

A.B.(B̄ + C) + B.C + B

= A.B.B̄ + A.B.C + B.C + B

= A.0 + A.B.C + B(C + 1) (B.B̄ = 0)

= A.B.C + B (C + 1 = 1)

= B(A.C + 1) (A.C + 1 = 1)

= B

Auto completion or code completion: Suggests or completes the function being typed including variables and arguments.

Bracket matching: Useful when coding in a language that uses blocks of code contained within brackets, for detecting missing brackets.

Syntax checks: Recognises and highlights errors in syntax during code input.

Formatting: e.g. indentation or colour coding of variables.

Converting the source code written by the programmer into machine code / executable code.

Errors in code syntax / syntax errors will prevent translation, e.g. spelling mistakes in command words / incorrect punctuation.

Logical errors / semantic errors / runtime errors will not be discovered during translation, e.g. 2 + 2 = 4 included as 2 * 2 = 8, any error in logic, divide by 0, infinite loops, referencing missing files.

1 mark for correct order of answer.

1 mark for correct answer: 10001001.

Converts decimal numbers to binary numbers.

bin as integer, despite being either 1 or 0, because values are to be used to form a binary number.

answer as string to represent the bit pattern of the denary number expressed as a binary number.

Each time the loop is executed the result of the MOD calculation is placed at the beginning of the output string.

Sets out the professional standards required by the Institute as a condition of membership.

A code of conduct includes standards for professional competence and integrity.

Only undertake to do work or provide a service that is within your competence.

Not claim any level of competence as an ICT Technician that you do not possess.

Develop your professional knowledge, skills and competence on a continuing basis.

Ensure that you have the knowledge and understanding of Legislation and that you comply with such Legislation.

Respect and value alternative viewpoints and seek, accept and offer honest criticisms of work.

Avoid injuring others, their property, reputation, or employment by false or malicious or negligent action or inaction.

Reject and will not make any offer of bribery or unethical inducement.

Confidentiality: respect confidentiality of pupils, exams, and staff.

Hash table stores data in an associative array and uses a hash technique to generate an index where details of stock items are to be inserted into the table.

The index is a numeric value calculated from the stock item’s key value.

The hash table provides direct access to the stock item via its index and therefore performance is not affected by the number of items stored.

<lowercase letter> ::= a|b|c...|z
<uppercase letter> ::= A|B|C...|Z
<digit> ::= 0|1|2|3|4|5|6|7|8|9
<string> ::= <lower case letter>|<string><lower case letter>
<number> ::= <digit>|<number><digit>
<two letters> ::= <uppercase letter><uppercase letter>
<two digits> ::= <digit><digit>
<house name> ::= <uppercase letter>|<uppercase letter><string>
<street name> ::= <uppercase letter>|<uppercase letter><string>
<street> ::= <number><street name>|<house name><street name>
<town> ::= <uppercase letter><string>
<postcode> ::= <two letters><two digits><two letters>|<two letters><two digits><digit><two letters>
<postal address> ::= <street><town><postcode>

Iteration is repeating a set of instructions a set number of times or until a logical condition is satisfied.

Recursion is a method where a function calls itself with different input values until the base case is reached.

Iterative solutions tend to be easier to program and easier to understand / maintain.

Functions that just iterate make no demands on stack space, and may be more efficient where memory is limited.

Each time a recursive function is called, certain values are placed onto the stack - this takes time and uses memory and if not terminated could use all stack space causing the program to crash.

Validation aims to make sure that data is sensible, reasonable, complete and within acceptable boundaries.

It is the process of checking the data against a set of validation rules set up in a program.

Validation only proves that the data entered has a reasonable value and cannot prove that the data entered is what the user intended.

Algorithm should include:

• Declare/initialise variables

• Setting a flag for valid/invalid

• String handling to extract year

• String handling to extract month

• String handling to extract day

• Calculation of leap year (Year MOD 4 = 0)

• Month comparisons for 31 days (months 1,3,5,7,8,10,12)

• Month comparisons for 30 days (months 4,6,9,11)

• Month comparisons for 29 days (February in leap year)

• Month comparisons for 28 days (February in non-leap year)

• Output correct message based on flag

OOP is a programming paradigm based on objects.

Objects are made up of properties and methods which are data structures.

Operations or functions which are applied to the data structures.

And code in the form of procedures known as methods.

A class is a programming template for creating objects.

An object is built from a class; an instance is a variable that holds the memory address of the object.

It is possible to have many objects from the same class and many instances of each of these objects.

A method is a program routine within an object designed to carry out a particular task on data within that object (private) or provided by another part of the program (public).

Methods can be inherited from parent classes.

Standardisation allows changes and enhancements to be incorporated in a controlled manner. Programming languages are subject to continuous development resulting in multiple versions that are often not fully compatible with each other.

Portability of programs: Applications written for a particular hardware platform may be used on different platforms if developed in a standardised language because compilers/interpreters for standardised languages exist for diverse hardware platforms. Portability of programmers: If different platforms support a standard programming interface, then the skills of the programmer are portable across these platforms. Easier to maintain the software: A standardised language ensures that there will be sufficient skilled programmers available to carry out maintenance tasks. Acceptability: Most business organisations would not consider using a non-standardised language for business-critical software development. Faster development: Standardisation promotes standard ways of working and speeds up team working. Standard library: A common set of library functions promotes re-use and faster programming. Libraries have been written by experts and thoroughly tested. Standard algorithms: reference to binary search, quick sorts etc. and benefits arising in design time and accuracy.

Address bus: used to transmit the address in RAM of the next line of program code to be fetched. Used to transmit the address of a RAM location or input/output port where data is to be stored or loaded.

Data bus: used to transfer program code between RAM memory and the processor. Used to transfer data between the processor and RAM memory or input/output ports.

Control bus: used to send control signals from the processor to the RAM memory or input/output ports to initiate data transfer. Carries interrupt signals to the processor to indicate that hardware/software requires attention.

The program command is accessed from the current instruction register. The processor then carries out actions which depend on the command.

On completion of the execute phase, the program counter is updated, ready to fetch the next program command.

1 mark for stating the program instruction is held in the current instruction register.

1 mark for correctly describing a load or save operation, including reference to the MAR and MDR.

1 mark for correctly describing one other processing operation (calculation, logic or jump).

1 mark for stating that the program counter is incremented at the end of the execute phase.

LOD S, 0 {initialise the count variable} LOD T, 0 {initialise the total variable} LOOP: IN R {start loop, input a value and store in R} JLZ R, END {jump out of loop if value is negative} INC S {add 1 to the count} ADD T, R {add current data value to the total} JMP LOOP {repeat the loop} END: OUT T {loop ends, output total} OUT S {output count}

1 mark for initialising count or total to zero. 1 mark for label marking start of loop. 2 marks for correct operation of the loop. 1 mark for updating total or count. 1 mark for output of total or count.

The overflow area is a separate file.

The overflow area uses serial storage.

Advantage: Records are likely to be stored at or close to the calculated location, so access will be fast. If a record is not in the file, this will be known as soon as the first empty location is reached. Less total storage space needed.

Disadvantage: The main file has a fixed maximum capacity, so storage of further records may be prevented.

NOV3099 = (14 + 15 + 22 + 30 + 99) = 180

180 MOD 1000 = 180

The records would be grouped near the start of the file, so collisions would be frequent.

A suitable hash method which incorporates the month, day and year figures and can generate hash values over most of the range 0-1000. Should produce a number in excess of 1000 by using powers or multiples of the day, month and year values, then apply the hash function: total MOD 1000. Should avoid collisions between records for similar dates in successive years.

A–C: 1,000,000/100,000 = 10

A–D: 1,000,000/200,000 = 5

B–D: 1,000,000/250,000 = 4

C–E: 1,000,000/50,000 = 20

D–E: 1,000,000/500,000 = 2

B: Route A-D-B, Cost 9

C: Route A-C, Cost 10

D: Route A-D, Cost 5

E: Route A-D-E, Cost 7

No key field, so confusion between customers with the same name.

Name field is not atomic. Names should be stored in separate Surname and Forename fields, to allow easy searching/sorting by surname.

Room field can contain multiple data items. In first normal form, each record should only contain one room number.

Identify a customer booking with a primary key field.

Surname and Forename as separate fields.

Splitting into individual room bookings i.e. 133 and 134 in separate records.

1 mark for each correct relationship.

Accept a table between trip and resident e.g. booking: trip-booking 1:M and booking-resident M:1.

erDiagram
    DRIVER ||--o{ TRIP : drives
    VEHICLE ||--o{ TRIP : "allocated to"
    TRIP ||--o{ BOOKING : has
    RESIDENT ||--o{ BOOKING : makes

DRIVER (DriverID [P], DriverName…) VEHICLE (RegNo [P], NumberOfSeats…) RESIDENT (ResidentID [P], ResidentName, ResidentAddress…) TRIP (TripID [P], DriverID [F], RegNo [F], Date, Destination…) BOOKING (BookingID [P], TripID [F], ResidentID [F]…)

1 mark for five tables, including BOOKING to link TRIP and RESIDENT. 1 mark for primary key fields [P] suitably identified. 4 marks, 1 for each foreign key field [F] suitably identified.

SELECT IncidentID, ProblemDescription FROM PROBLEM;