A column with 40 absent cells is added element-wise to a complete column of equal length — what does the result hold?
answer
- a hole is still an operand
- nothing to compute with
- absence wins the cell
- holes union across both operands
- chains accumulate, never recover
basics
~20 sForty cells of the result hold no value, and the remaining cells hold the sum. An operator meeting an absent operand carries the absence into its output rather than skipping it, substituting a zero, or raising an error.
solid answer
~50 sThe result is absent exactly where either operand was absent — here, 40 positions — and holds the sum everywhere else. That is the entire rule for arithmetic applied straight down a column: the operator works one cell at a time, and a cell with no value gives it nothing to compute with, so the matching output cell has no value either. Nothing is raised, nothing is skipped and no row is removed, which is what makes it easy to miss. The holes also *union*. If the second column had 40 absences of its own at different rows, the sum would carry up to 80. Chain three such steps and the output's absences are the union of every step's contribution, which is why a count taken only at the end of a pipeline tells you nothing about where they came from.
go deeper
Recall that arithmetic carries absence into its result instead of stepping over it. If a cell of either operand holds no value, the matching output cell holds no value, and the column keeps its length.
Explain the union: the output's absences are every operand's absences together, so a chain of steps accumulates them and a single count at the end cannot be attributed to any one step.
Show that you measure absence per step rather than at the end of a pipeline, because an end-of-pipeline count is produced equally by one bad input and by four mildly incomplete ones.
The standing tradeoff is where absence is allowed to enter at all: admit it early and propagate it honestly, or reject incomplete records at the boundary and pay for it in discarded data and an unhappy producer.
## The rule, stated once An **element-wise operation** — one operator applied straight down a whole column at once instead of once per record — works position by position. For each position it takes one value from each operand and produces one value for the result. If the cell in either operand holds no value, the operator has nothing to compute with at that position, so the result cell holds no value either. This is what **propagation** means: the hole is carried into the output. In the stated case, 40 positions of one operand hold nothing, so 40 positions of the sum hold nothing and the other 960 hold the sum of two present numbers. Three things the operator explicitly does **not** do: - **It does not raise.** The computation completes and hands back a full-length column. The absence is data, not a failure. - **It does not substitute a neutral value.** Treating an unrecorded reading as a zero is a claim about the world — that the thing not measured was zero — and an operator is not entitled to make that claim on your behalf. Substitution is a separate, deliberate step. - **It does not shorten the result.** No row is removed, so the output has exactly as many positions as the inputs, and it still lines up with every other column in the table. The silence is the point. A hole travelling through a chain of arithmetic raises nothing, logs nothing and changes no shape. The only visible consequence is that a number you expected is not there. ## Holes union; they do not cancel and they do not add When both operands carry absences, the result's absent positions are the **union** of the two operands' absent positions. That bounds the count on both sides: 1. If the two sets of positions coincide exactly, the result has the same count as each input — 40 and 40 give 40. 2. If they are completely disjoint, the result has the two counts together — 40 and 40 give 80. 3. Any partial overlap lands between the two, so the honest statement is "between 40 and 80", and you cannot narrow it without looking at the positions. What never happens is cancellation. A present value in one operand does not stand in for the missing one in the other; the operator needs both. ## Where the designs genuinely differ The propagation rule itself is common ground across this family. Several neighbouring behaviours are not, and a candidate who states a local habit as a law will be wrong in front of someone from another ecosystem. | Question about the result | One design | Another design | |---|---|---| | Is the result cell absent where an operand was? | Yes | Yes — this one does not vary | | What marks the absence in the output? | A pattern the floating-point format reserves for a result with no numeric answer, written into the value itself | A separate one-bit-per-row validity track beside the values, or a typed absence marker the tool defines | | Can absences appear at positions where no input had one? | Yes, where the operands carry their own row labels and the operator lines them up on the union of those labels | No, where the operands are plain positional rectangles of numbers, which match strictly by position | | Does a comparison behave like the arithmetic? | No — it yields no usable truth rather than an absent cell | No, and for a different reason again: a third outcome that is neither true nor false | The safe way to say any of this out loud is to attach the behaviour to the mechanism: *"where absence is written into the value as a reserved pattern…"*, *"where a validity bit is kept beside the values…"*. ## Why the compounding matters more than the single step A realistic derived column is the end of a chain: two inputs are combined, the result is scaled, the scaled column is combined with a third. Each step unions its operands' absences into its output, and each later step inherits the union. By the end, a single count of absent cells is the total contribution of every step in the chain and attributes to none of them. - A check placed only at the end tells you **how many** holes you have and nothing about **where** they entered. - The same end-count is produced by one bad input column and by four mildly incomplete ones. - Re-running the pipeline to bisect it is expensive and often not reproducible against a moving source. ## What to do about it - **Measure per step.** Record the count of absent cells per column immediately after each transform, not once at the end. The step where the count jumps is the step that owns the explanation. - **Decide before you compute.** Whether incomplete records are removed, stood up with a chosen value, or carried honestly into the output is a decision made once and written down, not one inherited from whatever an operator happened to do. - **Expect the output to be worse than any input.** Two columns that are each 96% complete do not produce a result that is 96% complete; they produce one somewhere between 96% and 92%. - **Never read a complete-looking result as evidence.** The column being full-length says nothing; only the absent-cell count does.
- Two 1,000-row columns each hold 40 absent cells. How many absences can their sum have?Between 40 and 80. If the two sets of absent positions coincide exactly, the sum has 40; if they are completely disjoint, it has 80; any partial overlap lands in between. The result's absences are the union of the operands', never the intersection, and never their arithmetic sum unless the two sets happen to be disjoint.
- Why does substituting a zero for the absent operand not solve the problem?Because it answers a different question. A zero is a reading; absence is the record that no reading exists, and substituting one commits you to a model — that the unmeasured quantity was zero — the data does not support. The arithmetic runs identically either way, so the commitment leaves no trace in the output. That is precisely why it belongs in an explicit step you can point at, not inside an operator.
saying these in an interview costs you the question
- Says the absent cells are treated as zero in the sum
- Expects a complete result because one operand was complete
- Thinks the operator raises as soon as an operand is absent
- Assumes the result is shortened by dropping the absent rows
- Believes the sum of two holed columns has as many holes as the worse one