FC0-U71 Applications and Software Practice Question
A software engineer is debugging a program and needs to identify potential issues. Which THREE tools or techniques are commonly used in debugging? (Select THREE.)
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Log files
Log files (B) are correct because they record runtime events, errors, and warnings that help engineers trace the sequence of actions leading to a defect. Breakpoints (C) are correct because they let a debugger pause program execution at a specific line or condition, allowing the engineer to inspect variables, call stack, and memory state at that moment. Step-through execution (E) is correct because it lets the engineer execute code line by line (step over, step into, step out) to observe how state changes and pinpoint where behavior diverges from expectations. A compiler (A) only translates source code into machine code or bytecode and reports syntax/type errors, but it does not provide runtime debugging capabilities. A source code editor (D) is merely a tool for writing and editing code and, while often integrated with debuggers, is not itself a debugging technique.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Compiler
Why it's wrong here
A compiler translates source code into machine code and reports syntax errors, but it does not let the engineer inspect runtime state or step through execution. It is tempting because it flags mistakes at build time, and would be correct for catching type and syntax faults before the program runs.
- ✓
Log files
Why this is correct
Log files record runtime events, errors and stack traces, giving the engineer historical evidence of what the program actually did before failing. This satisfies the debugging need to identify potential issues without halting execution, complementing interactive tools that inspect live state.
- ✓
Breakpoints
Why this is correct
Breakpoints pause program execution at a chosen line, letting the engineer inspect variables, call stack and memory at that exact moment. This satisfies the debugging need to isolate where behaviour diverges from expectation, rather than inferring it from output alone.
- ✗
Source code editor
Why it's wrong here
A source code editor only lets you read and modify text; it executes nothing and exposes no runtime state, so it cannot reveal the actual defect. It is tempting because editing is where fixes are typed, and it would be the right tool for writing or refactoring code before any debugging session begins.
- ✓
Step-through execution
Why this is correct
Step-through execution runs code one statement or line at a time, letting the engineer observe state changes and control flow sequentially. This satisfies the debugging need to pinpoint the precise instruction where incorrect behaviour originates, which static reading of source cannot reliably reveal.
Go deeper
Related to this question
About these practice questions
Courseiva writes every FC0-U71 question from scratch — 988 in total, each with an explanation and a wrong-answer breakdown. None are copied from real exams or dumps. Learn why practice questions differ from exam dumps →
Same concept, more angles
2 more ways this is tested on FC0-U71
These questions test the same concept from different angles. Work through them to make sure you can recognise it however the exam phrases it.
Variation 1. During debugging, a developer sets a breakpoint and steps through the code line by line. Which debugging tool feature is being used to execute one line of code at a time?
hard- ✓ A.Step execution
- B.Breakpoint
- C.Variable inspection
- D.Logging
Why A: Step execution (or stepping) is the debugging feature that executes one line of code at a time, allowing the developer to observe the program's state after each statement. This is typically done using 'Step Over', 'Step Into', or 'Step Out' commands in a debugger. The question describes exactly this line-by-line execution, which is step execution.
Variation 2. A developer is debugging a program that unexpectedly crashes. Which TWO tools or techniques are commonly used to identify the cause of the crash? (Select the two correct answers.)
medium- A.Code compilation
- B.Refactoring
- ✓ C.Breakpoints
- ✓ D.Logging
- E.Code review
Why C: Breakpoints (C) are correct because they let a developer pause program execution at a specific line or condition, inspect variables, call stack, and memory state at the moment before the crash, which directly reveals the faulty logic or invalid value causing the failure. Logging (D) is correct because strategically placed log statements (or a logging framework) record runtime events, error messages, and stack traces leading up to the crash, allowing post-mortem analysis of the sequence of operations that triggered it. Code compilation (A) only translates source into executable code and would surface syntax or type errors at build time, not the runtime cause of a crash. Refactoring (B) restructures existing code to improve readability or design without diagnosing the crash, and code review (E) is a static, human inspection of source that may catch defects but does not observe the program's actual runtime behavior during the crash.
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This FC0-U71 practice question is part of Courseiva's free CompTIA certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the FC0-U71 exam.