Software Engineering Fundamentals

Analyze time and space complexity of algorithms using Big-O notation.

Compare trade-offs of arrays, linked lists, and hash maps to solve a given problem.

Compare trade-offs of trees (BST), heaps, and graphs to solve a given problem.

Implement merge sort and analyze its time and space complexity.

Implement quicksort and compare its practical trade-offs with merge sort.

Solve graph traversal problems using Breadth-First Search (BFS) and Depth-First Search (DFS).

Solve the 0/1 knapsack problem using dynamic programming.

Select the most appropriate data structure and algorithm for a given problem scenario and justify the choice.

Explain the difference between a process and a thread, including their memory layout.

Describe the mechanism and performance implications of a context switch.

Describe the role of system calls in process management with concrete examples (e.g., fork, exec, wait).

Compare preemptive and non-preemptive CPU scheduling algorithms (FCFS, SJF, Round Robin).

Analyze a given workload to determine which scheduling algorithm minimizes average waiting time.

Compare Inter-Process Communication (IPC) mechanisms (pipes, shared memory, message passing) and identify practical use cases.

Explain virtual memory and its benefits, such as process isolation and larger address space.

Describe how paging and page tables translate virtual addresses to physical addresses.

Compare page replacement algorithms (e.g., LRU, FIFO) by calculating page faults for a given reference string.

Identify a race condition in a code snippet and use a mutex to protect the critical section.

Solve a producer-consumer problem using semaphores.

Compare binary and counting semaphores and apply them to a resource allocation problem.

Identify the four Coffman conditions for deadlock in a given system.

Apply a deadlock prevention strategy (e.g., resource ordering) to resolve a potential deadlock.

Trace a web request through the TCP/IP model, explaining each layer's primary role.

Analyze the TCP three-way handshake and connection teardown process using a packet diagram.

Compare the characteristics of TCP and UDP and select the appropriate protocol for different application scenarios (e.g., streaming vs. file transfer).

Trace the DNS resolution process from a browser query to the final IP address response.

Inspect an HTTP request/response cycle, identifying common methods, status codes, and headers.

Differentiate between HTTP/1.1, HTTP/2, and HTTP/3, focusing on their performance improvements.

Differentiate between symmetric and asymmetric encryption and describe the role of public/private key pairs.

Explain the key steps of a TLS/SSL handshake that establish a secure connection.

Compare REST and gRPC, identifying trade-offs in performance, payload size, and use cases.

Explain the function of a reverse proxy and its benefits, such as load balancing and SSL termination.

Describe the WebSocket protocol and identify scenarios where it is preferable to HTTP.

Explain how a Content Delivery Network (CDN) reduces latency and improves availability.