Computer Science, Mathematics, and Physics

Implement a Java class that protects a stated invariant through constructors, access control, and validated methods.

Distinguish object identity from logical equality by implementing and testing equals and hashCode for a value object.

Replace an inappropriate inheritance relationship with object composition in a small Java design.

Define a Java interface and use dynamic dispatch to substitute multiple implementations behind it.

Choose between an interface and an abstract class for a specified extension requirement.

Implement a type-safe reusable component using a bounded Java generic type parameter.

Define an exception boundary that preserves a Java object's invariant when an operation fails.

Refactor a small Java application so a high-level service depends on an interface rather than a concrete data source.

Distinguish user mode from kernel mode and use system-call tracing to connect a C++ library call to its underlying Linux system call.

Inspect a Linux process and identify its code, data, heap, stack, and mapped-memory regions.

Translate a sample virtual address using pages, page tables, and a translation lookaside buffer.

Create a child process in Linux and predict which resources are copied, shared, or inherited.

Measure context switches for CPU-bound and blocking processes and relate the results to process states and scheduling.

Use Linux file descriptors to read, write, seek within, and redirect byte streams in a C++ program.

Implement the same one-way interprocess message exchange with a pipe and shared memory, then compare their behavior.

Use Linux inspection tools to connect a pathname and file descriptor to inode metadata and allocated storage blocks.

Create and join C++ threads while partitioning independent work safely.

Reproduce a data race and confirm it with ThreadSanitizer or an equivalent analysis tool.

Protect a shared invariant using a mutex and justify the chosen critical section.

Coordinate producer and consumer threads using a condition variable and a predicate.

Use an atomic operation for a simple counter and distinguish atomicity from higher-level thread safety.

Reproduce a two-lock deadlock and eliminate it by imposing a consistent lock order.

Implement a bounded blocking queue and validate it with concurrent tests.

Build a fixed-size thread pool that executes submitted tasks through the bounded blocking queue.

Trace how an application message is encapsulated across the application, transport, internet, and link layers.

Inspect an interface address, subnet prefix, routing table, port, and socket in WSL to predict how an outbound connection is delivered.

Use ARP or neighbor-table inspection to determine how an IP next hop is mapped to a link-layer address.

Perform DNS queries and interpret the returned record types, aliases, and resolved addresses.

Capture and annotate a TCP exchange to identify connection setup, sequence numbers, acknowledgements, and receive-window flow control.

Compare TCP and UDP behavior by exchanging messages with one small client-server pair for each transport.

Implement a C++ TCP client and server that exchange length-delimited messages.

Design and test socket handling for malformed, partial, delayed, and disconnected client messages.

Transform a small application domain into relational tables with primary, foreign, and uniqueness constraints.

Write SQL queries that use filtering, joins, grouping, subqueries, and aggregation to answer specified questions.

Identify an update anomaly and normalize a relation to third normal form.

Compare a table scan with an indexed lookup by inspecting a database query plan.

Explain how a B-tree index changes read performance and write cost for a concrete workload.

Relate database pages and cache behavior to the I/O pattern observed for a specified query.

Demonstrate one transaction-isolation anomaly and select an isolation level that prevents it.

Trace how write-ahead logging permits recovery of committed work after a simulated database interruption.

State a loop invariant and use it to justify the correctness of a nontrivial iterative algorithm.

Prove a recursive algorithm correct using induction on its input structure.

Perform amortized analysis of a dynamic array using the aggregate method.

Model a small assignment problem as a maximum-flow network and verify the resulting allocation.

Benchmark two correct algorithms on controlled input distributions and explain the observed time-memory trade-off.

Model a simple computation with a finite-state machine and identify a language it recognizes.

Trace a Turing machine on a small input to explain its operational model of computation.

Explain why the halting problem is undecidable using the structure of the diagonal argument.

Distinguish P, NP, NP-hard, and NP-complete by classifying examples and checking a polynomial-time certificate.

Use a polynomial-time reduction from CLIQUE to INDEPENDENT SET, together with membership in NP, to establish NP-completeness.

Specify the commands, message framing, persistence model, concurrency policy, and failure behavior of a small networked key-value service.

Implement GET, PUT, and DELETE operations behind composable C++ command and persistence interfaces.

Expose the command engine through a length-delimited TCP protocol and test partial, malformed, and disconnected requests.

Add concurrent client handling using the thread pool and synchronization techniques developed earlier.

Add persistent storage using SQLite transactions and parameterized SQL statements.

Write integration tests that verify state persistence and recovery across process restarts and database transaction failures.

Execute concurrent stress tests with race detection to validate thread safety under client load.

Profile one end-to-end workload, identify its dominant bottleneck, and justify one measured optimization.