Background Concept

A logic gate is an electronic circuit that performs a Boolean operation on one or more binary inputs. Each input can only be 0 or 1, and the output is also 0 or 1.

For this question, the important idea is the function of each named gate:

• OR gives 1 if at least one input is 1.
• XOR means exclusive OR. It gives 1 only when the two inputs are different.
• NAND means NOT AND. First imagine an AND gate, then invert its result.
• NOR means NOT OR. First imagine an OR gate, then invert its result.

A quick way to remember them:

• AND is true only for 1 AND 1
• OR is true for any input containing a 1
• NAND is the opposite of AND
• NOR is the opposite of OR
• XOR is true for exactly one 1

Understanding the Question

This part asks you to describe the operation of four gates: NAND, NOR, XOR and OR. That means you do not need to draw symbols or make a truth table unless you want to think with one. You just need a correct statement of when each gate outputs 1 or 0.

Each gate is worth one mark, so each description should be short and exact.

Approach

The best approach is to define each gate by its output condition:

1. Say when the output is 1, or
2. Say when the output is 0, if that is simpler.

For NAND and NOR, it helps to think of the underlying gate first:

• NAND = NOT AND
• NOR = NOT OR

For XOR, the key word is exclusive: it does not behave like normal OR. It only outputs 1 when the inputs are different.

Step-by-Step Reasoning

Start with OR because it is one of the basic gates.

• If input A is 1 and input B is 0, OR outputs 1.
• If input A is 0 and input B is 1, OR outputs 1.
• If both are 1, OR still outputs 1.
• Only 0 OR 0 gives 0.

So the correct description is: output is 1 when one or both inputs are 1.

Now consider XOR.

• 0 XOR 0 = 0
• 0 XOR 1 = 1
• 1 XOR 0 = 1
• 1 XOR 1 = 0

So XOR outputs 1 only when the inputs are different. That is why it is called exclusive OR.

Next, NAND.

First think of AND:

• AND only gives 1 when both inputs are 1.

NAND is the opposite of that result, so:

• if both inputs are 1, NAND gives 0
• in every other case, NAND gives 1

So the best description is: output is 0 only when both inputs are 1.

Finally, NOR.

First think of OR:

• OR gives 1 when one or both inputs are 1
• OR gives 0 only when both inputs are 0

NOR reverses that, so:

• if both inputs are 0, NOR gives 1
• otherwise NOR gives 0

So the correct description is: output is 1 only when both inputs are 0.

Key Takeaways

• Learn the output condition of each standard logic gate.
• NAND and NOR are simply inverted versions of AND and OR.
• XOR is different from OR: XOR needs the inputs to be different.
• In short written answers, describing exactly when the output is 1 or 0 is usually enough.

Common Mistakes

• Saying XOR is the same as OR. This is wrong because OR gives 1 for 1,1, but XOR gives 0 for 1,1.
• Saying NAND gives 1 when both inputs are 1. That is AND, not NAND.
• Saying NOR gives 1 when either input is 1. That is the opposite of NOR.
• Giving vague descriptions such as "it combines two inputs" without stating the actual output condition.

Things to Be Careful About

• Use the exact gate name: XOR means exclusive OR, not ordinary OR.
• For NAND and NOR, remember the NOT changes the final output.
• If you describe a gate by when the output is 0, make sure the statement is complete and unambiguous.
• Keep the answer brief: one accurate sentence per gate is enough for full marks.

Background Concept

A Boolean expression can be turned into a logic circuit by replacing each operation with its matching gate and following the bracket structure carefully.

The basic mappings are:

• AND → AND gate
• OR → OR gate
• NOT → NOT gate

The most important rule is to work from the inside of the brackets outward. Each bracketed part becomes a smaller sub-circuit, and then those sub-circuits are connected together.

For the expression

$X = \text{NOT ((A AND B) OR (C AND D))}$

there are three stages:

1. Find A AND B
2. Find C AND D
3. OR those two results together, then NOT the final result

So the circuit is built in layers, not all at once.

Understanding the Question

This part asks you to draw the circuit for the given expression, not to simplify it.

You are given four inputs: A, B, C and D, and one output: X.

The expression is:

$X = \text{NOT ((A AND B) OR (C AND D))}$

This tells you exactly what operations must happen:

• A and B must go into an AND gate
• C and D must go into another AND gate
• the outputs of those two AND gates must go into an OR gate
• the output of the OR gate must go through a NOT gate
• the final output is X

The brackets are the clue to the correct structure.

Approach

A safe method for these questions is:

1. Identify each smallest bracketed expression.
2. Draw a gate for each of those parts.
3. Connect those outputs to the next gate.
4. Apply any outer NOT last.

Here, the smallest parts are (A AND B) and (C AND D). Since they are separate, you need two AND gates. Their outputs are then combined by one OR gate. Because the whole expression is wrapped in NOT, the OR output must finally go into a NOT gate.

Step-by-Step Reasoning

Take the first sub-expression:

A AND B

This means input A and input B both feed into the first AND gate. That gate produces an intermediate output.

Now take the second sub-expression:

C AND D

This means input C and input D feed into a second AND gate. That gate produces another intermediate output.

Now look at the next level:

(A AND B) OR (C AND D)

So the two intermediate outputs from the AND gates become the two inputs of an OR gate.

Finally, the whole expression begins with NOT, so the output from the OR gate must be inverted.

That means the OR output is connected to a NOT gate, and the output from that NOT gate is labelled X.

So the finished circuit has:

• two 2-input AND gates on the left
• one OR gate receiving the outputs of those AND gates
• one NOT gate after the OR gate
• output labelled X

A common check is to read your completed circuit from left to right:

• first AND, AND
• then OR
• then NOT

That matches the expression exactly.

Key Takeaways

• Translate Boolean expressions into circuits by following the brackets.
• Each inner bracket usually becomes a separate intermediate gate output.
• Apply an outer NOT at the end if it covers the whole expression.
• Reading the circuit left to right should reproduce the original expression structure.

Common Mistakes

• Drawing one large gate instead of separate gates for the two bracketed AND terms.
• Putting the NOT on one of the inputs instead of on the final OR output.
• Using a NAND gate directly without showing the required OR stage. Even if a simplified equivalent exists, the question asks for the given expression.
• Connecting A, B, C and D all directly into an OR gate, which ignores the bracketed AND operations.

Things to Be Careful About

• Follow the brackets exactly; they determine the order of operations.
• Make sure A pairs with B, and C pairs with D.
• The NOT applies to the whole result of the OR stage, not to the individual AND outputs.
• Label the final output as X, matching the expression and the diagram space provided.

Background Concept

A virtual reality headset combines output devices and input sensors to create an immersive environment. The output side usually includes small displays, one for each eye or sometimes a shared display arrangement, plus speakers for audio. The input side includes sensors that detect how the user's head is moving so that the image can be updated to match the user's viewpoint.

A common movement sensor in VR equipment is a gyroscope. A gyroscope measures rotational movement, so it helps the system detect how the user's head is turning. Some systems also use additional sensors such as accelerometers, but where a single sensor is asked for in this sort of question, gyroscope is the standard answer.

Many VR headsets also include eye-tracking hardware. This is commonly done with cameras or infrared camera systems that observe where the user's eyes are looking.

Understanding the Question

This part is a fill-in-the-blanks question about the main operation of a VR headset. The stem already tells you that:

• the headset outputs images and sound
• head movements are detected by a sensor
• a microprocessor analyses the sensor data
• some headsets also record eye movements

So each blank is asking for a hardware term or a simple description:

1. what outputs the image
2. which sensor detects movement
3. what aspect of movement is identified
4. what records eye movement

Approach

Use the clues in the sentence around each blank.

• “output the image to the user” points to displays or screens
• “sensor” plus “head movements” points to a gyroscope
• the processor uses the data to work out the direction of movement
• “record the user’s eye movements” points to cameras

This is mainly a recognition question: match each VR function to the correct hardware/component term.

Step-by-Step Reasoning

The first blank says the headset can have one or two things that output the image. The image is shown on displays or screens, so displays / screens fits.

The second blank asks for the type of sensor that detects the user's head movement. In VR, this is typically a gyroscope, which detects rotational movement.

The third blank asks what the microprocessor identifies from the sensor data. From movement data, it can determine the direction of movement.

The fourth blank asks what some headsets use to record eye movements. Eye tracking is done using cameras.

So the completed description uses:

• displays / screens
• gyroscope
• direction
• cameras

Key Takeaways

• VR headsets use displays/screens to show images.
• A gyroscope is a standard sensor for detecting head rotation/movement in VR contexts.
• Sensor data is analysed to determine movement direction.
• Eye tracking is commonly carried out using cameras.

Common Mistakes

• Writing a vague term like “sensor” for the second blank. The question already says it is a sensor, so the missing word needs the specific type.
• Giving “monitor” instead of display/screen if the wording suggests built-in headset hardware rather than a separate desktop device.
• Writing “speed” or “position” for the third blank when the sentence is asking what is identified from movement in a simple way; direction is the expected idea.
• Giving “infrared” alone for the final blank. Infrared may be part of the system, but the device doing the recording is typically a camera.

Things to Be Careful About

• In fill-in questions, keep the answer to the exact term needed rather than writing a long sentence.
• Use specific hardware names when the question asks for a device type.
• Where a mark scheme is likely to allow close alternatives, choose the clearest standard textbook term, such as gyroscope and cameras.

Background Concept

A buffer is a temporary holding area in memory used during data transfer. Buffers are needed when two devices do not operate at exactly the same speed. One device may produce data faster than the other can accept it, or the receiving device may briefly pause while processing earlier data.

Instead of forcing both devices to work at identical rates, the system places data into a buffer first. The receiving device can then read from that buffer as it becomes ready. This smooths out differences in speed and helps keep the data stream continuous.

In multimedia systems such as VR, this is especially important because images and sound need to arrive in time. Delays, gaps or lost data would reduce realism and could make the experience uncomfortable.

Understanding the Question

The question says the computer uses a buffer when transmitting data to a VR headset. It asks you to explain how the buffer is used during transmission.

So you need to do more than define a buffer. You must connect the idea of temporary storage to the actual transmission process between the computer and the headset, and explain why that helps.

The likely marking points are:

• what a buffer is
• where the data goes during transfer
• why buffering is needed in this situation

Approach

A good three-mark explanation follows a clear structure:

1. define the buffer as temporary storage
2. say that data is written to the buffer before the headset reads it
3. explain that this handles different transfer/processing speeds and prevents interruption or loss

That gives both the process and the purpose.

Step-by-Step Reasoning

First, identify the role of a buffer. It is not permanent storage, and it is not the final destination. It is a temporary memory area used during transfer.

Next, apply that to the VR scenario. The computer generates data for the headset, such as image frames and audio. Instead of sending every bit directly with perfect timing, the system places the data into the buffer.

Then the VR headset reads the data from the buffer. If the computer sends data slightly faster than the headset can process it, the extra data can wait in the buffer. If the headset is ready, it can continue reading from the buffer without needing the computer to supply every item at exactly that instant.

This matters because the two devices may operate at different speeds. The computer and VR headset may have different processing rates or timing. Without a buffer, data could be lost, or the display/audio could pause or break up.

So the complete explanation is that the buffer temporarily stores data between the computer and the headset, allowing them to operate at different rates while maintaining continuous transfer.

Key Takeaways

• A buffer is temporary memory used during transfer.
• Buffers are used when sender and receiver work at different speeds.
• Buffering helps avoid data loss, pauses and uneven output.
• VR systems benefit from buffering because smooth real-time output matters.

Common Mistakes

• Saying a buffer is “permanent storage.” It is temporary.
• Only defining a buffer without explaining the transmission process between the computer and headset.
• Saying the buffer “speeds up” the headset. Its main role is to smooth transfer, not to make processing inherently faster.
• Forgetting to mention different data rates or prevention of interruption/data loss.

Things to Be Careful About

• Link the answer to transmission, not just storage in general.
• Make it clear that data goes into the buffer before being read by the headset.
• For full marks, include the reason buffering is necessary: different operating speeds or timing differences between devices.

Background Concept

ROM is non-volatile memory, meaning it keeps its contents when power is switched off. Different types of ROM differ mainly in whether, and how easily, their contents can be changed.

• PROM is programmed once.
• EPROM can be erased and reprogrammed, but usually needs ultraviolet light and removal from the circuit.
• EEPROM can be erased and rewritten electrically while still in the device.

In embedded devices such as VR headsets, ROM is commonly used to store firmware: the low-level software that controls the hardware.

Understanding the Question

The question asks for the benefits of using EEPROM instead of other ROM types in a VR headset. So you should compare EEPROM with alternatives such as PROM or EPROM and explain what advantage EEPROM gives in this device.

The key clue is the phrase “instead of other types of ROM.” That means the answer should focus on what EEPROM uniquely improves, not general ROM properties that all ROM types share.

Approach

To answer well:

1. state that EEPROM can be erased and rewritten electrically
2. explain that this can be done without physically removing the chip
3. connect that to a practical benefit for the headset, such as firmware updates or corrections

These are the standard mark-scheme points for EEPROM questions.

Step-by-Step Reasoning

EEPROM stands for Electrically Erasable Programmable Read Only Memory. The important part here is that it is electrically erasable.

Compared with PROM, which is programmed once, EEPROM can be changed again after manufacture.

Compared with EPROM, EEPROM does not need a special ultraviolet-light erasure process and usually does not need to be removed from the device first.

That gives a clear benefit in a VR headset. If the manufacturer wants to fix a bug, improve performance, or update firmware, the memory contents can be rewritten while the chip remains installed. This makes maintenance easier and avoids replacing hardware.

So the practical advantages are:

• electrical erasure and rewriting
• no need to remove the chip
• easy updating of firmware/settings

Key Takeaways

• EEPROM is non-volatile ROM that can be erased and rewritten electrically.
• It is more flexible than PROM and more convenient than EPROM.
• It is useful in embedded devices because firmware can be updated without replacing components.

Common Mistakes

• Saying EEPROM is better because it is non-volatile. Other ROM types are also non-volatile, so that is not a distinguishing benefit here.
• Confusing EEPROM with RAM and saying data is lost when power is off. EEPROM retains its contents.
• Describing only what EEPROM stands for without explaining the practical benefit to the headset.
• Writing that EEPROM is faster than all other ROM. Speed is not the key expected point here.

Things to Be Careful About

• Focus on benefits relative to other ROM types, not relative to RAM.
• Mention that rewriting is electrical and can happen in place.
• A good answer should connect the memory feature to firmware updates or maintenance in the VR headset.

Background Concept

A thin client is a client device that depends heavily on a server. In a client-server system, the server does most of the processing, storage, or application management, while the client mainly provides the user interface.

Typical thin-client characteristics include:

• most processing happens on the server
• software may run centrally on the server
• little local storage is needed
• the client device can be lower specification
• a reliable network connection is important

This is different from a thick client, where much more processing and storage happen on the user's own computer.

Understanding the Question

The question says the exam markers use software that operates as a thin client to mark exam papers. It then asks for two characteristics of a thin client and for each one, a description of how it is used in this software.

So you cannot just list two general facts. Each fact must be linked to the exam-marking situation:

• scanned papers are stored on a server
• markers download papers to mark
• markers upload marks

That means the answer must apply the thin-client idea directly to this scenario.

Approach

Choose two classic thin-client characteristics that are easy to apply:

1. server-side processing / software runs on the server
2. centralised storage / little local storage on the client

Then connect them to the given system:

• the marker's machine mainly shows the paper and captures the entered marks
• the actual papers and marks are kept centrally on the server

Step-by-Step Reasoning

First characteristic: processing is done on the server.

Why this fits:

• In a thin-client model, the client machine is not expected to do the main work.
• For exam marking, the software can be hosted centrally.
• The marker's device mainly needs to display the digitised paper on screen and send the mark entered by the user.
• The server handles the main processing and management of the system.

Second characteristic: data is stored centrally on the server.

Why this fits:

• The question states that digitised papers are stored on a server.
• Markers download papers and upload marks, which suggests central control of files and results.
• A thin client usually does not need large amounts of permanent local storage.
• The marker's computer may only hold temporary copies while the files are being viewed or transferred, but the master copies remain on the server.

These two characteristics are both valid and clearly linked to the scenario.

Key Takeaways

• Thin clients rely on servers for most of the work.
• Good answers must not just name characteristics; they must apply them to the given system.
• Central processing and central storage are two of the most common thin-client features.

Common Mistakes

• Listing thin-client characteristics with no application to the exam-marking software.
• Giving characteristics of a thick client instead.
• Saying only "it is cheaper" or "it is easier to maintain". Those are benefits, not the clearest characteristics for this table.
• Writing the same idea twice in different words.

Things to Be Careful About

• The question asks for two characteristics, so give two distinct points.
• Make the description specific to the scenario: scanned papers, display, entering marks, central server.
• If you mention local storage, make clear that the important permanent storage is centralised on the server.

Background Concept

In a relational database, tables are linked by relationships. A relationship describes how many records in one table can be associated with records in another table.

The common types are:

• one-to-one
• one-to-many
• many-to-many

A one-to-many relationship means one record in the first table can match several records in the second table. This is usually implemented by putting the primary key from the first table into the second table as a foreign key.

Here, ExamID is the key link. If EXAM stores one row per exam paper, then EXAM_QUESTION stores the separate questions belonging to that paper.

Understanding the Question

You are given two tables:

• EXAM(ExamID, Subject, Level, TotalMarks)
• EXAM_QUESTION(ExamQuestionID, ExamID, QuestionNumber, Question, MaxMark)

The important clue is that EXAM_QUESTION contains ExamID. That means each question record belongs to a particular exam. The question asks only for the relationship type between the two tables.

Approach

Think about the real-world situation:

• one exam paper contains several questions
• each question belongs to one exam paper

So we decide the relationship by counting how many question rows can be linked to one exam row.

Step-by-Step Reasoning

EXAM represents a complete exam.

EXAM_QUESTION represents individual questions in that exam.

If an exam has, for example, Question 1, Question 2, Question 3, and so on, then several EXAM_QUESTION rows will all have the same ExamID.

That means:

• one EXAM record matches many EXAM_QUESTION records
• each EXAM_QUESTION record matches one EXAM record

So the relationship is one-to-many from EXAM to EXAM_QUESTION.

Key Takeaways

• A foreign key usually shows how tables are linked.
• If many rows in one table can share the same key from another table, that is one-to-many.
• Database relationships should match the real-world situation being modelled.

Common Mistakes

• Saying many-to-many: that would mean one question could belong to many exams, which is not what this structure shows.
• Writing only "linked by ExamID" without naming the relationship type.
• Reversing the wording and saying one EXAM_QUESTION has many EXAM records.

Things to Be Careful About

• State the direction clearly: one EXAM to many EXAM_QUESTION.
• Do not confuse the existence of a foreign key with the relationship name itself.
• Keep the table names exact as given in the question.

Background Concept

SQL DDL, or Data Definition Language, is used to create and change the structure of database tables. The most common statement for this is CREATE TABLE.

When defining a table, you must specify:

• the table name
• each field name
• a suitable data type for each field
• the key field or fields

A primary key uniquely identifies each record in the table. It cannot be duplicated. Data types should fit the data being stored:

• fixed-length text such as an ID with leading zeros can use CHAR
• variable-length text such as a subject name can use VARCHAR
• whole numbers such as levels and totals can use INTEGER

Understanding the Question

You must define the table EXAM from the sample data shown. The fields are:

• ExamID
• Subject
• Level
• TotalMarks

The sample values help you choose sensible data types. For example, ExamID begins with 0, so treating it as pure numeric data can be risky because leading zeros may be lost.

Approach

Build a CREATE TABLE statement that:

1. uses the exact field names from the table
2. assigns suitable SQL types
3. identifies ExamID as the primary key

The most important design decision here is that ExamID should be stored as text, not as an integer, because IDs are identifiers rather than values used in calculation.

Step-by-Step Reasoning

Start with the table name:

• CREATE TABLE EXAM

Now define each field:

• ExamID CHAR(8) because all example IDs are 8 characters long and include a leading zero
• Subject VARCHAR(20) because subject names are text and may vary in length
• Level INTEGER because values like 2 and 3 are whole numbers
• TotalMarks INTEGER because marks such as 75, 120, and 150 are whole numbers

Finally, set the primary key:

• PRIMARY KEY (ExamID)

That completes a valid table definition.

Key Takeaways

• Use CREATE TABLE to define a new table.
• Choose data types based on the nature of the data, not just how it looks at first glance.
• IDs with leading zeros are usually better stored as text.
• A primary key uniquely identifies each record.

Common Mistakes

• Using INTEGER for ExamID: this can lose the leading zero.
• Forgetting the primary key.
• Misspelling field names so they no longer match the required schema.
• Using a text type for numeric fields like Level or TotalMarks.

Things to Be Careful About

• Keep the identifier names exactly as given: ExamID, Subject, Level, TotalMarks.
• A different reasonable text length for Subject may still work, but the type must clearly be suitable for text.
• ExamID is an identifier, so do not choose its type based only on the fact that it contains digits.
• In exams, include both the field definitions and the primary key, because both are usually credited.

Background Concept

A foreign key is a field in one table that refers to the primary key in another table. It is used to enforce referential integrity, meaning the database will only allow linked values that actually exist in the parent table.

To add a foreign key after a table has already been created, SQL commonly uses ALTER TABLE.

The pattern is:

• choose the existing table to change
• add the foreign key field or constraint
• state which table and key it references

Understanding the Question

The question says EXAM_QUESTION already exists, but the foreign key has not yet been linked. So you do not create the whole table again. You must update the existing table structure so that ExamID in EXAM_QUESTION points to ExamID in EXAM.

Approach

Use an ALTER TABLE statement, because the table already exists.

Then add a foreign key on ExamID, referencing the matching primary key in EXAM.

The logic is:

• child table: EXAM_QUESTION
• foreign key field in child: ExamID
• parent table: EXAM
• primary key in parent: ExamID

Step-by-Step Reasoning

Start with the table being changed:

• ALTER TABLE EXAM_QUESTION

Now add the constraint:

• ADD FOREIGN KEY (ExamID)

Then specify the referenced table and field:

• REFERENCES EXAM(ExamID)

This means every ExamID placed into EXAM_QUESTION must already exist in EXAM.

That creates the link between the tables and enforces valid references.

Key Takeaways

• Use ALTER TABLE when changing an existing table definition.
• A foreign key in the child table refers to the primary key in the parent table.
• Foreign keys help keep linked data valid.

Common Mistakes

• Using CREATE TABLE instead of ALTER TABLE.
• Reversing the reference and trying to make EXAM point to EXAM_QUESTION.
• Referencing the wrong field name.
• Forgetting the REFERENCES clause.

Things to Be Careful About

• The field names must match exactly: ExamID and ExamID.
• The foreign key is added to EXAM_QUESTION, not to EXAM.
• The referenced field should be the primary key in the parent table.
• In many SQL dialects you can optionally name the constraint, but that is not necessary unless asked.

Background Concept

Database design starts by identifying entities, attributes, and relationships.

An entity is something you store data about, such as a student or an exam. A table is usually created for each entity.

A many-to-many relationship cannot usually be stored directly in a relational database. It must be resolved using a linking table, sometimes called a junction table or associative table.

For example:

• one student can take many exams
• one exam can be taken by many students

That is many-to-many, so a linking table is needed.

If you also need marks for each question, then you need another table that connects a student's exam entry to the individual questions for that exam.

Understanding the Question

The existing database already has:

• EXAM
• EXAM_QUESTION

The question says the database must also store:

• the students
• the exams the students have taken
• the marks the students achieved in each question of each exam

So the answer must go beyond naming one extra table. You need to think about the full structure needed to record all those facts without duplication and with proper links.

Approach

Break the problem into separate pieces of information:

1. information about students themselves
2. which student took which exam
3. the mark achieved by that student for each question in that exam

Then translate each piece into a table.

The relationship between students and exams is many-to-many, so create a linking table for that.

After that, create a table for per-question marks, linked both to the student-exam record and to the question definition.

Step-by-Step Reasoning

First, add a table for students.

A table such as STUDENT(StudentID, ...) is needed because the system must store details about each student. StudentID would be the primary key.

Second, think about students and exams.

A student can take more than one exam. Also, the same exam can be taken by many students. That means STUDENT and EXAM have a many-to-many relationship.

In a relational database, this is resolved with a linking table, for example:

• STUDENT_EXAM(StudentExamID, StudentID, ExamID)

Here:

• StudentExamID can be the primary key
• StudentID is a foreign key to STUDENT
• ExamID is a foreign key to EXAM

Each record in STUDENT_EXAM means one particular student took one particular exam.

Third, store the marks for each question.

One student taking one exam will have several question marks, one for each question in that paper. So add another table such as:

• STUDENT_EXAM_QUESTION(StudentExamID, ExamQuestionID, MarkAchieved)

This table records the mark a student got for one specific question in one specific exam sitting.

The links are:

• EXAM.ExamID to EXAM_QUESTION.ExamID for the exam's list of questions
• STUDENT.StudentID to STUDENT_EXAM.StudentID
• EXAM.ExamID to STUDENT_EXAM.ExamID
• STUDENT_EXAM.StudentExamID to STUDENT_EXAM_QUESTION.StudentExamID
• EXAM_QUESTION.ExamQuestionID to STUDENT_EXAM_QUESTION.ExamQuestionID

This structure lets you answer questions such as:

• which exams has a student taken?
• which students took a given exam?
• what did a student score on Question 4 of a particular exam?

It also avoids repeating full exam or student details in many places.

Key Takeaways

• Add a new table for each new entity you need to store.
• Resolve many-to-many relationships using a linking table.
• Use another table when a many-to-many relationship also needs its own data, such as MarkAchieved.
• Primary keys identify records; foreign keys link records across tables.

Common Mistakes

• Adding only a STUDENT table and forgetting how students link to exams.
• Trying to put multiple exam IDs into one student record.
• Storing all question marks as separate columns instead of separate rows.
• Forgetting that EXAM and EXAM_QUESTION are already in a one-to-many relationship.
• Not explaining how the tables are linked, even if the table names are correct.

Things to Be Careful About

• A student-exam link is needed because students and exams are many-to-many.
• Per-question marks need a separate table if you want one record per question attempt.
• Use foreign keys that reference the correct parent table.
• Keep the design normalised so that exam details, question details, and student details are not unnecessarily duplicated.
• In an exam answer, it is acceptable to give sensible example table names and key fields as long as the structure and links are correct.

Background Concept

This question tests tracing simple assembly-language instructions using different addressing modes.

The processor has two registers here:

• ACC (Accumulator), used for the main data value being worked on.
• IX (Index Register), used when indexed addressing is needed.

The key addressing modes are:

• Immediate addressing: the value is given directly in the instruction, for example LDM #11 loads the literal value 11.
• Direct addressing: the operand is a memory address, so you go to that address and use the data stored there, for example LDD 14 loads the contents of address 14.
• Indirect addressing: the given address does not hold the data itself; it holds another address. You must follow that second address to get the data, for example LDI 15 means "look in address 15 to find the real address, then load the contents of that real address".
• Indexed addressing: the effective address is formed by adding the given address to the value currently in IX, for example LDX 14 with IX = 2 means use address 16.

Arithmetic instructions then use whatever is currently in ACC:

• ADD adds to ACC
• SUB subtracts from ACC

Understanding the Question

You are given:

• a memory table showing what data is stored at addresses 10 to 16
• the starting contents of ACC and IX
• four small programs

You must work out the final content of ACC after each program finishes.

A very important reading point is that these are separate program traces. You do not carry the result of Program 1 into Program 2. Each one is considered using the starting memory and starting register contents shown in the question.

The main skill being tested is whether you can read each instruction correctly and tell the difference between:

• a number itself
• an address
• an address that contains another address

Approach

The safest approach is:

1. Start each program from the stated initial register values.
2. Read one instruction at a time, in order.
3. If the operand has #, use it as a literal number.
4. If the operand has no #, treat it as an address unless the instruction definition says otherwise.
5. For LDI, do two memory lookups.
6. For LDX, calculate the effective address by adding the base address and IX.
7. Record only the final ACC value.

This avoids the most common source of mistakes: confusing values with addresses.

Step-by-Step Reasoning

Program 1

Code:

• LDI 15
• SUB #1

Start with the given memory.

For LDI 15:

• Go to address 15
• The contents of address 15 are 16
• That means the real address to use is 16
• The contents of address 16 are 12
• So ACC becomes 12

Then SUB #1 means subtract the literal value 1:

• 12 - 1 = 11

Final ACC = 11

Program 2

Code:

• LDD 14
• ADD 11

LDD 14 is direct addressing:

• Address 14 contains 10
• So ACC = 10

ADD 11 has no #, so it means add the contents of address 11:

• Address 11 contains 3
• 10 + 3 = 13

Final ACC = 13

Program 3

Code:

• LDM #11
• ADD #3
• SUB 16

LDM #11 loads the literal value 11 directly:

• ACC = 11

ADD #3 adds the literal value 3:

• 11 + 3 = 14

SUB 16 means subtract the contents of address 16:

• Address 16 contains 12
• 14 - 12 = 2

Final ACC = 2

Program 4

Code:

• LDR #2
• LDX 14
• ADD #2

LDR #2 loads the index register, not the accumulator:

• IX = 2
• ACC is unchanged by this instruction

LDX 14 uses indexed addressing:

• Effective address = 14 + IX = 14 + 2 = 16
• Address 16 contains 12
• So ACC = 12

ADD #2 adds literal 2:

• 12 + 2 = 14

Final ACC = 14

Key Takeaways

• In assembly tracing, the exact addressing mode matters as much as the opcode.
• # means immediate data, not a memory location.
• Direct addressing uses the contents of the stated address.
• Indirect addressing follows a pointer stored in memory.
• Indexed addressing forms a new address using the index register.
• Always trace one instruction at a time in order.

Common Mistakes

• Treating ADD 11 as adding the number 11 instead of the contents of address 11. Here it should add 3, not 11.
• Treating LDI 15 like LDD 15. LDD 15 would load 16, but LDI 15 must continue and load the contents of address 16, which is 12.
• Forgetting that LDR #2 changes IX, not ACC.
• Forgetting to calculate 14 + IX for LDX 14.
• Carrying the result of one program into the next. Each line in the table is a separate trace.

Things to Be Careful About

• Watch for the # symbol very carefully.
• Keep addresses and data separate in your working.
• For indexed addressing, use the current value of IX at that moment.
• Unless an instruction says it changes memory, memory contents stay the same throughout the trace.
• The question asks for the ACC content after each whole program, not after every individual instruction.

Background Concept

This question is about bitwise logical operations on the contents of the accumulator.

A bitwise operation compares two binary numbers one bit at a time.

The three operations here are:

• AND: result bit is 1 only if both input bits are 1
• OR: result bit is 1 if at least one input bit is 1
• XOR: result bit is 1 if the two input bits are different

Useful one-bit rules:

• 1 AND 1 = 1, otherwise AND gives 0
• 1 OR 0 = 1, 0 OR 1 = 1, 1 OR 1 = 1, only 0 OR 0 = 0
• 1 XOR 1 = 0, 0 XOR 0 = 0, but 1 XOR 0 = 1 and 0 XOR 1 = 1

The addressing still matters here:

• XOR 29 means use the contents of memory location 29
• AND #29 means use the literal denary number 29, not memory address 29
• OR B11111111 means use the literal binary number 11111111

Understanding the Question

You are given:

• five memory locations containing 8-bit binary values
• an initial ACC value of 01000110
• three short programs using bitwise instructions

The key sentence is: "The binary number 01000110 is reloaded into the ACC before each program is run."

That means each program starts with exactly the same accumulator value. The result of Program 1 does not carry into Program 2.

You must write the final 8-bit contents of ACC after each separate program.

Approach

For each program:

1. Reset ACC mentally to 01000110.
2. Identify the second operand correctly.
   • If it is an address, look up memory.
   • If it is #29, convert denary 29 to 8-bit binary.
3. Line up the two 8-bit values.
4. Apply the logical operation column by column.
5. Write the resulting 8-bit binary value.

This method is reliable and avoids mixing up immediate operands with memory contents.

Step-by-Step Reasoning

The starting accumulator each time is:

01000110

Program 1: XOR 29

Because there is no #, 29 is a memory address.

From the table:

• address 29 contains 00001111

Now do the XOR:

• 0 XOR 0 = 0
• 1 XOR 0 = 1
• 0 XOR 0 = 0
• 0 XOR 0 = 0
• 0 XOR 1 = 1
• 1 XOR 1 = 0
• 1 XOR 1 = 0
• 0 XOR 1 = 1

So:

• 01000110 XOR 00001111 = 01001001

Final ACC = 01001001

Program 2: AND #29

Because of #, this is the literal denary value 29.

Convert 29 to 8-bit binary:

• 29 = 16 + 8 + 4 + 1
• so binary is 00011101

Now do the AND:

01000110
00011101

Compare bit by bit:

• only positions where both bits are 1 stay 1
• all other positions become 0

This gives:

• 00000100

Final ACC = 00000100

Program 3: OR B11111111

This time the second operand is already given as the binary literal 11111111.

With OR, if either bit is 1, the result is 1.
Since the second operand is all ones, every result bit becomes 1.

So:

• 01000110 OR 11111111 = 11111111

Final ACC = 11111111

Key Takeaways

• Bitwise logic works on each bit position independently.
• Always identify whether the operand is a literal value or a memory address.
• #29 and 29 do not mean the same thing.
• Converting denary to binary correctly is often part of bit-manipulation questions.
• OR with all ones always produces all ones.

Common Mistakes

• Using the contents of address 29 for AND #29. That would be wrong because #29 is immediate data, not an address.
• Forgetting to convert denary 29 into binary before doing the AND.
• Not reloading ACC to 01000110 before each new program.
• Confusing XOR with OR. XOR gives 1 only when bits are different, not whenever either one is 1.
• Writing a result with the wrong number of bits. Keep all answers as 8-bit values here.

Things to Be Careful About

• Keep leading zeroes in binary answers: 00000100 is not the same presentation as 100 in this context.
• Read operand prefixes carefully: no prefix can mean an address, # means denary immediate, B means binary immediate.
• Make sure the memory lookup is from the correct address.
• When converting denary to binary, ensure it is written to the correct bit width used by the question.
• Work systematically from left to right so you do not drop or swap bits.

Background Concept

File sizes can be written using either decimal prefixes or binary prefixes, and the difference matters.

• kilobyte (kB) means $1000$ bytes.
• megabyte (MB) means $1000 \times 1000 = 1\,000\,000$ bytes.
• kibibyte (KiB) means $1024$ bytes.
• mebibyte (MiB) means $1024 \times 1024 = 1\,048\,576$ bytes.

In computer science exam questions, kilo and mega are decimal prefixes, while kibi and mebi are binary prefixes. Because $1024 > 1000$, a value written in kibibytes or mebibytes is not exactly the same size as the same number of kilobytes or megabytes.

Understanding the Question

The question gives four file sizes written in mixed units:

• 3300 kibibytes
• 0.3 megabytes
• 3 mebibytes
• 3300 kilobytes

You must identify which one is the largest. The key clue is that the units are different, so you cannot compare just the numbers 3300, 0.3, 3 and 3300 directly. You must compare the actual sizes.

Approach

Convert every option into the same unit, such as bytes, then compare them.

That is the safest method because it removes any confusion between decimal and binary prefixes.

Step-by-Step Reasoning

Convert each option to bytes:

1. 3300 kibibytes

   • $1 \text{ KiB} = 1024$ bytes
   • $3300 \times 1024 = 3\,379\,200$ bytes

2. 0.3 megabytes

   • $1 \text{ MB} = 1\,000\,000$ bytes
   • $0.3 \times 1\,000\,000 = 300\,000$ bytes

3. 3 mebibytes

   • $1 \text{ MiB} = 1\,048\,576$ bytes
   • $3 \times 1\,048\,576 = 3\,145\,728$ bytes

4. 3300 kilobytes

   • $1 \text{ kB} = 1000$ bytes
   • $3300 \times 1000 = 3\,300\,000$ bytes

Now compare the byte totals:

• 3300 KiB = 3,379,200 bytes
• 0.3 MB = 300,000 bytes
• 3 MiB = 3,145,728 bytes
• 3300 kB = 3,300,000 bytes

The largest is 3300 kibibytes.

Key Takeaways

• Always check whether a storage unit uses decimal prefixes (kB, MB) or binary prefixes (KiB, MiB).
• To compare file sizes reliably, convert them all to the same unit.
• KiB and MiB are based on powers of 2, while kB and MB are based on powers of 10.

Common Mistakes

• Treating kB and KiB as the same unit.
• Assuming the largest written number must be the largest file size.
• Comparing 3 MiB with 3300 kB without converting them first.

Things to Be Careful About

• The spelling of the prefix matters: kilo is not the same as kibi, and mega is not the same as mebi.
• In exam questions, use the exact standard values: 1000 for decimal prefixes and 1024 for binary prefixes.
• A smaller-looking number in a larger unit can still represent a bigger file size, so always convert before deciding.

Background Concept

Binary subtraction works in the same way as denary subtraction, but each column can contain only 0 or 1.

Useful binary subtraction facts are:

• 0 - 0 = 0
• 1 - 0 = 1
• 1 - 1 = 0
• 0 - 1 needs a borrow from the next column to the left

When you borrow in binary, you borrow 1, but that borrowed 1 is worth 10₂ in the current column, which is 2 in denary.

For questions like this, the normal method is:

1. Convert the denary numbers to binary.
2. Write them with the same number of bits.
3. Subtract bit by bit from right to left.

Understanding the Question

The question asks you to subtract the denary number 10 from the denary number 100, but to do it using binary subtraction.

So the important point is that you should not just write 90. You first convert both denary values into binary, then show the subtraction working in binary.

Approach

First convert:

• 100 to binary
• 10 to binary

Then line them up to the same bit length so each place value matches correctly. After that, subtract from right to left, borrowing where necessary.

Step-by-Step Reasoning

1. Convert 100 to binary

Find the powers of 2 that make 100:

• $64 + 32 + 4 = 100$

So the binary for 100 is:

• 1100100

2. Convert 10 to binary

Find the powers of 2 that make 10:

• $8 + 2 = 10$

So the binary for 10 is:

• 1010

To subtract properly, write it with the same number of bits as 1100100:

• 0001010

3. Subtract the binary numbers

Set them out:

  1100100
- 0001010

Now work from right to left:

• Rightmost column: 0 - 0 = 0
• Next column: 0 - 1 so borrow from the left, giving result 1
• Next column becomes 0 - 0 = 0
• Next column: 0 - 1 so borrow across from a later 1, giving result 1
• Remaining columns give 1, 0, 1

So the result is:

• 1011010

You can check it by converting back to denary:

• 1011010 = 64 + 16 + 8 + 2 = 90

And $100 - 10 = 90$, so the subtraction is correct.

Key Takeaways

• Convert denary numbers to binary before carrying out binary arithmetic.
• Make sure both binary numbers are written to the same bit width before subtracting.
• Borrowing in binary works like denary borrowing, but the borrowed amount is 10₂.

Common Mistakes

• Writing the denary answer 90 instead of the binary result.
• Forgetting to pad the smaller binary number with leading zeros.
• Misaligning the place values, which causes subtraction in the wrong columns.
• Making an error when borrowing across a 0.

Things to Be Careful About

• The question asks for binary subtraction, so your working should show binary numbers, not only denary arithmetic.
• Leading zeros do not change the value, but they help line up the subtraction correctly.
• Check the final answer by converting it back to denary if you have time.

Background Concept

Hexadecimal is base 16, so each digit position represents a power of 16.

The hexadecimal digits are:

• 0 to 9 for values 0 to 9
• A = 10
• B = 11
• C = 12
• D = 13
• E = 14
• F = 15

When converting a hexadecimal number to denary, multiply each digit by its place value and add the results.

For a 3-digit hexadecimal number:

• left digit is multiplied by $16^2$
• middle digit is multiplied by $16^1$
• right digit is multiplied by $16^0$

Understanding the Question

You are given the hexadecimal number C0F and asked to convert it to denary.

That means you must:

1. change the letter digits into their denary values
2. use the correct powers of 16 for each position
3. add the totals

Approach

Use place value expansion.

Write C0F as:

• C × 16²
• 0 × 16¹
• F × 16⁰

Then replace C with 12 and F with 15, calculate each part, and add them.

Step-by-Step Reasoning

The number is C0F.

1. Convert the hexadecimal digits

• C = 12
• 0 = 0
• F = 15

2. Apply place values

From left to right, the powers of 16 are:

• $16^2 = 256$
• $16^1 = 16$
• $16^0 = 1$

So:

• C0F = 12 × 16² + 0 × 16¹ + 15 × 16⁰

3. Calculate each term

• $12 \times 256 = 3072$
• $0 \times 16 = 0$
• $15 \times 1 = 15$

4. Add the terms

• $3072 + 0 + 15 = 3087$

So the denary value is 3087.

Key Takeaways

• Hexadecimal is base 16, so place values are powers of 16.
• Letter digits must be converted correctly: for example, C = 12, F = 15.
• The standard method is digit value × place value, then add all parts.

Common Mistakes

• Treating C or F as if they were ordinary decimal digits.
• Using powers of 10 instead of powers of 16.
• Forgetting that the middle 0 still has a place value, even though its contribution is 0.
• Writing 16 × 16 × 12 + 15 incorrectly because of arithmetic slips.

Things to Be Careful About

• Count the place values from right to left starting at $16^0$.
• Include every digit, even if one of them is 0.
• If a question asks for denary, the final answer should be a decimal number, not a hexadecimal or binary one.

Background Concept

A translator converts source code into a form the computer can execute. Two common translators are a compiler and an interpreter.

A compiler translates the whole source program into object/executable code before the program is run. After successful compilation, the program can be executed directly.

An interpreter translates and executes the program one statement at a time while the program is running.

For testing, the important differences are:

• a compiler checks the whole program before execution
• a compiled program usually runs faster
• an interpreted program is often more convenient while still developing small parts, but slower when repeatedly running the finished program

Understanding the Question

The question says the programmer is testing the final program, not writing the first draft. That wording is important.

At the final testing stage, the program is likely to be mostly complete, so the programmer wants:

• quick execution for repeated test runs
• a full check of the whole program before running it

So the answer should focus on why a compiler is useful at that stage, not just define what a compiler is.

Approach

A good way to answer is to think of the two most exam-worthy benefits of compilation during testing:

1. the compiler translates the whole program, so errors can be found across the full code before execution
2. the resulting compiled code runs faster, so repeated tests take less time

These are direct, descriptive benefits and fit a 2-mark answer well.

Step-by-Step Reasoning

First, consider what happens when using a compiler.

• The source code is processed as a complete program.
• If there are syntax errors, these are reported during compilation.
• Only after successful compilation is the program run.

That gives the first benefit:

• the programmer can identify syntax errors in the program before running test cases
• because the whole program is checked, errors are not discovered only when execution reaches a particular line

Next, think about repeated testing.

• Final testing often means running the same program many times with different data
• A compiled program has already been translated
• So the processor runs machine/object code directly rather than translating each line as it goes

That gives the second benefit:

• execution is faster
• therefore testing is more efficient, especially for larger programs or many test cases

These are stronger answers than vague statements like "it is better" or "it is easier to use", because they explain exactly how the compiler helps.

Key Takeaways

• A compiler translates the whole program before execution.
• This helps testing because syntax errors can be found before running test data.
• Compiled code usually runs faster, which is useful when the final program is tested many times.

Common Mistakes

• Giving interpreter benefits instead: for example, saying errors are found one line at a time describes an interpreter, not a compiler.
• Only defining a compiler: the question asks for benefits during testing, so you must link the feature to why it helps the programmer.
• Saying "it finds all errors": a compiler mainly finds syntax and some compile-time errors, not every possible logic error.

Things to Be Careful About

• Use wording such as whole program is translated before running.
• Do not claim the compiler removes the need for testing; logic errors can still remain.
• Keep the answer focused on benefits during testing, especially speed and whole-program checking.

Background Concept

An Integrated Development Environment (IDE) is software that helps a programmer develop programs in one place. It usually includes an editor, translation tools, and many other support features.

In this syllabus, IDE features are often grouped by purpose:

• coding features help write source code more quickly and accurately
• presentation features improve the appearance and readability of code
• debugging features help find and correct errors

Common examples include:

• auto-completion
• syntax highlighting
• automatic indentation
• pretty printing
• breakpoints
• single stepping
• watch windows / variable display
• error diagnostics

Understanding the Question

The table gives three purposes:

• for coding
• for presentation
• for debugging

You must name one suitable IDE feature for each purpose and describe how it helps. The question also says:

• each feature must be different
• you must not use translator as one of the features

So you cannot repeat the same tool in more than one row, and you cannot answer with compiler or interpreter.

Approach

The safest approach is to choose one very standard feature for each category:

• coding: auto-completion
• presentation: pretty printer or automatic indentation
• debugging: breakpoint

Then, for each one, explain the practical benefit to the programmer.

A strong description should say both:

1. what the feature does
2. why that helps during development

Step-by-Step Reasoning

1. Coding purpose

A coding feature should help the programmer write code.

Auto-completion is a strong choice because:

• it suggests or finishes keywords, function names, or identifiers
• this reduces typing
• it also reduces spelling mistakes in identifiers and keywords

That is why the description says it makes code entry faster and reduces typing errors.

Other acceptable coding features in principle could include syntax highlighting or context-sensitive help, but auto-completion is especially clear.

2. Presentation purpose

A presentation feature should improve how the code looks.

Pretty printer or automatic indentation is a very suitable answer because:

• it lays out code consistently
• it aligns nested blocks properly
• it makes the structure of IF statements, loops, and procedures easier to see

That is why the description says it makes code easier to read.

This category is about readability, not about correcting logic.

3. Debugging purpose

A debugging feature should help find faults.

A breakpoint is a standard debugging tool because:

• the programmer chooses a line where execution should pause
• when the program stops there, the programmer can inspect variable values and program flow
• this helps locate the part of the program causing the error

That is why the description focuses on stopping execution and inspecting state.

A watch window or single-step execution could also be valid debugging answers, but the key is that the feature must be clearly linked to finding errors.

Key Takeaways

• IDE features can be grouped by what they help with: writing code, presenting code, or debugging code.
• A good exam answer names a specific feature and explains exactly how it helps.
• Typical safe examples are auto-completion, automatic indentation/pretty printer, and breakpoints.

Common Mistakes

• Using translator as an answer: the question specifically forbids this.
• Repeating one feature in more than one row: the features must all be different.
• Naming a feature without describing it: the description is needed for full marks.
• Giving a vague description: for example, "helps the programmer" is too weak unless you say how.
• Putting a debugging feature in the presentation row: make sure the feature matches the purpose given.

Things to Be Careful About

• If you use pretty printer and automatic indentation, treat them carefully since they are closely related; using one clear presentation feature is safest.
• For debugging, explain that execution pauses at a breakpoint; do not say it automatically fixes the error.
• For coding, link the feature to speed and/or accuracy of writing code.
• Keep the three features distinct and appropriate to their categories.

Background Concept

A program library is a collection of pre-written program code that a programmer can use in their own software. The library may contain routines, procedures, functions, classes, or modules for common tasks.

Instead of writing every feature from the beginning, a programmer can call code from the library when needed.

The main benefits usually relate to:

• reuse of existing code
• saving development time
• reliability, because library code is often well tested
• sometimes access to complex functionality without needing to implement it personally

Understanding the Question

The question asks for two benefits to the programmer of using program libraries.

So the focus is not on the computer system or the user of the final program. It is specifically on how libraries help the programmer while developing software.

The two clearest benefits are:

1. less code has to be written from scratch
2. the reused code is often already tested, so it is less error-prone

Approach

A good answer should give two separate points. The easiest high-value pair is:

• time saving through code reuse
• improved reliability because the code has already been tested/debugged

These are distinct and directly related to the programmer's work.

Step-by-Step Reasoning

Benefit 1: saves time

If a library already contains a routine the programmer needs, they can use it directly instead of designing, writing, and testing that routine themselves.

That means:

• fewer lines of new code to create
• less time spent implementing common tasks
• faster overall development

So the first benefit is not just "uses existing code"; the real benefit is that this saves development time and effort.

Benefit 2: improves reliability

Library code is often:

• pre-written by experienced developers
• used by many programs
• already tested and debugged

Because of that, it is less likely to contain mistakes than brand-new code written from scratch under time pressure.

So the programmer benefits because:

• there is less chance of introducing errors
• testing may be easier because trusted components are reused

This is why "already tested/debugged" is a strong second point.

Key Takeaways

• Program libraries support code reuse.
• Reusing library code helps programmers work faster.
• Libraries can improve program reliability because routines are often already tested.

Common Mistakes

• Giving two versions of the same benefit: for example, "saves time" and "less work" may be too similar unless clearly distinguished.
• Talking only about users: the question asks for benefits to the programmer.
• Saying libraries are always error-free: tested code is usually more reliable, but not guaranteed perfect.

Things to Be Careful About

• Make sure each benefit is distinct.
• Explain the advantage, not just the feature. For example, "pre-written code" should lead to "saves time".
• Keep the answer focused on development benefits such as time, effort, and reliability.