UGC NET CS Practice Set 4

Explanation: In a two-pass assembler, the first pass scans the source code to identify all labels and their addresses, building the symbol table. The second pass uses this symbol table to generate the actual machine code, resolving forward references.

Explanation: Belady's anomaly is the counterintuitive behavior where increasing the number of page frames increases the number of page faults. This can occur with FIFO page replacement. LRU and Optimal are stack algorithms and are immune to this anomaly.

Explanation: A macro processor replaces macro invocations with the corresponding macro body (expansion). It performs textual substitution, handling parameter substitution and nested macros. This is done before assembly or compilation.

Explanation: In segmentation, a logical address is a pair (segment number, offset). The segment number indexes into the segment table to find the base address and limit. If offset < limit, the physical address = base + offset.

Explanation: A linker combines multiple object modules (produced by the assembler or compiler) into a single executable, resolving external references between modules. The loader then places the executable into memory for execution.

Explanation: SJF (Shortest Job First) is provably optimal for minimizing average waiting time when all processes are available at the same time. It schedules the process with the smallest burst time first.

Explanation: Timeline: P1 runs 0-4 (1 remaining), P2 runs 4-7 (done), P3 runs 7-11 (4 remaining), P1 runs 11-12 (done), P3 runs 12-16 (done). P3 completes at time 16.

Explanation: The working set model defines the set of pages referenced by a process in the most recent Δ time window. By keeping the working set in memory, the system avoids excessive page faults (thrashing). If the sum of all working sets exceeds memory, some processes should be suspended.

Explanation: With LRU and 3 frames: 7(F,{7}), 0(F,{7,0}), 1(F,{7,0,1}), 2(F,replace 7→{0,1,2}), 0(H,{1,2,0}), 3(F,replace 1→{2,0,3}), 0(H,{2,3,0}), 4(F,replace 2→{3,0,4}), 2(F,replace 3→{0,4,2}), 3(F,replace 0→{4,2,3}), 0(F,replace 4→{2,3,0}), 3(H,{2,0,3}), 2(H,{0,3,2}). Page faults = 10.

Explanation: The Waterfall model follows a strict sequential approach: Requirements → Design → Implementation → Testing → Deployment → Maintenance. Each phase must be completed fully before the next one begins, with minimal backtracking.

Explanation: In COCOMO, the effort equation is E = a × (KLOC)^b. The embedded type (complex, tightly constrained systems) has the highest exponent (b=1.20) and coefficient, meaning highest effort per KLOC. Organic (simple) has b=1.05, semi-detached has b=1.12.

Explanation: A sequence diagram shows the time-ordered sequence of messages exchanged between objects/actors. It is a behavioral diagram that depicts how objects interact in a particular scenario, with time progressing downward along lifelines.

Explanation: White-box (structural/glass-box) testing uses knowledge of the internal code structure to design test cases. Techniques include statement coverage, branch coverage, path coverage, and data flow testing. Black-box testing only considers inputs and outputs.

Explanation: McCabe's cyclomatic complexity formula: V(G) = E − N + 2P, where E = edges, N = nodes, P = connected components. V(G) = 15 − 12 + 2(1) = 5. Wait: 15 - 12 + 2 = 5. Let me verify. Actually V(G) = E - N + 2P = 15 - 12 + 2 = 5. But that's not among the options correctly. V(G) = 15 - 12 + 2(1) = 5.

Explanation: In Scrum, a sprint is a time-boxed iteration typically lasting 1 to 4 weeks (commonly 2 weeks). At the end of each sprint, a potentially shippable product increment is delivered.

Explanation: An SRS should be unambiguous, consistent, verifiable, complete, and traceable. It should NOT be implementation-specific — it should describe WHAT the system should do, not HOW it should be implemented.

Explanation: Good software design aims for low coupling (minimal dependencies between modules) and high cohesion (each module performs a single, well-defined function). This makes the system easier to maintain, test, and modify.

Explanation: Integration testing verifies the interfaces and interactions between integrated components/modules. Unit testing tests individual components. System testing tests the complete system. Regression testing verifies that changes haven't broken existing functionality.

Explanation: Boehm's Spiral model combines the systematic aspects of the Waterfall model with the iterative nature of prototyping, adding explicit risk analysis at each iteration. Each loop through the spiral involves planning, risk analysis, engineering, and evaluation.

Explanation: In FPA, an External Input (EI) is a data entry by the user that adds, changes, or deletes data in an internal logical file. External Outputs are reports, External Inquiries are queries that don't update data, and External Interface Files are data shared with other systems.

Explanation: Software Configuration Management (SCM) involves identifying configuration items, controlling changes through baselines and change control boards, recording the status of changes, and auditing configurations for compliance. It applies to all software artifacts: code, documents, tests, etc.

Explanation: In the V-model, each development phase on the left arm (requirements, design, coding) has a corresponding testing phase on the right arm (acceptance testing, integration testing, unit testing). This emphasizes that test planning begins during development, not after.

Explanation: Boundary value analysis (BVA) is a black-box testing technique that focuses on testing at the boundaries of input domains (just below, at, and just above boundary values). Experience shows that bugs are most likely to occur at these boundaries.

Explanation: In COCOMO II, EM_i are effort multipliers representing cost drivers such as product reliability, database size, analyst capability, programmer experience, and development tools. Each driver has a rating (very low to very high) that multiplies the nominal effort.

Explanation: The Single Responsibility Principle (SRP), the 'S' in SOLID, states that a class should have only one reason to change — it should have one responsibility. This leads to more maintainable, testable, and flexible software.

Explanation: The critical path is the longest sequence of dependent tasks in a project network. It determines the minimum project duration. Tasks on the critical path have zero slack/float — any delay in them directly delays the project.

Explanation: Inserting into a heap involves placing the new element at the end of the array and performing a 'sift-up' (bubble-up) operation, which compares and swaps along the path from the leaf to the root. The height of the heap is O(log n), so insertion is O(log n).

Explanation: When merging two sorted arrays, we compare elements from both arrays. In the worst case, elements alternate between the two arrays, requiring a comparison for every element except the last (which is appended without comparison). Total = m + n − 1.

Explanation: Quicksort's worst case occurs when the pivot is always the smallest or largest element, causing maximally unbalanced partitions. This leads to n−1 levels of recursion with O(n) work each, giving O(n²). The average and best cases are O(n log n).

Explanation: For a successful search with chaining, the expected number of elements examined is 1 + α/2, where α = n/m is the load factor. This accounts for finding the element partway through its chain on average. When α = O(1), this is Θ(1).