Advanced
Debugging Language
#profiling
#performance
Profiler Output Vocabulary
6 exercises — read flame graphs and memory profiler output, and describe hotspots, self/total time, and allocation pressure with the correct terminology.
0 / 34 completed
1 / 34
A CPU profiler flame graph shows a wide, flat bar labelled `JSON.parse` taking up 40% of total sample width near the top of the stack. How do you correctly describe this in English to your team?
"Hotspot" is the standard term for a function that consumes a disproportionate share of CPU time. In a flame graph, width represents the proportion of samples (time), and a wide bar near the top of the stack (furthest from `main`) means the time is spent inside that function itself, not its children — this is called "self time" as opposed to "total time."
Key vocabulary: "hotspot" (disproportionate time consumer), "self time" (time in the function itself), "total/cumulative time" (time including children), "wide bar" (proportion of samples), "stack depth" (how deep in the call chain).
Key vocabulary: "hotspot" (disproportionate time consumer), "self time" (time in the function itself), "total/cumulative time" (time including children), "wide bar" (proportion of samples), "stack depth" (how deep in the call chain).
2 / 34
You see a very tall, narrow tower in a flame graph with dozens of stacked frames. What does this shape indicate, and how should you describe it?
In a flame graph, height represents call stack depth, while width represents time/sample count. A tall, narrow tower means deep recursion or nesting that consumes relatively little CPU time — worth noting for code complexity but not necessarily a performance concern.
Vocabulary: "deep call stack" / "deeply nested calls" (height), "narrow" (low time cost despite depth), distinguish this explicitly from a "wide" bar (high time cost). Conflating depth with cost is a common mistake when reading flame graphs for the first time.
Vocabulary: "deep call stack" / "deeply nested calls" (height), "narrow" (low time cost despite depth), distinguish this explicitly from a "wide" bar (high time cost). Conflating depth with cost is a common mistake when reading flame graphs for the first time.
3 / 34
A memory profiler shows retained heap growing steadily across GC cycles for a specific object type: `EventListener`, from 2MB to 400MB over 10 minutes without ever decreasing. How do you describe this correctly?
"Monotonically growing" (never decreasing, even across GC) is the key signal that distinguishes a genuine memory leak from normal fluctuating memory usage. If memory grows and then drops after GC, that's expected garbage collection behaviour; if it grows and stays high across multiple GC cycles, objects are being retained unintentionally — typically due to dangling references (e.g. an event listener that was never removed).
Vocabulary: "retained size / retained heap" (memory kept alive by references), "growing monotonically" (never decreasing), "GC cycle" (garbage collection pass), "dangling reference" (a reference preventing collection unintentionally), "detached DOM node" (a common browser-specific leak pattern).
Vocabulary: "retained size / retained heap" (memory kept alive by references), "growing monotonically" (never decreasing), "GC cycle" (garbage collection pass), "dangling reference" (a reference preventing collection unintentionally), "detached DOM node" (a common browser-specific leak pattern).
4 / 34
A profiler shows a function with high "total time" but low "self time." How should you correctly interpret and describe this to a colleague?
This is one of the most common profiler-reading mistakes: optimising a function with high total time (which includes everything it calls) instead of drilling down to find where self time is actually high.
Vocabulary: "self time / exclusive time" (time in the function's own code, excluding calls it makes), "total time / inclusive time" (self time + all descendants' time), "drill into / expand" (navigating into child frames in the flame graph). The correct workflow is always: find high total time → drill into children → find where self time is actually concentrated → that's your real optimisation target.
Vocabulary: "self time / exclusive time" (time in the function's own code, excluding calls it makes), "total time / inclusive time" (self time + all descendants' time), "drill into / expand" (navigating into child frames in the flame graph). The correct workflow is always: find high total time → drill into children → find where self time is actually concentrated → that's your real optimisation target.
5 / 34
You compare two flame graphs — before and after an optimisation. Which language correctly communicates the result to your team?
A strong before/after comparison names the specific hotspot, gives quantified percentages for both states, and connects the change back to the underlying fix (memoisation) so the causal story is clear, not just "it looks different."
Formula:
Formula:
"The [function] hotspot shrank from [X%] to [Y%] of total CPU time — [confirms/suggests] that [specific fix] eliminated [specific cause]." This is the language expected in performance PR descriptions and postmortems where profiler evidence needs to justify an engineering decision.6 / 34
You notice most CPU samples in a profiler are attributed to a frame labelled `(garbage collector)` or `GC`. How should you describe this observation?
High GC time is a strong signal of allocation pressure — the application is creating (and immediately discarding) too many objects, forcing the garbage collector to run frequently. The correct response is not to disable GC (not possible/advisable in most managed runtimes) but to reduce allocations in the hot path — e.g. object pooling, avoiding unnecessary intermediate arrays, or reusing buffers.
Vocabulary: "allocation pressure" (rate of object creation stressing the GC), "hot path" (frequently executed code), "object pooling / reuse" (a common mitigation), "short-lived objects" (objects that die quickly, often the main GC cost driver).
Vocabulary: "allocation pressure" (rate of object creation stressing the GC), "hot path" (frequently executed code), "object pooling / reuse" (a common mitigation), "short-lived objects" (objects that die quickly, often the main GC cost driver).
7 / 34
Sarah: "I've run a profiler on this endpoint and it's showing a huge spike in CPU time when processing large JSON payloads. The stack trace points to `fetch` calls handling the data."
Mark: "That sounds bad! What do you think we should say to the product team?"
Which of the following responses best communicates this situation effectively during a code review?This scenario requires framing the technical information for a non-technical audience. Option 2 correctly describes the problem – excessive CPU time from `fetch` handling large JSON – and suggests an area needing attention. The other options either oversimplify the issue (Insufficient), provide vague terminology (Good), or use overly complex jargon that isn't immediately understandable (Excellent). It's important to focus on the *impact* of the performance problem rather than just describing the technical details.
8 / 34
You're reviewing a performance report generated by a CPU profiler for an API endpoint. The report shows a consistently high percentage of time spent in the `_stream` method of the `ReadableStream` object during requests. Your team lead asks you to explain this to the development team. Which of the following descriptions best captures the issue and its potential impact?
The correct answer highlights the key concern: excessive use of `_stream` within `ReadableStream` often points to inefficient processing of streamed data. Options A and C are incorrect because they normalize an issue that could be causing performance problems. Option D is partially correct but doesn't fully explain *why* this might be a problem—the issue isn't simply asynchronous handling, it's the disproportionate use of `_stream` which likely indicates oversized chunks or inefficient parsing.
9 / 34
Sarah: "I've run a profiler on this endpoint and it's showing a huge spike in CPU time when processing large JSON payloads. The stack trace points to `fetch` calls handling the data."
Mark: "That sounds bad! What do you think we should say to the product team?"
Which of the following responses best communicates this situation effectively during a code review?This scenario requires framing the technical information for a non-technical audience. Option 2 correctly describes the problem – excessive CPU time from `fetch` handling large JSON – and suggests an area needing attention. The other options either oversimplify the issue (Insufficient), provide vague terminology (Good), or use overly complex jargon that isn't immediately understandable (Excellent). It's important to focus on the *impact* of the performance problem rather than just describing the technical details.
10 / 34
You're reviewing a performance report generated by a CPU profiler for an API endpoint. The report shows a consistently high percentage of time spent in the `_stream` method of the `ReadableStream` object during requests. Your team lead asks you to explain this to the development team. Which of the following descriptions best captures the issue and its potential impact?
The correct answer highlights the key concern: excessive use of `_stream` within `ReadableStream` often points to inefficient processing of streamed data. Options A and C are incorrect because they normalize an issue that could be causing performance problems. Option D is partially correct but doesn't fully explain *why* this might be a problem—the issue isn't simply asynchronous handling, it's the disproportionate use of `_stream` which likely indicates oversized chunks or inefficient parsing.
11 / 34
Sarah: "I've run a profiler on this endpoint and it's showing a huge spike in CPU time when processing large JSON payloads. The stack trace points to `fetch` calls handling the data."
Mark: "That sounds bad! What do you think we should say to the product team?"
Which of the following responses best communicates this situation effectively during a code review?This scenario requires framing the technical information for a non-technical audience. Option 2 correctly describes the problem – excessive CPU time from `fetch` handling large JSON – and suggests an area needing attention. The other options either oversimplify the issue (Insufficient), provide vague terminology (Good), or use overly complex jargon that isn't immediately understandable (Excellent). It's important to focus on the *impact* of the performance problem rather than just describing the technical details.
12 / 34
You're reviewing a performance report generated by a CPU profiler for an API endpoint. The report shows a consistently high percentage of time spent in the `_stream` method of the `ReadableStream` object during requests. Your team lead asks you to explain this to the development team. Which of the following descriptions best captures the issue and its potential impact?
The correct answer highlights the key concern: excessive use of `_stream` within `ReadableStream` often points to inefficient processing of streamed data. Options A and C are incorrect because they normalize an issue that could be causing performance problems. Option D is partially correct but doesn't fully explain *why* this might be a problem—the issue isn't simply asynchronous handling, it's the disproportionate use of `_stream` which likely indicates oversized chunks or inefficient parsing.
13 / 34
Sarah: "I've run a profiler on this endpoint and it's showing a huge spike in CPU time when processing large JSON payloads. The stack trace points to `fetch` calls handling the data."
Mark: "That sounds bad! What do you think we should say to the product team?"
Which of the following responses best communicates this situation effectively during a code review?This scenario requires framing the technical information for a non-technical audience. Option 2 correctly describes the problem – excessive CPU time from `fetch` handling large JSON – and suggests an area needing attention. The other options either oversimplify the issue (Insufficient), provide vague terminology (Good), or use overly complex jargon that isn't immediately understandable (Excellent). It's important to focus on the *impact* of the performance problem rather than just describing the technical details.
14 / 34
You're reviewing a performance report generated by a CPU profiler for an API endpoint. The report shows a consistently high percentage of time spent in the `_stream` method of the `ReadableStream` object during requests. Your team lead asks you to explain this to the development team. Which of the following descriptions best captures the issue and its potential impact?
The correct answer highlights the key concern: excessive use of `_stream` within `ReadableStream` often points to inefficient processing of streamed data. Options A and C are incorrect because they normalize an issue that could be causing performance problems. Option D is partially correct but doesn't fully explain *why* this might be a problem—the issue isn't simply asynchronous handling, it's the disproportionate use of `_stream` which likely indicates oversized chunks or inefficient parsing.
15 / 34
During a standup meeting, Alex says: "The profiler shows that the `process_data` function is consistently taking up over 80% of the total CPU time when handling large CSV files. The stack trace points to nested loops and string manipulation."
Which of the following best describes this observation for a discussion with the team?
This response accurately highlights the key concern – a dominant function consuming excessive CPU time. The incorrect options either downplay the issue (A), offer irrelevant technical advice (C), or suggest accepting a problematic situation without investigation (D). This focuses on actionable insights.
16 / 34
You're drafting a pull request description for a performance improvement. The profiler output shows a high percentage of time spent in a custom logging function called `log_event`. The log messages themselves are relatively short.
Which sentence best communicates this finding to your colleagues?
The correct answer directly addresses the core issue – the *logging function* is a performance bottleneck. The other options misinterpret the finding (A), focus on an unrelated benefit (C), or describe a different aspect of the change (D). It's crucial to pinpoint the root cause.
17 / 34
In a Slack message to your team, you're reporting findings from a memory profiler. The output shows a continuously increasing retained heap size for an `ImageProcessor` object over time.
Which of the following statements is most appropriate?
The correct answer identifies a memory leak – objects are being created without being released. This is a critical issue that needs investigation. The other options offer misleading reassurance (A), suggest an irrelevant solution (C), or accept a problematic situation as normal (D).
18 / 34
You're reviewing a code review comment: 'The profiler shows that the `calculate_distance` function is taking a significant amount of time. The stack trace points to frequent calls to an external API.'
What does this primarily suggest?
This observation focuses on the *external API call* as the primary source of the performance issue. While refactoring or data issues could contribute, the stack trace points directly to the external service. This guides investigation towards that specific area.
19 / 34
You're analyzing a flame graph produced by a profiler after deploying a new version of your application. The graph shows several short, intense spikes in CPU usage across multiple threads.
Which phrase best describes this situation to your team?
Short, intense spikes often signify competition for resources and potential bottlenecks. This phrasing accurately captures this concern, prompting further investigation into thread contention or resource management. The other options provide misleading reassurance (A) or suggest incorrect solutions (C & D).
20 / 34
During a standup meeting, Alex says: "The profiler shows that the `process_data` function is consistently taking up over 80% of the total CPU time when handling large CSV files. The stack trace points to nested loops and string manipulation."
Which of the following best describes this observation for a discussion with the team?
This response accurately highlights the key concern – a dominant function consuming excessive CPU time. The incorrect options either downplay the issue (A), offer irrelevant technical advice (C), or suggest accepting a problematic situation without investigation (D). This focuses on actionable insights.
21 / 34
You're drafting a pull request description for a performance improvement. The profiler output shows a high percentage of time spent in a custom logging function called `log_event`. The log messages themselves are relatively short.
Which sentence best communicates this finding to your colleagues?
The correct answer directly addresses the core issue – the *logging function* is a performance bottleneck. The other options misinterpret the finding (A), focus on an unrelated benefit (C), or describe a different aspect of the change (D). It's crucial to pinpoint the root cause.
22 / 34
In a Slack message to your team, you're reporting findings from a memory profiler. The output shows a continuously increasing retained heap size for an `ImageProcessor` object over time.
Which of the following statements is most appropriate?
The correct answer identifies a memory leak – objects are being created without being released. This is a critical issue that needs investigation. The other options offer misleading reassurance (A), suggest an irrelevant solution (C), or accept a problematic situation as normal (D).
23 / 34
You're reviewing a code review comment: 'The profiler shows that the `calculate_distance` function is taking a significant amount of time. The stack trace points to frequent calls to an external API.'
What does this primarily suggest?
This observation focuses on the *external API call* as the primary source of the performance issue. While refactoring or data issues could contribute, the stack trace points directly to the external service. This guides investigation towards that specific area.
24 / 34
You're analyzing a flame graph produced by a profiler after deploying a new version of your application. The graph shows several short, intense spikes in CPU usage across multiple threads.
Which phrase best describes this situation to your team?
Short, intense spikes often signify competition for resources and potential bottlenecks. This phrasing accurately captures this concern, prompting further investigation into thread contention or resource management. The other options provide misleading reassurance (A) or suggest incorrect solutions (C & D).
25 / 34
During a standup meeting, Alex says: "The profiler shows that the `process_data` function is consistently taking up over 80% of the total CPU time when handling large CSV files. The stack trace points to nested loops and string manipulation."
Which of the following best describes this observation for a discussion with the team?
This response accurately highlights the key concern – a dominant function consuming excessive CPU time. The incorrect options either downplay the issue (A), offer irrelevant technical advice (C), or suggest accepting a problematic situation without investigation (D). This focuses on actionable insights.
26 / 34
You're drafting a pull request description for a performance improvement. The profiler output shows a high percentage of time spent in a custom logging function called `log_event`. The log messages themselves are relatively short.
Which sentence best communicates this finding to your colleagues?
The correct answer directly addresses the core issue – the *logging function* is a performance bottleneck. The other options misinterpret the finding (A), focus on an unrelated benefit (C), or describe a different aspect of the change (D). It's crucial to pinpoint the root cause.
27 / 34
In a Slack message to your team, you're reporting findings from a memory profiler. The output shows a continuously increasing retained heap size for an `ImageProcessor` object over time.
Which of the following statements is most appropriate?
The correct answer identifies a memory leak – objects are being created without being released. This is a critical issue that needs investigation. The other options offer misleading reassurance (A), suggest an irrelevant solution (C), or accept a problematic situation as normal (D).
28 / 34
You're reviewing a code review comment: 'The profiler shows that the `calculate_distance` function is taking a significant amount of time. The stack trace points to frequent calls to an external API.'
What does this primarily suggest?
This observation focuses on the *external API call* as the primary source of the performance issue. While refactoring or data issues could contribute, the stack trace points directly to the external service. This guides investigation towards that specific area.
29 / 34
You're analyzing a flame graph produced by a profiler after deploying a new version of your application. The graph shows several short, intense spikes in CPU usage across multiple threads.
Which phrase best describes this situation to your team?
Short, intense spikes often signify competition for resources and potential bottlenecks. This phrasing accurately captures this concern, prompting further investigation into thread contention or resource management. The other options provide misleading reassurance (A) or suggest incorrect solutions (C & D).
30 / 34
During a standup meeting, Alex says: "The profiler shows that the `process_data` function is consistently taking up over 80% of the total CPU time when handling large CSV files. The stack trace points to nested loops and string manipulation."
Which of the following best describes this observation for a discussion with the team?
This response accurately highlights the key concern – a dominant function consuming excessive CPU time. The incorrect options either downplay the issue (A), offer irrelevant technical advice (C), or suggest accepting a problematic situation without investigation (D). This focuses on actionable insights.
31 / 34
You're drafting a pull request description for a performance improvement. The profiler output shows a high percentage of time spent in a custom logging function called `log_event`. The log messages themselves are relatively short.
Which sentence best communicates this finding to your colleagues?
The correct answer directly addresses the core issue – the *logging function* is a performance bottleneck. The other options misinterpret the finding (A), focus on an unrelated benefit (C), or describe a different aspect of the change (D). It's crucial to pinpoint the root cause.
32 / 34
In a Slack message to your team, you're reporting findings from a memory profiler. The output shows a continuously increasing retained heap size for an `ImageProcessor` object over time.
Which of the following statements is most appropriate?
The correct answer identifies a memory leak – objects are being created without being released. This is a critical issue that needs investigation. The other options offer misleading reassurance (A), suggest an irrelevant solution (C), or accept a problematic situation as normal (D).
33 / 34
You're reviewing a code review comment: 'The profiler shows that the `calculate_distance` function is taking a significant amount of time. The stack trace points to frequent calls to an external API.'
What does this primarily suggest?
This observation focuses on the *external API call* as the primary source of the performance issue. While refactoring or data issues could contribute, the stack trace points directly to the external service. This guides investigation towards that specific area.
34 / 34
You're analyzing a flame graph produced by a profiler after deploying a new version of your application. The graph shows several short, intense spikes in CPU usage across multiple threads.
Which phrase best describes this situation to your team?
Short, intense spikes often signify competition for resources and potential bottlenecks. This phrasing accurately captures this concern, prompting further investigation into thread contention or resource management. The other options provide misleading reassurance (A) or suggest incorrect solutions (C & D).
Frequently Asked Questions
What does the "Profiler Output Vocabulary" exercise practise?
Practise reading and describing profiler output: flame graphs, hotspots, self vs. total time, memory leaks, and GC pressure in professional English. 6 exercises.
How many questions are in this exercise?
This exercise has 34 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Advanced. If the vocabulary feels difficult, browse the Debugging Language category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "Profiler Output Vocabulary" part of a larger series?
Yes — it's one exercise in the Debugging Language category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Debugging Language category page for related exercises, or browse the main Exercises hub for other IT English topics.