The constant was chosen by someone who left

# Self-authored for the EML case corpus (no external origin). The constant is
# 4096 and nobody currently on the team knows why. What depends on it is
# computed below.
#
# Leaving it alone is the correct default. It has worked for six years, the
# person who chose it was competent, and a number that has survived that long in
# production has been tested by more traffic than any experiment anybody could
# run this quarter.
#
# "It works" is evidence about the current value and not about the reasoning.
# Whether the constraint that produced it still exists is a separate question,
# and it is one the number cannot answer, because a constant that is right for
# a reason and a constant that is right by accident look identical.
#
# The dependents are enumerated and the original constraint is checked.

4096 => value
6 => years_in_place

# [what depends on it, would break if it changed, was it derived from the constant or the other way round]
[["buffer allocation", 1, "derived from it"], ["page size in the on-disk format", 1, "derived from it"], ["the batch size in the importer", 1, "copied it"], ["a test fixture", 0, "copied it"], ["the retry chunk size", 1, "copied it"], ["a comment in the protocol doc", 0, "describes it"]] => dependents

len(dependents) => n
0 => breaking
0 => copied
for d in dependents:
    breaking + d[1] => breaking
    if d[2] == "copied it":
        copied + 1 => copied

"the constant : " + str(value) + ", in place " + str(years_in_place) + " years" ^0
"places that reference it : " + str(n) ^0
"  would break if it changed : " + str(breaking) ^0
"  that copied the number rather than importing it : " + str(copied) ^0
"" ^0

"dependent                        breaks   relationship" ^0
for d in dependents:
    "" => b
    if d[1] == 1:
        b + "yes" => b
    else:
        b + "no " => b
    "  " + d[0] + "   " + b + "      " + d[2] ^0
"" ^0

# ---- the constraint it was chosen for ----
#
# The original reason is recoverable: a disk page was 4096 bytes on the
# hardware of the time. Whether that is still the binding constraint is a
# question about today's hardware, not about the number.

[["the disk page on the 2020 hardware", 4096, 0], ["the disk page on the current hardware", 16384, 1], ["the network MTU path", 1500, 1], ["the allocator bucket", 8192, 1]] => constraints

"candidate constraints, and whether they still hold" ^0
0 => still_true
0 => matching
for c in constraints:
    "" => mark
    if c[2] == 1:
        mark + "current" => mark
        still_true + 1 => still_true
    else:
        mark + "gone   " => mark
    if c[1] == value:
        matching + 1 => matching
    "  " + c[0] + " : " + str(c[1]) + "  " + mark ^0
"" ^0
"constraints that still hold : " + str(still_true) + " of " + str(len(constraints)) ^0
"constraints whose value equals the constant : " + str(matching) ^0
if matching > 0:
    if still_true > 0:
        0 => matching_and_current
        for c in constraints:
            if c[1] == value:
                if c[2] == 1:
                    matching_and_current + 1 => matching_and_current
        "constraints that both hold today AND equal the constant : " + str(matching_and_current) ^0
        if matching_and_current == 0:
            "  none - the only constraint the number matches is the one that is gone" ^0
"" ^0

# ---- what "it works" establishes ----

"what six years of working establishes" ^0
"  the value does not break anything today : yes" ^0
"  the value is optimal today              : not tested" ^0
"  the reason for the value still holds    : not tested" ^0
"  a number that is right by accident produces exactly this evidence" ^0
"" ^0

# ---- what it costs to find out ----

"measuring it instead of reasoning about it" ^0
"  candidates to try : the " + str(still_true) + " constraints that still hold" ^0
"  what a benchmark answers : which value is fastest on this hardware" ^0
"  what it does not answer  : which of the " + str(copied) + " copies would also have to move" ^0
"  the copies are the expensive part, and they are expensive because the" ^0
"  number was copied rather than imported" ^0
"" ^0

# ---- the control: a constant with its reason attached ----
#
# Where the constant is derived in the code from the thing that constrains it,
# the reason cannot be lost and the value follows the hardware.

"control - the same constant written as a derivation" ^0
"  page_size = query_the_filesystem()" ^0
"  places that would need updating when the hardware changes : 0" ^0
"  what is lost : nothing, on this dependent set" ^0
"  what is gained : the question this case is about cannot be asked, because" ^0
"  the reason is in the expression" ^0
"" ^0

"The number has survived six years of production and the person who chose it" ^0
"knew the hardware. Working is evidence about the value; the constraint it" ^0
"was derived from is a separate fact, and it is the one that expired." ^0

value = 4096
years_in_place = 6
dependents = [["buffer allocation", 1, "derived from it"], ["page size in the on-disk format", 1, "derived from it"], ["the batch size in the importer", 1, "copied it"], ["a test fixture", 0, "copied it"], ["the retry chunk size", 1, "copied it"], ["a comment in the protocol doc", 0, "describes it"]]
n = len(dependents)
breaking = 0
copied = 0
for d in dependents:
    breaking = breaking + d[1]
    if d[2] == "copied it":
        copied = copied + 1
print("the constant : " + str(value) + ", in place " + str(years_in_place) + " years")
print("places that reference it : " + str(n))
print("  would break if it changed : " + str(breaking))
print("  that copied the number rather than importing it : " + str(copied))
print("")
print("dependent                        breaks   relationship")
for d in dependents:
    b = ""
    if d[1] == 1:
        b = b + "yes"
    else:
        b = b + "no "
    print("  " + d[0] + "   " + b + "      " + d[2])
print("")
constraints = [["the disk page on the 2020 hardware", 4096, 0], ["the disk page on the current hardware", 16384, 1], ["the network MTU path", 1500, 1], ["the allocator bucket", 8192, 1]]
print("candidate constraints, and whether they still hold")
still_true = 0
matching = 0
for c in constraints:
    mark = ""
    if c[2] == 1:
        mark = mark + "current"
        still_true = still_true + 1
    else:
        mark = mark + "gone   "
    if c[1] == value:
        matching = matching + 1
    print("  " + c[0] + " : " + str(c[1]) + "  " + mark)
print("")
print("constraints that still hold : " + str(still_true) + " of " + str(len(constraints)))
print("constraints whose value equals the constant : " + str(matching))
if matching > 0:
    if still_true > 0:
        matching_and_current = 0
        for c in constraints:
            if c[1] == value:
                if c[2] == 1:
                    matching_and_current = matching_and_current + 1
        print("constraints that both hold today AND equal the constant : " + str(matching_and_current))
        if matching_and_current == 0:
            print("  none - the only constraint the number matches is the one that is gone")
print("")
print("what six years of working establishes")
print("  the value does not break anything today : yes")
print("  the value is optimal today              : not tested")
print("  the reason for the value still holds    : not tested")
print("  a number that is right by accident produces exactly this evidence")
print("")
print("measuring it instead of reasoning about it")
print("  candidates to try : the " + str(still_true) + " constraints that still hold")
print("  what a benchmark answers : which value is fastest on this hardware")
print("  what it does not answer  : which of the " + str(copied) + " copies would also have to move")
print("  the copies are the expensive part, and they are expensive because the")
print("  number was copied rather than imported")
print("")
print("control - the same constant written as a derivation")
print("  page_size = query_the_filesystem()")
print("  places that would need updating when the hardware changes : 0")
print("  what is lost : nothing, on this dependent set")
print("  what is gained : the question this case is about cannot be asked, because")
print("  the reason is in the expression")
print("")
print("The number has survived six years of production and the person who chose it")
print("knew the hardware. Working is evidence about the value; the constraint it")
print("was derived from is a separate fact, and it is the one that expired.")

the constant : 4096, in place 6 years
places that reference it : 6
  would break if it changed : 4
  that copied the number rather than importing it : 3

dependent                        breaks   relationship
  buffer allocation   yes      derived from it
  page size in the on-disk format   yes      derived from it
  the batch size in the importer   yes      copied it
  a test fixture   no       copied it
  the retry chunk size   yes      copied it
  a comment in the protocol doc   no       describes it

candidate constraints, and whether they still hold
  the disk page on the 2020 hardware : 4096  gone   
  the disk page on the current hardware : 16384  current
  the network MTU path : 1500  current
  the allocator bucket : 8192  current

constraints that still hold : 3 of 4
constraints whose value equals the constant : 1
constraints that both hold today AND equal the constant : 0
  none - the only constraint the number matches is the one that is gone

what six years of working establishes
  the value does not break anything today : yes
  the value is optimal today              : not tested
  the reason for the value still holds    : not tested
  a number that is right by accident produces exactly this evidence

measuring it instead of reasoning about it
  candidates to try : the 3 constraints that still hold
  what a benchmark answers : which value is fastest on this hardware
  what it does not answer  : which of the 3 copies would also have to move
  the copies are the expensive part, and they are expensive because the
  number was copied rather than imported

control - the same constant written as a derivation
  page_size = query_the_filesystem()
  places that would need updating when the hardware changes : 0
  what is lost : nothing, on this dependent set
  what is gained : the question this case is about cannot be asked, because
  the reason is in the expression

The number has survived six years of production and the person who chose it
knew the hardware. Working is evidence about the value; the constraint it
was derived from is a separate fact, and it is the one that expired.

Trace event types