What are common examiner traps in Software Engineering?

Fault Seeding: Forgetting to subtract detected real faults (Rd) from the total estimated real faults (R) when the question asks for 'undetected' real faults. Fault Seeding: Mistaking total detected faults (Td) for detected real faults (Rd), forgetting that Rd = Td - Sd. Coupling vs. Cohesion: Confusing internal method-attribute connections (intra-module / cohesion) with external cross-module references (inter-module / coupling). Testing Category Overlap: Confusing acceptance/system testing (e.g., Alpha testing) with unit/integration testing techniques. Confusing external interfaces (user interfaces, hardware/software interfaces) with internal architectural and modular design specifications. Incorrectly assuming that non-functional requirements (e.g., performance, reliability, security) do not belong in an SRS. Failing to recognize that algorithm selection and internal data structures belong strictly to the design phase (SDD) rather than the requirement specification phase. Adding cyclomatic complexities directly during sequential composition (V(X) + V(Y) instead of V(X) + V(Y) - 1).

Software Engineering

9 topics · 13 Qs · 2 marks/paper · 2011–2015

Start mock (13 Qs)

GATE tests Software Engineering at a conceptual level by evaluating a candidate's understanding of Software Development Life Cycle (SDLC) artifacts and phase boundaries. In GATE CS… Guide

Topics

Open a topic to browse, or practice it timed.

By year

Jump to the first question from that paper.

Subject guide

What does GATE test in Software Engineering?

GATE tests Software Engineering at a conceptual level by evaluating a candidate's understanding of Software Development Life Cycle (SDLC) artifacts and phase boundaries. In GATE CS, Control Flow and Cyclomatic Complexity questions evaluate the student's ability to compute McCabe's Cyclomatic Complexity across multiple representations (C code snippets, explicit Control Flow Graphs, and composite/sequential modules). Software Testing appears very rarely in GATE Computer Science, historically tested under Software Engineering / Programming methodologies.

Core concepts

Software Development Life Cycle (SDLC) models (Waterfall, Spiral, Evolutionary, Component-Based)
Software Testing levels and classifications (White-box, Black-box, System, Performance, Alpha/Beta testing)
Condition Coverage and Equivalence Class Partitioning
Module Cohesion and Inter-module Coupling
Mills Fault Seeding reliability metric
Software Requirements Specification (SRS) scope and contents
Distinction between requirements ('what') and design/implementation ('how')
External interfaces (User Interfaces, third-party software interfaces) in SRS
Non-functional requirements and quality attributes in requirements documentation
Design specifications and architectural decisions as components of the Software Design Document (SDD)
McCabe's Cyclomatic Complexity metric
Control Flow Graph (CFG) construction (Nodes, Edges, Decision/Predicate nodes)

High-yield formulas

Mills Fault Seeding Model

\frac{S_d}{S} = \frac{R_d}{R}

Used to estimate total real faults ( $R$ ) from total seeded faults ( $S$ ), detected seeded faults ( $S_d$ ), and detected real faults ( $R_d = T_d - S_d$ ). Undetected real faults are given by $R_u = R - R_d$ .

McCabe's Cyclomatic Complexity (Graph formula)

V(G) = E - N + 2P

Used when the number of edges $E$ , nodes $N$ , and connected components $P$ (usually $P=1$ for a single program) of a Control Flow Graph are known.

McCabe's Cyclomatic Complexity (Predicate formula)

V(G) = P + 1

Used directly on source code where $P$ is the count of simple predicate/decision nodes (e.g., if, while, for).

McCabe's Cyclomatic Complexity (Planar Region formula)

V(G) = R

Used when counting bounded enclosed regions plus one unbounded (external) region in a planar control flow graph.

Sequential Composition of Single-Entry Single-Exit (SESE) Modules

V(Z) = V(X) + V(Y) - 1

Used when two independent modules $X$ and $Y$ are concatenated sequentially with a single transition edge from exit of $X$ to entry of $Y$ .

Discriminant Condition for Quadratic Equation

D = b^2 - 4ac

Used to partition input domain into real distinct ( $D > 0$ ), real equal ( $D = 0$ ), and complex roots ( $D < 0$ ) alongside boundary condition $a = 0$ .

Basic COCOMO Effort Equation

E = a_b (\text{KLOC})^{b_b}

Used to estimate total effort in person-months given the software size in thousands of lines of code (KLOC).

Basic COCOMO Development Time Equation

D = c_b (E)^{d_b}

Used to estimate the chronological project duration (schedule) in months using the estimated effort $E$ .

Examiner traps in Software Engineering

Fault Seeding: Forgetting to subtract detected real faults (Rd) from the total estimated real faults (R) when the question asks for 'undetected' real faults.
Fault Seeding: Mistaking total detected faults (Td) for detected real faults (Rd), forgetting that Rd = Td - Sd.
Coupling vs. Cohesion: Confusing internal method-attribute connections (intra-module / cohesion) with external cross-module references (inter-module / coupling).
Testing Category Overlap: Confusing acceptance/system testing (e.g., Alpha testing) with unit/integration testing techniques.
Confusing external interfaces (user interfaces, hardware/software interfaces) with internal architectural and modular design specifications.
Incorrectly assuming that non-functional requirements (e.g., performance, reliability, security) do not belong in an SRS.
Failing to recognize that algorithm selection and internal data structures belong strictly to the design phase (SDD) rather than the requirement specification phase.
Adding cyclomatic complexities directly during sequential composition (V(X) + V(Y) instead of V(X) + V(Y) - 1).

How questions show up

SDLC Model Matching
occasional · MCQ · 1 marks · 2014
Matching standard software process models (e.g., Waterfall, Evolutionary, Component-based, Spiral) to their defining characteristics such as risk recognition, incremental specs, or rigid stage partitioning.
Software Testing Classification Matching
occasional · MCQ · 1 marks · 2015
Matching specific testing techniques and levels (e.g., Condition coverage, Equivalence class partitioning, Volume testing, Alpha testing) to testing categories (White-box, Black-box, Performance, System testing).
Mills Fault Seeding Calculation
rare · NAT · 1 marks · 2015
Computing the estimated number of undetected real faults in a program given the total seeded faults, total detected faults, and the count of detected seeded faults.
Structural Cohesion and Coupling Analysis
rare · MCQ · 2 marks · 2013
Evaluating the impact of refactoring (e.g., moving methods between modules) on intra-module interactions (cohesion) and inter-module interactions (coupling) using access graphs.
Scope and Boundaries of Software Requirements Specification (SRS)
rare · MCQ · 1 marks · 2015
Identifying valid components versus excluded details in an SRS document, specifically testing the boundary between external requirements/constraints and internal architectural/design choices.
Multi-Representation Cyclomatic Complexity Calculation
rare · MCQ · 2 marks · 2015
Given a mix of code snippets, a control flow graph diagram, and a composite module connected sequentially, determine the respective cyclomatic complexities.