Medium AI infra interview questions

Count two matrix shapes to derive the H100 ridge, throughput ceilings and time floors. Compare an illustrative measurement with its bound before deciding what to optimize.

Derive the weight-only shortcut, then add KV traffic and feasible eight-GPU placement. A worked latency floor shows why batch size alone cannot establish the decode bottleneck.

Use proportional bit layouts and adjacent values around one to distinguish range from precision. Then choose formats from numerical tests and actual kernel support.

Separate H200 bandwidth and capacity gains from measured speedup, then test realistic memory headroom and cost per useful completed workload.

Normalize link directions, count collective bytes, and see why a gradient reduction can outlast its real overlap window.

Compare the same 1,024 items under mixed and grouped lane assignments. Derive issue-work waste, then include regrouping and memory costs before claiming a speedup.

Derive a block-level occupancy limit, then compare the extra residency with spill traffic and lost reuse. Use a matched experiment rather than a target percentage.

Derive HBM bandwidth from interface width and pin rate, then connect it to a model that actually fits. Separate raw interface capacity from measured decode time.

See the GPU-instance and compute-instance boundaries, budget a small slice, and distinguish memory capacity controls from bandwidth isolation.

Compare host-staged and direct GPU-to-NIC transfers, count traffic at each boundary, and check transport selection before blaming a slow collective on missing GPUDirect.

Derive how reusing weights changes arithmetic intensity, then separate the roofline ceiling from tile-wave effects and measured GEMM throughput.

Trace a changed BF16 bit, distinguish corrected and uncorrectable errors, and calculate recovery cost without assuming every device has the same ECC overhead.

Specify a cluster from workload and facility constraints, then derive node counts, network ports, storage bursts and acceptance tests.

Compare GPU memory, decode traffic and measured useful throughput. Work out a capacity ceiling without mistaking it for a performance forecast.

Compare rack-level power, cooling, structural and connectivity requirements with the offered site, then evaluate quoted deployment alternatives.

Diagnose failed 800G links using endpoint compatibility, lane modes, inventory and controlled swaps. Learn why speed labels and failure patterns do not prove a cause.

Build a cluster power budget with clear equipment boundaries, facility overhead and failover requirements. Distinguish energy use from reserved electrical capacity.

Bring up the supported hardware and software stack one dependency at a time, then prove correctness and recovery at increasing scale.

Size adapter and full-parameter jobs before comparing RTX PRO 6000 and H100. Test memory headroom, MIG packing, software support and real communication costs.

Count one complete rail, then distinguish logical links from cages, optical modules and cable assemblies. Derive power from the same physical inventory.

Build a storage budget that includes retained checkpoints, the next save, overlapping datasets and failure protection. Then check whether the same tier can meet write and restore deadlines.

Compare cooling methods from the supported hardware and heat path. Calculate airflow or liquid flow, then verify capacity, residual air load and failure response.

Estimate replacement demand over replenishment time, then size for shortage risk and failure correlation. Distinguish shelf parts from runnable spare nodes.

Separate compute, storage and management responsibilities, then decide which need independent physical paths and count their endpoints correctly.

Compare ownership, colocation and rental using the same useful work, full annual costs and realistic demand. Work a break-even from explicit assumptions.

Fabric Manager helps make an NVSwitch system ready. Learn the platform-specific roles, failure symptoms and checks that prove the communication path works.

Map stable endpoints to rails, choose supported cables from measured routes, and verify topology before interpreting collective performance.

Test the vendor claim on your workload, including quality, latency, scaling and operating costs. A lower peak or lower price alone does not settle it.

Gate admission with fresh, platform-aware evidence. Use absolute and peer baselines, budget test overhead and keep automated cordons under control.

Define who owns each facility and hardware action, model restoration time, and verify power, cooling, telemetry and growth commitments before deployment.

Collect stable device identities, versions and freshness, then compare them with approved configurations and retain the history for investigations.

Compare the old fleet's useful value with operating costs and resale, verify its health, and complete data handling before reassignment or transfer.

Build a mask-aware classifier that counts complete byte intervals, separates duplicate lane demand from distinct bytes, and streams trace summaries.

Derive the bank mapping before and after padding, trace a fixed-tile kernel, and measure whether the saved conflict outweighs other resource costs.

Trace stable row normalization, handle independent strides and fully masked inputs, then separate fusion traffic from measured speed.

Derive resident-block limits and distinguish resident warps from ready work before trading registers for more occupancy.

Follow the running maximum and weighted sum across attention tiles, with executable arithmetic and an honest memory-traffic comparison.

Start with the operation, supported hardware and performance target. Compare ordinary Triton, lower-level Triton interfaces and CUDA using a measured gap that is large enough to justify maintaining custom code.

Build a reduction with a checked tail, one partial result per block and a final combine. Count the input bytes, then investigate the instructions, synchronization and numerical behavior that a bandwidth estimate leaves out.

Trace how a shared-memory tile turns coalesced input rows into coalesced output rows. Then separate global sector footprints, shared-bank conflicts and measured bandwidth, including the cost of handling edge tiles.

Follow graph capture, guards, differentiation and generated kernels. Then distinguish graph breaks from recompilation and measure whether warm execution repays compilation and startup costs.

An asynchronous call returns early, but the timeline still shows copies and kernels taking turns. Derive the pipeline's fill and drain costs, then check dependencies, buffers and hardware before expecting overlap.

Watch a low-precision sum stop changing and a small weight update round away. Separate storage precision, accumulation, optimizer state and dynamic range before choosing a mixed-precision training policy.

Choose between local candidates, radix selection and sorting from k and the required output. A tested FP32 reference makes ties, signed zero, NaNs and threshold selection explicit.

A few extra live values can change register allocation, residency, generated instructions or spills. Compare compiler evidence with runtime behavior before attributing a 30% slowdown to any one of them.

Compare FSDP2 and ZeRO-3 through one parameter group’s lifetime, a scoped traffic model and a save-resume experiment, rather than a universal speed ranking.

Separate the 100B memory floor from the training deadline, then compare two 1,024-GPU layouts with their actual state ownership and communication schedules.

Trace a chunk, derive both traffic phases, and state the endpoint model behind bandwidth optimality. A worked example shows why nearly constant bytes do not imply constant completion time.

Trace a legal two-stage schedule and count its idle slots. Separate bubble denominators and explain how 1F1B changes activation lifetimes under explicit assumptions.

Count tensor-parallel messages and compare their payload service time on two explicit paths. Explain why TP8 is a common placement choice, not a fixed ceiling.

Follow saved and recomputed values through backward. Compare complete update time and peak memory instead of promising a fixed memory saving or slowdown.

Separate gradient range from update precision using a small numerical example, and make the training-state recipe explicit.

Use per-rank arrival times and controlled substitutions to explain a slow step without mistaking collective wait for network transfer.

Read a watchdog timeout without blaming the reporting rank. Compare group-scoped traces, separate missing evidence from mismatched calls, and distinguish CPU submission from GPU completion.

Offline DPO trains on existing preference pairs, so online rollout and reward services leave the update loop. Account for both responses, decide whether reference scores can be cached, and retain the data-generation and evaluation costs outside training.

Trace one cache position through a block table, calculate the memory recovered from oversized reservations, and explain why sharing still needs careful writes and matching.

Work from each GPU's cache budget, reserve room for generated tokens, then check latency separately. A limiting-rank example shows why fitting today's prompts is not enough to admit tomorrow's work.

Trace a 20,000-token prompt through a shared token budget, including the last partial chunk. Then choose a setting from measured first-token waits and streaming gaps.

Trace an accepted prefix, a rejection and the correction token; derive emitted progress and compare it with a measured round cost.

Draw query-head sharing, count actual stored state and compare payloads with explicit model geometry and binary units.

Separate weight storage, matrix arithmetic and attention-cache precision. Choose a supported candidate using task quality, memory and service measurements.

Two requests share 2,000 leading tokens but ask different questions afterward. Follow the shared state through a branch, calculate the reusable blocks, and distinguish memory savings from measured latency savings.

Preserve document identity through packed prompts and completion reordering. Derive rounded cache reservations, then measure feasible wave sizes against the API contract.

Trace a dropped stream through bounded queues, engine cancellation and safe resource release; define what retries and incomplete delivery mean.

Separate device throughput bounds from measured service curves, then choose a feasible operating point using latency, quality and goodput.

Thirty percent GPU utilization means kernels ran during about thirty percent of the sampled time. Find out what limits those kernels, what happens between them, and whether requests are meeting their latency targets.

Greedy decoding chooses the highest-scoring token, but identical prompt text does not guarantee identical inputs or numerical execution. Check the effective request and deployment, investigate the first differing token, and define the reproducibility guarantee precisely.

Work two audio timelines: input accumulation before transcription and playback starvation after synthesis. Compare real-time factor, response delay and safe concurrent capacity without mixing their units.

Derive a deployment candidate from the official tensor index, then account for latent-cache replication and the product workload. A worked example shows why enough aggregate HBM can still leave every GPU out of memory.

Find which startup step runs out of memory, count the allocations on that GPU, and change the setting that controls the shortage.

Turn public metadata into a deployment candidate with explicit uncertainty. Inspect architecture, stored formats and engine support, then work a per-rank memory example that explains why an aggregate fit can fail.

Measure reachable prefix reuse, separate token savings from latency, and compare both engines on the same agent contract and resource budget.

Derive a prompt-plus-output contract, calculate per-rank state capacity, and measure the concurrency that meets latency and overload targets.

The answers sound fluent, but the scores dropped. Compare inputs, generation settings, raw output, parsing and scoring to find where the new deployment differs.

Define a reproducible workload and service contract, account for every offered request, and choose a measured operating region with evidence and margin.

Compare actual encoded tensors, per-rank runtime fit, supported kernels and held-out task quality. Four-bit weight-only kernels can accelerate wider arithmetic, and smaller weights need not reduce the GPU count.

A repeated-prompt test measures one reuse pattern. Production gains depend on token-weighted reuse, routing, residency, alignment and the prefill share of latency; a falling hit rate does not uniquely identify eviction.

The output forecast is a starting point. Match the prompt and state workload, derive replica counts from an SLO-tested rate, check simultaneous loss scenarios and keep the cost denominator consistent with the forecast.

Confirm that requests are waiting for usable state capacity. Separate allocated memory, live blocks and evictable prefixes, then compare admission, lower-precision state, prefix sharing and hardware changes with explicit assumptions.

Price the same workload and service guarantees, including input tokens, idle capacity, failures and operations. Then check whether the algebraic crossover fits the fleet before treating it as a buying decision.

An apparent outlier can reflect workload mix, queueing, runtime state or a degraded execution path. Normalize the comparison, run a matched replay and use critical-path arithmetic to test possible causes.

A minor revision can change weights, encoding or response behavior. Compare pinned deployment bundles, evaluate task slices, monitor a representative canary and keep enough capacity to restore the old service.

Apply the project’s offline tuning guidance in context, derive the memory tradeoff, and use workload-specific acceptance criteria instead of universal queue and headroom targets.

Separate pre-routing from a sequential cascade, charge every attempted generation, and measure checker mistakes. A lower escalation rate is not proof of higher quality, and the largest model is not a correctness oracle.

Follow media through fetching, preprocessing, encoding and language-model execution. Derive visual positions from the actual processor output, account for encoder placement and separate the caches and latency stages that text-only monitoring misses.

A partial drop does not rule out the parser. Define success and its denominator, trace failures through encoding, generation, parsing and execution, then replay the relevant boundary with controlled versions.

Constrained decoding restricts valid continuations; it does not guarantee completion or correct values. Define success and error contracts, validate supported schemas, and measure compilation, masking and queueing under the actual workload.

Screen exact checkpoints for hard requirements, then compare deployable candidates on held-out product tasks, service limits and total cost. Smaller artifacts, leaderboard scores and token rates each answer only part of the decision.

A mutable branch or local model directory can change what a restarted replica loads. Establish the actual artifact identity, separate disk evidence from loaded state, and make rollout and restart behavior reproducible.

Follow a shard index to the tensors a loader actually receives. Diagnose a missing file and a shape mismatch, then check architecture, quantization and request compatibility before changing hardware.

Map a checkpoint format to compute capability, then say which part of the speedup survives on each generation. The same file can load on two GPUs and take two different execution paths.

A measured run shows where the time goes in a small batch job, then why every result parsed but none was deliverable. The answer turns on startup cost, co-tenant latency and a per-item contract.

Walk a single-GPU vLLM Deployment from pod scheduling to the first token, then show the three settings that turn a working manifest into restart loops and stuck rollouts.

Solve for useful throughput, round to a supported parallel layout, and account for calendar time once. The right GPU count need not be a power of two.

Compute cost from a matched bill and token count. Show when an activity factor belongs in the denominator and when it would double-count idle time.

Separate frozen weights from trainable state, count rank-16 adapters from matrix shapes, and check peak memory before choosing a fine-tuning layout.

Turn FLOPs and HBM bytes into resource bounds, then compare them with elapsed time. A tighter memory bound suggests an investigation rather than proving the measured bottleneck.

Count gradient traffic with the actual dtype, convert one-direction rates, and expose the bucket-readiness constraint that an average bandwidth division misses.

Work through projection and attention FLOPs for an 8,192-token prompt. Separate a peak-based lower bound, an assumed-rate estimate and observed TTFT.

Derive GPU-hours from an explicit FLOP convention, compare Meta’s 30.84 million reported hours, and avoid mistaking the residual for a measured MFU.

Inventory a resumable checkpoint instead of rounding its bytes per parameter. Trace snapshot stall, durable drain and publication, then calculate the storage floor.

Build a power budget from complete servers to the facility meter, then check rack limits and distinguish a design maximum from an annual electricity bill.

Calculate FP8 savings by separating weights, KV cache and other step costs. Compare the same batch first, then check whether larger batches meet latency and quality targets.

Derive ring all-reduce traffic, match directional bytes to bandwidth, and check memory feasibility before estimating the communication exposed on a training step.

Count weight and cache traffic on a specified B200 configuration, check finite capacity, and separate aggregate throughput from per-user pace. Worked bounds guide a benchmark rather than replace it.

Calculate the fleet, duration and rental budget for a 7B training run. Check the deadline, actual sharding scheme and paid reservation period before placing the order.

Choose between supported InfiniBand and RoCE designs using workload tests, congestion behavior and a complete cost model.

Follow corresponding GPU positions through a rail, including the leaf and spine links needed when one rail outgrows a switch.

A bandwidth regression narrows the search only after the experiment is defined. Work through rank-count normalization, controlled path tests and the difference between collective time and training progress.

Compare serialized and overlapped storage paths, then test whether direct GPU I/O improves the actual pipeline stage.

Design a durable dataset and optional working-set cache around access semantics, request overhead and versioned readiness.

Measure batch readiness and producer capacity, then size prefetch for bursts without hiding a sustained throughput deficit.

Separate NCCL logging, device selection and execution overrides from PyTorch failure handling. Work through a faster collective that makes the job slower, and learn which timeout actually fired.

Separate host-buffer, GPU-buffer and collective tests, with explicit message-size models and bandwidth metric definitions.

Derive bandwidth from actual per-rank traffic and readiness deadlines, showing why bucketing cannot erase a capacity shortfall.

Compare tensor, pipeline and expert traffic with per-request KV transfer. Work through declared payload and latency assumptions before choosing a serving network.

Calculate how many reads a training loader needs in flight, then see when larger requests waste bandwidth. Worked examples separate useful samples, fetched bytes, prefetch and the limits of Little's Law.

Can one storage system serve datasets and checkpoints? Follow a save from staging to recovery, calculate its budget beside protected reads, and learn when separate paths actually solve the contention.

Distinguish GPU-memory capability, registration and selected transport. Compare direct and staged paths without relying on a half-speed rule or one log substring.

Choose the control plane from job admission, placement, recovery and service needs, with a concrete partial-allocation failure.

Design fractional GPU admission around explicit shapes and enforceable guarantees, then reconcile reservations with the runtime.

Use actual rank placement and measured job duration to decide whether waiting for locality beats starting immediately.

Separate quota, borrowing, reclaim latency and fairness, with a demand-conserving example of when pooling improves utilization.

Diagnose GPU pod failures by scheduling, container startup and execution boundaries, without treating Allocatable as a health certificate.

Balance durable checkpoint cost against replay and restart loss, with explicit assumptions and a warning sign when the approximation breaks down.

Trace Kubernetes pod placement and Ray bundle reservation as separate layers, including logical GPU limits and autoscaling delay.

Measure scheduling, image transfer, unpacking and model initialization separately. A missing-device error needs its own checks for allocation, container access and CUDA compatibility.

Compare the cost of committed capacity with the demand each additional GPU would actually serve. Keep billing discounts separate from capacity guarantees, and account for bursts without counting the same work twice.

DRA gives the scheduler device claims and attributes to work with. Compare that with extended-resource counts, then check the deployed driver and controller support before promising sharing, partitioning or gang placement.

Use a short admission check for recent changes and a deeper acceptance suite for new or repaired nodes. Set thresholds from matched healthy baselines, and make quarantine and return-to-service decisions explicit.

Follow a GPU request from node inventory through allocation, device confinement and task launch. A single-node, eight-task example shows how resource shape and per-task device numbering fit together.

Make readiness mean that the engine can serve, scale from measured demand and ready capacity, and drain streams before termination. Kubernetes can implement these controls; an operator packages and reconciles them.

Size notebook capacity from concurrent demand, memory needs and burst tolerance. Choose a sharing mode for the trust model, and make idle release explicit about which state can actually be restored.

Build observability around durable useful progress and aligned phase timing, showing why full-step timers can hide the late rank.

Investigate rising corrected-memory errors without promising a failure prediction, and follow recovery flags and vendor repair criteria.

Handle an inaccessible GPU with bounded recovery and preserved evidence, without treating a reboot or repeat count as proof of root cause.

Find the critical-path delay using local phase timing and controlled comparisons, rather than diagnosing a node from utilization or clock ratios.

Derive a checkpoint interval from measured job interruptions and exposed save cost. Trace durability, lost work and recovery before treating an estimate as goodput.

Promise measurable job outcomes: time to useful work, recoverable progress and successful restoration. Define the population and exclusions before choosing targets, and give each error budget an agreed operating policy.

Define request success, first-output latency and streaming continuity for each service class. Count bad outcomes against an explicit budget, then use paired long and short windows to detect significant ongoing degradation.

Build an acceptance suite around the node’s intended workload and supported hardware limits. Combine configuration, correctness, communication and sustained-load evidence, then record a baseline and an explicit return-to-service decision.

Correlate clock-event reasons, temperature, configured limits and workload timing. Use the scope of the slowdown to choose the next investigation, and distinguish intentional power limits from unexpected thermal constraints.

Page when material impact or risk needs timely human action. Verify that automation actually recovered the workload, group related events, and use measured responder load to improve the policy.

Stop rollout expansion, preserve evidence and use the safest available mitigation. Compare versions under representative load, and size canary exposure from the regression you need to detect rather than a fixed traffic percentage.

Define which work survived, count the resources it occupied, and explain the remaining time without counting the same delay twice.

Page when timely human action matters. Use budget burn, careful grouping, bounded maintenance rules, and regular testing to keep those pages useful.

Follow a request from the client's connection pool to the first text on screen. Work the timing budget, locate a buffering delay and choose what to trace without losing the slow requests.

Compare equivalent requests, inspect the replica’s software and device state, and reduce new traffic only after checking where that load will go.

Build an incident-review process that leads to verified changes. Set review thresholds, budget the work and interpret recurrence without mistaking a metric for proof.

Track request admission through a concrete page-reservation example, then connect scheduling, growth and stream cleanup to measured service limits.

Trace GPU credits through reservation, allocation, metering and settlement, with crash-safe ownership and a separate fairness policy.

Four result rows can still hide a missing case. Build immutable evaluation identities, retry-safe commits, versioned scoring and a capacity estimate tied to measured prompt throughput.

Derive adapter bytes from the target matrices, share compatible base weights, and keep each request's cache identity separate. A worked pool design avoids applying the mixed-adapter cost twice.

A 60-second demand ramp meets a 70-second startup delay. Compare the rate and ready-capacity curves, then design a controller that tracks pending launches without a blind cooldown.

Bind weights, tokenizer, configuration and evaluation to one immutable release. Follow verification, prefetch, canary readiness and rollback, with bandwidth floors that do not pretend to be rollout measurements.

Divide one token budget across gateways instead of copying it. Follow output reservation and settlement, then handle grants, retries and outages without inventing extra burst capacity.

Separate durable conversation state from live generation, bound streaming buffers, and make reconnect, cancellation and free-tier budgets explicit.

Trace a stalled stream without unbounded telemetry, understand what sampling loses, and reconcile GPU allocation with a stated cost policy.

A team returns to claim its GPUs, but another team is borrowing them in one indivisible job. Work through the quota tree, whole-job reclaim, recovery costs and release-to-ready budget before promising a start time.

Trace usage from execution to one settled charge. Distinguish requests, attempts and events, then handle cancellation, late records, replay and reconciliation.

Define model aliases, permission-aware routing, response reuse and bounded retries. Trace a request whose cached answer becomes invalid after its source permissions change.

Per key, an ascending list of versions and a parallel list of values, with reads doing a binary search. The three cases that decide whether the design is right: a key that did not exist yet, a key that was deleted, and a version at which some other key was written.

Implement size- and timer-triggered batching, then test cancellation, handler errors and the latency added before dispatch.

Implement priority admission and completion, preserve a preempted job’s sequence, and distinguish a sufficient greedy victim set from an optimal one.

Stream a trace with an explicit record format, bounded access groups and measured aggregation size. Preserve group identity and report rejected data.

Build a byte-budget cache with reference-counted pins and admission that preserves existing entries when it fails.

Implement a bounded producer-consumer pipeline with explicit shutdown and error reporting. Keep work outside collection locks and account for memory beyond the input queue.

Compare three GPU placement heuristics with executable traces. Show how admission and free-space shape change, then add workload and topology constraints.

Decode fragmented UTF-8 with an incremental codec. Test malformed bytes, truncated endings and the boundary between byte decoding and event parsing.

Simulate both phases of ring all-reduce and verify values, preserved inputs and each rank’s payload bytes.

Write a bounded Go downloader that propagates cancellation, joins every worker and publishes files under explicit unique names.

Reconstruct GPU-hour intervals, clip them to a period and preserve provisional usage and conflicting-event evidence.

Implement bounded recovery probes, state-generation tickets and a recent failure window. Test concurrency and late completions.

Detect missing and silent ranks from a roster, distinguish liveness from progress, and derive thresholds without assuming independent delays.

Implement shared and sharded C++ counters, explain relaxed ordering and test final counts without promising unmeasured scaling.

Compare standard-map guarantees with flat-table layouts. Implement bounded probing and choose from semantics and representative measurements.

Derive and simulate speculative output counts, then compare them with explicitly assumed or measured round costs.

Design job creation, cancellation and listing around retries, durable ownership and an explicit pagination contract.

Write and verify tiled NumPy matmul, derive its logical footprint and distinguish a cache model from the causes of measured runtime.

Clarify what the 256-GPU request must accomplish, then compare it with real placement and quota constraints. Offer a feasible alternative and explain who can decide when teams’ priorities conflict.

Explain the reason for an unpopular migration, choose informative rollout cohorts and describe recovery, communication and transition cost without inventing an incident.

Connect your view on AI safety to systems you could build: model access, audit evidence, evaluation capacity and a tested way to stop or reverse a release. Explain the costs and limits of each control.

Compare net time saved, maintenance and failure risk before automating. Work a payback example and explain why concurrency limits alone do not bound repeated damage.

Explain how a plausible diagnosis became too certain, what disproved it and what changed in your investigation. Separate observed symptoms from causal evidence.

Plan a useful first month by tracing a real job, reviewing incidents, helping under supervision and shipping a bounded improvement with the team.

Separate a disagreement about measurements from a real capacity shortage. Work a reclaim example, expose the missing reserve and escalate an authorized decision.

Show a cost reduction with comparable service evidence, realized savings and a feasible recovery plan. Distinguish a quiet trial from proof of unchanged reliability.

Use an evidence-based timeline, specific contributing conditions and verified follow-up to make a postmortem useful.

Move a vendor case forward with controlled comparisons, a faithful reproduction and a safe mitigation. Escalate by impact while evidence improves.

Support a new responder without turning an outage into an exam. Choose an appropriate role, explain handoffs and review the decisions afterward.

Coordinate simultaneous incidents with the people available. Contain urgent harm, assign next actions and revisit priorities as evidence changes.

Explain a decision under uncertainty through the cost of waiting, bounded exposure and evidence that changes the next action.

Turn a design disagreement into a concrete comparison. Use a gang-scheduling example to explain evidence, decision ownership and responsible follow-through.

Explain a career move using the actual role, team and your priorities. Test assumptions about ownership, hardware access and support.

Connect a researcher tool to the workflow it improved. Measure the whole loop, meaningful adoption and effects on other users.