What does Sprint to Cruise and the Three-Hour Cap conclude, in numbers, about “The Founder as a Single Server: Queueing and the Cost of Switching”?

Answer: Chapter 3 treats the founder as a single server: raising utilisation from eighty to ninety-five per cent multiplies waiting by 4.75, and a single three-hour window lengthens the longest creative block from 3.34 to 5.68 hours.

Scope of the numbers: Its parameters are illustrative; all calculations are generated by its programs; energy and sleep are personal tracking trends only; the book is not medical advice and not personalised business or investment advice. Chapter 1 uses a concave hours-output curve and a parameter grid to show that the best daily duration falls in a narrow band, with 0.734 of the illustrative grid between two and four hours.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 3.34, 5.68

A. 712 requests over 60 days
policymean waitP90 waitstarts/daycreative hlongest block
always0.120.1310.09.283.34
two5.3615.343.510.884.36
one8.8720.112.311.175.68
Show the full program
# Chapter 3. p32: answer-at-once versus fixed approval windows.
# 60 synthetic days, 14 waking hours each (08:00 to 22:00). Decision
# requests arrive as a Poisson stream, 12 a day; service is exponential
# with mean 12 minutes. Each time the desk starts work after being idle
# the creator also loses a residue of 15 minutes of creative focus
# (illustrative, after the task-switching literature). Policies:
#   always   serve on arrival, first come first served
#   two      two windows, 11:00-12:30 and 17:00-18:30
#   one      one window, 14:00-17:00
# Urgent requests (5 %) are served at once under every policy.
# Unfinished work carries to the next window. Reported: mean and P90
# wait in hours, desk starts a day, creative hours left, and the mean
# longest uninterrupted creative block.
import math
import random
import statistics

DAYS = 60
RATE = 12
ES = 0.2
RESIDUE = 0.25
URGENT = 0.05
POLICIES = {"always": [(0.0, 14.0)],
            "two": [(3.0, 4.5), (9.0, 10.5)],
            "one": [(6.0, 9.0)]}


def arrivals(rng):
    out = []
    for d in range(DAYS):
        t = 0.0
        while True:
            t += rng.expovariate(RATE / 14.0)
            if t >= 14.0:
                break
            out.append((d * 24.0 + t, rng.expovariate(1.0 / ES),
                        rng.random() < URGENT))
    return out


def in_window(t, wins):
    d = int(t // 24.0)
    for a, b in wins:
        lo, hi = d * 24.0 + a, d * 24.0 + b
        if lo <= t < hi:
            return True
    return False


def next_open(t, wins):
    d = int(t // 24.0)
    best = None
    for dd in (d, d + 1):
        for a, b in wins:
            lo = dd * 24.0 + a
            if lo > t and (best is None or lo < best):
                best = lo
    return best


def simulate(reqs, wins):
    events = sorted(reqs)
    t, i, last_end = 0.0, 0, -1.0
    queue, waits, busy = [], [], []
    starts = [0] * DAYS
    while i < len(events) or queue:
        while i < len(events) and events[i][0] <= t:
            queue.append(events[i])
            i += 1
        pick = None
        for q in queue:
            if q[2]:
                pick = q
                break
        if pick is None and in_window(t, wins):
            for q in queue:
                pick = q
                break
        if pick is None:
            nxt = []
            if i < len(events):
                nxt.append(events[i][0])
            if queue:
                nxt.append(next_open(t, wins))
            t = min(nxt)
            continue
        queue.remove(pick)
        if t > last_end + 1e-9:
            starts[min(int(t // 24.0), DAYS - 1)] += 1
        waits.append(t - pick[0])
        busy.append((t, t + pick[1]))
        t = t + pick[1]
        last_end = t
    return waits, busy, starts


def creative(busy, starts):
    hours, longest = [], []
    for d in range(DAYS):
        lo, hi = d * 24.0, d * 24.0 + 14.0
        segs = sorted((max(a, lo), min(b, hi)) for a, b in busy
                      if b > lo and a < hi)
        used = math.fsum(b - a for a, b in segs)
        hours.append(14.0 - used - RESIDUE * starts[d])
        gaps, cur = [], lo
        for a, b in segs:
            gaps.append(a - cur - RESIDUE)
            cur = max(cur, b)
        gaps.append(hi - cur)
        longest.append(max(gaps))
    return statistics.mean(hours), statistics.mean(longest)


if __name__ == "__main__":
    rng = random.Random(40432)
    reqs = arrivals(rng)
    print("A. {} requests over {} days".format(len(reqs), DAYS))
    print("   policy  mean wait  P90 wait  starts/day  creative h"
          "  longest block")
    for name in ("always", "two", "one"):
        w, b, st = simulate(reqs, POLICIES[name])
        w.sort()
        p90 = w[int(0.9 * len(w)) - 1]
        ch, lb = creative(b, st)
        print("   {:<6}  {:>8.2f}  {:>8.2f}  {:>10.1f}  {:>10.2f}"
              "  {:>12.2f}".format(name, statistics.mean(w), p90,
                                   statistics.mean(st), ch, lb))

Single source and citation

Fan, Y. (2026). Transitioning from Sprint to Sovereign Cruise: The Three-Hour Daily Decision Cap and Sustainable Creator Vitality (Version 1.0.0), Chapter 3: The Founder as a Single Server: Queueing and the Cost of Switching. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-404 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026404,
  author    = {Fan, Yafu},
  title     = {Transitioning from Sprint to Sovereign Cruise: The Three-Hour Daily Decision Cap and Sustainable Creator Vitality},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book