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).

GATE CSE Software Engineering (SE) PYQs

GATE tests Software Engineering at a conceptual level by evaluating a candidate's understanding of Software Development Life Cycle (SDLC) artifacts and phase bo… Read the guide

Start mock · 13 Qs

Topics: 9
Questions: 13
Marks / paper: 2
Asked: 2011–2015

These are the 13 GATE CSE Software Engineering PYQs (2011–2015), grouped topic-wise with solutions. See all GATE CSE PYQs or GATE CSE question papers by year.

Topics

Open a topic to browse its questions, or practice it as a timed test.

By year

Jump to the first question from each year’s paper.

What GATE tests in Software Engineering

Concepts, patterns, formulas and traps distilled from past papers.

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)

How questions show up

SDLC Model Matching
OccasionalMCQ1 marks2014
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
OccasionalMCQ1 marks2015
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
RareNAT1 marks2015
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
RareMCQ2 marks2013
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)
RareMCQ1 marks2015
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
RareMCQ2 marks2015
Given a mix of code snippets, a control flow graph diagram, and a composite module connected sequentially, determine the respective cyclomatic complexities.

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).

Paper trends

Questions are predominantly 1-mark classification items (matching SDLC models and testing types) along with straightforward numerical application (fault seeding). High-mark questions evaluate structural design metrics using graphical representations.
2015, 2014, 2013
Software Engineering questions appeared as standalone 1-mark conceptual MCQs testing foundational knowledge of standard SDLC documentation and requirements engineering.
2015
Appears as a 2-mark comprehensive question testing cyclomatic complexity across code, graph representation, and serial composition of modules.
2015
Software Testing was briefly tested as part of the broader Software Engineering / C programming syllabus in GATE 2011 as a 2-mark conceptual application question.
2011