Question 1

What is the difference between a Process and a Thread? Explain Context Switching.

Accepted Answer

Process vs Thread:

1. Process:
- An executing instance of a program with its own dedicated memory space (Code, Data, Heap, Stack).
- Processes are isolated from each other. Communication requires Inter-Process Communication (IPC).
- Heavyweight: Process creation and context switching have high OS resource overhead.
- Crash Isolation: If one process crashes, it does not affect other processes.

2. Thread:
- A thread is the smallest unit of CPU execution within a process (often called a lightweight process).
- Threads belonging to the same process share the same memory space (Heap, Code, Data), but maintain their own private Stack, Registers, and Program Counter (PC).
- Lightweight: Thread creation and context switching are significantly faster.
- Crash Impact: If an unhandled exception crashes one thread, it can crash the entire host process.

Context Switching:
Context switching is the process where the CPU saves the execution state (registers, program counter, stack pointer) of a currently running process/thread and loads the saved state of another process/thread to resume execution. Thread context switching is faster because page tables and memory mappings do not need to be swapped.
Code Example:
// Conceptual Multi-threading vs Multi-processing in JS (Worker Threads vs Child Processes)
const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  // Main thread spawns a worker thread (Shares memory options via SharedArrayBuffer)
  const worker = new Worker(__filename);
  worker.on('message', (msg) => console.log('Received from worker:', msg));
} else {
  // Worker thread executing in background
  parentPort.postMessage('Task finished on thread ID: ' + require('worker_threads').threadId);
}

Question 2

Explain CPU Scheduling Algorithms: FCFS, SJF, Round Robin, and Priority Scheduling.

Accepted Answer

CPU Scheduling determines which process in the ready queue receives CPU execution time.

Common Scheduling Algorithms:

1. First-Come, First-Served (FCFS):
- Non-preemptive. Processes are executed in arrival order.
- Drawback: Convoy Effect (short processes wait behind a long process, increasing average waiting time).

2. Shortest Job First (SJF) / Shortest Remaining Time First (SRTF):
- Selects process with shortest CPU burst time. SRTF is preemptive.
- Optimal for minimizing average waiting time.
- Drawback: Starvation of long processes.

3. Round Robin (RR):
- Preemptive. Each process gets a fixed time quantum (e.g. 10ms) in round-robin sequence.
- Ideal for time-sharing systems. Performance depends heavily on time quantum size (too large = FCFS, too small = excessive context switching overhead).

4. Priority Scheduling:
- CPU allocated to highest priority process. Can be preemptive or non-preemptive.
- Drawback: Starvation of low priority processes. Solution: Aging (gradually increasing process priority over time).
Code Example:
// Round Robin CPU Scheduling Simulation Concept
function roundRobin(processes, quantum) {
  let queue = [...processes];
  let time = 0;
  
  while (queue.length > 0) {
    let p = queue.shift();
    if (p.remainingTime > quantum) {
      time += quantum;
      p.remainingTime -= quantum;
      queue.push(p); // Re-queue process
    } else {
      time += p.remainingTime;
      p.remainingTime = 0;
      p.completionTime = time;
      console.log(`Process ${p.id} completed at time ${time}`);
    }
  }
}

Question 3

What is Process Synchronization? Explain Mutex vs Semaphore and the Producer-Consumer Problem.

Accepted Answer

Process Synchronization prevents race conditions when concurrent processes/threads access shared data (Critical Section).

Race Condition: Occurs when multiple threads read/write shared data concurrently, and the final output depends on execution timing.

Mutex (Mutual Exclusion Lock):
- A locking mechanism used to synchronize access to a resource.
- Binary nature (Locked / Unlocked).
- Ownership Rule: The thread that locks the Mutex MUST be the thread that unlocks it.

Semaphore:
- A signaling mechanism using an integer counter variable.
- Counting Semaphore: Allows up to N threads to access a resource concurrently.
- Binary Semaphore: Value ranges between 0 and 1 (similar to Mutex, but has no thread ownership restrictions).

Producer-Consumer Problem:
Producers generate items into a fixed-size buffer; Consumers remove items. Uses 3 semaphores:
1. Mutex: Ensures exclusive access to buffer.
2. Empty Semaphore (Count = Buffer Size): Tracks empty slots.
3. Full Semaphore (Count = 0): Tracks filled slots.
Code Example:
// Mutex Pattern Implementation in JS
class Mutex {
  constructor() {
    this._lock = Promise.resolve();
  }

async acquire() {
    let release;
    const nextLock = new Promise(resolve => {
      release = resolve;
    });
    const currentLock = this._lock;
    this._lock = this._lock.then(() => nextLock);
    await currentLock;
    return release; // Callback to unlock mutex
  }
}

// Usage in Critical Section
const mutex = new Mutex();
async function safeCriticalSection() {
  const unlock = await mutex.acquire();
  try {
    // Critical Section: Access shared resource safely
  } finally {
    unlock(); // Release lock
  }
}

Question 4

What is a Deadlock? Explain the 4 Necessary Conditions for Deadlock and how to Prevent it.

Accepted Answer

A Deadlock is a situation where a set of processes are permanently blocked because each process holds a resource and waits for another resource held by another process in the set.

4 Necessary Conditions for Deadlock (Coffman Conditions):
1. Mutual Exclusion: At least one resource must be held in a non-shareable mode.
2. Hold and Wait: A process holding at least one resource is waiting to acquire additional resources held by other processes.
3. No Preemption: Resources cannot be forcibly taken away from a process; they can only be released voluntarily.
4. Circular Wait: A closed chain of processes exists such that P0 waits for P1, P1 waits for P2, and Pn waits for P0.

Deadlock Handling Strategies:
- Prevention: Invalidate at least one of the 4 Coffman conditions (e.g. impose total ordering on resource acquisition to eliminate Circular Wait).
- Avoidance: Dynamically examine resource allocation state to ensure a 'Safe State' (Banker's Algorithm).
- Detection & Recovery: Allow deadlocks to occur, periodically detect using Resource Allocation Graphs, and recover by aborting processes or preemption.
Code Example:
// Resource Ordering Strategy to Prevent Deadlock
// Always acquire locks in a globally defined order (e.g. by resource ID)
async function acquireResourcesSafely(resA, resB) {
  // Ensure res1 is always the smaller ID to prevent Circular Wait
  const [first, second] = resA.id < resB.id ? [resA, resB] : [resB, resA];

const unlockFirst = await first.mutex.acquire();
  const unlockSecond = await second.mutex.acquire();

return () => {
    unlockSecond();
    unlockFirst();
  };
}

Question 5

Explain Virtual Memory, Paging, Page Faults, Thrashing, and LRU Page Replacement.

Accepted Answer

Virtual Memory is a memory management technique that gives a process the illusion of a large contiguous memory space, even if physical RAM is smaller or fragmented.

Paging & Page Tables:
- Virtual Memory is divided into fixed-size blocks called Pages (e.g., 4KB).
- Physical RAM is divided into equal-sized blocks called Page Frames.
- The Memory Management Unit (MMU) uses a Page Table to translate Virtual Addresses to Physical Addresses.

Page Fault:
Occurs when a process accesses a page that is not currently loaded in physical RAM (valid bit = 0). The OS traps to kernel mode, fetches page from disk swap space into RAM, updates Page Table, and resumes execution.

Thrashing:
Occurs when the system spends more time swapping pages in and out of disk than executing instructions, caused by insufficient physical memory for active process working sets.

LRU Page Replacement Algorithm:
When RAM is full during a page fault, LRU evicts the page that has not been referenced for the longest period.
Code Example:
// Page Table Address Translation Concept
function translateAddress(virtualAddress, pageSize = 4096, pageTable) {
  const pageNumber = Math.floor(virtualAddress / pageSize);
  const offset = virtualAddress % pageSize;

if (pageNumber in pageTable && pageTable[pageNumber].valid) {
    const frameNumber = pageTable[pageNumber].frameNumber;
    const physicalAddress = (frameNumber * pageSize) + offset;
    return { status: "HIT", physicalAddress };
  } else {
    return { status: "PAGE_FAULT", pageNumber, offset };
  }
}

Question 6

Explain Inter-Process Communication (IPC): Shared Memory vs Message Passing vs Sockets.

Accepted Answer

Inter-Process Communication (IPC) allows separate processes to exchange data and synchronize actions.

Primary IPC Mechanisms:

1. Shared Memory:
- A region of physical memory is mapped into the virtual address spaces of two or more processes.
- Maximum Speed: Fastest IPC mechanism because data reading/writing involves zero kernel copy overhead after setup.
- Requires explicit synchronization (Mutexes/Semaphores) to prevent race conditions.

2. Message Passing (Pipes, Message Queues):
- Processes communicate by sending and receiving messages through OS kernel system calls.
- Safer than Shared Memory as kernel handles synchronization.
- Pipe (Anonymous Pipe): Unidirectional communication between parent/child processes.
- Named Pipe (FIFO): Communication between unrelated processes on same machine.

3. Network Sockets (TCP/UDP Sockets):
- Allows communication between processes on the SAME machine (loopback 127.0.0.1) or DIFFERENT machines over a network.
Code Example:
// Node.js IPC using Parent-Child Process Message Passing
const { fork } = require('child_process');

// Parent Process
if (process.argv[2] === 'parent') {
  const child = fork(__filename, ['child']);
  child.send({ msg: 'Hello from Parent via IPC' });
  child.on('message', (reply) => console.log('Parent received:', reply));
} 
// Child Process
else if (process.argv[2] === 'child') {
  process.on('message', (data) => {
    console.log('Child received:', data.msg);
    process.send({ reply: 'Hello back from Child process!' });
  });
}

Question 7

Explain the OSI 7-Layer Model vs TCP/IP 4-Layer Model and layer-by-layer functions.

Accepted Answer

The OSI (Open Systems Interconnection) reference model divides network communication into 7 logical layers. The TCP/IP model condenses this into 4 practical layers used on the Internet.

OSI 7 Layers (Top to Bottom):

7. Application Layer: End-user protocols & interfaces (HTTP, HTTPS, FTP, SMTP, DNS, SSH).
6. Presentation Layer: Data formatting, encryption/decryption, compression (SSL/TLS, JPEG, JSON).
5. Session Layer: Establishes, manages, and terminates communication sessions (NetBIOS, RPC).
4. Transport Layer: End-to-end transport, segmentation, flow control, error recovery (TCP, UDP).
3. Network Layer: Logical addressing, packet routing across networks (IP, ICMP, ARP, Routers).
2. Data Link Layer: Physical addressing (MAC), framing, hop-to-hop delivery (Ethernet, Wi-Fi, Switches).
1. Physical Layer: Transmission of raw binary bits over physical medium (Cables, Fiber optics, Radio signals).

TCP/IP 4-Layer Mapping:
- Application Layer (OSI 5, 6, 7)
- Transport Layer (OSI 4)
- Internet Layer (OSI 3)
- Network Access / Link Layer (OSI 1, 2)
Code Example:
/* OSI vs TCP/IP Layer Mapping Summary
+---------------------+---------------------+------------------------+
| OSI 7-Layer Model   | TCP/IP 4-Layer Model| Protocols & Units      |
+---------------------+---------------------+------------------------+
| 7. Application      |                     | HTTP, DNS, SMTP (Data) |
| 6. Presentation     | Application Layer   | SSL/TLS, Encryption    |
| 5. Session          |                     | RPC, Sessions          |
+---------------------+---------------------+------------------------+
| 4. Transport        | Transport Layer     | TCP, UDP (Segment/Datagram)
+---------------------+---------------------+------------------------+
| 3. Network          | Internet Layer      | IP, ICMP, BGP (Packet) |
+---------------------+---------------------+------------------------+
| 2. Data Link        | Network Access      | Ethernet, MAC (Frame)  |
| 1. Physical         | Layer               | Cables, Bits (Bits)    |
+---------------------+---------------------+------------------------+
*/

Question 8

Explain TCP vs UDP protocols, TCP 3-Way Handshake, and 4-Way Teardown.

Accepted Answer

TCP (Transmission Control Protocol):
- Connection-Oriented, Reliable, Ordered delivery with Error Checking, Flow Control (Sliding Window), and Congestion Control.
- Used in: HTTP/HTTPS, SSH, FTP, Database connections.

UDP (User Datagram Protocol):
- Connectionless, Unreliable, Unordered datagram transmission with low latency.
- Used in: Video Streaming, Gaming, VoIP, DNS queries, QUIC.

TCP 3-Way Handshake (Connection Establishment):
1. Client -> Server: SYN (Synchronize sequence number `seq = x`)
2. Server -> Client: SYN-ACK (Server acknowledges `ack = x + 1` and sends own `seq = y`)
3. Client -> Server: ACK (Client acknowledges `ack = y + 1`)
Connection becomes ESTABLISHED.

TCP 4-Way Teardown (Connection Termination):
1. Client -> Server: FIN (Client wants to close)
2. Server -> Client: ACK (Server acknowledges FIN)
3. Server -> Client: FIN (Server finishes sending remaining data and closes)
4. Client -> Server: ACK (Client acknowledges server's FIN, enters TIME_WAIT)
Code Example:
// TCP Socket Server vs UDP Socket Server in Node.js

// 1. TCP Server (Connection-oriented)
const net = require('net');
const tcpServer = net.createServer((socket) => {
  console.log('Client connected via TCP 3-Way Handshake');
  socket.write('Hello TCP Client
');
  socket.on('data', (data) => console.log('Received:', data.toString()));
});

// 2. UDP Server (Connectionless datagram)
const dgram = require('dgram');
const udpSocket = dgram.createSocket('udp4');
udpSocket.on('message', (msg, rinfo) => {
  console.log(`UDP Datagram from ${rinfo.address}:${rinfo.port}: ${msg}`);
});

Question 9

What is the difference between HTTP, HTTPS, HTTP/1.1, HTTP/2, and HTTP/3?

Accepted Answer

HTTP vs HTTPS:
HTTP transmits plaintext over TCP port 80. HTTPS wraps HTTP inside SSL/TLS encryption over TCP port 443, guaranteeing Confidentiality, Data Integrity, and Server Authentication.

Evolution of HTTP Versions:

1. HTTP/1.1:
- Uses persistent TCP connections (`Keep-Alive`).
- Problem: Head-of-Line (HOL) Blocking at HTTP level. Only one request can be processed per TCP connection at a time.

2. HTTP/2:
- Binary protocol (instead of text format).
- Multiplexing: Transmits multiple requests and responses concurrently over a SINGLE TCP connection.
- Header Compression (HPACK) and Server Push.
- Problem: TCP Head-of-Line Blocking (if one TCP packet is dropped, all streams stall waiting for retransmission).

3. HTTP/3:
- Built on QUIC protocol (which uses UDP instead of TCP).
- Eliminates TCP Head-of-Line blocking completely; packet loss on one stream does not block other streams.
- Faster 0-RTT / 1-RTT Connection establishment combining transport and TLS 1.3 handshake.
Code Example:
/* HTTP Evolution Summary Table
+--------------+------------------+---------------------+-------------------+
| Feature      | HTTP/1.1         | HTTP/2              | HTTP/3            |
+--------------+------------------+---------------------+-------------------+
| Transport    | TCP              | TCP                 | QUIC (UDP)        |
| Format       | Text Plain       | Binary Frames       | Binary Frames     |
| Multiplexing | No (HOL Blocking)| Yes (Single TCP)    | Yes (Native UDP)  |
| Compression  | None / Gzip body | HPACK (Headers+Body)| QPACK             |
| Handshake    | TCP + TLS (~3RTT)| TCP + TLS (~2-3RTT) | QUIC+TLS1.3(0-1RTT|
+--------------+------------------+---------------------+-------------------+
*/

Question 10

Explain the DNS Resolution Process step-by-step.

Accepted Answer

DNS (Domain Name System) translates human-readable domain names (e.g. `example.com`) into IP addresses (e.g. `93.184.216.34`).

DNS Lookup Resolution Steps (when visiting `https://example.com`):

1. Browser & OS Cache Check:
- Browser checks local DNS cache. If absent, checks OS hosts file / local OS DNS cache.

2. Recursive DNS Resolver (ISP / 8.8.8.8):
- OS queries the configured Recursive DNS Resolver.

3. Root Name Server (`.`):
- Resolver queries Root Name Server. Root responds with the address of the Top-Level Domain (TLD) server for `.com`.

4. TLD Name Server (`.com`):
- Resolver queries `.com` TLD Server. TLD responds with the Authoritative Name Server for `example.com`.

5. Authoritative Name Server:
- Resolver queries Authoritative Server. It returns the A record (IPv4) or AAAA record (IPv6) IP address.

6. Caching & Response:
- Recursive Resolver caches IP with TTL (Time-To-Live) and returns IP to browser. Browser initiates TCP handshake.
Code Example:
// Node.js DNS Lookup Example
const dns = require('dns');

// Resolves hostname to IP address via DNS lookup
dns.lookup('google.com', (err, address, family) => {
  console.log('IP Address:', address); // e.g. 142.250.190.46
  console.log('IP Family:', family);   // 4 (IPv4)
});

// Query specific DNS records (A, AAAA, MX, TXT)
dns.resolveMx('github.com', (err, addresses) => {
  console.log('Mail Exchange Records:', addresses);
});

Question 11

Compare Real-Time Web Communication: WebSockets vs HTTP Long Polling vs Server-Sent Events (SSE).

Accepted Answer

Comparison of Real-Time Web Data Technologies:

1. Short Polling:
- Client repeatedly sends HTTP requests at fixed intervals. Inefficient, heavy network overhead.

2. HTTP Long Polling:
- Client sends HTTP request. Server holds request open until new data is available or timeout occurs. Once responded, client immediately re-opens a new request.
- Use case: Legacy real-time systems fallback.

3. Server-Sent Events (SSE):
- Unidirectional (Server -> Client) continuous data stream over a single HTTP connection using `text/event-stream` MIME type.
- Automatic reconnection, native browser EventSource API.
- Use case: Live stock tickers, news feeds, AI ChatGPT streaming responses.

4. WebSockets:
- Full-Duplex, Bidirectional communication over a single long-lived TCP connection (starts with HTTP Upgrade handshake).
- Ultra-low overhead (2-byte frame header).
- Use case: Online multiplayer gaming, chat apps, collaborative document editors.
Code Example:
// Server-Sent Events (SSE) Response Stream in Node.js
function handleSSE(req, res) {
  res.writeHead(200, {
    'Content-Type': 'text/event-stream',
    'Cache-Control': 'no-cache',
    'Connection': 'keep-alive'
  });

// Send message stream every 2 seconds
  const timer = setInterval(() => {
    res.write(`data: ${JSON.stringify({ time: new Date().toISOString() })}

`);
  }, 2000);

req.on('close', () => clearInterval(timer));
}

Question 12

Explain IP Addressing: IPv4 vs IPv6, Subnetting, CIDR Notation, and NAT.

Accepted Answer

IP Addressing uniquely identifies devices on a network.

IPv4 vs IPv6:
- IPv4: 32-bit address represented as 4 decimal octets (e.g. `192.168.1.1`). Total ~4.3 billion addresses (exhausted).
- IPv6: 128-bit address represented as 8 hexadecimal blocks (e.g. `2001:0db8:85a3::8a2e:0370:7334`). Provides ~3.4 x 10^38 addresses.

CIDR (Classless Inter-Domain Routing) & Subnetting:
- CIDR notation `192.168.1.0/24` means the first 24 bits represent the Network Prefix, leaving `32 - 24 = 8` bits for Host addresses ($2^8 - 2 = 254$ usable hosts).
- Subnet Mask `/24` = `255.255.255.0`.

NAT (Network Address Translation):
- Maps multiple private IP addresses inside a local network (e.g. `192.168.x.x`) to a single public IP address on the router when accessing the Internet, conserving public IPv4 addresses and adding security.
Code Example:
/* Subnetting CIDR Reference Table
+--------------+-------------------+---------------+------------------+
| CIDR Prefix  | Subnet Mask       | Total IPs     | Usable Hosts     |
+--------------+-------------------+---------------+------------------+
| /32          | 255.255.255.255   | 1             | 1 (Single Host)  |
| /24          | 255.255.255.0     | 256           | 254              |
| /16          | 255.255.0.0       | 65,536        | 65,534           |
| /8           | 255.0.0.0         | 16,777,216    | 16,777,214       |
+--------------+-------------------+---------------+------------------+
*/

Question 13

What are the 4 Pillars of Object-Oriented Programming (OOP)? Provide practical code examples.

Accepted Answer

The 4 core pillars of Object-Oriented Programming (OOP) are:

1. Encapsulation:
- Bundling data (attributes) and methods that operate on that data into a single class while restricting direct access to internal implementation details (using private `#` fields or getters/setters).

2. Abstraction:
- Hiding complex implementation details and showing only essential features/interfaces to the outside world.

3. Inheritance:
- Mechanism where a subclass derives properties and behaviors from a parent class (`extends`), promoting code reusability.

4. Polymorphism:
- Ability of different objects to respond to the same method call in their own specific way.
- Compile-time (Method Overloading) vs Runtime (Method Overriding).
Code Example:
// Encapsulation & Abstraction
class BankAccount {
  #balance = 0; // Private field (Encapsulation)

constructor(owner) {
    this.owner = owner;
  }

deposit(amount) {
    if (amount > 0) this.#balance += amount;
  }

getBalance() {
    return this.#balance; // Controlled access
  }
}

// Inheritance & Polymorphism
class Animal {
  makeSound() {
    console.log('Generic sound');
  }
}

class Dog extends Animal {
  makeSound() {
    console.log('Bark! Bark!'); // Method Overriding (Polymorphism)
  }
}

class Cat extends Animal {
  makeSound() {
    console.log('Meow!');
  }
}

Question 14

Explain the SOLID Principles of Object-Oriented Design with examples.

Accepted Answer

SOLID Principles for clean, maintainable, and scalable software design:

1. S - Single Responsibility Principle (SRP):
- A class should have one, and only one, reason to change.

2. O - Open/Closed Principle (OCP):
- Software entities (classes, modules) should be open for extension, but closed for modification (use abstractions/interfaces).

3. L - Liskov Substitution Principle (LSP):
- Subtypes must be substitutable for their base types without altering correctness.

4. I - Interface Segregation Principle (ISP):
- Clients should not be forced to depend on interfaces they do not use (prefer smaller, focused interfaces over monolithic ones).

5. D - Dependency Inversion Principle (DIP):
- High-level modules should not depend on low-level modules. Both should depend on abstractions (interfaces).
Code Example:
// Dependency Inversion Principle (DIP) Example
// Abstraction (Interface / Contract)
class MessageService {
  sendMessage(message, recipient) {}
}

class EmailService extends MessageService {
  sendMessage(message, recipient) {
    console.log(`Sending Email to ${recipient}: ${message}`);
  }
}

class SMSService extends MessageService {
  sendMessage(message, recipient) {
    console.log(`Sending SMS to ${recipient}: ${message}`);
  }
}

// High-level Notification Manager depends on abstraction, NOT concrete class
class NotificationManager {
  constructor(service) {
    this.service = service; // Dependency Injection
  }

notify(user, msg) {
    this.service.sendMessage(msg, user);
  }
}

Question 15

Explain the Singleton Pattern and how to implement a Thread-Safe Singleton.

Accepted Answer

The Singleton Pattern ensures a class has ONLY ONE instance and provides a global access point to it.

Common Use Cases:
- Database connection pools, Logger instances, Configuration settings managers.

Implementation Considerations:
1. Private Constructor: Prevents direct instantiation with `new` operator.
2. Static Reference: Stores the single instance.
3. Static Getter Method: Returns existing instance or creates it if null.
4. Thread Safety: In multi-threaded environments (Java/C++), double-checked locking or static initialization must be used to prevent race conditions during concurrent initialization.
Code Example:
// Singleton Pattern in JavaScript (ES6 Modules & Classes)
class DatabaseConnection {
  constructor() {
    if (DatabaseConnection.instance) {
      return DatabaseConnection.instance; // Return existing instance
    }
    
    this.connectionString = "mongodb://localhost:27017/mydb";
    this.isConnected = true;
    
    DatabaseConnection.instance = this; // Store singleton instance
  }

query(sql) {
    console.log(`Executing query on single DB instance: ${sql}`);
  }
}

const db1 = new DatabaseConnection();
const db2 = new DatabaseConnection();
console.log(db1 === db2); // true (Identical instance references)

Question 16

Explain Creational Patterns: Factory Method Pattern and Builder Pattern.

Accepted Answer

Creational Design Patterns deal with object creation mechanisms:

1. Factory Method Pattern:
- Defines an interface for creating an object, but lets subclasses decide which class to instantiate.
- Decouples client code from concrete object creation logic.

2. Builder Pattern:
- Separates the construction of a complex object from its representation, allowing the same construction process to create different representations.
- Solves Telescoping Constructor anti-pattern (constructors with many parameters).
Code Example:
// 1. Factory Pattern Example
class PaymentFactory {
  static createPayment(type) {
    switch (type) {
      case 'credit': return { process: () => console.log('Credit Card Payment') };
      case 'paypal': return { process: () => console.log('PayPal Payment') };
      case 'crypto': return { process: () => console.log('Crypto Payment') };
      default: throw new Error('Invalid payment type');
    }
  }
}

// 2. Builder Pattern Example
class UserBuilder {
  constructor(name) {
    this.name = name;
  }
  setAge(age) { this.age = age; return this; }
  setPhone(phone) { this.phone = phone; return this; }
  setAddress(addr) { this.address = addr; return this; }
  build() { return new User(this); }
}

Question 17

Explain Behavioral & Structural Patterns: Observer Pattern and Strategy Pattern.

Accepted Answer

1. Observer Pattern (Behavioral):
- Defines a one-to-many dependency between objects so that when one object (Subject) changes state, all its dependents (Observers) are notified and updated automatically.
- Basis of Event-driven architecture, Pub/Sub, RxJS, and UI event listeners.

2. Strategy Pattern (Behavioral):
- Defines a family of algorithms, encapsulates each one, and makes them interchangeable at runtime.
- Enables selecting an algorithm's behavior dynamically without modifying client code (satisfies Open/Closed Principle).
Code Example:
// Strategy Pattern Example
class ZipCompression {
  compress(file) { console.log(`Compressing ${file} using ZIP`); }
}

class RarCompression {
  compress(file) { console.log(`Compressing ${file} using RAR`); }
}

class CompressionContext {
  setStrategy(strategy) {
    this.strategy = strategy;
  }
  createArchive(file) {
    this.strategy.compress(file);
  }
}

// Usage: Switch algorithm dynamically at runtime
const context = new CompressionContext();
context.setStrategy(new ZipCompression());
context.createArchive('data.txt'); // ZIP compression
context.setStrategy(new RarCompression());
context.createArchive('data.txt'); // RAR compression

Question 18

Why is 'Composition over Inheritance' a fundamental software engineering principle?

Accepted Answer

The principle 'Favor Composition over Inheritance' suggests that classes should achieve polymorphic behavior and code reuse by containing instances of other classes (Has-A relationship) rather than inheriting from a parent class (Is-A relationship).

Drawbacks of Deep Inheritance Trees:
1. Tight Coupling: Subclasses are tightly coupled to parent class implementations (Fragile Base Class problem).
2. Rigid Hierarchy: Changing parent behavior can unexpectedly break subclasses.
3. Multiple Inheritance Limitations: Many languages (Java, C#, JS) do not support multiple class inheritance.

Advantages of Composition:
1. Loose Coupling: Components interact via interfaces.
2. Dynamic Runtime Flexibility: Behavior can be swapped dynamically at runtime (Strategy pattern).
3. Modular Testing: Easier to mock composed dependencies in unit tests.
Code Example:
// Inheritance Anti-Pattern (Rigid)
class RobotWorker extends Person { ... } // What if Robot is not a Person?

// Composition Pattern (Flexible & Modular)
class Engine {
  start() { console.log('Engine started'); }
}
class Radio {
  play() { console.log('Radio playing'); }
}

class Car {
  constructor(engine, radio) {
    this.engine = engine; // Composed dependency (Has-A)
    this.radio = radio;   // Composed dependency (Has-A)
  }
  drive() {
    this.engine.start();
    this.radio.play();
  }
}

Core CS Fundamentals Interview Questions

Difficulty Filters

Tools & Options

What is the difference between a Process and a Thread? Explain Context Switching.

Explain CPU Scheduling Algorithms: FCFS, SJF, Round Robin, and Priority Scheduling.

What is Process Synchronization? Explain Mutex vs Semaphore and the Producer-Consumer Problem.

What is a Deadlock? Explain the 4 Necessary Conditions for Deadlock and how to Prevent it.

Explain Virtual Memory, Paging, Page Faults, Thrashing, and LRU Page Replacement.

Explain Inter-Process Communication (IPC): Shared Memory vs Message Passing vs Sockets.

Explain the OSI 7-Layer Model vs TCP/IP 4-Layer Model and layer-by-layer functions.

Explain TCP vs UDP protocols, TCP 3-Way Handshake, and 4-Way Teardown.

What is the difference between HTTP, HTTPS, HTTP/1.1, HTTP/2, and HTTP/3?

Explain the DNS Resolution Process step-by-step.

Compare Real-Time Web Communication: WebSockets vs HTTP Long Polling vs Server-Sent Events (SSE).

Explain IP Addressing: IPv4 vs IPv6, Subnetting, CIDR Notation, and NAT.

What are the 4 Pillars of Object-Oriented Programming (OOP)? Provide practical code examples.

Explain the SOLID Principles of Object-Oriented Design with examples.

Explain the Singleton Pattern and how to implement a Thread-Safe Singleton.

Explain Creational Patterns: Factory Method Pattern and Builder Pattern.

Explain Behavioral & Structural Patterns: Observer Pattern and Strategy Pattern.

Why is 'Composition over Inheritance' a fundamental software engineering principle?

Explore Related Tools

Bootstrap 5 Column Sizes: Grid System, Auto & Fixed Columns

Bootstrap 5 Flex Utilities: Alignment, Direction & Examples

Bootstrap 5 Headings: Display, Typography & Utility Classes

Bootstrap 5 Nesting Columns: Complex Layouts & Grid Nesting

Kubernetes Health Checks: Liveness & Readiness Probes Guide

Kubernetes Persistent Storage: PV, PVC & StorageClass Guide

Follow Us

Our Tools

Our Company

Special Tools