Programming and Operating System Concepts¶

Exam-ready answer

An algorithm is a finite, ordered and unambiguous sequence of effective steps that accepts zero or more inputs, produces at least one output and terminates while solving a defined problem. A flowchart is the graphical representation of such logic using standard symbols joined by directed flow lines. The algorithm states what actions occur; the flowchart makes their sequence, decisions and loops visually traceable.

Pseudocode example: find the larger of two values.

START
READ A, B
IF A >= B THEN
    largest <- A
ELSE
    largest <- B
END IF
PRINT largest
STOP

Its flowchart uses terminal → input → decision; each decision branch performs an assignment, the branches rejoin before output, and Stop has no outgoing arrow. Both forms must be tested for equal values and boundary inputs. They describe logic rather than programming-language syntax and do not by themselves prove correctness, efficiency or safe input handling; desk checking, test cases and bounds validation are still necessary.

Practice target: 8–9 minutes; write both definitions, reproduce the six symbols, compare the forms, and include one short pseudocode example.

Exam-ready answer

(a) Algorithm [4 marks]¶

The input is one unsigned 8-bit word from Port A; every bit must be inverted and the resulting 8-bit word written to Port B. If the machine's bitwise NOT operates on a wider integer, masking is essential:

START
CONFIGURE Port A as INPUT
CONFIGURE Port B as OUTPUT
A <- READ Port A
A <- A AND 0xFF
B <- (NOT A) AND 0xFF
WRITE B to Port B
STOP

The two masks guarantee that only bits \(b_7\ldots b_0\) participate, so the output field is

A = | a7 | a6 | a5 | a4 | a3 | a2 | a1 | a0 |
B = |~a7 |~a6 |~a5 |~a4 |~a3 |~a2 |~a1 |~a0 |

(b) Flowchart [4 marks]¶

The flowchart uses terminal symbols for Start/Stop, parallelograms for port input/output, and a rectangle for B <- (NOT A) AND 0xFF; arrows give the exact execution order. Port-direction initialization may be performed once before the repeated acquisition loop on a real microcontroller.

Trace example: if Port A supplies

A = 10110010₂ = 0xB2 = 178

then each bit is inverted and

B = 01001101₂ = 0x4D = 77 = 255 - 178.

The edge cases are A=0x00 -> B=0xFF and A=0xFF -> B=0x00. Without AND 0xFF, a language using 16- or 32-bit signed integers may retain upper one-bits after NOT and produce a negative or oversized value. In hardware, the program must also use the correct port addresses, direction registers and voltage/interface limits; simultaneous asynchronous input changes may require latching or debouncing.

Practice target: 13–14 minutes; split space equally, keep the pseudocode textual, draw the referenced flowchart with correct symbols, and verify one binary example.

Exam-ready answer

A data type specifies a value's representation, storage size/range and permitted operations. A variable is a named storage location whose value may change during execution, whereas a constant is a named value that the program must not modify after definition. Choosing an appropriate type prevents meaningless operations and controls memory use and numerical range.

An array is an indexed collection of same-type elements, normally stored in contiguous locations. For zero-based one-dimensional array A, base address \(B\), element width \(w\) bytes and index \(i\),

For row-major array A[R][N],

Example: if five 4-byte integers begin at address 1000, A[3] is at \(1000+3(4)=1012\). Indexed access is therefore \(O(1)\) and arrays compactly represent tables, buffers and matrices. Their limitations are fixed size in many languages, costly middle insertion/deletion, homogeneous elements and the need for valid indices. An unchecked index can corrupt memory or disclose data, so safe programs validate \(0\le i<R\) and \(0\le j<N\), use language bounds checks where available and avoid arithmetic overflow when calculating allocation size.

Practice target: 8–9 minutes; distinguish type, variable and constant, show the type table, and calculate one array address.

5-mark answer and 10-mark extension

For 5 marks — write this¶

An operating system (OS) is system software that acts as an interface between users/applications and computer hardware. It abstracts devices into convenient services, allocates resources fairly and safely, and provides the controlled environment in which programs execute.

Thus the OS is both a resource manager and an extended machine that hides hardware-specific details.

Add for a 10-mark variant¶

A process moves through well-defined states. The long-term scheduler admits New work to Ready; the short-term scheduler dispatches a Ready process to Running. A timeout/preemption returns it to Ready, an I/O request blocks it in Waiting, event completion returns it to Ready, and completion moves it to Terminated.

Useful scheduling measures are

For memory, the OS maintains per-process address spaces and page tables, allocates frames, handles page faults and reclaims pages. For files it maps names and offsets to storage blocks, maintains metadata and access permissions, and buffers I/O. Device drivers translate generic system calls into controller commands; interrupts report completion, while spooling lets several processes share a printer without direct conflict.

Example: when a user opens a protected file, the OS authenticates the process credentials, checks directory/file permissions, resolves the pathname, allocates a file descriptor, fetches blocks through the storage driver and page cache, then returns bytes through a system call. Concurrently it may preempt that process, run another and later restore registers from the saved process control block.

The OS must balance utilization, responsiveness, fairness and isolation. Deadlock, starvation, thrashing, driver failure and privilege escalation are limitations/risks. Process isolation, memory execute/write permissions, least-privilege accounts, secure boot, patching, access-control lists, logging, backups and quotas reduce them, but all consume resources and cannot compensate for faulty applications or failed hardware without redundancy.

Practice target: 9 minutes for the five-mark core or 17–18 minutes for the full answer; draw both OS layers and process states, then explain one end-to-end file request.

Exam-ready answer

Assembly language is a processor-specific low-level language in which mnemonic operation names and symbolic operands represent machine instructions. An assembler translates source statements into object/machine code, resolves labels to addresses and reports syntax or range errors. A typical source format is

[label:]  opcode  operand(s)  ; comment

For example, MOV R1, #5 loads an immediate constant, ADD R1, R2 names an opcode and register operands, and JNZ LOOP branches to a symbolic label when the zero flag is clear. A linker may then combine object modules and relocate addresses before loading.

Example application: a short interrupt service routine may save registers, read a device status port, acknowledge the interrupt and restore context with exact latency. Assembly is therefore appropriate for boot code, context switching, tiny embedded targets and measured performance-critical sections, but compilers are normally preferred for complete applications because they provide portability and optimization across large code bases.

Efficiency is not automatic: poor hand-written assembly may be slower than optimized compiled code. Unsafe pointer arithmetic, unchecked buffers and privileged instructions can corrupt memory or compromise the system, so interfaces, stack alignment, bounds and saved-register conventions must be documented and tested. The central trade-off is maximum hardware control versus portability, productivity and safety.

Practice target: 8–9 minutes; define assembler/opcode/operand/label, show one statement, and balance at least three advantages against three disadvantages.