Software Engineering · End Term · May 2026 · AN

**1. Identify the role responsible for wireframes, mock-ups, and usability prototypes:** Creating user interface wireframes, interactive mock-ups, and usability prototypes to validate user experience before coding is the primary responsibility of the **Designer** (UI/UX Designer). **Answer: B — Designer.** A: **Incorrect:** Product Managers define product vision, roadmap, and business requirements. B: **Correct:** UI/UX Designers create wireframes, interactive mock-ups, and usability prototypes. C: **Incorrect:** Software Engineers implement and test the production code. D: **Incorrect:** Engineering Managers oversee the engineering team and technical delivery.

**1. Distinguish deployment environments:** - **Development:** Used by developers while writing code. - **Testing / QA:** Used by testers to run automated and manual test suites. - **Staging:** Pre-production mirror used for final rehearsal before release. - **Production:** The live environment that **directly serves real end-users/customers**. **Answer: C — Production.** A: **Incorrect:** Development is used internally by engineers for coding. B: **Incorrect:** Testing is used internally by QA for verification. C: **Correct:** Production is the live environment serving real customers. D: **Incorrect:** Staging is a pre-release replica environment, not the live customer environment.

**1. Compare hosting models by level of hardware control:** When an organization requires **complete control over physical server hardware, operating system kernel, storage configuration, and networking** without hypervisor virtualization overhead or multi-tenancy, a dedicated **Bare Metal Server** is the most suitable option. **Answer: A — Bare Metal Server.** A: **Correct:** Bare Metal Servers provide direct, unvirtualized access to physical server hardware, OS, storage, and networking. B: **Incorrect:** PaaS abstracts away both hardware and the operating system. C: **Incorrect:** IaaS provides virtualized machines where the cloud provider still controls the underlying physical hardware and hypervisor. D: **Incorrect:** Shared hosting shares a single server and OS across many customers with minimal control.

**1. Recall the levels of software testing:** 1. **Unit Testing:** Tests individual functions/classes in isolation. 2. **Integration Testing:** Combines tested units/functions and verifies that they **interact and exchange data correctly**. 3. **System Testing:** Tests the complete integrated system end-to-end. 4. **Acceptance Testing:** Validates the system against user/customer business requirements. **Answer: B — Integration Testing.** A: **Incorrect:** Unit testing tests individual functions in isolation, which has already been completed. B: **Correct:** Integration testing verifies the interfaces and interactions between combined functions/modules. C: **Incorrect:** System testing evaluates the entire end-to-end system after integration. D: **Incorrect:** Acceptance testing is performed to get final customer sign-off.

**1. Match the software metric to decision points:** **McCabe's Cyclomatic Complexity** \( V(G) = P + 1 \) (where \( P \) is the number of predicate/decision points such as `if`, `for`, `while`) directly measures the number of linearly independent paths through a function and increases with every decision point. **Answer: C — Cyclomatic Complexity.** A: **Incorrect:** Halstead metrics count operators and operands rather than control-flow decision points. B: **Incorrect:** Raw metrics (like Lines of Code, LOC) measure size rather than branching complexity. C: **Correct:** Cyclomatic complexity equals `1 + number of decision points` and directly quantifies control-flow complexity. D: **Incorrect:** Branch coverage is a test adequacy criterion, not a static code complexity metric.

**1. Distinguish UML diagram types:** - **Sequence Diagram:** A behavioral interaction diagram that shows **how objects interact with each other via messages ordered over time** (along vertical lifelines). - **Class Diagram:** Shows static classes, attributes, and relationships. - **State Diagram:** Shows states and transitions of a single object. - **Activity Diagram:** Shows workflow/business process steps. **Answer: B — Sequence Diagram.** A: **Incorrect:** Class diagrams model static structure, not time-ordered object interactions. B: **Correct:** Sequence diagrams depict message exchanges between object lifelines over time. C: **Incorrect:** State diagrams model the lifecycle states of a single class/object. D: **Incorrect:** Activity diagrams model step-by-step workflows rather than object-to-object message timelines.

**1. Identify the usability goal:** Pre-filling a returning customer's saved delivery address and payment method reduces the number of clicks and keystrokes required to complete a purchase, which directly improves **Efficiency** (how quickly and with how little effort experienced users can perform tasks). **Answer: C — Efficiency.** A: **Incorrect:** Safety protects users from making dangerous errors. B: **Incorrect:** Memorability is how easily a user remembers how to use the interface after a period away. C: **Correct:** Reducing the number of interactions/steps to complete a task directly improves Efficiency. D: **Incorrect:** Effectiveness is whether users can achieve their goal accurately at all.

**1. Match to Nielsen's usability heuristics:** Using the same font, color scheme, and button placement across every screen exemplifies **Consistency (Consistency and standards)**. **Answer: A — Consistency.** A: **Correct:** Maintaining uniform visual styling and button placement across screens is Consistency. B: **Incorrect:** User control and freedom refers to providing Undo, Redo, and Cancel options. C: **Incorrect:** Recognition rather than recall refers to making options visible so users don't have to memorize commands. D: **Incorrect:** Showing status (visibility of system status) refers to progress bars and feedback indicators.

**1. Identify the software engineering tool:** An **Issue Tracking Tool** (or Bug/Defect Tracker, such as Jira, Bugzilla, or GitHub Issues) records open defects, assignee developers, priority/severity levels, and defect age/status. **Answer: D — Issue Tracking Tool.** A: **Incorrect:** An IDE (Integrated Development Environment) is used for writing and debugging code. B: **Incorrect:** A Version Control System (like Git) tracks source code commits and branches. C: **Incorrect:** A Deployment Tool automates releasing builds to servers. D: **Correct:** An Issue Tracking Tool tracks defect counts, assignees, priorities, and resolution times.

**1. Identify the deployment strategy:** Maintaining two identical production environments (**Blue / Environment A** serving live traffic and **Green / Environment B** hosting the new version), validating Environment B, and then switching all user traffic over from A to B is **Blue-Green Deployment**. **Answer: B — Blue-Green Deployment.** A: **Incorrect:** Canary deployment gradually routes a small percentage (e.g., 5%) of traffic to the new version first. B: **Correct:** Running two parallel production environments and switching router traffic from A to B after validation is Blue-Green Deployment. C: **Incorrect:** Versioned deployment maintains multiple API/app versions concurrently for different clients. D: **Incorrect:** Option B is the exact deployment pattern.

**1. Identify the integration testing strategy:** Waiting until all modules are completed and combining all of them together at once in a single step is called **Big Bang Integration**. **Answer: C — Big Bang Integration.** A: **Incorrect:** Top-down integration integrates incrementally from the top control module downward using stubs. B: **Incorrect:** Bottom-up integration integrates incrementally from low-level utility modules upward using drivers. C: **Correct:** Combining all modules simultaneously after all are coded is Big Bang Integration. D: **Incorrect:** Sandwich integration combines incremental top-down and bottom-up integration.

**1. Match each objective to Black-box vs. White-box testing:** 1. Verifying that every **functional requirement** works from the external specification (without looking at internal code) is **Black-box Testing**. 2. Ensuring that every **branch of the source code** is executed requires inspecting the internal control flow, which is **White-box Testing**. **Answer: A — Black-box Testing for (1) and White-box Testing for (2).** A: **Correct:** Functional requirement verification is Black-box testing, and code branch coverage is White-box testing. B: **Incorrect:** Reverses the definitions of Black-box and White-box testing. C: **Incorrect:** Branch coverage cannot be measured by pure Black-box testing. D: **Incorrect:** Functional requirements validation against specifications is Black-box testing.

**1. Recall the Interface Segregation Principle (ISP):** The **Interface Segregation Principle** states that *clients should not be forced to depend upon interfaces (or implement methods) that they do not use*. Forcing `EBook` to implement physical shipping methods (`packageOrder()` and `deliver()`) as empty dummy methods directly violates ISP. **Answer: C — Interface Segregation Principle.** A: **Incorrect:** SRP concerns a class having a single reason to change, whereas the issue here is a fat interface forcing unused methods on implementers. B: **Incorrect:** OCP concerns extending behavior without modifying existing code. C: **Correct:** Forcing `EBook` to implement unused `packageOrder()` and `deliver()` methods from a bloated interface violates the Interface Segregation Principle. D: **Incorrect:** DIP concerns depending on abstractions rather than concrete classes.

**1. Identify the creational design pattern:** Encapsulating the `if/else` object instantiation logic (`new CreditCardPayment()`, `new UPIPayment()`, etc.) inside a dedicated creator component so the booking module works through a common `Payment` interface without directly instantiating concrete payment classes is the **Factory** (Factory Method / Simple Factory) pattern. **Answer: C — Factory.** A: **Incorrect:** Builder is used for step-by-step construction of a single complex object with many optional parameters. B: **Incorrect:** Observer is a behavioral pattern for one-to-many event notification. C: **Correct:** The Factory pattern delegates and centralizes object creation based on payment type, decoupling the booking module from concrete payment classes. D: **Incorrect:** Facade is a structural pattern that provides a simplified interface to a complex subsystem.

**1. Trace the Git commands (`git add` and `git commit` without `git push`):** - `git add app.py` stages the file in the local index (staging area). - `git commit -m "..."` records the staged snapshot into the **local repository** commit history. - Because **`git push` has NOT been run**, the remote repository has not been updated yet; **only the local repository contains the new commit**. **Answer: B — Only the local repository contains the new commit.** A: **Incorrect:** Updating the remote repository requires running `git push`. B: **Correct:** `git commit` saves the commit locally; without `git push`, it exists only in the local repository. C: **Incorrect:** `git commit` has already committed the staged changes into the local repository. D: **Incorrect:** `git commit` succeeds locally without `git push`.

**1. Identify the debugging technique:** Saving (dumping) program state/output from a working run and a failing run into files and using a comparison tool (`diff`) to pinpoint where they diverge is called **Dump and Diff**. **Answer: B — Dump and Diff.** A: **Incorrect:** Logging prints runtime trace messages during a single execution rather than diffing good vs. bad output dumps. B: **Correct:** Comparing output dumps from a passing run and a failing run line-by-line is Dump and Diff. C: **Incorrect:** Profiling measures CPU time and memory usage to find performance bottlenecks. D: **Incorrect:** Stepping in a debugger executes instructions interactively one line at a time.

**1. Recall types of module cohesion:** When the activities inside a module are organized as a pipeline such that **the output data of one step serves directly as the input data to the next step** (receive readings \( \to \) filter noise \( \to \) compute average \( \to \) store result), the module exhibits **Sequential cohesion**. **Answer: B — Sequential cohesion.** A: **Incorrect:** Communicational cohesion occurs when multiple independent steps operate on the same input/output data record without forming a pipeline. B: **Correct:** When the output of each step is the input to the next step, it is Sequential cohesion. C: **Incorrect:** Coincidental cohesion is when unrelated tasks are grouped arbitrarily. D: **Incorrect:** Procedural cohesion is when steps follow a control sequence without passing data from one to the next.

**1. Recall the Product Backlog in Agile Scrum:** The **Product Backlog** is an ordered list of everything that is known to be needed in the product, primarily derived from **user stories and requirements** gathered from stakeholders. **Answer: B — User stories and requirements.** A: **Incorrect:** Source code is produced during sprints to implement backlog items. B: **Correct:** The Product Backlog consists of prioritized user stories, features, and requirements. C: **Incorrect:** Test reports are generated during verification. D: **Incorrect:** UML diagrams are design artifacts, not the source of the Product Backlog.

**1. Compute the Risk Score (\( \text{Risk Exposure} = \text{Probability} \times \text{Impact} \)) for each risk:** From the risk table: - **R1:** \( 0.40 \times 4 = 1.60 \) - **R2:** \( 0.25 \times 5 = 1.25 \) - **R3:** \( 0.50 \times 3 = 1.50 \) - **R4:** \( 0.30 \times 2 = 0.60 \) **2. Identify the lowest-priority risk:** **R4** has the smallest risk score (\( 0.60 \)) and therefore receives the **lowest priority**. **Answer: D — R4.** A: **Incorrect:** R1 has the highest risk score (\( 0.40 \times 4 = 1.60 \)), so it has the highest priority. B: **Incorrect:** R2 has risk score \( 0.25 \times 5 = 1.25 > 0.60 \). C: **Incorrect:** R3 has risk score \( 0.50 \times 3 = 1.50 > 0.60 \). D: **Correct:** R4 has the lowest risk exposure (\( 0.30 \times 2 = 0.60 \)), giving it the lowest priority.

**1. Identify the requirement elicitation technique:** Watching users (supermarket cashiers) perform their actual work in their real working environment without interfering is **Naturalistic Observation** (ethnographic/field observation). **Answer: C — Naturalistic Observation.** A: **Incorrect:** No written survey/questionnaire was distributed. B: **Incorrect:** The analyst observed live work rather than reading existing manuals. C: **Correct:** Passively observing users in their natural workplace environment is Naturalistic Observation. D: **Incorrect:** The analyst explicitly observed cashiers rather than interviewing them with questions.

**1. Compare the original and revised requirement against SMART criteria:** - Original: *'The checkout page should load quickly.'* (vague, unquantified) - Revised: *'The checkout page should load **within 2 seconds for 95% of user requests**.'* Replacing the subjective word *'quickly'* with a concrete quantitative threshold (*within 2 seconds for 95% of requests*) makes the requirement objectively **Measurable**. **Answer: B — Measurable.** A: **Incorrect:** Both statements specify the checkout page loading; the key change is adding a quantifiable metric. B: **Correct:** Adding 'within 2 seconds for 95% of user requests' provides a verifiable quantitative metric, making it Measurable. C: **Incorrect:** Relevance to business goals was not the property changed. D: **Incorrect:** Adding a numerical metric primarily addresses Measurability.

**1. Identify the SDLC phase:** After requirements are finalized, defining module decompositions (`Payment Gateway`, `User Authentication`, `Order Management`), their interfaces/interactions, and preparing **architecture diagrams** takes place in the **Design** phase. **Answer: B — Design.** A: **Incorrect:** Requirements Specification has already been finalized. B: **Correct:** Defining module interactions and system architecture diagrams is the Design phase. C: **Incorrect:** Development (coding) follows architectural and detailed design. D: **Incorrect:** Maintenance occurs after deployment.

**1. Evaluate why an asynchronous task queue is used for bulk email sending:** - **Option A:** By enqueueing email jobs asynchronously, the web server can respond immediately without making users wait for 5 million emails to be sent. **True.** - **Option B:** Background worker processes can pull jobs from the queue in parallel to process emails simultaneously. **True.** - **Option C:** False! Asynchronous queues *decouple* email sending from the HTTP request/response cycle. - **Option D:** The number of background workers can be scaled up dynamically during peak campaigns. **True.** **Answer: A, B, and D.** A: **Correct:** Offloading long-running tasks to a background queue keeps user-facing responses fast. B: **Correct:** Multiple worker processes can consume tasks from the queue concurrently. C: **Incorrect:** Asynchronous queues remove email sending from the synchronous HTTP response path. D: **Correct:** Worker pools can be horizontally scaled up or down based on queue backlog.

**1. Analyze the branches in `calculate_discount(amount, is_member)`:** From the Python function: ```python if amount <= 0 or amount > 10000: return "Invalid" if amount > 5000 and is_member: return amount * 0.8 return amount * 0.9 ``` To achieve 100% **Branch Coverage**, we must exercise Both True and False outcomes of the 1st `if` AND both True and False outcomes of the 2nd `if`: 1. `amount <= 0 or amount > 10000` is **True** (e.g., `(-100, False)` or `(12000, False)`). 2. `amount <= 0 or amount > 10000` is **False**, and `amount > 5000 and is_member` is **True** (e.g., `(6000, True)`). 3. `amount <= 0 or amount > 10000` is **False**, and `amount > 5000 and is_member` is **False** (e.g., `(2000, False)` or `(6000, False)`). Both **Option A (`{(-100, False), (6000, True), (2000, False)}`)** and **Option C (`{(12000, False), (6000, False), (6000, True)}`)** cover all three paths (and all four branches). **Answer: A and C.** A: **Correct:** Covers the 1st `if` True (`-100`), 2nd `if` True (`6000, True`), and 2nd `if` False (`2000, False`). B: **Incorrect:** Never makes the 1st `if` (`amount <= 0 or amount > 10000`) True. C: **Correct:** Covers the 1st `if` True (`12000`), 2nd `if` False (`6000, False`), and 2nd `if` True (`6000, True`). D: **Incorrect:** Never makes the 2nd `if` (`amount > 5000 and is_member`) True.

**1. Analyze Multiple Condition Coverage for `calculate_discount(amount, is_member)`:** To cover all feasible combinations of atomic conditions in: - Decision 1 (`amount <= 0` or `amount > 10000`): requires `(T, F)` via `(-100, False)`, `(F, T)` via `(12000, False)`, and `(F, F)` via `0 < amount <= 10000`. - Decision 2 (`amount > 5000` and `is_member`): requires `(T, T)` via `(6000, True)`, `(T, F)` via `(6000, False)`, and `(F, F)` via `(2000, False)`. **Option C (`{(-100, False), (12000, False), (6000, True), (6000, False), (2000, False)}`)** includes all 5 test cases needed to exercise every feasible atomic condition combination. **Answer: C.** A: **Incorrect:** Does not test either `amount <= 0` or `amount > 10000` being True. B: **Incorrect:** Only has 3 test cases, missing `amount > 10000` (`12000`) and `(6000, False)`. C: **Correct:** Includes all 5 test cases required to cover all feasible condition combinations of both compound predicates. D: **Incorrect:** Misses `amount <= 0`, `(6000, False)`, and `(2000, False)`.

**1. Map the domain requirements to UML Class Diagram relationships:** - *'Students can enroll in multiple courses' and 'A course can have multiple students':* This is a many-to-many **Association between `Student` and `Course`** (**Option A is true**; it is NOT composition (Option C) because courses and students have independent lifecycles). - *'`UndergraduateStudent` and `PostgraduateStudent` are specialized versions of `Student` sharing common attributes':* This is an 'is-a' **Generalization (Inheritance)** relationship between `Student` and `UndergraduateStudent` (**Option B is true**) and between `Student` and `PostgraduateStudent` (**Option D is true**). **Answer: A, B, and D.** A: **Correct:** Enrollment between `Student` and `Course` is a many-to-many Association. B: **Correct:** `UndergraduateStudent` is a specialized subclass of `Student` (Generalization/Inheritance). C: **Incorrect:** Composition implies strong whole-part ownership where destroying one destroys the other, which does not apply to Students and Courses. D: **Correct:** `PostgraduateStudent` is a specialized subclass of `Student` (Generalization/Inheritance).

**1. Identify the COCOMO project mode:** The project is control software for an **autonomous railway signalling system** with stringent safety requirements, strict hardware constraints, and real-time communication. This is a classic **Embedded** mode project (\( a = 3.6,\ b = 1.20 \)). **2. Calculate the initial (nominal) effort \( E_{\text{initial}} = a \times (\text{KLOC})^b \):** For \( \text{KLOC} = 40 \): \[ E_{\text{initial}} = 3.6 \times (40)^{1.20} \approx 3.6 \times 83.651 = 301.14 \approx 301.2 \text{ PM} \] **Answer: D — 301.2 PM.** A: **Incorrect:** `186.8 PM` uses the Semi-detached mode constants (\( 3.0 \times 40^{1.12} \)). B: **Incorrect:** `114.6 PM` uses the Organic mode constants (\( 2.4 \times 40^{1.05} \)). C: **Incorrect:** Does not match \( 3.6 \times 40^{1.20} \). D: **Correct:** For an Embedded project of 40 KLOC, \( E = 3.6 \times 40^{1.20} \approx 301.2 \text{ PM} \).

**1. Compute the Effort Adjustment Factor (EAF):** Multiplying the four given cost-driver multipliers (\( 1.40,\ 1.15,\ 0.86,\ 0.91 \)): \[ \text{EAF} = 1.40 \times 1.15 \times 0.86 \times 0.91 = 1.61 \times 0.7826 = 1.259986 \] **2. Multiply the initial effort by the EAF:** \[ E_{\text{final}} = E_{\text{initial}} \times \text{EAF} = 301.2 \times 1.259986 \approx 379.5 \text{ PM} \] **Answer: C — 379.5 PM.** A: **Incorrect:** Does not apply the net EAF multiplier `1.26`. B: **Incorrect:** Miscalculates the product of the four cost drivers. C: **Correct:** \( 301.2 \times (1.40 \times 1.15 \times 0.86 \times 0.91) \approx 379.5 \text{ PM} \). D: **Incorrect:** Overestimates the effort adjustment factor.