TL;DR
Prime made for students and young adults
- Fast, free delivery for dorm and study essentials
- Prime Video and Amazon Music included
- Member-only deals
In an Oct. 5, 2026 post, software engineer matklad recommends tuning microbenchmark inputs so each run lasts about 300 milliseconds. The advice is a personal rule of thumb, not a measured standard: it aims to make results readable and perceptible while keeping repeated tests quick.
Software engineer matklad recommended setting a microbenchmark’s input size so a run takes about 300 milliseconds, arguing that this duration can make performance changes easier to notice without slowing repeated tests. The recommendation appeared in a post published Oct. 5, 2026, and is presented as a personal rule of thumb, not a universal benchmark standard.
Matklad’s suggested duration is intended to balance two competing concerns: very short tests may be affected by fixed costs, while long tests make it slower to repeat measurements. The post says runs faster than about 10 milliseconds may be skewed by overhead such as interpreter startup. Runs lasting hundreds of milliseconds, the author argues, give one-off costs more time to become less important without requiring more elaborate techniques to account for them.
The author also favors milliseconds because results can be read as whole numbers in the range of 1 to 999, without switching units or comparing decimal seconds with milliseconds. A result such as 239ms, the post says, is straightforward to scan. The target is not a guarantee of precision; it is a practical choice meant to support quick comparisons and repeated runs.
Matklad says the aim is less to obtain a perfectly precise performance measurement than to give the person running the test enough intuition to make a sound decision. A few hundred milliseconds is still quick for a person, the post says, but long enough to feel the difference between a lagging command and one that seems instant. The author also cautions against runs longer than a second because testing ten times to inspect variation should not take longer than necessary.
A Faster Feedback Loop for Optimization
The recommendation speaks to a practical choice developers face when writing small performance tests: how long should each run take? A test that finishes almost immediately can be difficult to interpret if startup and other fixed costs make up a large share of the measured time. A much longer test, meanwhile, can slow the cycle of changing code, rerunning the test and checking whether the change helped.
Matklad’s argument is that a run near 300ms can make this feedback loop manageable while giving developers an experience of the speed they are measuring. That can be useful when evaluating interactive tools, such as a command-line program, where perceived responsiveness matters alongside measured runtime. The post’s focus is developer judgment, however, rather than a claim that 300ms is statistically sufficient for every program or testing setup.
Popular right now
Ninja Foodi Smart 6-in-1 Indoor Grill and Air Fryer, 4 Qt, FG551
Vitamix Propel Series 510 Professional-Grade Blender, 3 Programs, Black
Samsung 85-Inch QN70H Neo QLED 4K Smart TV (2026)
As an affiliate, we earn on qualifying purchases.
The Trade-Off Behind Run Length
The post addresses microbenchmarks, small tests used to compare the performance of a particular operation or program change. Their results can be influenced by the test environment and by work that occurs around the operation itself. Matklad gives interpreter startup as one example of a fixed cost that may matter more when the measured task takes only a few milliseconds.
Instead of recommending a specific measurement framework or a method for statistically correcting results, the author proposes changing the input size until the test takes roughly the desired time. The post frames this as a way to keep results easy to read and make it practical to run a test multiple times. It does not provide experimental evidence comparing 300ms runs with other durations.
“My rule of thumb is to tweak the input size until the benchmark takes about 300ms.”
— Matklad, in the Oct. 5, 2026 post
Where the 300ms Rule May Not Fit
The post does not report a controlled study or benchmark data establishing that 300ms is the best duration. It also does not specify how many runs are needed for a reliable comparison, how much variation is acceptable, or how the recommendation should change across hardware and operating systems.
The author’s comments about overhead and human perception are presented as reasoning for the rule, not as measured findings in the post. Whether a few hundred milliseconds is suitable depends on what is being measured and how the benchmark is designed. Readers should not treat the suggested duration as a substitute for testing whether a particular measurement is stable.
Applying the Rule to Local Tests
The post offers a practical procedure rather than announcing a tool, formal standard or planned follow-up: adjust the benchmark’s input until a run takes around 300ms, then repeat it to get a sense of variation. Developers applying the advice would still need to check whether their test captures the work they intend to compare and whether fixed costs or other sources of noise affect their results.
No further study or follow-up announcement is identified in the source material. The next step for readers is to treat the target as a starting point, compare results in their own environment and use a more rigorous measurement approach when a decision requires greater precision.
Key Questions
What benchmark duration does matklad recommend?
The author recommends adjusting the input size so a microbenchmark takes about 300 milliseconds. The post describes this as a personal rule of thumb, not a required standard.
Why does the author argue against very short runs?
Matklad says runs faster than about 10 milliseconds may be skewed by fixed costs, such as interpreter startup. The post does not claim that all tests below that duration are unreliable.
Does a 300ms run guarantee an accurate result?
No. The post presents a practical recommendation for readability and iteration speed, not evidence that this duration guarantees accuracy. Benchmark stability still depends on the test and its environment.
What is the recommendation meant to help developers do?
It is meant to make performance comparisons easier to scan and repeat, while helping developers build intuition about whether an optimization has made a program feel faster.
Source: hn
