ApiaryActiveLive
Try: pause · settings · learn · wipe
← Community / Reading Room
RW
craft · 24 min read

Record When the Build Ran and How Long It Took With Different Clocks

A public archive prints a small event program as HTML. The team changes its template renderer and runs a before and after comparison on a development machine.…

AI disclosure: Drafted with AI assistance for Apiary. The build, fixtures, and timing values are invented examples rather than benchmark results.

A public archive prints a small event program as HTML. The team changes its template renderer and runs a before and after comparison on a development machine. The new build's log says it began at 15:14:02 and ended at 15:13:57. The run did not travel backward. The machine's time of day shifted, and the script tried to turn two time-of-day readings into an elapsed duration. Once that impossible negative value lands in a spreadsheet, someone has to decide whether to delete a row, clean it into a positive number, or report that the comparison lost its evidence. None of those fixes reconstructs a trustworthy measure of the work that actually ran.

The clock that places an event on a calendar and the clock that measures a short interval serve different purposes. Preserve both in a build receipt. A wall-clock timestamp can link the run to a maintenance log, a review, or a host incident. An elapsed measure adds a statement about what happened between start and finish within a defined local observation. Each needs its own label, origin, units, and limitations. A short build harness that separates these two signals can find timing mistakes without pretending to resolve distributed time or prove why a machine slowed down.

Specify the interval before choosing the timer

A build can mean many operations. If the question is how long a developer waits from invoking a local command until it exits, a wrapper's elapsed clock should start immediately before launch and stop when the child returns. That measurement may include process startup, a cache lookup, and a flush to disk. If the question is just how long expanding a local template takes, instrument an intentionally narrower pair of landmarks inside the build. Do not compare the wrapper's 11 seconds to the renderer's 2 seconds and call it a performance improvement. The numbers describe different boundaries.

Write the operation in a sentence that can be checked against the receipt. The invented team measures launch to successful child exit for a single command running against a fixed synthetic catalog of 80 records. Dependency installation, remote fetches, and preview-server startup are separate. This definition may differ from a real developer's full wait, but it is an honest isolated comparison. A follow-up test can measure the workflow with those extra steps added. Name that test accordingly and choose whether it can be compared across runs with different external service conditions.

CPU execution time is also not a synonym for elapsed time. A process can finish in four elapsed seconds while spending only one second on a CPU when most of its work waits for I/O. Several threads can accumulate more CPU time than the elapsed interval. Metrics about machine load or CPU can still be valuable evidence, but only if their scope is named: wrapper, build child, process group, or entire machine. A timer measuring just the Python wrapper's CPU won't capture much about a child process doing the rendering. Add those metrics when they answer a question; do not blur them into the single number called build time.

Decide whether an interrupted run belongs in the performance comparison. A failed build can be timed for diagnosis, but don't include it as a fast successful attempt. Keep it with status and reason. A timeout may record the time at which the harness gave up rather than a complete elapsed run. A successful command that prints diagnostics and writes no full output is also not automatically comparable with an earlier run that produced HTML. A defensible comparison checks output coverage across runs and makes the stop condition explicit. It doesn't reward programs for silently doing less.

Read a time of day and an elapsed clock

In Python, the runtime time documentation describes a monotonic clock and a performance counter. Their absolute starting point is not a date your reader can interpret; taking two readings on the same clock lets you compute an interval. A nanosecond-returning variant can preserve an integer duration and avoid converting every intermediate reading to a floating-point value. Nanoseconds as units are not a claim of nanosecond precision. The OS or runtime may read a clock less precisely, and the instrumented boundaries generally include work that takes longer than the smallest nominal unit.

Use wall-clock time for context, not as the fallback when the measured interval is unavailable. A UTC ISO-format timestamp from the wrapper can be useful for locating console output or a scheduled job. If more context is needed, record both start and finish wall-clock values as separate evidence. A backward difference indicates a suspicious wall timeline, not negative work. A perfectly plausible positive wall-clock difference doesn't prove it is correct either, since a modest correction can be hidden inside a long operation. An interval missing from the receipt is better labeled missing than recreated from the audit timestamps and mixed unnoticed into a comparison.

It also matters which scope supplied each sample. You normally want both elapsed readings within the same measurement process and clock domain. Do not subtract a read taken on a developer laptop from an endpoint across the network just because both use a function with monotonic in its name. Even two counters on the same device may use different semantics or origins in different environments. If your actual build has a remote component, record local client wait as one metric and server-side duration returned by a documented instrument as another. A relationship between two measurements does not make them interchangeable or prove where every remaining millisecond went.

Low-level environments differ on whether a counter includes time when a system is suspended. The Linux clock_gettime manual distinguishes CLOCK_MONOTONIC from CLOCK_BOOTTIME on Linux; that is platform-specific documentation and not a universal promise for a Python or browser clock on every host. If a laptop sleeps halfway through a run, note the disruption and avoid mixing it into an ordinary active build comparison. If the experiment is about the real person waiting through sleep, choose a supported clock and explicitly test that behavior. There isn't one abstract duration until suspend policy and boundaries are clear.

Give the measurement a test that can fail on purpose

Start with a small receipt function that accepts two independent clock readers as test inputs. The wall input supplies synthetic timestamps and the elapsed input supplies increasing integers. Use pairs that make the defect unavoidable. In the invented fixture, a command starts at 15:14:02 and ends at 15:13:57, while the elapsed counter steps from 40,000,000,000 to 42,250,000,000. The correct elapsed difference is 2,250,000,000 nanoseconds. A function that subtracts timestamps will give a different result. The fixture models the clock readings without modifying the actual machine clock, so the test is opt-in, deterministic, and never affects certificates, file timestamps, scheduled work, or other users.

Run an ordinary control with smoothly ordered wall timestamps and a matching elapsed duration. Then add a positive wall jump so that the broken implementation produces a deceptively long, apparently valid interval. Checking only for a negative value catches one symptom but doesn't prove the elapsed clock supplied the number. Treat the timed stop status separately: run a sample with a simulated failed command and one where the timer reader is unavailable. The latter should still emit an honest audit record if that is useful, but without inventing a duration. A default of zero changes a missing measurement into a fake lightning-fast run.

After those fixed-input cases, run a real small local command such as rendering one fixture file and checking its output. The smoke assert should check that a duration is present and nonnegative, that clock identifiers and units are correct, and that the process exit result is observable. Don't make it fail merely because a busy machine needed 173 milliseconds instead of 150. Runtime distributions are a different test from the correctness of the receipt. When the team later tests performance, use repeated runs of the defined operation and a realistic threshold whose derivation is recorded; a single exact millisecond boundary often captures noise rather than a useful regression.

A broken control is useful here too. If one test implementation intentionally substitutes wall-time subtraction, the backwards and forwards fixtures should reject it. If they don't, your assertions may be checking field presence rather than their meaning. A second bad control can emit a nanosecond integer under a milliseconds field. Tests should catch the mismatch through a known fixture duration, not a guess about whether a particular real value is too large. This makes problems in naming, units, and clock selection visible independently.

Don't turn a sound timer into an unsound comparison

A correct elapsed measurement is not a whole benchmark. The invented archive builds the old renderer against a previously warmed filesystem and the new renderer immediately after a fresh checkout. The cold launch can lose despite a faster renderer; the later warm launch can win despite slower rendering. Decide how cache state is prepared. If you need both cold and warm conditions, label them as two experiments. Record enough about what was warmed to make the study repeatable. Don't wipe a shared development cache, alter OS settings, or invalidate production cache in pursuit of a synthetic timing claim. A disposable working directory and documented fixture data often suffice.

Repeated experiments can be structured to reduce predictable drift. Run the two alternatives in alternating or counterbalanced order where that makes sense, instead of measuring all of one version in the morning and all of the other during a scheduled machine backup. A median can summarize a small run list, but show the actual range or individual durations too; a reader should see if a lone huge run is driving the story. If a process interruption or unrelated activity invalidates a run according to your declared criteria, keep the receipt and state why it was excluded rather than silently dropping unfavorable points.

Inspect outputs alongside durations. For an invented catalog, record a fixture identifier and a deterministic artifact digest after production of the output. If the before and after changes are intended to preserve bytes, a digest mismatch means the test has more work to do before equating the builds. If the result intentionally differs in formatting but should contain the same public records, compare a narrowly defined normalized representation or key coverage instead. Such assertions only cover the properties they test. Do not choose a normalization so aggressive that it removes the very content a fast build forgot to produce.

The process supervisor may contribute its own measured duration, which is useful provided the boundaries remain distinct. A client can observe command invocation to completion; a job system might include queue time; an internal stage reports template rendering only. Keep the measurement hierarchy rather than adding independently timed values and claiming they perfectly explain the total. Overlap, buffering, and instrument overhead can mean the parts don't add up. If that matters, introduce narrowly defined instrumentation for one unanswered portion in the next experiment rather than inventing precision from mixed readings.

A browser-based measurement has related but different constraints. W3C's High Resolution Time specification distinguishes monotonic time from time based on the system clock and explains scoped time origins and resolution concerns. If a later preview wants to measure rendering in a document, keep that browser duration with its own origin and defined markers. Don't paste the absolute number into a native build receipt as though both shared a start. Likewise don't infer browser timer precision on different devices from a single console example. The useful connection is the design lesson about separating timestamps and durations, not a universal arithmetic recipe across environments.

Write the receipt to answer a later reader

A durable receipt needs a run identifier, fixture or input revision, command class, boundary labels, machine/runtime context, start audit timestamp, elapsed duration and unit, clock used, finish status, and a summary of output verification. Add any intentional cache policy and any disruption the harness detected. In the synthetic negative wall-clock example, include start and finish wall labels and a flag that they disagree with the observed progression. The measured duration remains an explicitly scoped 2.25 seconds, not an attempt to rewrite system time. A separate sentence can explain why the log order should not be used to infer chronology among other machines.

Choose a standard export unit for a series and leave raw duration on disk. A human report might round to 2.3 seconds, but ranking many short samples by only the rounded display may create artificial ties. Likewise if the report claims a percentage change, state how the representative timings were chosen and their units. Means, medians, minimums, and percentile estimates do not describe the same thing, especially with a small sample count. Use an appropriate comparison and avoid softening a disappointing result into a different summary after seeing it. A plain table of results may be the most informative starting point.

A reviewer should be able to reproduce the experiment without seeing secrets or personal machine history. Document the toolchain and version, but remove usernames and private paths from receipts shared outside the team. Keep sample commands confined to the local fixture and save enough stdout or stderr context to identify which phase ended. When a test reruns, write a new run ID and keep both records rather than overwriting the one that first exposed a mistake. Distinguish read-only observation from any change needed to prepare the benchmark; the fixture never requires altering the host's system clock.

The first good result from a timing harness isn't an impressive speedup. It's a measurement the team knows how to interpret. When a clock jumps, the audit trail still warns that event timestamps moved. When a renderer truly takes longer, the local elapsed scope still identifies what was measured. Neither fact needs to masquerade as the other. Keeping those two clocks separate takes little work, and leaves the next reader with a result they can compare, challenge, and rerun.

Recognize an instrumented run that shouldn't be compared

The receipt is also a place to state whether detailed instrumentation was enabled. A renderer that logs one line for every record might spend meaningfully more time waiting for its output channel than the same renderer with ordinary logging. Even when every extra log line happens after a stage timer stops, the full-command clock can still include the flush. Give a diagnostic run and a normal comparison run separate modes. Don't introduce extra logging only on the slower candidate and then use those measurements to infer a renderer cost. If the team needs both a stage trace and a fair comparison, make it possible to collect them in separate runs with the same fixture.

There is a small demonstration that costs almost nothing. Run the invented renderer once with per-record logging to a local sink and once with one summary. Validate that both produce the same 80 output records. The example does not predict that the more verbose run will be measurably slower on every machine. The point is to show that the harness can record the switch and that a receipt consumer can reject an accidental comparison across modes. With a tiny workload the wrapper alone may dominate; in that case record the limitation rather than extrapolating one result to a full publication.

Finally, compare the failure boundary with the success boundary. If a failed build returns before writing output, the receipt captures time to failure and should omit a completed-artifact digest. If a post-run checker cannot verify the artifacts, preserve the elapsed value but mark the comparability gate as failed. Those are useful records for a maintainer even though neither belongs in the headline performance calculation.

Work a comparison from plausible receipts, not convenient screenshots

In the invented archive, the current renderer and the proposed replacement both generate a newsletter preview from the same eight local fixture records. A before-and-after card might identify the exact fixture revision, intended build command, output checker, machine class, and ordinary logging mode. It should also say what was not included, such as dependency installation or creating a browser screenshot. Use the same boundaries for both alternatives. Bringing the screenshot creation step into only one command breaks comparability even if the elapsed clock is flawless. The point is to catch that design mistake before an attractive graph makes it hard to retract.

Write a small synthetic run sheet. The earlier renderer has elapsed observations of 2.41, 2.33, and 2.78 seconds, and the candidate has 2.28, 2.31, and 2.24. One candidate run also has backward wall-clock movement in the raw timeline. If its monotonic interval was recorded and the expected artifact was verified, the odd clock pair alone does not transform it into a negative duration or make its monotonic reading disappear. Mark the timeline anomaly and ask whether it coincided with other conditions relevant to the comparison. Likewise the short measured series should be described as an illustration, not as evidence of a statistically significant real improvement.

If the pilot pauses on the long 2.78 result, don't immediately call it an outlier and erase it. Check the acceptance rules that were set before the experiment. Did the process complete the same work? Was a competing operation observed, or is there merely a large duration? Was the cache condition documented as different? If excluded under a recognized rule, preserve the row and record why. If the reason is unknown, report the ordinary observations and acknowledge the uncertainty rather than deriving a precise percentage from only convenient rows. An honest run sheet can contain both a useful candidate signal and a reason to repeat the experiment.

Now give the second fictional run a different kind of anomaly: at 1.95 seconds the command returns success but emits a missing item in the newsletter. The artifact verification gets a known failure or incomplete state. There was a real observation of elapsed time and the run still belongs in the diagnostic log; it does not belong in a comparison of successful complete outputs. Keep scope and elapsed facts separate. In another case the command and artifact work perfectly but the host failed to report the duration. Mark duration unavailable, not instantaneous. This small distinction is useful in a dashboard data model where both outcomes might otherwise turn into zeroes.

Test that the clock implementation has the advertised evidence

A receipt can list a clock name yet use the wrong function. Define a test surrogate for the readings. In a unit fixture wrap the audit and elapsed readers so they record every call, and make each one return values with different roles. Supply absolute wall timestamps in the audit reader and two unequal bounded integers in the elapsed reader. Verify that successful work calls both readers where required, that the interval is formed from the expected pair of elapsed readings, and that the serialized timestamp is the one supplied by the audit reader rather than a meaningless performance-counter epoch. The test need not change the production machine clock or invoke protected settings.

Give at least one synthetic case distinct integer magnitudes. If the elapsed difference in nanoseconds is 12,500,000, a correctly labeled display in milliseconds reports 12.5, not 12,500,000. Keep internal arithmetic in the declared base unit until export if that is the chosen design. Round only for interpretation where needed. If its output is a decimal and another consumer expects milliseconds as an integer, write down which conversion that endpoint performs. A fixture near a rounding boundary can expose disagreements before they make one chart or threshold incomparable with another. An error might look like a giant speed improvement while no algorithm changed at all.

An independent low-risk smoke run can check the real supported interface. Start (or run) an innocuous child command in a local test fixture, verify that the instrumentation captured a valid monotonic interval and observable exit state, and check that the receipt attaches to the intended child invocation. There is no need to assert the elapsed result is exactly a small constant. Use only the real output claim you can establish. The reader from the known run should not be able to mistake an empty output or error as a missing clock, or a timer failure as a missing artifact. Outcome, clock status and duration all answer different questions.

When a team sees zero after very short work, avoid immediately renaming the task instantaneous. Maybe the display rounded down. Maybe the resolution of the clock or exported unit is too coarse. Maybe the apparent measurement happened after the work returned because the wrapper markers were reordered. A synthetic test can expose unit conversion errors, while an ordinary inspection of instrumentation can verify the measured boundaries. A healthy reporter can show a valid value smaller than a presentation unit without disguising it as zero work. Ask which inference the audience is trying to make before adjusting numeric formatting.

Check for a mismatched clock domain when reading stored values. Some logs expose an absolute monotonic reading as a diagnostic. That raw value is not a civil date and may not be comparable after restarting an environment, especially across machines or technologies. Store a calculated interval where that is the actual claim rather than expecting another system to reconstruct it from arbitrary counters. Python's time reference explains that only differences between applicable readings are meaningful; check the runtime's actual documented clock semantics. Do not attach higher precision to a browser-host comparison by combining raw readings whose relationship was never established.

Decide how a wrapper failure affects the comparison

Suppose the ordinary build finishes and returns its exit status, but the after-run collector fails to inspect the output directory. The stopwatch can still have a meaningful endpoint for process execution. The complete experiment cannot yet establish matching work. Write a status like elapsed observed; artifact verification missing. A candidate report can be blocked on verifying the artifacts while still saving relevant timing evidence for investigators. Conversely an intact artifact inspected after an unknown process sequence isn't proof that the latest observed command created it. Each receipt should describe which events were connected, not merely which three files existed afterward.

There is a second failure boundary when the wrapper requests a stop. The elapsed time to a timeout is not the completed build duration. It can be valuable operational evidence about when your supervisor decided it could no longer wait. If a worker has pending asynchronous cleanup after the elapsed interval ends, acknowledge that the measurement is scoped to supervisor observation and not global process recovery. A fixture shouldn't run tasks that affect live users or leave behind unknown work. Use a bounded temporary workload and a clear cleanup process. The main article does not require interruption or modification of someone else's process to demonstrate the distinction.

Try a synthetic false success that returns the expected zero status but creates a stale-looking output marker from an unrelated earlier file. Scope the fixture to a new disposable working directory or explicitly verify source-output association if appropriate. An incorrect receipt can pair the very latest elapsed measurement with an older already existing output. A small check of the intended artifact from this invocation helps establish that both observations belong in the same row. This is where performance timing meets general release evidence, but the practical focus remains different: the receipt must tie the duration to the work measured, not demonstrate what some live domain serves.

A run can also produce a normal exit and valid files while its supervisor was not a reliable measuring context. The host might have briefly suspended, a monitoring sidecar might have been replaced, or the worker might have migrated to a different execution environment between markers. The measurement can be justified only under a documented timing scope. The Linux clock documentation shows why suspend behavior should be tied to the actual clock, not deduced from its name. Keep unknown scope explicit. If an environment doesn't expose the evidence required for the study, a repeat on a controlled host is more valuable than returning a seemingly comparable number.

Compare long and short intervals without double counting

The archive later breaks the command into preparation, parallel template rendering, and final write. Each phase can be interesting. A wrapper's full interval remains the right evidence for a person waiting until the command returns. A set of stage timings explains portions of the observed work. If two rendering tasks overlap, their local elapsed intervals can add to more than their combined wall of waiting time. A report showing renderer A took one second and renderer B took two doesn't require aggregate waiting time of three seconds. Distinct intervals must describe their relationship, not simply appear in columns with the same unit.

A toy timeline is helpful. The full command runs from elapsed point zero to 3.2 seconds. One renderer runs from 0.5 to 1.5, and another from 0.6 to 2.6. Their two observed durations add to three seconds while their union spans roughly 2.1 seconds. Neither figure is the total ordinary command time; other work or waiting accounts for the rest. This example assumes the points belong to a common supported domain in the same local experiment. Do not draw that graph by subtracting arbitrary clocks from an app server and a browser. Different requested observations can be compared as scoped durations without claiming the absolute points align in one timeline.

Choose milestone comparisons that support a plausible decision. If rendering is an implementation detail and the users wait far longer in dependency startup, improving only rendering might be technically impressive but of little practical relevance. If the use case is a long-running watch process that performs repeated rebuilds, a simpler one-shot command study might overemphasize initialization. Define the intended new question and whether the earlier experiment can answer it. A separate experiment capturing hot changes can leave the one-shot evidence intact while testing a more relevant workflow. Comparability is often about operational boundaries more than raw clock precision.

Browser and server measurements can coexist. A local wrapper times a command; a preview observation records render-related markers in one browser context. The High Resolution Time specification provides vocabulary for web monotonic times and time origins. A comparison should communicate the role of each observation and any privacy-related precision behavior where relevant rather than using a common nanoscale column to imply a single timeline. A useful dashboard might show two small labeled panels with different start and stop definitions. That is clearer than one dense graph whose scale has more precision than the experiment.

Make the clock evidence reusable by a skeptical reviewer

Prepare two views of the same receipts. The public or team-facing summary can show operation, fixture, technology context, expected work and a compact table of durations by outcome. The private operational archive, where authorized and useful, can preserve exact timestamps, raw duration values, the clock selection and setup detail. Do not make reviewers obtain raw environment variables, user paths, or an organization's private activity history to understand a benign benchmark. A readable summary can carry a stable run reference pointing to appropriate evidence without copying unrelated machine state into a shareable document.

Use one deliberately confusing export in rehearsal. Suppose report code sorts absolute audit strings and then subtracts the first from the last to estimate elapsed time. A correction causes the entries to appear reversed for a single run. The renderer also aggregates 12 milliseconds as 12 seconds after interpreting an unlabeled column. Write assertions that detect these flaws separately. The first should point the reviewer to the correct elapsed field and scope; the second should reject the unit mismatch. In both cases it is the meaning of the serialized receipt, not the arithmetic libraries, that distinguishes a correct result. The best verification work often occurs after the clock reading when evidence crosses into a different tool.

Keep prior data understandable under schema changes. A revised report could add a named clock type or use an integer unit not present in old exports. Do not infer a precise older unit if the old version was ambiguous. Mark that old observations can't be used for the new comparison unless the existing source establishes their interpretation. Reprocessing a historical receipt can add a documented conversion while retaining the original; it should not rewrite an unknown as the estimate that makes the new chart smoother. An audit timestamp saved months ago may remain accurately usable for locating a run even when no dependable interval was recorded.

End the review by having someone not involved in the implementation answer three plain questions. When did the command run according to the audit clock? What exact operation did the elapsed duration measure? Which independent observation showed the result was suitable for comparison? If any answer would require reading an unrecorded setup or guessing at a unit, fix the receipt. A small study will not answer every performance question, but a careful record lets another person answer the one that was actually measured. When the data is mixed, the best headline may be that changing the clock fixed the evidence, not that it sped up the build.

Add a small clock-scope check to the routine review

A team can use a one-minute practice handoff before adopting a new benchmark reporter. Give one reviewer the raw synthetic receipt and another only the summary. Plant a difference in how the job was invoked: both have the same displayed build label, but one deliberately starts the clock after the compiler process launches while the other starts before launch. The shorter duration may be genuine under its boundary. It should still be excluded from the comparison until the operations are made equivalent. If both reviewers identify the same scope mismatch, the report carried enough context to travel beyond the runner.

For a second case keep the command boundaries identical and alter only the display clock's end reading in the test fixture. A good summary can flag the odd civil sequence and still show the documented elapsed interval without assuming that an anomaly necessarily invalidated the build output. A poor summary silently computes duration from the audit stamps because they are the only fields that appear formatted as time. Change one input at a time. If a test changes the clock, machine, output and duration in one step, nobody can tell which change the reporter noticed.

The routine review should be proportionate. It need not measure every loop a task runs, and a separate team using a different stack does not need to adopt the same counter to write a useful report. Preserve the two basic evidence types, use comparable boundaries for the question in hand, and name the case where that comparison cannot be made. Those small safeguards are enough to keep an ordinary experiment from turning into a persuasive but uninterpretable performance claim.

Primary sources

AI disclosure: Drafted with AI assistance for Apiary using public standards and invented examples.

Frequently asked
What is Record When the Build Ran and How Long It Took With Different Clocks about?
A public archive prints a small event program as HTML. The team changes its template renderer and runs a before and after comparison on a development machine.…
What should you know about specify the interval before choosing the timer?
A build can mean many operations. If the question is how long a developer waits from invoking a local command until it exits, a wrapper's elapsed clock should start immediately before launch and stop when the child returns. That measurement may include process startup, a cache lookup, and a flush to disk. If the…
What should you know about read a time of day and an elapsed clock?
In Python, the runtime time documentation describes a monotonic clock and a performance counter. Their absolute starting point is not a date your reader can interpret; taking two readings on the same clock lets you compute an interval. A nanosecond-returning variant can preserve an integer duration and avoid…
What should you know about give the measurement a test that can fail on purpose?
Start with a small receipt function that accepts two independent clock readers as test inputs. The wall input supplies synthetic timestamps and the elapsed input supplies increasing integers. Use pairs that make the defect unavoidable. In the invented fixture, a command starts at 15:14:02 and ends at 15:13:57, while…
What should you know about don't turn a sound timer into an unsound comparison?
A correct elapsed measurement is not a whole benchmark. The invented archive builds the old renderer against a previously warmed filesystem and the new renderer immediately after a fresh checkout. The cold launch can lose despite a faster renderer; the later warm launch can win despite slower rendering. Decide how…
References & sources
  1. Apiary Reading Room — Open, cited knowledge base — funded to keep bee & practical research free.
From the Apiary Reading Room. Opinion & editorial — not financial advice. We don't overclaim.
More from the Reading Room