Practice profiling tools vocabulary: Node.js CPU profiler, flame graphs, V8 profiler, py-spy for Python, async-profiler for JVM, and interpreting profiling output.
0 / 18 completed
1 / 18
'We ran the Node.js ___ profiler.' Which type of profiler measures execution time per function?
A CPU profiler (or sampling profiler) records which functions are executing over time, showing where the program spends CPU time. Node.js has a built-in CPU profiler accessible via --prof or Chrome DevTools.
2 / 18
'The ___ graph shows the hot path.' Which visualization is standard for profiling data?
A 'flame graph' visualizes CPU profiling data as stacked horizontal bars — wider bars mean more time spent in that function. The 'hot path' (widest bars at the top) reveals the performance bottleneck.
3 / 18
What is py-spy used for?
py-spy is a sampling profiler for Python that attaches to a running process without requiring code modifications or restarts — making it safe to use in production environments.
4 / 18
'The profiling run shows 60% time in ___.' Which function name is being called out?
'60% time in JSON.parse' is a classic profiling finding in Node.js services. It often means large JSON payloads are being deserialized in a hot path — a candidate for caching or streaming parsing.
5 / 18
What is async_profiler used for?
async_profiler is a low-overhead sampling profiler for the JVM (Java, Kotlin, Scala). It can profile CPU, heap allocations, and wall-clock time, and is safe to use in production.
6 / 18
During a code review of a new microservice, Sarah notices the following comment from David:
'I'm seeing a lot of time spent in the `process_payment` function. Could you investigate why it's taking so long?'
What does David *most likely* mean when referring to 'time spent'?
David is referring to the duration that the code within the `process_payment` function actually executes. Profilers measure execution time, which is a key metric for identifying performance bottlenecks. Options A, C, and D relate to other aspects of service behavior—memory usage, API calls, or gateway latency—but not directly the runtime of the function itself.
7 / 18
You're using a Slack channel dedicated to debugging performance issues. Mark sends the following message:
'Just ran `perf record -g --vm` on the database server. The output shows a huge spike in calls to the `executeQuery` function when handling large query sets. Looks like we have a potential issue.'
What does Mark's message indicate?
Mark's message suggests a problem with the `executeQuery` function's performance—specifically its call frequency and execution time. The use of `perf record -g --vm` captures virtual memory operations, which are often indicative of inefficient query processing. Options A and D describe broader system issues, while option B is related to memory but doesn't directly address the observed spike.
8 / 18
During a standup meeting, you're discussing your profiling work. You say: 'I used perf stat to analyze the performance of my new feature and found that _______ was consuming the majority of the CPU time.'
What should replace the blank?
The blank should be filled with the name of a function or code block that's consuming CPU time. `perf stat` is used to measure resource usage over time, and in this context, we're looking for the specific operation causing the bottleneck. Options A, B, and D represent different metrics but not the direct cause of high CPU utilization.
9 / 18
You're writing a PR description for a performance optimization you've made. You include the following statement: 'I utilized Async Profiler to identify that the `handle_request` function was blocking the event loop.'
What is the primary benefit of using Async Profiler in this scenario?
Async Profiler is specifically designed to profile asynchronous Python code where traditional profilers struggle. It excels at identifying blocking operations—code that prevents the event loop from processing other tasks—which are a common cause of performance issues in concurrent systems. Options A and C relate to broader profiling capabilities, while option D focuses on database optimization.
10 / 18
John is investigating a slow API endpoint. He uses `perf record -g` and then analyzes the output with `perf report`. The report shows a large percentage of time spent in the `get_data()` function. Which profiling technique is John primarily using?
perf record -g collects data on CPU usage at a very granular level. This generates a call graph, visually representing which functions are consuming the most processing time – essential for identifying performance bottlenecks like `get_data()`. Heap profiling focuses on memory allocation, while flame graphs provide an overview of function execution times.
11 / 18
Sarah, a code reviewer, sees the following comment in a pull request:
'The profiling data indicates that `calculate_total()` is responsible for approximately 70% of the execution time. Could we consider optimizing this function?' What does Sarah likely need to understand to effectively evaluate this feedback?
Profiling tools like `perf` or Async Profiler focus on *how* code is executed. A high percentage in a function suggests it's the primary cause of performance issues; therefore, understanding the algorithm and potential bottlenecks within that function (e.g., inefficient loops, complex calculations) is crucial for targeted optimization.
12 / 18
Mark sends a Slack message: 'Just ran `async_profiler` on the server. The output shows that `handle_requests()` is consistently blocking the event loop and causing high latency.' What does Mark's message suggest about the problem?
`async_profiler` excels at detecting asynchronous code that's blocking the event loop. A high percentage of time spent in `handle_requests()` coupled with the mention of blocking suggests it's likely performing synchronous operations (e.g., waiting for network responses) which is a common cause of performance issues in asynchronous applications.
13 / 18
David, a senior engineer, comments on a pull request: 'I'm seeing a lot of time spent in the `process_payment` function. Could you investigate why it's taking so long?' Which profiling tool would be most appropriate for directly answering this question and pinpointing the exact bottleneck within that function?
Async Profiler excels at providing detailed stack traces within functions, allowing you to see exactly where the function is spending its time. Flamegraphs are good for high-level views of call frequencies but don't pinpoint bottlenecks within a specific function. `perf stat` focuses on overall CPU usage and isn't granular enough for this scenario, while a heap profiler analyzes memory which isn't relevant to David's question about execution time.
14 / 18
Maria is investigating a performance bottleneck in her microservice. She uses `perf record -g` and then analyzes the output. The report shows that a specific function, `validate_input`, is consuming a disproportionately large amount of CPU time. Which of the following best describes Maria's approach to profiling?
Maria's use of `perf record -g` followed by analysis demonstrates a systematic approach to identifying performance bottlenecks. Profiling tools are designed to pinpoint resource-intensive functions within an application, allowing developers to focus optimization efforts effectively. The other options represent either incorrect usage or unnecessary steps.
15 / 18
Liam is debugging a slow database query and uses Async Profiler to capture execution traces. He observes that the `get_user_details` function spends a significant amount of time waiting for I/O operations. What does this suggest about potential areas for optimization?
Async Profiler reveals that `get_user_details` is blocked waiting for I/O. This strongly suggests that the database query itself (or the way it's executed) is the primary cause of the slowdown, rather than a general problem with the server or application logic. Optimizing the query would directly address this.
16 / 18
During a code review, David points out that the `process_order` function is taking an unusually long time. He suggests using a profiler to understand why. Which tool would be most suitable for this investigation?
The `perf` command (part of the Linux Performance Toolkit) is specifically designed to profile CPU usage and identify performance hotspots within a running application. It's ideal for investigating function-level execution times, as David requires. The other tools are not focused on profiling performance at this level.
17 / 18
Elena is analyzing the performance of a complex algorithm in her Python code using py-spy. She observes that the `calculate_result` function dominates CPU usage. What is the primary purpose of using py-spy in this scenario?
py-spy specializes in tracing function call stacks and providing detailed insights into the execution flow of a program. This allows Elena to pinpoint exactly which functions are consuming the most CPU time, facilitating targeted optimization efforts. It's not designed for memory leak detection or network analysis.
18 / 18
You're receiving an alert from a monitoring system indicating high latency in your API endpoint, `get_product_details`. You suspect a performance issue. Which command would be most useful for diagnosing the root cause?
Using `curl -v get_product_details` allows you to send a request to the endpoint and observe the full HTTP response headers, including timing information. This provides valuable insights into the latency experienced by the client, helping to identify potential bottlenecks within the API server's processing or network communication.
What will I practise in "Profiling Tools Vocabulary"?
This module focuses on Performance Profiling — real workplace phrasing you'll use on the job. It contains 18 scenario-based multiple-choice questions with instant feedback.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account or sign-up required.
How many questions does this exercise have?
This module includes 18 questions. Each one gives an immediate right/wrong result plus a full explanation of the correct phrasing.
What happens if I answer a question incorrectly?
You'll see the correct answer highlighted straight away, along with a plain-English explanation of why it's right and why the other options don't fit — mistakes are part of the learning here.
Can I retry the exercise if I want a better score?
Yes — use the 'Try again' button on the results screen to reset your score and go through the questions again. There's no limit on attempts.
Who is this Performance Profiling exercise for?
It's aimed at IT professionals with working English who want to sound more natural and precise around performance profiling — useful whether you're preparing for real conversations at work or just building confidence with the vocabulary.
Do I need an account to track my progress?
No account is needed. Your progress through the exercise is tracked locally in your browser for the current session, and you can replay the module at any time.
How is this different from reading a blog article?
This exercise is an interactive drill that tests and reinforces specific phrasing through multiple-choice questions with instant feedback, while blog articles explain concepts and vocabulary in prose. The two work well together.
Where can I find more Performance Profiling exercises?
See the Performance Profiling hub for more modules like this one, or browse the full Exercises page for other IT-English topics.
Can I complete this exercise on my phone?
Yes — every exercise on CoderSlingo is fully responsive and works on phones and tablets, so you can practise anywhere.