Backend Development and Computer Systems

Construct truth tables for Boolean expressions.

Rewrite simple Boolean expressions using standard Boolean algebra laws.

Implement Boolean functions using AND, OR, NOT, NAND, and XOR gates.

Trace binary addition through half-adder and full-adder circuits.

Select and route binary signals using multiplexers and decoders.

Explain how latches and flip-flops store one bit of state.

Trace state changes through a clocked register or counter.

Trace data and control signals through a simple register-and-ALU datapath.

Configure an ARM64 Linux virtual machine and verify its shell, compiler, debugger, and system-inspection tools.

Navigate the Linux filesystem and manipulate files and directories from the shell.

Find and interpret command documentation using manual pages and built-in help.

Apply Linux ownership and permission bits to control file access.

Connect commands using standard streams, redirection, and pipelines.

Inspect foreground and background jobs and control them from the shell.

Write a shell script using variables, arguments, conditions, loops, and exit statuses.

Record, inspect, and restore source-code changes using a basic Git workflow.

Build and run a C program while distinguishing preprocessing, compilation, assembly, and linking.

Write C functions using scalar types, expressions, branches, and loops.

Manipulate fixed-size arrays and null-terminated strings without crossing their bounds.

Use pointers to read and update values through memory addresses.

Define and manipulate related data using structures and enumerations.

Determine the scope and lifetime of local, static, global, and heap-allocated objects.

Allocate, resize, and release dynamic memory without leaks or dangling pointers.

Diagnose a C program using compiler warnings, a debugger, and memory-safety sanitizers.

Derive time and space complexity for simple loops and nested loops using Big-O notation.

Relate array indexing and pointer arithmetic to contiguous memory layout.

Implement a resizable array that preserves its elements while growing.

Implement insertion, search, and deletion in a singly linked list.

Implement last-in-first-out operations using a stack.

Implement first-in-first-out operations using a queue.

Trace recursive function calls and returns on a call stack.

Choose between arrays, linked lists, stacks, and queues based on operation cost and locality.

Identify the roles of the processor, memory, buses, and input/output devices in a computer.

Trace an instruction through fetch, decode, execute, memory access, and write-back stages.

Distinguish an instruction set architecture from a specific processor implementation.

Trace basic data-processing, load/store, comparison, and branch instructions in simple ARM64 code.

Relate a short C function to the ARM64 assembly emitted by a compiler.

Trace an ARM64 function call using calling conventions, registers, and a stack frame.

Calculate cache locations and predict hits or misses for simple memory-access sequences.

Explain how interrupts and direct memory access let devices interact with the processor and operating system.

Distinguish user mode from kernel mode and classify core operating-system responsibilities.

Trace the boot path from firmware through the bootloader, kernel, and user-space initialization.

Invoke and trace a read or write operation from C, identifying the library wrapper, system-call boundary, and file descriptor.

Trace process creation and program replacement using fork, exec, and wait.

Classify process states and explain what occurs during a context switch.

Compare first-come-first-served, round-robin, and priority scheduling on a short workload.

Handle and send Unix signals while accounting for asynchronous execution.

Connect two processes using an anonymous pipe and inherited file-descriptor redirection.

Distinguish processes from threads in terms of address spaces and shared resources.

Create, join, and pass data to POSIX threads in a C program.

Demonstrate a race condition by tracing conflicting thread interleavings.

Protect a shared invariant using a mutex.

Coordinate threads around a state change using a condition variable.

Identify the four necessary conditions for deadlock in a resource-allocation scenario.

Remove a deadlock by enforcing a consistent lock-acquisition order.

Implement a bounded producer-consumer queue using mutexes and condition variables.

Identify code, static data, heap, shared-library, and stack regions in a process address space.

Translate a virtual address into a physical page and offset using a simplified page table.

Explain how a translation lookaside buffer speeds up address translation.

Trace demand paging from a memory reference through a page fault and page load.

Compare FIFO and least-recently-used page replacement on a reference sequence.

Explain how copy-on-write supports efficient process creation.

Inspect a Linux process's memory mappings, resident memory, and resource usage.

Measure page faults for contrasting memory-access patterns and explain the observed differences.

Compare registers, caches, RAM, solid-state storage, and remote storage by latency, capacity, and persistence.

Explain how an SSD reads, writes, erases, and manages blocks.

Relate pathnames, directories, inodes, and hard and symbolic links in a Unix filesystem.

Open, read, write, seek within, and close files through POSIX file-descriptor operations in C.

Distinguish application buffering, kernel page caching, and persistent device storage.

Explain how memory-mapped files connect virtual memory with filesystem data.

Trace how journaling or copy-on-write preserves filesystem consistency after a crash.

Diagnose filesystem capacity and file metadata using Linux inspection commands.

Map application data through link, internet, transport, and application protocol layers, identifying the data unit and addressing used at each layer.

Trace local network delivery using Ethernet frames, MAC addresses, and ARP.

Calculate host ranges and network prefixes for basic IPv4 subnets.

Trace a packet through routing decisions and network address translation.

Query DNS records and trace how a hostname is resolved.

Compare UDP and TCP by connection setup, reliability, ordering, flow control, and typical use.

Implement a TCP client using the socket API.

Implement an iterative TCP server using the socket API.

Create a basic threat model by identifying assets, entry points, trust boundaries, and plausible threats.

Apply least privilege when choosing the user account, permissions, and exposed interfaces for a service.

Distinguish cryptographic hashes, message authentication codes, symmetric encryption, and asymmetric encryption by purpose.

Trace the main steps of a TLS connection and explain certificate validation.

Identify and correct a memory-safety vulnerability in a small networked C program.

Adapt an iterative server to handle multiple clients using a bounded set of worker threads.

Parse a minimal HTTP request and return a valid bounded HTTP response while handling malformed input safely.

Trace and diagnose one request across application, socket, process, system-call, virtual-memory, filesystem, and network boundaries.