Software Engineering MCQs with Answers
This page offers software engineering MCQs with answers for NTS and GAT (Subject) tests, FPSC and PPSC tests for IT posts, university semester exams and technical job interviews. The questions follow the standard syllabus through every stage of the software development life cycle (SDLC), and every answer has a short explanation.
Topics include process models (waterfall, spiral, incremental, prototyping, RAD and cleanroom), Agile methods such as Scrum and Extreme Programming, requirements engineering and traceability, design (coupling and cohesion, SOLID principles, design patterns and UML), architecture, microservices and domain-driven design. Other questions cover testing (black-box and white-box techniques, boundary value analysis, decision tables and code coverage), project estimation with COCOMO and function points, risk management, CMM and software quality, and maintenance.
In object-oriented design, which principle states that high-level modules should not depend on low-level modules, but both should depend on abstractions?
The Dependency Inversion Principle (the 'D' in SOLID) ensures high-level policy modules remain decoupled from low-level implementation details.
Which SOLID principle states that software entities (classes, modules, functions) should be open for extension, but closed for modification?
The Open-Closed Principle allows system behavior to be extended via polymorphism or inheritance without modifying existing source code.
According to the Liskov Substitution Principle (LSP), objects of a superclass should be replaceable with objects of its subclasses without:
LSP (the 'L' in SOLID) requires that subclass instances fulfill all contracts of the superclass without introducing unexpected errors.
The Interface Segregation Principle (ISP) dictates that clients should not be forced to depend upon:
ISP advocates breaking large, monolithic interfaces into smaller, specific interfaces so that implementing classes only depend on methods they require.
Which type of cohesion occurs when elements of a module are grouped together because they execute during the same phase of execution (e.g., initialization routines)?
Temporal Cohesion groups operations that must be performed together in time, such as system startup or shutdown routines.
Which type of cohesion is present when functions are placed together in a module purely because they process the same data structures or input stream?
Communicational Cohesion occurs when operations operate on the same shared dataset or input/output data structures.
Which type of cohesion occurs when the output of one component in a module serves as the direct input to the next component?
Sequential Cohesion reflects a assembly-line setup where output from one step flows directly into the input of the next.
Which type of coupling occurs when one module modifies internal data or branch logic of another module directly?
Content Coupling is the most dangerous form of coupling where one module directly accesses or alters the internal working state of another.
Which type of coupling occurs when one module controls the execution flow of another module by passing control flags or switches?
Control Coupling exists when one module passes execution flags to direct the conditional logic of another module.
Which type of coupling is considered the cleanest and most desirable where modules interact exclusively by passing elementary primitive data parameters?
Data Coupling is the best form of loose coupling, as modules pass only essential parameters with no shared state or control flags.
When entire composite data structures (e.g., a complete record or object) are passed between modules, but the receiving module uses only a subset of fields, it is called:
Stamp Coupling occurs when composite structures are passed into functions that only require a few specific fields.
An architectural style where components communicate asynchronously across an enterprise by generating and consuming messages is called:
Event-Driven Architecture relies on event producers and consumers to maintain high decoupling and scalability.
In Software Testing, the process of executing a program with the deliberate intent of finding errors is the classic definition by:
Glenford Myers defined testing in 'The Art of Software Testing' as 'the process of executing a program with the intent of finding errors.'
What is the difference between Software Verification and Software Validation?
Verification checks conformance to specifications ('Are we building the product right?'), whereas Validation checks user satisfaction ('Are we building the right product?').
Static software verification techniques performed without executing program code include:
Static verification inspects design documents, code syntax, and logic without running executable code.
In Integration Testing, combining all software modules simultaneously to test the entire system at once without incremental integration is called:
Big-Bang Integration delays module combination until all units are coded, making fault isolation extremely difficult.
In Top-Down Integration Testing, dummy control routines used to simulate lower-level modules that are not yet developed are called:
Stubs act as dummy modules to receive calls from higher-level components during top-down integration.
In Bottom-Up Integration Testing, dummy modules created to call lower-level components under test are known as:
Drivers simulate higher-level calling modules during bottom-up integration testing.
A formal, rigorous static code review technique led by a trained peer moderator using checklists and defined entry/exit criteria is a:
Fagan Inspection is a highly structured review process designed by Michael Fagan to detect defects early.
Which testing metric evaluates the percentage of executable branches in a control flow graph evaluated by a test suite?
Branch Coverage measures whether each decision outcome (True and False branches) has been tested at least once.
Path Coverage criteria requires that every linearly independent control path through a module must be executed at least once. This requires minimum test cases equal to:
The number of test cases required for 100% basis path coverage equals the Cyclomatic Complexity value V(G).
Software Acceptance Testing conducted by customers at the software developer’s site in a controlled environment is:
Alpha testing is conducted at the developer's site by internal teams or end-users in a controlled environment prior to external release.
Software testing conducted by potential users at their own work locations under real-world operational conditions is:
Beta testing collects real-world user feedback outside the controlled developer environment.
Automated regression testing techniques that record user GUI actions and replay them to verify system output are called:
Capture-Replay tools record user interactions and play them back to automate UI testing.
In Agile Scrum, what diagram graphically displays the remaining amount of work against time during a Sprint?
A Sprint Burndown Chart displays completed vs. remaining story points across iteration days.
In Software Risk Management, active measures taken to reduce the probability or magnitude of a risk before it occurs is called:
Risk Mitigation seeks to decrease the likelihood or severity of potential risk events.
Transferring risk impact to a third party (e.g., purchasing insurance or outsourcing a risky component) is called:
Risk Transfer shifts the financial or operational impact of a risk to external entities.
Completely eliminating a risk exposure by altering project scope or technical approach is:
Risk Avoidance changes the project plan to eliminate the risk condition entirely.
The Critical Path Method (CPM) in software project scheduling determines:
The Critical Path represents the longest sequence of dependent activities, determining the earliest possible project completion.
In project management network diagrams, total float (or slack time) represents:
Total Float/Slack is the duration a non-critical activity can slip without postponing overall project delivery.
Tasks located on the Critical Path in a PERT/CPM software project network diagram always have a Total Float of:
Critical path tasks have zero float (slack time = 0), meaning any delay on these tasks directly delays project completion.
In Function Point Analysis (FPA), software functionality is evaluated across five primary components: External Inputs, External Outputs, External Inquiries, Internal Logical Files, and:
FPA counts External Inputs (EI), External Outputs (EO), External Inquiries (EQ), Internal Logical Files (ILF), and External Interface Files (EIF).
In software effort estimation, what does a Story Point measure in Agile frameworks?
Story Points measure relative effort, complexity, and risk rather than absolute time.
The rate at which an Agile development team converts User Stories into completed working software per Sprint is called:
Velocity tracks the average number of story points completed per iteration to predict future release schedules.
The mythical law in software engineering stating that ‘adding manpower to a late software project makes it later’ is known as:
Coined by Fred Brooks in 'The Mythical Man-Month', Brooks' Law accounts for communication overhead when adding personnel to delayed projects.
Conway’s Law states that organizations design software systems that mirror:
Melvin Conway observed that system architecture inevitably reflects the social communication topology of the organization.
In Object-Oriented Software Engineering, hiding internal state details of an object and restricting direct access via getter/setter methods is:
Encapsulation bundles data and operating methods together, shielding internal attributes from unauthorized direct access.
The ability of different objects to respond to the same message or method call in their own unique manner is known as:
Polymorphism ('many forms') allows uniform treatment of objects via dynamic method dispatch at runtime.
In object-oriented modeling, a relationship representing a ‘has-a’ whole-part connection where child components CAN exist independently of the whole container is:
Aggregation represents a weak whole-part relationship where child entities survive container destruction.
A strong whole-part ownership relationship where child objects CANNOT exist independently of their parent container (e.g., Building and Rooms) is:
Composition is a strong whole-part association; if the container object is destroyed, all child components are also destroyed.
In Requirements Engineering, the process of resolving conflicting requirements between different stakeholders is known as:
Requirement Negotiation mediates trade-offs and resolves conflicts among opposing stakeholder priorities.
Which document serves as the formal contractual agreement between software developers and customers detailing system functionality?
The SRS document formally details all functional and non-functional requirements governing system acceptance.
According to IEEE standards, an ideal Software Requirement Specification (SRS) document must be:
IEEE standards mandate that an SRS must possess clarity, completeness, verifiability, traceability, and consistency.
The phenomenon where software requirements continuously expand during development beyond original scope limits is termed:
Scope Creep occurs when unchecked changes or additions are added to project scope without adjusting time, budget, or resources.
In Software Maintenance, Lehman’s Laws of Software Evolution state that continuous change causes software structure to deteriorate unless work is done to maintain it. This is the law of:
Lehman's Law of Increasing Complexity dictates that as software evolves, its complexity increases unless actively restructured.
Technique used to assess the specific software components that will be affected by a proposed requirement change is:
Impact Analysis evaluates potential consequences, side-effects, and component dependencies before applying code modifications.
The software quality metric calculated as the total number of confirmed defects divided by the size of the software module (e.g., defects per KLOC) is:
Defect Density measures software quality normalized by code size (e.g., defects / 1000 Lines of Code).
The mean average operating time between consecutive system failures in a repairable software system is measured by:
MTBF calculates operational uptime reliability between repair cycles (MTBF = MTTF + MTTR).
The average time required to troubleshoot, fix, and restore a failed software system back into operational status is:
MTTR measures maintenance efficiency and downtime recovery speed.
Software System Availability is mathematically defined using MTBF and MTTR as:
Availability measures operational readiness as the ratio of operational uptime to total time (MTBF / (MTBF + MTTR)).
Which software development lifecycle model is best suited for projects with high uncertainty, changing requirements, and complex risk management needs?
The Spiral Model, created by Barry Boehm, combines iterative development with systematic risk analysis at each phase.
In Agile software development, what is the recommended duration for a standard Sprint iteration?
Agile Sprints are time-boxed iterations usually lasting between 1 to 4 weeks to deliver working increments.
Which SDLC model strictly links each development phase with a corresponding testing phase in a parallel ‘V’ structure?
The V-Model maps each phase of system development (e.g., Requirements, Design) directly to a corresponding test stage (e.g., Acceptance, Unit Testing).
In Scrum, who is primarily responsible for defining User Stories and managing the Product Backlog prioritization?
The Product Owner represents the customer/stakeholders and manages the Product Backlog items and priorities.
Which Software Engineering process model is characterized by incremental prototyping followed by strict evolutionary refinement?
Evolutionary models develop initial implementations, expose them to user feedback, and refine them through multiple versions.
The Extreme Programming (XP) practice where two developers work together at a single workstation is known as:
Pair Programming involves a 'Driver' writing code while a 'Navigator' reviews each line as it is typed.
In Scrum framework, a short 15-minute daily synchronization meeting for the development team is called:
The Daily Stand-up keeps team members aligned on progress, daily goals, and immediate blockers.
Which architectural software engineering model relies on continuous integration and frequent releases, emphasizing simplicity and feedback?
XP focuses on small, frequent releases, relentless refactoring, and continuous integration.
In software process assessment, CMMI stands for:
CMMI is a process and behavioral model that helps organizations streamline process improvement and encourage productive behaviors.
Which maturity level in the CMMI staged representation is characterized by processes that are quantitatively measured and controlled?
At CMMI Level 4, process performance metrics are collected and quantitatively managed using statistical techniques.
The dynamic prototyping approach where a prototype is quickly built to clarify requirements and then discarded is called:
Throwaway prototyping focuses on resolving ambiguous requirements before constructing the final system.
Which Agile tool or visual board is used to track work in progress (WIP) and optimize workflow efficiency?
Kanban boards visualize tasks across workflow stages and explicitly limit Work-In-Progress (WIP) to prevent bottlenecks.
Requirements that define specific system behaviors, inputs, outputs, and functional reactions to inputs are classified as:
Functional requirements specify what the system must do, such as processing transactions or generating reports.
Requirements specifying system attributes such as security, scalability, performance, reliability, and maintainability are:
Non-Functional Requirements (NFRs) define quality attributes and performance parameters of the overall system.
In Software Design Patterns (GoF), which design pattern restricts the instantiation of a class to one single instance and provides global access to it?
The Singleton design pattern ensures that only one instance of a class exists in memory throughout application execution.
Which Gang of Four (GoF) design pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified automatically?
The Observer pattern is a behavioral pattern commonly used in event-driven systems and GUI frameworks.
The Gang of Four design pattern that allows incompatible interfaces to collaborate by converting the interface of a class into another expected interface is the:
The Adapter pattern acts as a wrapper between two objects with incompatible interfaces.
Which structural design pattern provides a unified, simplified interface to a complex set of interfaces in a subsystem?
The Facade pattern shields clients from system complexity by providing a high-level simplified interface.
Which creational pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes?
Abstract Factory defines an interface for creating families of related objects without binding to concrete classes.
Which behavioral design pattern encapsulates a request as an object, thereby letting you parameterize clients with queues, requests, and operations?
The Command pattern decouples the sender of a request from its receiver by encapsulating the action inside an object.
In Unified Modeling Language (UML), which diagram models the static structure of a system including classes, attributes, operations, and relationships?
Class diagrams represent the static structural layout of an object-oriented software system.
Which UML diagram emphasizes the time ordering of messages exchanged between objects during interaction?
Sequence diagrams illustrate object interactions arranged in chronological time order.
Which UML diagram models the physical runtime configuration of a system, showing hardware nodes and the software artifacts deployed on them?
A deployment diagram is a structural UML diagram showing nodes (servers, devices) and the artifacts deployed on them, with their communication paths.
Component diagrams show software components and their interfaces, package diagrams group model elements, and object diagrams show instances at a point in time.
The software architectural pattern that separates application logic into three interconnected components—Data, User Interface, and Control Logic—is:
MVC decouples data presentation (View) and data storage (Model) using an intermediate Controller.
Software testing technique where internal logical structure, code paths, and implementation details are fully known to the tester is called:
White-box testing focuses on code coverage, control paths, branches, and internal logic verification.
Software testing conducted without any knowledge of internal code structure, focusing purely on inputs and expected outputs, is called:
Black-box testing evaluates system behavior against specification requirements without examining code implementation.
Testing individual software components or modules in isolation from the rest of the system is called:
Unit testing verifies the correct behavior of small, isolated units of source code (e.g., functions, methods).
Re-running functional and non-functional tests to ensure that recent code modifications or bug fixes have not adversely affected existing features is called:
Regression testing prevents unwanted side effects and verifies that legacy functionality remains intact after changes.
The preliminary build-verification testing performed to verify that the core critical functionalities of a software build operate correctly before deep testing is:
Smoke testing (Build Verification Testing) validates whether the overall build is stable enough for rigorous testing.
Software testing executed to evaluate system performance and stability under extreme operational loads beyond normal limits is:
Stress testing pushes systems past specified capacity limits to assess failure modes and graceful degradation.
Black-box testing technique that divides input domain data into equivalent groups from which test cases are derived is called:
Equivalence Partitioning assumes that test cases within a valid or invalid partition will produce identical software behavior.
Testing strategy that focuses specifically on testing input values at the extreme lower and upper edges of input partitions is:
BVA complements equivalence partitioning by testing boundary conditions where defects frequently occur.
In Software Maintenance, modifying software to fix discovered bugs and operational defects is classified as:
Corrective maintenance rectifies faults, errors, or defects detected during active system operation.
Modifying a software system to keep it operational in a changed or evolving environment (e.g., new operating system or DBMS) is:
Adaptive maintenance updates software to adapt to environmental, platform, or external API modifications.
Modifying software to enhance system performance, maintainability, or add new user features is termed:
Perfective maintenance improves software quality, execution performance, and user-requested feature extensions.
Modifying software to detect and correct latent faults before they manifest as operational failures in the future is:
Preventive maintenance (such as re-engineering or refactoring) mitigates future software degradation risks.
In Software Engineering, Cyclomatic Complexity measures:
Developed by Thomas McCabe, Cyclomatic Complexity measures control flow paths using graph theory formula V(G) = E - N + 2P.
If a software control flow graph has 10 edges (E) and 7 nodes (N) with 1 connected component (P=1), its Cyclomatic Complexity V(G) is:
Using McCabe's formula V(G) = E - N + 2P = 10 - 7 + 2(1) = 5.
Degree to which a software component or module performs a single, tightly-focused purpose is termed:
High Cohesion inside a module implies that its elements are strongly related and focused on a single function.
Degree of interdependence and direct connection between different software modules is termed:
Software design strives for Low Coupling to reduce dependencies and ensure modularity.
Which type of cohesion is considered the strongest and most desirable in software design?
Functional Cohesion occurs when all elements of a module contribute to executing one single, well-defined task.
Which software estimation technique decomposes a system into Function Points based on inputs, outputs, inquiries, files, and interfaces?
Function Point Analysis, developed by Allan Albrecht, measures software size independently of programming language.
In the Constructive Cost Model (COCOMO), software projects with small team size and well-understood requirements are classified as:
COCOMO Organic mode applies to small software teams working with familiar constraints.
Software development projects operating within tight hardware constraints and strict operational regulation fall under COCOMO’s:
Embedded mode software projects face complex hardware, software, and regulatory restrictions.
In Risk Management, the process of prioritizing risks based on their probability of occurrence and potential impact is:
Risk Analysis ranks identified risks according to probability and impact scores to plan response strategies.
Re-organizing and internal refactoring of existing software source code without changing its external behavior is known as:
Refactoring cleans up code structure, improves readability, and reduces technical debt without altering functional output.
The process of analyzing a software system to identify its components and interrelationships, creating abstractions at higher levels, is:
Reverse engineering analyzes existing system artifacts to extract design details and architectural documentation.
In Software Architecture, a pipe-and-filter architectural pattern is best suited for:
Pipe-and-Filter architecture processes continuous streams of data through independent filter transformations.
In Clean Architecture and SOLID principles, the ‘S’ in SOLID stands for:
Single Responsibility Principle dictates that a class or module should have one, and only one, reason to change.
Which software engineering process model emphasizes zero-defect software development through formal mathematical verification and statistical quality assurance?
Cleanroom Software Engineering, pioneered by Harlan Mills, uses formal specification, correctness verification, and statistical testing to achieve near zero-defect software.
In Cleanroom Software Engineering, traditional unit testing by developers is replaced by:
Cleanroom avoids program execution/unit testing by developers, relying instead on mathematical proofs of correctness and code verification before statistical testing.
Which software development model focuses on assembling pre-built, reusable software components rather than custom coding from scratch?
CBSE emphasizes software reuse by composing applications using standardized off-the-shelf software components.
The software process framework designed by Rational Software Corporation that operates in four sequential phases (Inception, Elaboration, Construction, Transition) is:
RUP is an iterative process framework structured across four lifecycle phases: Inception, Elaboration, Construction, and Transition.
In Rational Unified Process (RUP), during which phase are system requirements clarified and core architectural baselines established?
The Elaboration phase in RUP focuses on analyzing problem domain requirements and designing a stable architectural baseline.
In Rational Unified Process (RUP), which phase delivers the final software product to end-users in their operational production environment?
The Transition phase transfers the software system from development to actual customer production deployment.
Which capability level in the CMMI Continuous Representation indicates that a process is standardized, documented, and integrated into organizational processes?
In CMMI Continuous Representation, Level 3 (Defined) means processes are well documented, standardized, and integrated across the enterprise.
In CMMI, the highest maturity level (Level 5) characterized by continuous process improvement through innovative technological and process enhancements is:
Level 5 (Optimizing) focuses on continuously refining process performance through innovative engineering and technology improvements.
The Software Engineering Institute (SEI) Capability Maturity Model (CMM) defines how many key maturity levels?
CMM/CMMI defines 5 maturity levels: Initial, Managed, Defined, Quantitatively Managed, and Optimizing.
Which software engineering methodology uses ‘Timeboxing’ to strictly limit the time allocated to complete a project iteration or task?
DSDM is an Agile framework that mandates strict Timeboxing to guarantee on-time delivery of core features.
In Agile software development, a user story estimate written in relative terms using modified Fibonacci numbers (1, 2, 3, 5, 8, 13, 21) is used in:
Planning Poker uses a modified Fibonacci sequence for consensus-based relative effort estimation.
In Software Process Improvement, the ISO/IEC standard that provides a framework for software process assessment (also known as SPICE) is:
ISO/IEC 15504 (SPICE) defines standard international criteria for assessing software software development processes.
Which creational design pattern provides a mechanism to create objects by cloning or copying an existing instance rather than instantiating via new operator?
The Prototype pattern creates new objects by copying an existing prototype instance, avoiding expensive creation steps.
Which creational design pattern separates the construction of a complex object from its representation, allowing the same process to create different representations?
The Builder pattern constructs complex objects step-by-step using a Director and Builder interface.
Which structural design pattern dynamically attaches additional responsibilities and behavior to an object without modifying its original source code?
The Decorator pattern wraps an object to dynamically extend its functionality at runtime without inheritance.
Which structural design pattern provides a surrogate or placeholder for another object to control access, delay instantiation, or provide logging?
The Proxy pattern acts as an intermediary or surrogate to control or restrict access to the underlying real object.
Which structural design pattern uses sharing to support large numbers of fine-grained objects efficiently by sharing common intrinsic state?
The Flyweight pattern minimizes memory usage by sharing common data across multiple similar objects.
Which structural design pattern composes objects into tree structures to represent part-whole hierarchies, allowing clients to treat individual objects and compositions uniformly?
The Composite pattern lets clients treat individual objects and groups of objects in a tree structure identically.
Which behavioral design pattern defines an algorithm’s skeleton in a base class, allowing subclasses to override specific steps without changing the overall structure?
Template Method sets up an algorithm framework in a method, delegating step implementations to subclasses.
Which behavioral design pattern enables selecting an algorithm’s implementation dynamically at runtime from a family of interchangeable algorithms?
The Strategy pattern encapsulates alternative algorithms inside separate classes and makes them interchangeable at runtime.
Which behavioral design pattern allows an object to alter its behavior when its internal state changes, appearing as if its class changed?
The State pattern encapsulates state-specific behaviors in distinct classes and delegates calls to the active state object.
Which behavioral design pattern encapsulates how a set of objects interact, preventing explicit direct references and promoting loose coupling through a central coordinator?
The Mediator pattern centralizes complex communications between collating objects to prevent direct tight coupling.
Which behavioral pattern provides a way to capture and restore an object’s internal state without violating encapsulation (enabling Undo mechanisms)?
The Memento pattern captures an object's internal state so it can be restored later without exposing its private fields.
An architecture made up of small, independently deployable services that communicate through lightweight APIs such as REST over HTTP is known as:
Microservices Architecture structures an application as a collection of loosely coupled, independently deployable services.
Which testing technique automatically feeds large volumes of invalid, malformed or random data into a program’s inputs to find crashes and security vulnerabilities?
Fuzz testing (fuzzing) automatically sends invalid, unexpected or random inputs to a program to expose crashes, memory leaks and security flaws.
Mutation testing changes the program code to check how good the tests are, smoke testing is a quick check that a build's main functions work, and regression testing re-runs tests after changes.
A fault-based software testing technique where small intentional errors (mutants) are introduced into the source code to evaluate test suite quality is:
Mutation testing tests the effectiveness of a test suite by modifying code and checking if existing tests detect (kill) the mutants.
A white-box testing metric that checks whether every boolean sub-expression in a logical decision has been evaluated independently as True and False is:
Condition Coverage verifies that each individual boolean condition in a decision statement evaluates to both true and false.
The advanced code coverage metric mandated for critical safety-avionics systems (DO-178C) requiring every condition in a decision to independently affect the outcome is:
MC/DC ensures that every condition inside a decision is tested to independently affect the decision's overall output.
System testing focused on evaluating how effectively a software system recovers from intentional hardware or software crashes is:
Recovery testing forces system failures to verify that recovery algorithms execute correctly and maintain data integrity.
Testing performed to measure system response times, throughput, and resource utilization under normal expected operational workload is:
Load testing validates system performance characteristics under anticipated normal and peak user concurrency loads.
Performance testing that subjects a system to a high operational workload over an extended continuous period to detect memory leaks is:
Soak testing monitors system performance over long durations to uncover memory leaks, resource depletion, or performance degradation.
Testing conducted to check software performance when subjected to sudden, massive surges in traffic volume is called:
Spike testing checks system stability during sudden dramatic increases and decreases in transaction traffic.
In Software Testing, testing a system with large volumes of database data to evaluate performance under big data conditions is:
Volume testing subjects software to huge volumes of data in database records or file transfers to identify storage bottlenecks.
The percentage of test cases in a test suite that executed successfully without detecting failures is called:
Test Pass Rate measures the percentage of executed test cases that passed against total tests executed.
Defect Removal Efficiency (DRE) is calculated as DRE = E / (E + D), where E is defects found before release and D is:
DRE calculates the percentage of total defects caught by QA internal testing prior to production release.
A system that remains operational continuously even during hardware component failures is said to possess high:
Fault tolerance allows a system to continue operating properly in the event of component failure.
The process of maintaining track of requirements from their origin through analysis, design, coding, and testing is known as:
Requirement Traceability links requirements across artifacts using a Requirements Traceability Matrix (RTM).
A matrix used to map customer requirements to corresponding design modules and test cases is called a:
RTM verifies that all requirements are tracked and validated by corresponding test cases.
In Software Configuration Management (SCM), a baseline is defined as:
A baseline serves as an officially agreed landmark configuration item subject to formal change control.
In Version Control Systems (VCS), creating an isolated parallel line of development to work on new features without affecting main code is:
Branching creates an isolated development path for feature additions or experimental fixes.
Combining code modifications from an isolated feature branch back into the main baseline branch is called:
Merging integrates independent commits from one branch back into another targeted development branch.
In SCM, the formal group of stakeholders responsible for reviewing, evaluating, approving, or rejecting proposed software changes is the:
The CCB reviews change requests to analyze project impact, cost, and necessity before approving implementations.
In software cost estimation, the Basic COCOMO model calculates effort (E) in person-months using the formula E = a × (KLOC)^b. What does KLOC stand for?
KLOC measures source code volume in thousands of lines of code.
In Intermediate COCOMO (COCOMO 81), the nominal effort is adjusted by multiplying it by fifteen factors called:
Intermediate COCOMO adjusts the nominal effort using 15 cost drivers (effort multipliers), grouped into product, computer (hardware), personnel and project attributes, such as required reliability, analyst capability and use of software tools.
COCOMO II's Post-Architecture model uses 17 effort multipliers plus 5 scale factors.
Which software engineering technique involves transforming an existing system’s implementation into a new higher-quality form without changing system functionality?
Software Re-engineering involves reverse engineering, code restructuring, and forward engineering to modernize legacy software.
In Software Project Risk Analysis, Risk Exposure (RE) is calculated as:
Risk Exposure measures overall potential loss by multiplying occurrence probability by financial/operational impact.
If a software risk has a probability of occurrence P = 0.20 and a financial impact I = $50,000, its Risk Exposure (RE) is:
Using the formula RE = P × I = 0.20 × $50,000 = $10,000.
Which software development model integrates automated code building, continuous testing, and immediate deployment into production pipelines?
DevOps establishes Continuous Integration and Continuous Deployment (CI/CD) pipelines to automate building, testing, and deployment.
In Model-View-Presenter (MVP) architecture, what role does the Presenter play compared to the Controller in MVC?
In MVP, the Presenter retrieves data from the model and formats it for the View, keeping the View entirely passive.
Which architectural pattern uses independent processing units (filters) connected by data transmission channels (pipes) where output of one filter flows into the next?
Pipe and Filter architecture processes data streams sequentially through discrete, independent transformation filters.
Which architectural style uses a central data repository surrounded by independent specialized worker components (agents) that solve complex AI or signal problems cooperatively?
Blackboard architecture allows heterogenous specialized knowledge sources to iteratively update a central shared blackboard state.
Which architectural style consists of a minimal core application system with feature extensions added dynamically through plug-in modules?
Microkernel architecture provides a minimal core system along with standalone plugin modules to supply extended capabilities.
In Object-Relational Mapping (ORM), which pattern maps a database table record directly to an object instance where object methods mirror column fields?
Active Record encapsulates both table database access and business logic directly inside a single domain object.
Which ORM design pattern keeps domain objects completely independent of database access logic by using a separate mapper object to transfer data?
Data Mapper separates domain business objects from persistence logic, promoting clean separation of concerns.
Which enterprise pattern maintains a list of database operations affected by a business transaction and coordinates writing out changes in a single unified operation?
Unit of Work tracks everything done during a transaction that affects the database and coordinates the resolution of changes.
Which pattern mediates between domain logic and data mapping layers using a collection-like interface for accessing domain objects?
Repository pattern acts as an in-memory domain object collection, insulating application logic from data persistence details.
In distributed software engineering, Remote Procedure Call (RPC) client-side stub proxies perform marshaling, which means:
Marshaling converts complex in-memory data structures into a standard byte stream for cross-network transmission.
The process of converting a transmitted network byte stream back into in-memory object structures on the remote server is termed:
Unmarshaling converts serialized wire data formats back into runtime programming language object representations.
In object-oriented distributed systems, what middleware standard allows heterogeneous objects written in different languages to communicate across network boundaries?
CORBA is an Object Management Group (OMG) standard enabling multi-language distributed object communication.
In Mutation Testing, a mutant program is classified as ‘Killed’ when:
A mutant is 'killed' when test cases detect the seeded defect, proving the test suite's diagnostic power.
In Mutation Testing, a mutant program that produces functionally identical output to the original program for all possible inputs is a:
Equivalent mutants cannot be killed by any test case because their behavior is semantically identical to original code.
The ratio of killed mutants to total non-equivalent mutants generated during Mutation Testing is called:
Mutation Score measures the quality of a test suite ($ ext{Mutation Score} = rac{ ext{Killed Mutants}}{ ext{Total Mutants} - ext{Equivalent Mutants}}$).
Testing technique where software execution is conducted by generating inputs based on formal state transition models is:
State Transition testing validates system behaviors as it transitions between discrete finite states upon input events.
Black-box testing technique that uses a tabular grid to represent complex business logic rules and their corresponding system actions is:
Decision Tables systematically detail combinations of input conditions and resulting output actions.
If an integer input field accepts values between 10 and 100 inclusive, the critical boundary values for Boundary Value Analysis (BVA) are:
Two-value BVA tests the exact boundary values and their immediate outer neighbors (10-1=9, 10, 100, 100+1=101).
Software static code analysis metric that counts the total number of decision statements (D) in a function to compute Cyclomatic Complexity using V(G) = D + 1 is:
McCabe's formula calculates complexity based on decision predicates (V(G) = D + 1 or E - N + 2P).
In Halstead’s Software Science, program length (N) is calculated using total operators (N₁) and total operands (N₂) as:
Halstead defines total program length as the simple sum of total operator count N₁ and operand count N₂.
In Chidamber & Kemerer (C&K) Object-Oriented metrics, Weighted Methods per Class (WMC) measures:
WMC calculates class complexity by summing the individual complexity metrics of all methods contained in that class.
In C&K OO metrics, Depth of Inheritance Tree (DIT) measures:
DIT measures inheritance depth; deeper trees indicate higher design complexity and potential reuse challenges.
In PERT project estimation, the expected activity duration (Te) is calculated using Optimistic (a), Most Likely (m), and Pessimistic (b) estimates as:
PERT uses a weighted beta distribution formula Te = (a + 4m + b) / 6 to calculate expected task duration.
In PERT scheduling, the variance (σ²) of a task duration estimate is mathematically given by:
PERT standard deviation is σ = (b - a) / 6, so variance is σ² = ((b - a) / 6)².
If a software task has optimistic estimate a = 4 days, most likely m = 7 days, and pessimistic b = 16 days, its PERT expected duration Te is:
Using formula Te = (4 + 4(7) + 16) / 6 = (4 + 28 + 16) / 6 = 48 / 6 = 8 days.
The systematic technique used to analyze failure modes, their immediate effects on system operation, and criticality ranking is:
FMEA systematically identifies potential failure modes within individual components and evaluates their severity.
A top-down deductive safety analysis technique that uses boolean logic diagrams (AND/OR gates) to trace system failure causes to root events is:
FTA works backwards from an undesirable top-level system failure event down to basic cause events using boolean logic.
In safety-critical software engineering, Hazard Analysis focuses primarily on identifying conditions that could lead to:
Hazard Analysis identifies physical hazards and failure conditions that threaten safety or cause catastrophic loss.
The international functional safety standard governing safety-critical electrical/electronic/programmable software systems across industries is:
IEC 61508 is the umbrella international standard for functional safety of programmable electronic safety systems.
In Agile project management, what chart plots project scope backlog growth alongside sprint completion progress to predict release dates?
A Burnup chart tracks total scope changes alongside work completed, making scope expansion clearly visible.
The total time elapsed from the moment a user request or requirement is submitted until it is fully delivered into production is:
Lead Time encompasses the full end-to-end duration from request initiation to final release delivery.
The duration of time required by a software development team to actively work on and complete a task once development actually begins is:
Cycle Time measures active work duration from start of coding execution to completion.
In Agile Kanban frameworks, setting a Work In Progress (WIP) limit on workflow columns prevents:
WIP limits restrict active work items to maintain smooth throughput and expose workflow bottlenecks.
A software development estimation model that combines historical project data, statistical regression, and mathematical modeling (like COCOMO) is a:
Parametric estimation relies on statistical algorithms and historical metrics to estimate cost and effort.
In Requirements Engineering, non-functional requirements specifying performance, response time, and throughput are classified as:
Non-functional performance parameters define quality attributes such as efficiency and response speed.
Non-functional requirements governing compliance with laws, privacy regulations (e.g. GDPR), and safety rules are classified as:
Regulatory requirements enforce compliance with legal mandates, industry standards, and privacy laws.
A prototyping approach where software begins as a simple core model and is iteratively refined until it becomes the final production system is:
Evolutionary prototyping continuously refines a working baseline system into the final software product.
In Requirements Validation, verifying that software requirements do not contradict each other across different documentation sections is checking for:
Consistency checks ensure that no two requirement statements express conflicting capabilities or constraints.
Verification checking that an SRS contains all necessary functional descriptions required by the customer is checking for:
Completeness guarantees that all user needs, constraints, and system responses are fully specified.
According to Lientz and Swanson, which category accounts for the largest proportion (over 50%) of total software maintenance effort?
Lientz & Swanson's studies showed perfective maintenance (enhancing user features and performance) comprises >50% of maintenance effort.
The software maintenance metric representing the percentage of software changes that introduce new defects into the system is the:
Change Error Rate evaluates how frequently modification activities inject fresh bugs into existing functionality.
In software architecture, the principle that modules should exhibit high cohesion internally while maintaining low coupling externally is:
High cohesion inside modules combined with loose coupling between modules is the foundational cornerstone of robust software architecture.
The Law of Demeter (Principle of Least Knowledge) states that an object’s method should only invoke methods of:
The Law of Demeter restricts method call chains to immediate neighbors to prevent tight structural coupling.
In Domain-Driven Design (DDD), an entity that acts as the root gatekeeper for a cluster of associated domain objects to enforce consistency boundaries is an:
In DDD, an Aggregate Root guarantees consistency of changes within an aggregate boundary by treating internal elements as a unit.
In Domain-Driven Design (DDD), an object defined solely by its attribute values rather than a unique identity is a:
Value Objects (e.g. Money, Address) have no identity; two Value Objects are considered equal if all their attributes match.
An architectural pattern that segregates the read data model from the write data model to optimize performance and scalability is:
CQRS separates mutative operations (Commands) from read-only retrieval operations (Queries) into distinct domain models.
An architectural pattern that captures all changes to an application state as a chronological sequence of immutable events is:
Event Sourcing persists state changes as an append-only log of events, enabling complete state replaying and historical auditing.
In microservices architecture, what resiliency pattern prevents cascade failures by wrapping remote calls and immediately returning a fallback if error thresholds are exceeded?
The Circuit Breaker pattern detects remote service faults and short-circuits requests to prevent network thread starvation across dependent services.
Which microservices pattern isolates elements into pools so that if one component fails, the remaining components continue operating without system-wide crash?
Named after ship compartments, the Bulkhead pattern partitions service resources (e.g., thread pools) to isolate failures.
An architectural migration pattern that incrementally replaces legacy monolithic system features with new microservices until the monolith is phased out is:
The Strangler Fig pattern gradually replaces legacy monolithic components with microservices until the old system can be retired.
In microservices architecture, managing distributed transactions across multiple independent service databases without global two-phase commit relies on the:
The Saga pattern manages distributed transactions across microservices using a sequence of local transactions and compensating actions.
Which deployment pattern deploys a secondary helper component alongside a primary application container to share logging, proxy, or monitoring services?
The Sidecar pattern attaches co-located supporting tasks (e.g. logging, proxying) alongside the main container process.
In cloud-native applications, Twelve-Factor App methodology recommends storing all application configuration settings in:
Twelve-Factor App guidelines state configuration options must be stored in environment variables to remain distinct across dev, staging, and prod.
In RESTful API design, the concept where server responses include dynamic hypermedia links informing clients of next available state transitions is known as:
HATEOAS allows clients to dynamically navigate REST API resources via hypermedia links embedded in JSON/XML responses.
A grey-box software testing technique that combines static analysis with dynamic execution by executing code with symbolic input variables is:
Symbolic Execution evaluates software execution paths using symbolic input expressions rather than concrete data values.
A formal verification technique that exhaustively checks whether a finite-state model of a system satisfies a given temporal logic property is:
Model Checking uses automated mathematical verification algorithms to systematically check system states against formal properties.
In formal specifications, Linear Temporal Logic (LTL) and Computation Tree Logic (CTL) are mathematical frameworks used to model:
LTL and CTL are temporal logics used to specify safety, liveness, and correctness properties of dynamic reactive systems over time.
In formal software specification, a ‘Liveness Property’ mathematically states that:
Liveness properties guarantee that desired conditions (e.g. task completion, deadlock freedom) will eventually be fulfilled.
In formal software specification, a ‘Safety Property’ mathematically states that:
Safety properties guarantee that unwanted or unsafe states (e.g. system deadlock, illegal memory access) will never occur.
A white-box software testing technique that measures execution of all independent paths through a control flow graph is:
Basis path testing uses McCabe's cyclomatic complexity V(G) to define a basis set of linearly independent paths through the control flow graph.
Executing these V(G) paths ensures that every statement and every branch runs at least once, although it does not cover every possible combination of paths.
In Control Flow Graph (CFG) analysis, a node with two or more outgoing edges is called a:
Predicate nodes contain conditional logic statements causing execution paths to split into multiple branches.
In testing automation, test double objects that store pre-configured canned answers to calls made during test execution are called:
Stubs provide canned responses to method calls made during a test, without verifying execution behavior.
In testing automation, test double objects that record calls they receive and verify expected method invocations are called:
Mocks are configured with expectations to inspect and verify behavior and interactions during unit test execution.
In testing automation, test double objects that possess working business logic implementations but take shortcuts (e.g. in-memory database) are called:
Fakes have functional implementations suitable for testing (e.g., lightweight in-memory storage) but are unsuited for production.
Software static analysis tool warning where the tool reports a flaw or vulnerability in code that does NOT actually exist in reality is a:
A False Positive occurs when an automated tool flags clean code as erroneous or vulnerable.
Software static analysis result where the analysis tool FAILS to detect an actual bug or security flaw that exists in code is a:
A False Negative represents a missed defect that static analysis failed to identify.
In Scrum, a timeboxed iteration where a development team produces a potentially releasable product increment is called a:
A Sprint is a core timeboxed unit of development in Scrum, typically lasting between 1 to 4 weeks.
In Scrum, the artifact that represents an ordered list of everything that is known to be needed in the software product is the:
The Product Backlog is an evolving, prioritized inventory of user requirements, enhancements, and fixes.
In Scrum, the meeting held at the end of a Sprint where the team inspects its own performance and identifies process improvements is the:
The Sprint Retrospective focuses on team process continuous improvement, analyzing what went well and what can be improved.
In Scrum, the event where the Scrum Team and stakeholders inspect the working product increment delivered during the Sprint is the:
The Sprint Review demonstrates working software to stakeholders and collects feedback to refine the Product Backlog.
In Extreme Programming (XP), the principle stating that any team member can modify any part of the project codebase at any time is:
Collective Code Ownership empowers developers to fix bugs or enhance code anywhere in the system without permission silos.
In Agile project planning, a large user story that is too complex to be completed within a single Sprint and must be broken down is an:
An Epic is a body of work that can be broken down into smaller specific user stories based on customer feedback.
In Agile development, a timeboxed research or prototyping task undertaken to investigate an unknown technical solution or estimate effort is a:
A Spike is a brief research activity designed to eliminate technical uncertainty before estimating feature user stories.
The deployment strategy where two identical production environments exist, with one live receiving traffic and the other updated with new software, is:
Blue-Green deployment reduces downtime and risk by running two identical environments and toggling router traffic.
A deployment strategy where new software features are gradually released to a small percentage of production users before full rollout is:
Canary Deployment tests new releases on a small live user subset to detect production errors before full deployment.
In Function Point Analysis (FPA), Function Points (FP) are calculated using Unadjusted Function Points (UFP) and Value Adjustment Factor (VAF) as:
Function Point Analysis multiplies Unadjusted Function Points by the Value Adjustment Factor (FP = UFP × VAF).
In Function Point Analysis (FPA), the Value Adjustment Factor (VAF) is calculated from 14 General System Characteristics (GSC) using:
The standard FPA formula scales VAF between 0.65 and 1.35 using VAF = 0.65 + 0.01 × ΣGSC.
In Function Point Analysis, files generated, owned, and maintained entirely within the boundaries of the application being measured are:
ILFs are logical groups of user-data maintained within the software system application boundary.
In Function Point Analysis, user-data files referenced by the application but maintained and updated by an external application are:
EIFs are read-only referenced data sources maintained inside an external application boundary.
In Software Maintenance, Lehman’s Law of Continuing Change states that a software application used in a real-world environment must:
Lehman's 1st Law states that systems must undergo continual change to stay useful in operational environments.
In Object-Oriented metrics, the Lack of Cohesion in Methods (LCOM) metric measures:
High LCOM indicates low cohesion (methods do not share instance variables), suggesting the class should be split.
In Object-Oriented metrics, Coupling Between Object Classes (CBO) measures:
CBO counts non-inherited class references; high CBO indicates tight coupling and reduced maintainability.
In Software Cost Estimation, COCOMO II replaces KLOC with which alternative early-stage size metric when source code is not yet written?
COCOMO II uses Function Points or Object Points for early sizing before line-of-code metrics are available.
The Software Configuration Management process of creating a record of changes, release notes, and build manifests for audit compliance is:
Status Accounting and Configuration Audits document change histories, baselines, and release compliance.