BICIC Assistant Programmer Exam: 2022 (BUET)প্রশ্ন ও সমাধান

Waterfall is a linear, sequential SDLC model — requirements → design → implementation → testing → deployment → maintenance — where each phase must finish before the next begins. Agile is an iterative, incremental model that delivers working software in short cycles (sprints, typically 1–4 weeks), continuously re-planning based on feedback.

Aspect	Waterfall	Agile
Process	Sequential, one-pass phases	Iterative sprints, repeated cycles
Requirements	Fixed upfront, hard to change later	Expected to evolve; re-prioritized every sprint
Customer involvement	Mainly at the start and the end	Continuous, every sprint review
Delivery	One final product at the end	A working increment after every sprint
Risk detection	Late (during the testing phase)	Early (each sprint is tested)
Best fit	Well-understood, stable requirements (e.g. regulatory systems)	Evolving requirements, fast-changing markets
Documentation	Heavy, formal	Lightweight — "working software over documentation"

graph LR
  subgraph Waterfall
  R1[Requirements] --> D1[Design] --> I1[Implement] --> T1[Test] --> M1[Deploy]
  end
  subgraph Agile
  S1[Sprint 1] --> S2[Sprint 2] --> S3[Sprint 3] --> S4[Sprint N]
  end

Exam takeaway: Waterfall is predictable but rigid; Agile is flexible and fast-feedback but needs disciplined, continuous customer collaboration.

A page fault is a hardware trap raised by the MMU when a running program references a virtual-memory page that is not currently loaded into a physical memory frame (it exists only on disk/backing store, or has not been allocated yet).

Why it occurs:

• The page was never loaded before (first reference — "demand paging").
• The page was swapped out earlier to make room for other pages.
• The access itself is invalid (e.g. writing to a read-only page, or an out-of-bounds address, which is technically a segmentation fault rather than an ordinary page fault).

Handling steps:

flowchart TD
  A([CPU references a page]) --> B{Page in memory?}
  B -- Yes --> C[Continue execution normally]
  B -- No --> D[Trap to OS: Page Fault]
  D --> E{Valid reference?}
  E -- No --> F[Terminate process / segfault]
  E -- Yes --> G[Find a free frame or evict a page]
  G --> H[Load the page from disk into the frame]
  H --> I[Update the page table]
  I --> J[Restart the faulting instruction]

The CPU saves its state (program counter, registers) before handing control to the OS, and once the page is fetched from the backing store, the faulting instruction is simply re-executed — the program is unaware a fault ever happened.

Exam takeaway: a page fault means "the wanted page isn't in RAM"; it's a normal, expected part of demand-paged virtual memory, not necessarily an error — an excessive fault rate that hurts performance is specifically called thrashing.