Intermediate
#technical-concepts
#precision-vocabulary
#false-friends
Technical Concepts — Commonly Confused Pairs
5 exercises on technical terms that developers and engineers often use interchangeably — even though they have distinct meanings. Getting these right signals technical fluency.
The most confused technical word pairs in IT English
- parameter (defined in signature) vs argument (passed at call)
- method (belongs to object) vs function (standalone)
- compile-time (caught by compiler) vs runtime (occurs while running)
- scalability (handles more load) vs performance (fast at current load)
- latency (delay) vs throughput (rate) vs bandwidth (capacity)
0 / 36 completed
1 / 36
A code reviewer comments: "You're passing the wrong ___ — the function expects a string, but you're sending an integer."
Which word belongs in the blank?
Which word belongs in the blank?
Argument — the actual value you pass when calling a function:
This is one of the most common confused word pairs in programming English. The distinction is precise:
Parameter (also: formal parameter)
Related terms:
This is one of the most common confused word pairs in programming English. The distinction is precise:
Parameter (also: formal parameter)
- The variable name declared in the function definition
- It is a placeholder — it exists in the code structure, not yet associated with a value
- "
function greet(name)" —nameis a parameter"
- The actual value you supply when you call the function
- It is data — it flows into the parameter at call time
- "
greet("Alice")" —"Alice"is an argument
- ✅ "The function takes two parameters."
- ✅ "Call the function with these arguments."
- ✅ "Pass a string argument to the first parameter."
Related terms:
- default parameter — a parameter with a fallback value if no argument is provided
- named argument (Python, Kotlin) — an argument explicitly addressed to a parameter by name
- variadic parameter — a parameter that accepts any number of arguments (
*args,...rest) - type annotation / type hint — declaring what type an argument must be
2 / 36
During an OOP design discussion, a senior engineer asks: "Should
What is the core difference?
calculateTax() be a standalone function or a class method?"What is the core difference?
Method vs. Function — the OOP distinction:
Function
Function
- A standalone block of reusable code
- Defined outside any class (or inside, depending on language)
- Operates purely on its inputs:
calculateTax(price, rate) - Has no implicit access to object state
- Languages: all procedural/functional languages; also exists in OOP languages
- A function that belongs to an object or class
- Has implicit access to the object's own data via
this/self cart.calculateTax()— knows aboutthis.items,this.discountCode, etc.- Can read and modify object state (instance method) or class state (class/static method)
- instance method — operates on one specific object (
self/this) - class method / static method — belongs to the class, not a specific instance; no
self/thisaccess to instance data - getter / setter — methods for reading/writing object properties
- Python:
def greet(self):— the explicitselfmakes it a method - JavaScript: a function defined on an object literal or class body is a method
- Java/C#: everything must be inside a class — "function" is rarely used; "method" is the standard
- Go: uses "method" only for functions with a receiver type; other functions are just "functions"
3 / 36
A developer files a bug report: "App crashes on startup with
At which stage does this type of error occur?
NullPointerException."At which stage does this type of error occur?
Runtime error — happens while the program is running:
Understanding when an error occurs is fundamental to diagnosing and fixing it.
Compile-time — errors caught by the compiler before the program runs
Understanding when an error occurs is fundamental to diagnosing and fixing it.
Compile-time — errors caught by the compiler before the program runs
- Syntax errors: missing semicolons, mismatched brackets
- Type errors (in statically typed languages): "cannot assign
inttostring" - Missing imports, undeclared variables
- The program fails to build — you never run it
- Examples:
SyntaxErrorin Python, Java compilation failure
- The code compiled fine, but something went wrong during execution
NullPointerException/NullReferenceException— accessing a null referenceIndexOutOfBoundsException— array access beyond its boundsDivisionByZeroException— arithmetic error at runtimeStackOverflowError— recursive call depth exceeded- Network errors, file-not-found — environment-dependent
- No exception is thrown; the output is simply incorrect
- Hardest to detect — requires tests and code review
- "The compiler rejects / flags this at compile-time."
- "This exception is thrown at runtime."
- "Static analysis catches compile-time errors before execution."
- "Add runtime validation to guard against null inputs."
4 / 36
A CTO reviews an architecture proposal: "Our current system handles 1,000 requests/second well, but can it handle 100,000?"
This question is primarily about which concept?
This question is primarily about which concept?
Scalability vs. Performance — two related but distinct concepts:
Performance
Performance
- How fast / efficiently a system operates at its current load
- Measured by: response time, latency, throughput at a specific concurrency level
- "Our API responds in 50ms for 1,000 concurrent users." — that is performance
- Improving performance = optimising the present: caching, query tuning, code optimisation
- The ability to maintain acceptable performance as load increases — by adding resources
- A scalable system can handle 10× or 100× the load if you add hardware/instances
- Two types:
— Horizontal scaling (scale out): add more servers/instances
— Vertical scaling (scale up): add more CPU/RAM to existing servers - Key test: "If we add 10 more servers, does throughput increase proportionally?"
- A system can be fast (good performance) but not scalable — works fine with 100 users, collapses at 10,000
- A system can be scalable but slow — you can add pages of servers, but each request is 2 seconds
- "We need to improve performance" → optimise existing code, reduce latency
- "We need to improve scalability" → redesign for horizontal growth, add load balancers, use microservices, introduce queues
- "Does this design scale?" → will it still work under 100× the current load?
5 / 36
A product manager asks: "Why does our video streaming service feel slow even though our servers have plenty of unused bandwidth?"
Which metric best explains this user experience issue?
Which metric best explains this user experience issue?
Latency, Throughput, and Bandwidth — the three must-know network terms:
These three concepts are constantly confused even by experienced engineers. The streaming example is perfect for illustrating the differences.
Latency
These three concepts are constantly confused even by experienced engineers. The streaming example is perfect for illustrating the differences.
Latency
- The time delay for a single piece of data to travel from source to destination
- Measured in milliseconds (ms)
- High latency = things feel slow and unresponsive, even if the connection is "fast"
- Examples: round-trip time (RTT), ping time, time-to-first-byte (TTFB)
- "Our CDN reduced latency from 300ms to 30ms for Asian users."
- Streaming issue: high latency causes buffering, delayed start, out-of-sync audio
- The actual amount of data (or operations) successfully transferred per unit of time
- Measured in MB/s, requests/second, transactions/second
- "The pipeline processes 500 messages/second." — throughput
- Related to latency: high latency reduces throughput (you're waiting for each response)
- The maximum possible data transfer rate — the capacity of the channel
- Measured in Mbps, Gbps
- "We have a 1Gbps link to the data center." — bandwidth
- Bandwidth is the ceiling; throughput is the actual rate; latency is the delay
- You can have high bandwidth but also high latency (a fast but long pipe)
- Imagine a water pipe: bandwidth = pipe diameter (how much can flow), throughput = actual flow rate now, latency = how long it takes for water to travel from one end to the other
6 / 36
PR Description
Subject: Refactor User Profile Service - Improved Latency
Hi Team,
This PR addresses recent performance concerns with the user profile service. We've optimized database queries and caching strategies to reduce latency. Initial tests show a 30% improvement in response times under load, but we need to monitor throughput closely.
Thanks!
- JohnThis question tests understanding of key differences in performance metrics. Latency refers specifically to the delay experienced by a user or system when requesting something, while throughput measures the *volume* of data processed – essentially how much work is getting done. Confusing these terms can lead to misinterpretations of performance improvements and inaccurate troubleshooting. A high throughput doesn't necessarily mean low latency; it's about the speed at which operations are completed.
7 / 36
Sarah: "Hey team, I'm seeing some slow response times when fetching user data. The API call to get a profile is taking almost 5 seconds. We've been hitting our service with around 50 requests per second lately. What should we investigate first?"Sarah's question directly addresses latency. Latency is the delay experienced by a single request, which is exactly what she's observing with that 5-second response time. While throughput (the number of requests) *can* contribute to latency under heavy load, it's not the primary metric in this immediate situation; focusing on latency provides the most actionable insight into resolving the user experience issue. Database indexing and API versioning are relevant but less immediately impactful than understanding the delay itself.
8 / 36
Sarah is investigating slow response times for the user profile service. She notes that API calls are taking around 5 seconds and the service is handling approximately 50 requests per second. Considering the context of latency versus throughput, which statement best describes the primary issue Sarah should investigate?
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The core of Sarah's observation centers on latency. Latency is a measure of how long it takes for *one* request to complete; in this case, 5 seconds per API call is unacceptable. While throughput measures the overall volume of requests handled, focusing solely on that without addressing the high latency would be missing the fundamental problem. The other options – concurrency, scalability, and even throughput – are related but secondary concerns in diagnosing a specific slow response time.
9 / 36
A DevOps engineer is monitoring the performance of a new microservice. The service's logs show a high volume of requests (around 200 per second) and an average response time of 150ms. During a spike in traffic, the response time jumps to 800ms, and the error rate increases slightly. Considering the situation, which term best describes the engineer's primary concern? The focus is on measuring how consistently the system delivers results within a defined timeframe – not simply the total number of requests it handles.
Latency refers to the time it takes for a single request to be processed and responded to. The engineer is specifically concerned about the *response time*, which has increased dramatically under load—this is what's driving the problem. Throughput measures the total volume of requests handled, while scalability addresses the system's ability to handle increasing loads; availability focuses on uptime. Focusing solely on throughput wouldn't explain why a single request is taking so long.
10 / 36
PR Description
Subject: Refactor User Profile Service - Improved Latency
Hi Team,
This PR addresses recent performance concerns with the user profile service. We've optimized database queries and caching strategies to reduce latency. Initial tests show a 30% improvement in response times under load, but we need to monitor throughput closely.
Thanks!
- JohnThis question tests understanding of key differences in performance metrics. Latency refers specifically to the delay experienced by a user or system when requesting something, while throughput measures the *volume* of data processed – essentially how much work is getting done. Confusing these terms can lead to misinterpretations of performance improvements and inaccurate troubleshooting. A high throughput doesn't necessarily mean low latency; it's about the speed at which operations are completed.
11 / 36
Sarah: "Hey team, I'm seeing some slow response times when fetching user data. The API call to get a profile is taking almost 5 seconds. We've been hitting our service with around 50 requests per second lately. What should we investigate first?"Sarah's question directly addresses latency. Latency is the delay experienced by a single request, which is exactly what she's observing with that 5-second response time. While throughput (the number of requests) *can* contribute to latency under heavy load, it's not the primary metric in this immediate situation; focusing on latency provides the most actionable insight into resolving the user experience issue. Database indexing and API versioning are relevant but less immediately impactful than understanding the delay itself.
12 / 36
Sarah is investigating slow response times for the user profile service. She notes that API calls are taking around 5 seconds and the service is handling approximately 50 requests per second. Considering the context of latency versus throughput, which statement best describes the primary issue Sarah should investigate?
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The core of Sarah's observation centers on latency. Latency is a measure of how long it takes for *one* request to complete; in this case, 5 seconds per API call is unacceptable. While throughput measures the overall volume of requests handled, focusing solely on that without addressing the high latency would be missing the fundamental problem. The other options – concurrency, scalability, and even throughput – are related but secondary concerns in diagnosing a specific slow response time.
13 / 36
A DevOps engineer is monitoring the performance of a new microservice. The service's logs show a high volume of requests (around 200 per second) and an average response time of 150ms. During a spike in traffic, the response time jumps to 800ms, and the error rate increases slightly. Considering the situation, which term best describes the engineer's primary concern? The focus is on measuring how consistently the system delivers results within a defined timeframe – not simply the total number of requests it handles.
Latency refers to the time it takes for a single request to be processed and responded to. The engineer is specifically concerned about the *response time*, which has increased dramatically under load—this is what's driving the problem. Throughput measures the total volume of requests handled, while scalability addresses the system's ability to handle increasing loads; availability focuses on uptime. Focusing solely on throughput wouldn't explain why a single request is taking so long.
14 / 36
PR Description
Subject: Refactor User Profile Service - Improved Latency
Hi Team,
This PR addresses recent performance concerns with the user profile service. We've optimized database queries and caching strategies to reduce latency. Initial tests show a 30% improvement in response times under load, but we need to monitor throughput closely.
Thanks!
- JohnThis question tests understanding of key differences in performance metrics. Latency refers specifically to the delay experienced by a user or system when requesting something, while throughput measures the *volume* of data processed – essentially how much work is getting done. Confusing these terms can lead to misinterpretations of performance improvements and inaccurate troubleshooting. A high throughput doesn't necessarily mean low latency; it's about the speed at which operations are completed.
15 / 36
Sarah: "Hey team, I'm seeing some slow response times when fetching user data. The API call to get a profile is taking almost 5 seconds. We've been hitting our service with around 50 requests per second lately. What should we investigate first?"Sarah's question directly addresses latency. Latency is the delay experienced by a single request, which is exactly what she's observing with that 5-second response time. While throughput (the number of requests) *can* contribute to latency under heavy load, it's not the primary metric in this immediate situation; focusing on latency provides the most actionable insight into resolving the user experience issue. Database indexing and API versioning are relevant but less immediately impactful than understanding the delay itself.
16 / 36
Sarah is investigating slow response times for the user profile service. She notes that API calls are taking around 5 seconds and the service is handling approximately 50 requests per second. Considering the context of latency versus throughput, which statement best describes the primary issue Sarah should investigate?
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The core of Sarah's observation centers on latency. Latency is a measure of how long it takes for *one* request to complete; in this case, 5 seconds per API call is unacceptable. While throughput measures the overall volume of requests handled, focusing solely on that without addressing the high latency would be missing the fundamental problem. The other options – concurrency, scalability, and even throughput – are related but secondary concerns in diagnosing a specific slow response time.
17 / 36
A DevOps engineer is monitoring the performance of a new microservice. The service's logs show a high volume of requests (around 200 per second) and an average response time of 150ms. During a spike in traffic, the response time jumps to 800ms, and the error rate increases slightly. Considering the situation, which term best describes the engineer's primary concern? The focus is on measuring how consistently the system delivers results within a defined timeframe – not simply the total number of requests it handles.
Latency refers to the time it takes for a single request to be processed and responded to. The engineer is specifically concerned about the *response time*, which has increased dramatically under load—this is what's driving the problem. Throughput measures the total volume of requests handled, while scalability addresses the system's ability to handle increasing loads; availability focuses on uptime. Focusing solely on throughput wouldn't explain why a single request is taking so long.
18 / 36
PR Description
Subject: Refactor User Profile Service - Improved Latency
Hi Team,
This PR addresses recent performance concerns with the user profile service. We've optimized database queries and caching strategies to reduce latency. Initial tests show a 30% improvement in response times under load, but we need to monitor throughput closely.
Thanks!
- JohnThis question tests understanding of key differences in performance metrics. Latency refers specifically to the delay experienced by a user or system when requesting something, while throughput measures the *volume* of data processed – essentially how much work is getting done. Confusing these terms can lead to misinterpretations of performance improvements and inaccurate troubleshooting. A high throughput doesn't necessarily mean low latency; it's about the speed at which operations are completed.
19 / 36
Sarah: "Hey team, I'm seeing some slow response times when fetching user data. The API call to get a profile is taking almost 5 seconds. We've been hitting our service with around 50 requests per second lately. What should we investigate first?"Sarah's question directly addresses latency. Latency is the delay experienced by a single request, which is exactly what she's observing with that 5-second response time. While throughput (the number of requests) *can* contribute to latency under heavy load, it's not the primary metric in this immediate situation; focusing on latency provides the most actionable insight into resolving the user experience issue. Database indexing and API versioning are relevant but less immediately impactful than understanding the delay itself.
20 / 36
Sarah is investigating slow response times for the user profile service. She notes that API calls are taking around 5 seconds and the service is handling approximately 50 requests per second. Considering the context of latency versus throughput, which statement best describes the primary issue Sarah should investigate?
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The goal isn't just to see if the system *can* handle more requests (throughput), but rather how quickly individual requests are processed (latency).
The core of Sarah's observation centers on latency. Latency is a measure of how long it takes for *one* request to complete; in this case, 5 seconds per API call is unacceptable. While throughput measures the overall volume of requests handled, focusing solely on that without addressing the high latency would be missing the fundamental problem. The other options – concurrency, scalability, and even throughput – are related but secondary concerns in diagnosing a specific slow response time.
21 / 36
A DevOps engineer is monitoring the performance of a new microservice. The service's logs show a high volume of requests (around 200 per second) and an average response time of 150ms. During a spike in traffic, the response time jumps to 800ms, and the error rate increases slightly. Considering the situation, which term best describes the engineer's primary concern? The focus is on measuring how consistently the system delivers results within a defined timeframe – not simply the total number of requests it handles.
Latency refers to the time it takes for a single request to be processed and responded to. The engineer is specifically concerned about the *response time*, which has increased dramatically under load—this is what's driving the problem. Throughput measures the total volume of requests handled, while scalability addresses the system's ability to handle increasing loads; availability focuses on uptime. Focusing solely on throughput wouldn't explain why a single request is taking so long.
22 / 36
Review this code review comment:
'This change introduces a new dependency and increases the overall latency of the service by approximately 30ms. We need to investigate further.' What does the comment primarily highlight?
The comment explicitly mentions 'increased latency'. While dependencies can sometimes introduce vulnerabilities, the primary focus here is on the measurable effect on response time. The phrase 'approximately' suggests a measured impact, aligning with the concept of latency.
23 / 36
You're designing an API to serve images. You want to minimize the time it takes for users to see a picture. Which metric is MOST important to optimize?
Latency directly impacts user experience when it comes to displaying images. While throughput is important, optimizing *latency* will almost always result in faster perceived performance for the end-user. A slow response time before the image loads is a poor user experience.
24 / 36
During a standup meeting, Alex says: "We're seeing some spikes in latency for the order processing service – sometimes up to 800ms. We've got around 150 requests per second hitting it right now." Which of the following best describes Alex's primary concern?
Alex's statement clearly identifies 'latency' (800ms) and links it to the number of requests ('150'). The question tests understanding that high latency during peak load is a critical issue. Options A & B are partially correct but misinterpret the core message; option C is dismissive and incorrect, while D contradicts the provided data.
25 / 36
You're analyzing an API response from a user authentication service. The latency for each request is consistently around 250ms. The service handles approximately 300 requests per minute. Which statement best describes the situation?
This question tests understanding of both latency *and* throughput. While 300 requests/minute isn't terrible, 250ms is a point for scrutiny. The options highlight that performance can be improved even with decent volume and the need to investigate bottlenecks is key. Option A is misleading; option C is too extreme; and option D presents an incorrect relationship.
26 / 36
PR Description
Subject: Optimizing Data Retrieval - Reduced Parameter Overhead
Hi Team,
This PR refines the data retrieval process for user profiles. We've reduced the number of parameters passed to the database query by 2, which has resulted in a measurable decrease in latency – approximately 10ms on average across requests. We're still monitoring throughput at around 75 requests per second.
Considering this change, what is the MOST significant impact reported?
The description explicitly states the 'measurable decrease in latency.' The question asks about the *most* significant impact – focusing on latency reduction is the core takeaway. Option A is incorrect because throughput was unchanged; option C contradicts the PR's purpose; and option D minimizes the importance of the reported benefit.
27 / 36
A developer suspects their application's API is performing poorly. They are experiencing a high number of requests (around 200 per second) and an average response time of 300ms. Which metric should they primarily focus on optimizing to improve overall system performance?
While all options contribute to performance, 'latency' is the most direct measure of user experience. Reducing response time (latency) will have the biggest immediate impact on perceived performance. Throughput is important but optimizing latency first often provides a better user experience.
28 / 36
Mark: "Hey, the new feature is causing significant latency. We're seeing response times of around 600ms for simple user searches, and it's spiking to 850ms during peak usage (around 120 requests per second). What's the *most* important thing we need to investigate first?"
The question focuses on *latency*, which is response time. While all options could contribute to latency, high response times during peak usage strongly suggest a bottleneck in the system – likely the database or server resources. Focusing here allows for targeted investigation before assuming network issues.
29 / 36
Review this code review comment:
'The query is returning a large result set (over 10,000 records) even though the user only requested data for their own profile. This is contributing to high latency and should be optimized.' What does the comment primarily highlight?
The comment directly addresses the *query* and its output. Excessive result sets are a common cause of latency when retrieving large amounts of data, especially in database-heavy applications. The focus is on optimizing the query to reduce the amount of data returned.
30 / 36
Sarah: "We've noticed a sustained latency issue with our payment processing API – averaging around 450ms per request. We're handling roughly 80 requests per second. The system is stable, but this delay is impacting the user experience. Which metric should we prioritize addressing to improve performance?"
Latency is directly tied to response time. Database queries are often the biggest bottleneck in API performance. Optimizing these queries will have the most immediate and measurable impact on reducing latency compared to simply scaling up servers or caching.
31 / 36
Which statement accurately describes the difference between a 'parameter' and an 'argument' in the context of a function call?
This question tests fundamental understanding. A *parameter* is a variable declared within a function's definition to receive values, while an *argument* is the actual value that's passed into the function when it's called. It's crucial to distinguish between these roles.
32 / 36
Mark is discussing performance issues with the team. He states: 'We're seeing around 120 requests per second to our recommendation engine and the average response time is 750ms.' Which of the following best describes what Mark is primarily concerned about?
A The number of requests per second (throughput) is too high.
B The latency of 750ms is acceptable for a recommendation engine, given the load.
C The latency of 750ms is likely a problem, as it exceeds typical expectations for this service.
D Throughput and latency are equally important metrics to monitor simultaneously.
A The number of requests per second (throughput) is too high.
B The latency of 750ms is acceptable for a recommendation engine, given the load.
C The latency of 750ms is likely a problem, as it exceeds typical expectations for this service.
D Throughput and latency are equally important metrics to monitor simultaneously.
Mark's primary concern is the 750ms latency. While throughput (120 requests per second) provides context, the *latency* itself is the key metric indicating a potential performance bottleneck. Option A suggests that high throughput is inherently bad, which isn't always true; it's the combined effect of throughput and latency that matters most. Option B incorrectly assumes acceptable latency based on load alone.
33 / 36
During a Slack conversation about a new feature release, Emily says: "The API endpoint for user authentication is experiencing high latency – around 380ms on average. We're seeing roughly 450 requests per minute, which seems normal for the initial rollout." Which of the following statements best reflects Emily's understanding?
A High latency indicates a critical system error and immediate investigation is required.
B The average latency of 380ms is excessively high and needs to be addressed urgently.
C The observed latency, combined with 450 requests per minute, suggests the system is performing as expected during a typical rollout.
D Emily's assessment doesn't take into account whether the API handles concurrent requests efficiently.
A High latency indicates a critical system error and immediate investigation is required.
B The average latency of 380ms is excessively high and needs to be addressed urgently.
C The observed latency, combined with 450 requests per minute, suggests the system is performing as expected during a typical rollout.
D Emily's assessment doesn't take into account whether the API handles concurrent requests efficiently.
Emily correctly interprets that the average latency of 380ms alongside 450 requests per minute suggests normal behavior for an initial feature release. This acknowledges that performance can vary during rollout and doesn't immediately flag a critical issue. Option A is too alarmist; option B incorrectly assumes high latency is always bad, and option D introduces a factor (concurrency) not explicitly mentioned.
34 / 36
A developer is reviewing a code change that adds caching to a database query. The previous version had an average response time of 1.2 seconds, while the new version with caching has an average response time of 250ms. Which metric primarily demonstrates the *benefit* of this change?
A Throughput – the number of queries processed per second.
B Latency – the time taken to complete a single query.
C The number of cached records.
D The size of the database table.
A Throughput – the number of queries processed per second.
B Latency – the time taken to complete a single query.
C The number of cached records.
D The size of the database table.
The primary benefit demonstrated by a significant reduction in latency (from 1.2 seconds to 250ms) is the improvement in *latency* itself. While throughput might also increase with caching, the core objective was to reduce response time for individual queries, which is directly reflected in this metric change.
35 / 36
You're analyzing data from a monitoring system for an e-commerce service. The system reports the following: Throughput – 500 requests per second; Average Latency – 600ms. Which of the following statements is MOST accurate?
A The service is performing optimally, with both high throughput and low latency.
B The service is experiencing performance issues due to high latency, regardless of throughput.
C The service's performance depends on the balance between throughput and latency; 500 requests per second and 600ms are acceptable values for this load.
D The service should immediately be scaled up to handle the high throughput.
A The service is performing optimally, with both high throughput and low latency.
B The service is experiencing performance issues due to high latency, regardless of throughput.
C The service's performance depends on the balance between throughput and latency; 500 requests per second and 600ms are acceptable values for this load.
D The service should immediately be scaled up to handle the high throughput.
The accuracy lies in understanding that both throughput (requests per second) and latency (response time) are important. 500 requests per second and 600ms represent a reasonable balance for many e-commerce services. Option A is overly optimistic; option B oversimplifies the situation; and option D suggests a premature scaling solution.
36 / 36
During a code review discussion, a developer proposes adding an index to a database table. The reviewer responds: "That's good – it should improve the query performance and reduce latency." What is the *primary* reason for this improvement?
A An index automatically increases the throughput of the database server.
B An index helps the database system quickly locate specific data, reducing the time required to retrieve it.
C Adding an index always guarantees a reduction in latency, regardless of the complexity of the query.
D An index automatically converts all queries into parallel execution.
A An index automatically increases the throughput of the database server.
B An index helps the database system quickly locate specific data, reducing the time required to retrieve it.
C Adding an index always guarantees a reduction in latency, regardless of the complexity of the query.
D An index automatically converts all queries into parallel execution.
The core function of an index is to speed up data retrieval. By providing a shortcut for locating specific records, it dramatically reduces the time (latency) required by the database system to respond to queries. Option A is incorrect; option C is misleading – latency reduction isn't guaranteed; and option D describes parallel execution, which is a separate optimization technique.
Related exercises:
IT-Specific Tricky Words →
Frequently Asked Questions
What does the "Technical Concepts — Parameter vs Argument, Latency vs Throughput — English for IT" exercise cover?
5 exercises on technical terms developers often confuse: parameter vs argument, method vs function, compile-time vs runtime, scalability vs performance, latency vs throughput vs bandwidth.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account, sign-up, or paywall.
How many questions are in "Technical Concepts — Parameter vs Argument, Latency vs Throughput — English for IT"?
This exercise has 36 questions. Each one gives instant feedback with an explanation, so you can see exactly why an answer is right or wrong.
Do I need to create an account to save my progress?
No account is required. The progress bar and score are tracked in your browser for the current session -- the exercise is designed to be a quick, repeatable drill rather than something you resume later.
What happens if I get an answer wrong?
You'll see the correct answer highlighted immediately, along with a short explanation of why it's correct. Wrong answers aren't penalized beyond your score, and you can keep going through every question.
How is this exercise different from reading an article?
Articles explain vocabulary and concepts through prose, while exercises like this one are interactive drills -- multiple-choice questions -- that test and reinforce your recall of specific terms and phrasing.
Can I retry this exercise?
Yes -- use the "Try again" button on the results screen to reset your score and go through all the questions again from the start.
Where can I find more False Friends & Tricky Words exercises?
Browse the full False Friends & Tricky Words hub for related drills, or check the site-wide exercises index for other IT English topics.
Is this exercise suitable for beginners?
This exercise assumes basic familiarity with IT terminology. If a term feels unfamiliar, check the site Glossary for a plain-English definition before attempting the questions.
How often is new content like this published?
New exercises are added regularly across all categories, alongside new vocabulary sets and articles. Check back on the exercises hub to see what's new.