Posts by:

Tim Booher

The Data Doesn’t Lie: How 266 Runs Revealed The Truth About My Marathon Goal

For the BMW Marathon in Dallas, I’m targeting 7:30/mile pace—a 3:16:45 finish, what training plan should I follow from today? Work has been insane stressful, and has destroyed my training. Can AI help me here?

My long runs felt good at that pace for 8-10 miles, so I thought I was on track. I’m always testing to see how much I can do myself and I’m curious to use AI to coach me. AI isn’t useful without the right data, so I analyzed 266 runs from the past two years to build a good training plan.

The most recent data is the most important, so it was important that I took note of my run this morning. I ran a half marathon at 8:10 average pace with a heart rate of 137-148 bpm—very easy aerobic effort. I finished the last two miles at 7:42 and 7:49 pace.

Here’s what 266 runs over two years revealed:

DISTANCE RANGE	RUNS	AVERAGE PACE	BEST PACE	PATTERN
3-4 miles	92	8:14	6:44	Speed is there!
6-7 miles	31	8:25	7:23	Solid training pace
10-11 miles	8	8:11	7:47	Sub-8:00 capability proven
13-14 miles	3	7:48	7:53	THE SWEET SPOT
14-15 miles	2	7:54	7:41	Strong mid-distance
16-17 miles	2	8:26	8:20	Starting to fade
18-19 miles	2	8:11	7:44	Inconsistent
20+ miles	5	8:54	8:00	THE PROBLEM

The pattern was clear: 13-14 mile average of 7:48 versus 20+ mile average of 8:32. A 44-second-per-mile dropoff. My best 20+ mile run: 8:00 pace. Still 30 seconds slower than goal. My average 20+ mile run: 8:32 pace. A 1:02/mile gap to close. But this morning’s half marathon told a different story. I ran 13.1 miles at low heart rate (137-148 bpm) and finished strong at 7:42-7:49 pace. “Very easy,” I noted afterward. “Could have done a lot more.” This suggests my aerobic base is much better than the historical 8:32 suggests. That average likely came from poor pacing on long runs, not lack of fitness.

My 3-4 mile best pace: 6:26. That’s 1:04 faster than my marathon goal. The problem isn’t speed—it’s extending that speed over distance. The gap: extending my 7:48 pace from 13-14 miles to 20+ miles, then racing smart for 26.2 miles. When you define it that specifically, you can build a plan to address it.

The dropoff from 7:48 pace (13-14 miles) to 8:32 pace (20+ miles) isn’t random—it’s physiological. Research on elite marathoners shows that even well-trained runners deplete muscle glycogen stores significantly after 90-120 minutes at marathon pace. For me, 13-14 miles at 7:48 takes about 1:47—right in the window where glycogen runs low. When I push to 20 miles without proper fueling and without training my body to use fat efficiently, I hit the metabolic wall. But fuel isn’t the only issue. My legs simply aren’t conditioned for the distance.

By “legs aren’t ready,” I mean muscular endurance breaks down, neuromuscular efficiency degrades, and form deteriorates. The quads that fire smoothly at mile 10 are misfiring by mile 18. The signal from brain to muscle becomes less crisp. Motor unit recruitment—the coordinated firing of muscle fibers—gets sloppy. I’m sending the same “run at 7:45 pace” command, but my legs execute it as 8:30 pace. Meanwhile, small biomechanical breakdowns compound: hip drops slightly, stride shortens, each foot strike becomes less efficient. Running 20 miles means roughly 30,000 foot strikes. If I haven’t progressively trained my legs to absorb that cumulative pounding, my body literally slows me down to prevent injury.

Studies on elite marathon training show successful marathoners spend 74% of their training volume at easy intensity (Zone 1-2) because it builds aerobic capacity without accumulating neuromuscular fatigue. My data suggests I was probably running too many miles too hard, accumulating fatigue faster than I could recover—especially at 48. Research on masters athletes shows recovery takes 10-20% longer after age 40. Some coaches recommend 10-12 day training cycles for older athletes instead of traditional 7-day cycles, allowing more space between hard efforts. If I’m not recovering fully before the next quality session, my 20+ mile pace suffers even more than it would for a younger runner.

There’s also cardiovascular drift to consider. During prolonged running, cardiac output gradually decreases while heart rate increases to compensate. This is more pronounced at higher intensities. If I’m running long runs at or near race pace (7:30-7:50), I’m experiencing significant cardiovascular drift by mile 15-18. The effort to maintain pace increases exponentially. My 20+ mile pace of 8:32 might simply reflect the point where my cardiovascular system says “enough.”

My training strategy alternates run days with bike days—typically 18-28 miles at 15-18 mph. Research shows that cycling can maintain aerobic fitness while reducing impact stress, with one mile of running equaling approximately three miles of cycling for cardiovascular equivalence. This means my weekly aerobic load is higher than running mileage suggests: 45 miles running plus 85 miles cycling equals roughly 73 “running equivalent” miles per week. The cycling protects my legs while maintaining cardiovascular fitness—smart training at 48. But it also means my running-specific adaptations (neuromuscular patterns, impact tolerance, glycogen depletion management) might be underdeveloped relative to my aerobic capacity.

The data reveals a specific problem: I have speed (6:26 for 3-4 miles), good mid-distance endurance (7:48 for 13-14 miles), and strong aerobic fitness (cycling adds volume). But I haven’t trained the specific adaptation of holding sub-8:00 pace beyond 14 miles. This isn’t a fitness problem—it’s a specificity problem. The solution isn’t to run more miles. It’s to progressively extend the distance at which I can hold my proven 7:48 pace, while managing fatigue and recovery as a 48-year-old athlete.

Traditional marathon training plans prescribe long runs at “easy pace” or 30-60 seconds slower than race pace. That builds aerobic base, but it doesn’t address my specific limitation: I need to teach my body to hold quality pace for progressively longer distances.

This morning’s half marathon changes the starting point. Instead of beginning conservatively at 16 miles, I can start more aggressively at 18 miles next Saturday. The plan builds from there: 18 miles at 7:50 average pace (two miles easy warmup, 14 miles at 7:45-7:50, two miles easy cooldown). The goal is simple—extend this morning’s easy 13.1-mile effort to 14 quality miles. Week two pushes to 20 miles at 7:45 average, tackling my historical problem distance at a pace 47 seconds per mile faster than my 8:32 average. Week three peaks at 22 miles averaging 7:40 pace—the breakthrough workout that proves I can hold sub-7:40 pace for 18 continuous miles.

After peaking, the volume drops but the intensity holds. Week four: 16 miles at 7:35 average with 12 miles at race pace (7:30-7:35). Week five adjusts for Thanksgiving with 14 miles at 7:35. Week six is the dress rehearsal: 10 miles with six at 7:25-7:30 pace, confirming goal pace is ready. The progression is deliberate—each week either extends distance or drops pace by five seconds per mile, allowing physiological adaptation without overwhelming the system. Elite marathon training research supports this approach: progressive overload with strategic recovery.

Tuesday speedwork leverages my natural speed. My best 3-4 mile pace is 6:26—more than a minute per mile faster than marathon goal pace. Research consistently shows that running intervals 30-60 seconds faster than marathon pace improves race performance by increasing VO2 max, improving running economy, and creating a “speed reserve” that makes race pace feel controlled.

The plan starts with 8×800 meters at 6:30 pace (3:15 per repeat) with 90-second recovery jogs—establishing that I can run fast repeatedly. Week two builds to 10×800 at the same pace. Week three shifts to marathon-specific longer intervals: 6×1200 meters at 6:40 pace. Week four is a six-mile tempo run at 7:10-7:15 pace—faster than race pace, sustained effort. The final speedwork comes in week five: 6×800 at 6:25 pace for sharpness, not volume. Running 6:30 pace in workouts creates a one-minute-per-mile speed reserve over my 7:30 goal. Analysis of 92 sub-elite marathon training plans found successful programs include 5-15% high-intensity training. My Tuesday sessions provide exactly this stimulus.

At 48, recovery determines whether I arrive at race day peaked or exhausted. Complete rest days come every five to six days—no running, no cross-training, just rest. Easy runs stay at 6-7 miles at 8:20-8:30 pace, conversational effort that builds aerobic capacity without adding fatigue. Bike days alternate with run days: recovery rides of 18-22 miles at 15 mph with high cadence and low resistance, or moderate rides of 22-28 miles at 16 mph for steady aerobic work. The cycling maintains cardiovascular fitness and increases blood flow to running muscles while reducing impact stress. Research on masters runners consistently emphasizes that recovery adaptations—not just training adaptations—determine race day performance for athletes over 40.

Fueling practice matters as much as the miles themselves. My data shows pace dropping significantly after 90-120 minutes, suggesting glycogen depletion. Case studies on elite marathoners found optimal race-day fueling to be 60 grams of carbohydrate per hour, delivered as 15 grams every 15 minutes in a 10% carbohydrate solution. I need to practice this in training, not just on race day. Every long run over 90 minutes becomes a fueling rehearsal at goal pace.

This morning’s half marathon rewrites the race plan. I ran 13.1 miles at low heart rate (137-148 bpm), averaging 8:10 for the first 11 miles before closing the last two at 7:42 and 7:49 pace. My note afterward: “very easy, could have done a lot more.” That performance suggests my aerobic base is significantly better than my historical 8:32 average for 20+ miles indicates. That average likely came from poor pacing on long runs, not lack of fitness.

The conservative approach mirrors this morning’s pattern: controlled start, gradual build, strong finish. Miles 1-10 at 7:30-7:35 pace—just like this morning’s easy start—predicted split of 1:15:00 to 1:16:40. It will feel easy, almost too easy. The temptation will be to push harder. Don’t. Miles 11-20 settle into goal pace range at 7:28-7:32, predicted split of 1:15:00 to 1:16:00. This is half-marathon distance, and my data proves I can hold 7:48 pace for 13-14 miles. Running 7:30-7:35 is only 13-23 seconds per mile faster—controlled and sustainable. Miles 21-26.2 finish strong at 7:25-7:30 pace, just like this morning’s close. Predicted split: 38:45 to 39:00. Total projected finish: 3:15:00 to 3:16:45.

The aggressive approach—even 7:30 splits from mile one for a 3:16:45 finish—only makes sense if week three’s 22-mile peak run at 7:40 average feels as easy as this morning’s half marathon felt, if weather is perfect (50-55°F, low humidity, no wind), if taper goes flawlessly, and if I wake up on race day feeling exceptional. Otherwise, the conservative negative split strategy is smarter.

Three scenarios, all representing massive improvement over historical data. Best case: 3:15:00-3:16:00, requiring perfect execution of the conservative strategy and this morning’s negative split pattern. Probability: 45 percent, up significantly after this morning’s performance. Realistic: 3:16:00-3:17:00, solid execution with maybe imperfect conditions. Probability: 40 percent. Solid: 3:17:00-3:18:30, good race with slight fade or challenging conditions. Probability: 15 percent.

All three outcomes crush the historical 8:32 pace for 20+ miles. All three are victories. The goal isn’t to cling to 7:30 pace at all costs—it’s to run the smartest race possible given training data and this morning’s proof that the aerobic base is there.

I thought I was running long runs at 7:30 pace. The data showed 7:48 for 13-14 miles and 8:32 for 20+ miles. Memory is selective. Data isn’t.

But this morning’s half marathon revealed something the historical data missed: I ran 13.1 miles at a heart rate of 137-148 bpm—easy aerobic effort—and finished strong at 7:42 and 7:49 pace. Afterward, I noted “very easy, could have done a lot more.” That 8:32 average for 20+ miles wasn’t about fitness—it was about pacing. I’d been going out too hard and fading. The aerobic base is better than the numbers suggested.

The limitation isn’t speed—my best 3-4 mile pace is 6:26. It’s not aerobic fitness—the cycling adds significant volume and this morning proved the engine is strong. The gap is specificity: I haven’t trained to hold quality pace beyond 14 miles. At 48, I need more recovery than I did at 35. Research shows masters athletes need 10-20% more recovery time. The alternating run-bike schedule isn’t a compromise—it’s smart training that keeps me healthy enough to execute the progressive long runs that will close the gap.

Seven weeks to race day. Progressive long runs build from 18 to 22 miles at progressively faster paces. Tuesday speedwork at 6:30 pace creates a one-minute-per-mile reserve over goal pace. Complete rest every five to six days. Race strategy mirrors this morning’s pattern: controlled start, build into goal pace, finish strong.

Will I hit 3:16:45? Good chance—this morning proved the base is there. Will I run 3:16:00-3:17:00? More likely. Either way, it’s significantly faster than 8:32. The data showed the problem. This morning showed the solution. Now execute.

RESEARCH REFERENCES

Stellingwerff, T. (2012). “Case Study: Nutrition and Training Periodization in
Three Elite Marathon Runners.” International Journal of Sport Nutrition and
Exercise Metabolism, 22(5), 392-400.
Sports Medicine – Open (2024). “Quantitative Analysis of 92 12-Week Sub-elite
Marathon Training Plans.”
Tanaka, H. (1994). “Effects of cross-training. Transfer of training effects on
VO2max between cycling, running and swimming.” Sports Medicine, 18(5), 330-339.
Runner’s World / Marathon Training Academy (2024-2025). “Marathon Training After 50”

Research on masters athlete adaptations and recovery needs.

Haugen, T., et al. (2019). “The Training and Development of Elite Sprint Performance: an Integration of Scientific and Best Practice Literature.” Sports Medicine – Open.

October 25, 2025 (updated October 26, 2025) By Tim Booher 0 Comments

Personal Projects & Interests

Fixing the inlet on my Ryobi Pressure Washer

Some posts I write to inform others of cool stuff. Others posts I write to save someone else time when they google. This post is just a story of frustration, written to look like the second example. You have been warned.

Several years ago, I bought this pressure washer and then let it sit unused for far too long—a bad move. The Ryobi RY80940B, powered by a Honda GCV190 engine, delivers 3,100 PSI at approximately 2.5 GPM, more than enough force for serious cleaning but also enough to punish neglected hardware. For anyone working on one of these, the operating manual is available here: Ryobi RY80940B Service Manual (PDF).

When I finally tried to remove the hose, the metal fitting was stuck. The smart thing would have been to leave the hose stuck in there forever. I didn’t do that. I wanted to get the old hose out and, well, I’m an arrogant engineer and this was a battle of wills not of wits. I’ve spent the better part of an afternoon fighting with a broken brass fitting fused inside the outlet coupler of my Ryobi RY80940B pressure washer. What should have been a simple hose replacement turned into a problem. The brass insert from the old high-pressure hose sheared off cleanly, leaving a ring of corroded metal wedged inside the plastic spindle. I tried everything — prying, tapping, a bolt extractor — but the brass just spun or smeared instead of breaking free.

Eventually, I realized I was wasting time trying to rescue a part that costs less than lunch. The black collar that covers the quick-connect doesn’t unscrew; it slides over a spring and bearing set. Once you see the parts diagram for this model, it’s obvious the spindle (part #642058001) and collar (part #310993003) are meant to be replaced together.

Per the service manual, I first tried an 8 mm hex key to back out the fitting, but it immediately began to strip, producing nothing but a rain of metal shavings.

After exhausting every polite method of extraction, I escalated. Since I knew the brass and aluminum had fused completely, I cut most of the seized coupler off with an angle grinder, then used diagonal cutters to peel the remaining sleeve away from the spindle. With the bulk removed, I applied heat from a torch, clamped a pair of vice grips onto what was left, and added a four-foot cheater bar for leverage. The grips slipped off more than once, but eventually I felt the faint give of motion—the threads finally broke free. Sometimes the “fix” isn’t surgical precision; it’s controlled brutality, executed carefully enough not to destroy the surrounding parts.

Because this took so much work. I’m going to show you two pictures.

Tech Details

So what happened here? The failure wasn’t merely mechanical — it was electrochemical and thermomechanical. The brass hose insert (nominally Cu–Zn alloy, ≈ $Cu_{60}Zn_{40}$) had been pressed into a steel spindle (Fe–C alloy with minor Mn, Si). Over years of intermittent water exposure, this dissimilar-metal couple set up a galvanic cell with the water acting as electrolyte. Brass is more noble than steel in the galvanic series:

$$E^\circ_{\text{Cu}^{2+}/\text{Cu}} = +0.337\text{ V}, \quad E^\circ_{\text{Fe}^{2+}/\text{Fe}} = -0.440\text{ V} $$

The potential difference,

$$\Delta E = E_{\text{cathode}} – E_{\text{anode}} \approx 0.777\text{ V},$$

was sufficient to drive anodic dissolution of iron and the formation of iron oxides/hydroxides.

The local electrochemical reactions were:

Anode (steel):

$$\text{Fe} \rightarrow \text{Fe}^{2+} + 2e^-$$

Cathode (brass surface):

$$\text{O}_2 + 2H_2O + 4e^- \rightarrow 4OH^-$$

The resulting $Fe(OH)_2$ and $Fe_2O_3$ corrosion products expanded volumetrically, wedging the interface tighter. The growth strain of oxide formation can be expressed as:

$$\varepsilon_v = \frac{V_{\text{oxide}} – V_{\text{metal}}}{V_{\text{metal}}}$$

For iron oxides, $\varepsilon_v \approx 1.9$, meaning nearly a doubling in volume. This expansion induced radial compressive stress at the interface:

$$\sigma_r = \frac{E \, \varepsilon_v}{1 – \nu}$$

With $E_{\text{Fe}} \approx 210\,\text{GPa}$ and $\nu \approx 0.3$, localized stresses easily exceeded hundreds of MPa, enough to plastically deform the surrounding brass and produce microscopic cold-welding through diffusion and oxide bridging.

At the same time, dezincification occurred in the brass:

$$\text{CuZn} \rightarrow \text{Cu} + \text{Zn}^{2+}$$

leaving a porous copper-rich layer with high surface energy. Under compression and mild heat cycling, solid-state diffusion across the Cu–Fe interface promoted the formation of intermetallic compounds such as $CuFe_2$ or $Fe_3Zn_{10}$, effectively brazing the two metals together.

The end state was a compound joint bonded both by corrosion-product expansion and diffusion adhesion — a quasi-metallurgical weld. The torque required to shear it loose later had to exceed the yield strength of both alloys plus the adhesion energy of the oxide layer:

$$\tau_{\text{break}} \ge \frac{\sigma_y A + \gamma_{\text{adh}}}{r}$$

where $\sigma_y$ is the yield stress, A the contact area, $\gamma_{\text{adh}}$ the oxide interfacial energy, and r the effective radius. I estimate I needed breakaway torque of in the neighborhood of 80–160 N·m, danger close to the ~200-250 N·m that will break a Grade 8.8 M16 bolt — and this was a thin walled threaded tube. The geometry also doesn’t help. Since brass (CuZn) was threaded into the aluminum/steel pump body at M16 scale, the fine 1.5 mm pitch meant very tight thread flank contact. Over years of water exposure, galvanic corrosion products grew in the tiny 60° V thread roots, effectively cold-welding the joint.

So the “fused” fitting wasn’t rusted in the casual sense — it had become a galvanic, mechanically locked, diffusion-bonded composite system, obeying the same physics that make bimetallic corrosion joints and accidental cold-welds in space so hard to undo.

October 19, 2025 (updated October 19, 2025) By Tim Booher One Comment

Autonomy

The Connectome Scaling Wall: What Mapping Fly Brains Reveals About Autonomous Systems

In October 2024, the FlyWire consortium published the complete connectome of an adult Drosophila melanogaster brain: 139,255 neurons, 54.5 million synapses, 8,453 cell types, mapped at 8-nanometer resolution. This is only the third complete animal connectome ever produced, following C. elegans (302 neurons, 1986) and Drosophila larva (3,016 neurons, 2023). The 38-year gap between the first and third isn’t just a story about technology—it’s about fundamental scaling constraints that apply equally to biological neural networks and autonomous robotics.

A connectome is the complete wiring diagram of a nervous system. Think of it as the ultimate circuit board schematic, except instead of copper traces and resistors, you’re mapping biological neurons and the synapses that connect them. But unlike an electrical circuit you can trace with your finger, these connections exist in three-dimensional space at scales invisible to the naked eye. A single neuron might be a tenth of a millimeter long but only a few microns wide—about 1/20th the width of a human hair. The synapses where neurons connect are even tinier: just 20-40 nanometers across, roughly 2,000 times smaller than the width of a hair. And there are millions of them, tangled together in a three-dimensional mesh that makes the densest urban skyline look spacious by comparison. The connectome doesn’t just tell you which neurons exist—it tells you how they talk to each other. Neuron A connects to neurons B, C, and D. Neuron B connects back to A and forward to E. That recurrent loop between A and B? That might be how the fly remembers the smell of rotting fruit. The connection strength between neurons—whether a synapse is strong or weak—determines whether a signal gets amplified or filtered out. It’s the difference between a whisper and a shout, between a fleeting thought and a committed decision.

Creating a connectome is almost absurdly difficult. First, you preserve the brain perfectly at nanometer resolution, then slice it into thousands of impossibly thin sections—the fruit fly required 7,000 slices, each just 40 nanometers thick, about 1/1,000th the thickness of paper, cut with diamond-knife precision. Each slice goes under an electron microscope, generating a 100-teravoxel dataset where each pixel represents an 8-nanometer cube of brain tissue. Then comes the nightmare part: tracing each neuron through all 7,000 slices, like following a single thread through 7,000 sheets of paper where the thread appears as just a dot on each sheet—and there are 139,255 threads tangled together. When Sydney Brenner’s team mapped C. elegans in the 1970s and 80s, they did this entirely by hand, printing electron microscopy images on glossy paper and tracing neurons with colored pens through thousands of images. It took 15 years for 302 neurons. The fruit fly has 460 times more.

This is where the breakthrough happened. The FlyWire consortium used machine learning algorithms called flood-filling networks to automatically segment neurons, but the AI made mistakes constantly—merging neurons, splitting single cells into pieces, missing connections. So they crowdsourced the proofreading: hundreds of scientists and citizen scientists corrected errors neuron by neuron, synapse by synapse, and the AI learned from each correction. This hybrid approach—silicon intelligence for speed, human intelligence for accuracy—took approximately 50 person-years of work. The team then used additional machine learning to predict neurotransmitter types from images alone and identified 8,453 distinct cell types. The final result: 139,255 neurons, 54.5 million synapses, every single connection mapped—a complete wiring diagram of how a fly thinks.

The O(n²) Problem

Connectomes scale brutally. Going from 302 to 139,255 neurons isn’t 460× harder—it’s exponentially harder because connectivity scales roughly as n². The worm has ~7,000 synapses. The fly has 54.5 million—a 7,800× increase in edges for a 460× increase in nodes. The fly brain also went from 118 cell classes to 8,453 distinct types, meaning the segmentation problem became orders of magnitude more complex.

Sydney Brenner’s team in 1986 traced C. elegans by hand through 8,000 electron microscopy images using colored pens on glossy prints. They tried automating it with a Modular I computer (64 KB memory), but 1980s hardware couldn’t handle the reconstruction. The entire project took 15 years.

The FlyWire consortium solved the scaling problem with a three-stage pipeline:

Exponential Growth

460× more neurons in 38 years

7,142× more synapses

Complexity: O(n²) connections

Stage 1: Automated segmentation via flood-filling networks
They sliced the fly brain into 7,000 sections at 40nm thickness (1/1000th the thickness of paper), generating a 100-teravoxel dataset. Flood-filling neural networks performed initial segmentation—essentially a 3D region-growing algorithm that propagates labels across voxels with similar appearance. This is computationally tractable because it’s local and parallelizable, but error-prone because neurons can look similar to surrounding tissue at boundaries.

Stage 2: Crowdsourced proofreading
The AI merged adjacent neurons, split single cells, and missed synapses constantly. Hundreds of neuroscientists and citizen scientists corrected these errors through a web interface. Each correction fed back into the training set, iteratively improving the model. This hybrid approach—automated first-pass, human verification, iterative refinement—consumed approximately 50 person-years.

Stage 3: Machine learning for neurotransmitter prediction
Rather than requiring chemical labeling for every neuron, they trained classifiers to predict neurotransmitter type (glutamate, GABA, acetylcholine, etc.) directly from EM morphology. This is non-trivial because neurotransmitter identity isn’t always apparent from structure alone, but statistical patterns in vesicle density, synapse morphology, and connectivity motifs provide signal.

The result is complete: every neuron traced from dendrite to axon terminal, every synapse identified and typed, every connection mapped. UC Berkeley researchers ran the entire connectome as a leaky integrate-and-fire network on a laptop, successfully predicting sensorimotor pathways for sugar sensing, water detection, and proboscis extension. Completeness matters because partial connectomes can’t capture whole-brain dynamics—recurrent loops, feedback pathways, and emergent computation require the full graph.

50 largest neurons of the fly brain connectome.
Credit: Tyler Sloan and Amy Sterling for FlyWire, Princeton University, (Dorkenwald et al., 2024)

Power Scaling: The Fundamental Constraint

Here’s the engineering problem: the fly brain operates on 5-10 microwatts. That’s 0.036-0.072 nanowatts per neuron. It enables:

Controlled flight at 5 m/s with 200 Hz wing beat frequency
Visual processing through 77,536 optic lobe neurons at ~200 fps
Real-time sensorimotor integration with ~10ms latencies
Onboard learning and memory formation
Navigation, courtship, and decision-making

Compare this to autonomous systems:

System	Power	Capability	Efficiency
Fruit fly brain	10 μW	Full autonomy	0.072 nW/neuron
Intel Loihi 2	2.26 μW/neuron	Inference only	31× worse than fly
NVIDIA Jetson (edge inference)	~15 W	Vision + control	10⁶× worse
Boston Dynamics Spot	~400 W total	90 min runtime	–
Human brain	20 W	1 exaFLOP equivalent	50 pFLOPS/W
Frontier supercomputer	20 MW	1 exaFLOP	50 FLOPS/W

The brain achieves ~10¹² better energy efficiency than conventional computing at the same computational throughput. This isn’t a transistor physics problem—it’s architectural.

Why Biology Wins: Event-Driven Sparse Computation

The connectome reveals three principles that explain biological efficiency:

1. Asynchronous event-driven processing
Neurons fire sparsely (~1-10 Hz average) and asynchronously. There’s no global clock. Computation happens only when a spike arrives. In the fly brain, within four synaptic hops nearly every neuron can influence every other (high recurrence), yet the network remains stable because most neurons are silent most of the time. Contrast this with synchronous processors where every transistor is clocked every cycle, consuming 30-40% of chip power just on clock distribution—even when idle.

2. Strong/weak connection asymmetry
The fly connectome shows that 70-79% of all synaptic weight is concentrated in just 16% of connections. These strong connections (>10 synapses between a neuron pair) carry reliable signals with high SNR. Weak connections (1-2 synapses) may represent developmental noise, context-dependent modulation, or exploratory wiring that rarely fires. This creates a core network of reliable pathways overlaid with a sparse exploratory graph—essentially a biological ensemble method that balances exploitation and exploration.

3. Recurrent loops instead of deep feedforward hierarchies
The Drosophila larval connectome (3,016 neurons, 548,000 synapses) revealed that 41% of neurons receive long-range recurrent input. Rather than the deep feedforward architectures in CNNs (which require many layers to build useful representations), insect brains use nested recurrent loops. This compensates for shallow depth: instead of composing features through 50+ layers, they iterate and refine through recurrent processing with 3-4 layers. Multisensory integration starts with sense-specific second-order neurons but rapidly converges to shared third/fourth-order processing—biological transfer learning that amortizes computation across modalities.

Neuromorphic Implementations: Narrowing the Gap

Event-driven neuromorphic chips implement these principles in silicon:

Intel Loihi 2 (2024)

1M neurons/chip, 4nm process
Fully programmable neuron models
Graded spikes (not just binary)
2.26 μW/neuron (vs. 0.072 nW for flies—still 31,000× worse)
16× better energy efficiency than GPUs on audio tasks

The Hala Point system (1,152 Loihi 2 chips) achieves 1.15 billion neurons at 2,600W maximum—demonstrating that neuromorphic scales, but still consumes orders of magnitude more than biology per neuron.

IBM NorthPole (2023)

Eliminates von Neumann bottleneck by co-locating memory and compute
22 billion transistors, 800 mm² die
25× better energy efficiency vs. 12nm GPUs on vision tasks
72× better efficiency on LLM token generation

NorthPole is significant because it addresses the memory wall: in traditional architectures, moving data between DRAM and compute costs 100-1000× more energy than the actual computation. Co-locating memory eliminates this overhead.

BrainChip Akida (2021-present)

First commercially available neuromorphic chip
100 μW to 300 mW depending on workload
Akida Pico (Oct 2024): <1 mW operation
On-chip learning without backprop

The critical insight: event-driven cameras + neuromorphic processors. Traditional cameras output full frames at 30-60 fps whether or not anything changed. Event-based cameras (DVS sensors) output asynchronous pixel-level changes only—mimicking retinal spike encoding. Paired with neuromorphic processors, this achieves dramatic efficiency: idle power drops from ~30W (GPU) to <1mW (neuromorphic).

RoboBees
Credit: Wyss Institute at Harvard University

The Micro-Robotics Power Wall

The scaling problem becomes acute at insect scale. Harvard’s RoboBee (80-100 mg, 3 cm wingspan) flies at 120 mW. Solar cells deliver 0.76 mW/mg at full sun—but the RoboBee needs 3× Earth’s solar flux to sustain flight. This forces operation under halogen lights in the lab, not outdoor autonomy.

The fundamental constraint is energy storage scaling. As robots shrink, surface area (power collection) scales as r², volume (power demand) as r³. At sub-gram scale, lithium-ion provides 1.8 MJ/kg. Metabolic fat provides 38 MJ/kg—a 21× advantage that no battery chemistry on the roadmap approaches.

This creates a catch-22: larger batteries enable longer flight, but add weight requiring bigger actuators drawing more power, requiring even larger batteries. The loop doesn’t converge.

Alternative approaches:

Cyborg insects: Beijing Institute of Technology’s 74 mg brain controller interfaces directly with bee neural tissue via three electrodes, achieving 90% command compliance. Power: hundreds of microwatts for control electronics. Propulsion: biological, running on metabolic fuel. Result: 1,000× power advantage over fully robotic micro-flyers.
Chemical fuels: The RoBeetle (88 mg crawling robot) uses catalytic methanol combustion. Methanol: 20 MJ/kg—10× lithium-ion density. But scaling combustion to aerial vehicles introduces complexity (fuel pumps, thermal management) at millimeter scales.
Tethered operation: MIT’s micro-robot achieved 1,000+ seconds of flight with double aerial flips, but remains tethered to external power.

For untethered autonomous micro-aerial vehicles, current battery chemistry makes hour-long operation physically impossible.

The Dragonfly Algorithm: Proof of Concept

The dragonfly demonstrates what’s possible with ~1 million neurons. It intercepts prey with 95%+ success, responding to maneuvers in 50ms:

10 ms: photoreceptor response + signal transmission
5 ms: muscle force production
35 ms: neural computation

That’s 3-4 neuron layers maximum at biological signaling speeds (~1 m/s propagation, ~1 ms synaptic delays). The algorithm is parallel navigation: maintain constant line-of-sight angle to prey while adjusting speed. It’s simple, fast, and works with 1/100th the spatial resolution of human vision at 200 fps.

The dragonfly’s visual system contains 441 input neurons feeding 194,481 processing neurons. Researchers have implemented this in III-V nanowire optoelectronics operating at sub-picowatt per neuron. The human brain averages 0.23 nW/neuron—still 100,000× more efficient than conventional processors per operation. Loihi 2 and NorthPole narrow this to ~1,000× gap, but the remaining distance requires architectural innovation, not just process shrinks.

Distributed Control vs. Centralized Bottlenecks

Insect nervous systems demonstrate distributed control:

Spinal reflexes: 10-30 ms responses without brain involvement
Central pattern generators: rhythmic movements (walking, flying) produced locally in ganglia
Parallel sensory streams: no serialization bottleneck

Modern autonomous vehicles route all sensor data to central compute clusters, creating communication bottlenecks and single points of failure. The biological approach is hierarchical:

Low-level reactive control: fast (1-10 ms), continuous, local
High-level deliberative planning: slow (100-1000 ms), occasional, centralized

This matches the insect architecture: local ganglia handle reflexes and pattern generation, brain handles navigation and decision-making. The division of labor minimizes communication overhead and reduces latency.

Scaling Constraints Across Morphologies

The power constraint manifests predictably across scales:

Micro-aerial (0.1-1 g): Battery energy density is the hard limit. Flight times measured in minutes. Solutions require chemical fuels, cyborg approaches, or accepting tethered operation.

Drones (0.1-10 kg): Power ∝ v³ for flight. Consumer drones: 20-30 min. Advanced commercial: 40-55 min. Headwinds cut range by half. Monarch butterflies migrate thousands of km on 140 mg of fat—200× better mass-adjusted efficiency.

Ground robots (10-100 kg): Legged locomotion is 2-5× less efficient than wheeled for the same distance (constantly fighting gravity during stance phase). Spot: 90 min runtime, 3-5 km range. Humanoids: 5-10× worse cost of transport than humans despite electric motors being more efficient than muscle (90% vs. 25%). The difference is energy storage and integrated control.

Computation overhead: At large scale (vehicles drawing 10-30 kW), AI processing (500-1000W) is 5-10% overhead. At micro-scale, computation dominates: a 3cm autonomous robot with CNN vision gets 15 minutes from a 40 mAh battery because video processing drains faster than actuation.

The Engineering Path Forward

The connectome provides a blueprint, but implementation requires system-level integration:

1. Neuromorphic processors for always-on sensing
Event-driven computation with DVS cameras enables <1 mW idle power. Critical for battery-limited mobile robots.

2. Hierarchical control architectures
Distribute reflexes and pattern generation to local controllers. Reserve central compute for high-level planning. Reduces communication overhead and latency.

3. Task-specific optimization over general intelligence
The dragonfly’s parallel navigation algorithm is simple, fast, and sufficient for 95%+ interception success. General-purpose autonomy is expensive. Narrow, well-defined missions allow exploiting biological efficiency principles.

4. Structural batteries and variable impedance actuators
Structural batteries serve as both energy storage and load-bearing elements, improving payload mass fraction. Variable impedance actuators mimic muscle compliance, reducing energy waste during impacts.

5. Chemical fuels for micro-robotics
At sub-gram scale, metabolic fuel’s 20-40× energy density advantage over batteries is insurmountable with current chemistry. Methanol combustion, hydrogen fuel cells, or cyborg approaches are the only paths to hour-long micro-aerial autonomy.

Minuscule RoBeetle Turns Liquid Methanol Into Muscle Power
Credit: IEEE Spectrum

Conclusion: Efficiency is the Constraint

The fruit fly connectome took 38 years after C. elegans because complexity scales exponentially. The same scaling laws govern autonomous robotics: every doubling of capability demands exponentially more energy, computation, and integration complexity.

The fly brain’s 5-10 μW budget for full autonomy isn’t just impressive—it’s the benchmark. Current neuromorphic chips are 1,000-30,000× worse per neuron. Closing this gap requires implementing biological principles: event-driven sparse computation, strong/weak connection asymmetry, recurrent processing over deep hierarchies, and distributed control.

Companies building autonomous systems without addressing energetics will hit a wall—the same wall that kept connectomics at 302 neurons for 38 years. Physics doesn’t care about better perception models if the robot runs out of power before completing useful work.

When robotics achieves even 1% of biological efficiency at scale, truly autonomous micro-robots become feasible. Until then, the scaling laws remain unforgiving. The connectome reveals both how far we are from biological efficiency—and the specific architectural principles required to close that gap.

The message for robotics engineers: efficiency isn’t a feature, it’s the product.

Explore the full FlyWire visualization at https://flywire.ai/

October 16, 2025 (updated October 17, 2025) By Tim Booher 3 Comments

Engineering & Code

The GENIUS Act: From Crypto Experiment to National Security Infrastructure

When President Trump signed the GENIUS Act on July 18, 2025, he didn’t just regulate stablecoins—he legitimized an entire technology stack that will become core infrastructure for defense and intelligence agencies. By requiring full liquid reserves and exempting compliant stablecoins from securities regulations, the Act transforms what was once speculative technology into government-grade payment and settlement infrastructure.

This matters because modern military operations aren’t starved for bandwidth and processing power—they need immutable state, enforceable trust, and precise data distribution. The same technology that powers a dollar-pegged stablecoin can lock mission events in seconds, encode rules of engagement in self-executing code, and prove compliance without compromising operational security.

Command and control breaks when everyone maintains their own version of “truth.” Byzantine fault-tolerant consensus—the same mechanism that prevents double-spending in stablecoins—forces independent nodes to agree on each state change before it’s recorded. No more reconciliation queues. No more debating which ROE update is authoritative. Just a single, cryptographically locked sequence of events that can’t be quietly rewritten.

With that single, tamper‑proof log in place, autonomous systems can graduate from lone‑wolf behaviors to coordinated swarms: the ledger’s state becomes the authoritative “leader,” while each drone, satellite, or ground robot is a “follower” that subscribes to—and writes into—the same stream. AI planners can post composite tasks (sensor → shooter chains, refuel rendezvous, med‑evac corridors) as smart‑contract directives; individual platforms claim subtasks, stake cryptographic commitments, and update status the moment they act. Because every node sees identical state within seconds, hand‑offs and deconfliction happen in code, not over voice nets, and higher‑level orchestration engines can reason over the evolving mission graph in real time. The result is multi‑platform C2 where machines negotiate roles, verify execution, and re‑task themselves under a commander’s intent—while commanders and auditors retain an immutable play‑by‑play of who led, who followed, and whether the AI kept faith with policy.

But this tech can do more than just enable coordinated higher level autonomy. Supply chains fail when we can’t prove provenance. The tokenization standards legitimized by the GENIUS Act give every part, payment, and piece of data a cryptographic birth certificate. A counterfeit component breaks the chain instantly. Payment releases automatically when secure oracles confirm delivery and compliance. Cash cycles drop from 60-120 days to near real-time.

Zero-trust architectures stall without programmable policy. Smart contracts—now legally deployable for government use—convert access control from organizational charts into mathematical proofs. A fire mission only executes if the required cryptographic signatures align. Coalition partners can verify actions without seeing raw intelligence.

Before the GENIUS Act, stable‑coin rails and tokenised provenance rarely moved beyond DARPA demos because the scale‑up money wasn’t there: mission engineers could prove value in a sandbox, but CFOs and contracting officers lacked a legally accepted funding mechanism and a clear path to classify the R&D spend. The existence of large‑volume pilots—and the capital that follows—will harden the stack, integrate it with legacy systems, and drive down technical risk for the war‑fighter.

Now, with explicit statutory protection for properly-backed digital assets, defense contractors can build at scale. The same legal framework that protects a stablecoin’s dollar peg protects a tokenized part inventory, a programmable budget line, or a cryptographically-governed sensor feed.

The Act doesn’t just permit this infrastructure—it demands it. Full reserve requirements and regular attestations? That’s exactly the level of auditability the DoD needs for financial management. Bankruptcy-remote custody structures? Perfect for protecting government assets in contractor systems. Real-time settlement with cryptographic finality? Precisely what accelerated kill chains require.

The GENIUS Act creates a rare alignment between financial innovation and national security needs. The question isn’t whether this technology will reshape defense operations—it’s who will build it.

This will intersect with formal methods in a powerful way. Recent breakthroughs in large‑scale formal verification—driven by Amazon’s Byron Cook and Michael Hicks—slot perfectly into this Merkle‑anchored world: their push‑button model‑checking and property‑based compilation pipelines can exhaustively prove that a smart contract (or autonomous‑agent policy) preserves invariants like “never fire without dual‑key authorization” or “funds only move when supply‑chain proofs are valid” before the code ever deploys, while the Merkle tree records every compiled binary and configuration hash so field auditors can show the running system is exactly the one that passed the proofs.

Silicon Valley fintechs are already racing to capture the civilian market. They’ll build the protocols, control the standards, and rent access back to the government. Or defense primes can recognize this moment: the regulatory green light to build sovereign, military-grade distributed systems that we control from the ground up.

The experimental phase is over. The GENIUS Act provides the legal foundation. The technology works at massive scale. The operational need is real.

The only question left is whether the national security establishment will seize this opportunity to build its own cryptographic infrastructure—or wake up in five years dependent on systems designed for retail banking, hoping they can be retrofitted for combat.

July 25, 2025 (updated July 25, 2025) By Tim Booher One Comment

Autonomy

Robot Bees and other Little Robots

Researchers in China are crafting cyborg bees by fitting them with incredibly thin neural implants (article: Design of flight control system for honeybee based on EEG stimulation). The story isn’t that biology replaces electronics; it’s that biology supplies free actuation, sensing, and ultra low power computation that we can piggyback on with just enough silicon to plug those abilities into our digital world. Through leveraging natural flight capabilities and endurance of biological hosts, you have an ideal covert reconnaissance or delivery platform ideal for military surveillance, counterterrorism operations, physically hacking hardware and disaster relief missions where traditional drones would be too conspicuous or lack the agility to navigate complex environments.

So, there are lots of news articles on this, but the concept of miniature flying machines is far from new. For over a decade before projects like Harvard’s pioneering RoboBee took flight in 2007, researchers were already delving into micro-aerial vehicles (MAVs), driven by the quest for stealthy surveillance and other specialized applications. Early breakthroughs, such as the untethered flight of the Delft University of Technology’s “DelFly,” laid crucial groundwork, proving that insect-scale flight was not just a sci-fi dream but an achievable engineering challenge. This long history underscores a persistent, fascinating pursuit: shrinking aerial capabilities to an almost invisible scale.

Unlike the “China has a robot Bee!” articles, I wanted to step back and survey this space and where it’s going, and, well, this is kinda a big deal. The plot below reveals the tug-of-war between a robot’s mass and its flight endurance. While a general trend shows heavier robots flying longer, the interesting data are in the extremes. Beijing’s “Cyborg Bee” is a stunning outlier, achieving incredible flight times (around 45 minutes) with a minuscule 0.074-gram control unit by cleverly outsourcing the heavy lifting to a living bee – a biological cheat code for endurance. Conversely, the “NUDT Mosquito-Sized Drone” pushes miniaturization to its absolute limit at 0.3 grams, but sacrifices practical flight time, lasting only a few minutes . This highlights the persistent “holy grail” challenge: building truly insect-scale artificial robots that can fly far–and obey orders. Even cutting-edge artificial designs like MIT’s latest robotic insect, while achieving an impressive 17 minutes of flight, still carry more mass than their biological counterparts. The plot vividly demonstrates that while human ingenuity can shrink technology to astonishing scales, nature’s efficiency in flight remains the ultimate benchmark.

Researchers figured out how to deliver precise electronic pulses that create rough sensory illusions, compelling the bee to execute flight commands—turning left or right, advancing forward, or retreating on demand. And this works. During laboratory demonstrations, these bio-hybrid drones achieved a remarkable 90% command compliance rate, following directional instructions with near-perfect accuracy. By hijacking the bee’s neural pathways, China has effectively weaponized nature’s own engineering, creating a new class of biological surveillance assets that combine the stealth of living organisms with the precision of electronic control systems.

The Beijing team’s breakthrough lies in their precise neural hijacking methodology: three hair-width platinum-iridium micro-needles penetrate the bee’s protocerebrum, delivering charge-balanced biphasic square-wave pulses at a soothing ±20 microamperes—just above the 5-10 µA activation threshold for insect CNS axons yet safely below tissue damage limits. These engineered waveforms, typically running at 200-300 Hz to mimic natural flight central pattern generators, create directional illusions rather than forcing specific muscle commands. Each pulse lasts 100-300 microseconds, optimized to match the chronaxie of 2-4 micrometer diameter insect axons.

Figuring this out is more guessing than careful math. Researchers discovered these “magic numbers” through systematic parametric sweeps across amplitude (5-50 µA), frequency (50-400 Hz), and pulse width (50-500 µs) grids, scoring binary outcomes like “turn angle >30°” until convergence on optimal control surfaces. Modern implementations use closed-loop Bayesian optimization with onboard IMUs and nRF24L01 radios, reducing tuning time from hours to ~90 seconds while adding ±10% amplitude jitter to counteract the bee’s rapid habituation response.

You can’t figure this out on live bees. To get these measurements, the honeybee head capsule is isolated from the body while leaving the entire brain undamaged. The head is cut free and placed into a dye-loaded and cooled ringer solution in a staining chamber for 1 hour, then fixed in a recording chamber, covered with a cover-slip, and imaged under the microscope. After you do this, you can conduct experiments on hundreds of honeybees using low and high current intensity. After stimulation, the Isolated Pulse Stimulator was modulated to generate a dissociating pulse (20 µA DC, 15–20 s), which partially dissociated Fe³⁺ from the stimulating electrode and deposited it in surrounding brain tissue marking where they stimulated for post-mortem analysis.

Precise probe placement relies on decades of accumulated neuroanatomical knowledge. Researchers leverage detailed brain atlases created through electron microscopy and confocal imaging, which map neural structures down to individual synaptic connections. Before inserting stimulation electrodes, they consult these three-dimensional brain maps to target specific neural clusters with sub-millimeter accuracy. During experiments, they verify their targeting using complementary recording techniques: ultra-fine borosilicate glass microelectrodes with 70-120 MΩ tip resistance penetrate individual neurons, capturing their electrical chatter at 20,000 samples per second. These recordings reveal whether the stimulation reaches its intended targets—researchers can literally watch neurons fire in real-time as voltage spikes scroll across their screens, confirming that their three platinum-iridium needles are activating the correct protocerebral circuits. This dual approach—anatomical precision guided by brain atlases combined with live electrophysiological validation—ensures the cyborg control signals reach exactly where they need to go.

What was cool here is that they found a nearly linear relationship between the stimulus burst duration and generated torque. This stimulus-torque characteristic holds for burst durations of up to 500ms. Hierarchical Bayesian modeling revealed that linearity of the stimulus-torque characteristic was generally invariant, with individually varying slopes. This allowed them to get generality through statistical models accounting for individual differences.

Learning the signals is only half the battle. The power challenge defines the system’s ultimate constraints: while a flying bee dissipates ~200 milliwatts mechanically, the cyborg controller must operate within a ~10 mW mass-equivalent budget—about what a drop of nectar weighs. Current 3-milligram micro-LiPo cells provide only ~1 milliwatt-hour, forcing engineers toward energy harvesting solutions like piezoelectric thorax patches that scavenge 20-40 microwatts from wingbeats or thermoelectric films adding single-digit microwatts from body heat. Yes, the bee is the battery.

This power scarcity drives the next evolution: rather than imposing external commands, future systems will eavesdrop on the bee’s existing neural traffic—stretch receptors encoding wingbeat amplitude, Johnston’s organs signaling airspeed, and antennal lobe spikes classifying odors with <50ms latency at just 5 µW biological power. Event-driven neuromorphic processors like Intel’s Loihi 2 can decode these spike trains at <50 microjoules per inference, potentially enabling bidirectional brain-computer interfaces where artificial intelligence augments rather than overrides the insect’s 100-million-year-evolved sensorimotor algorithms.

Challenges

Power remains the fundamental bottleneck preventing sustained cyborg control. A flying bee burns through ~200 milliwatts mechanically, but the electronic backpack must survive on a mere ~10 milliwatt mass budget—equivalent to carrying a single drop of nectar. Current micro-LiPo cells weighing 3 milligrams deliver only ~1 milliwatt-hour, barely enough for minutes of operation. Engineers have turned to the bee itself as a power source: piezoelectric patches glued to the thorax harvest 20-40 microwatts from wingbeat vibrations, while thermoelectric films capture single-digit microwatts from body heat. Combined, these provide just enough juice for duty-cycled neural recording and simple radio backscatter—but not continuous control. The thermal constraint is equally brutal: even 5 milliwatts of continuous power dissipation heats the bee’s dorsal thorax by 1°C, disrupting its olfactory navigation. This forces all onboard electronics to operate in the sub-milliwatt range, making every microjoule precious. The solution may lie in passive eavesdropping rather than active control—tapping into the bee’s existing 5-microwatt neural signals instead of imposing power-hungry external commands.

I summarize the rest of the challenges below:

Challenge	Candidate approach	Practical limits
RF antenna size	Folded‑loop 2.4 GHz BLE or sub‑GHz LoRa patterns printed on 20 µm polyimide	Needs >30 mm trace length—almost bee‑size; detunes with wing motion
Power for Tx	Ambient‑backscatter using 915 MHz carrier (reader on the ground)	100 µW budget fits; 1 kbps uplink only (ScienceDaily)
Network dynamics	Bio‑inspired swarm routing: every node rebroadcasts if SNR improves by Δ>3 dB	Scalability shown in simulation up to 5 000 nodes; real tests at NTU Singapore hit 120 roach‑bots (ScienceDaily)
Localization	Fusion of onboard IMU (20 µg) + optic‑flow + Doppler‑based ranging to readers	IMU drift acceptable for ≤30 s missions; longer tasks need visual odometry

The cyborg bee’s computational supremacy becomes stark when viewed through the lens of task efficiency rather than raw processing power. While silicon-based micro-flyers operate on ARM Cortex processors churning through 20-170 MOPS (mega-operations per second), the bee’s million-neuron brain achieves full visual navigation on just 5 MOPS—neurons firing at a leisurely 5 Hz average. This thousand-fold reduction in arithmetic operations masks a deeper truth: the bee’s sparse, event-driven neural code extracts far more navigational intelligence per computation.

$$ \text{SEI} = \frac{\text{MAP vox}/\text{sec} \times \text{Pose bits}}{\text{MOPS}}$$

To show this, I made up a metric that combines each vehicle’s vision rate, positional accuracy and onboard compute into a single “task‑efficiency” score—the Simultaneous localization and mapping (SLAM)-Efficiency Index (SEI)—so we could compare a honey‑bee brain running on microwatts with silicon drones running on megahertz. Simply put, SEI measures how many bits of world-state knowledge each platform generates per unit of processing. With SEI, the bee achieves 290,000 bits/MOPS—over 100 times better than the best silicon autopilots. Even DJI’s Mini 4K, with its 9,600 MOPS quad-core processor, manages only 420 bits/MOPS despite throwing two thousand times more compute at the problem.

This efficiency gap stems from fundamental architectural differences: bee brains process visual scenes through parallel analog channels that compress optic flow into navigation commands without digitizing every pixel, while our drones waste cycles on frame buffers and matrix multiplications. The bee’s ring-attractor neurons solve path integration as a single rotation-symmetric loop, updating its cognitive map 200 times per second (synchronized with wingbeats) using mere microwatts. Silicon systems attempting equivalent SLAM functionality—feature extraction, bundle adjustment, loop closure—burn 5-15 watts on embedded GPUs. Until neuromorphic processors can match the bee’s event-driven, power-sipping architecture, cyborg insects will remain the only sub-gram platforms capable of autonomous navigation. The chart’s below tells the story on a logarithmic scale: that lonely dot at 290,000 SEI represents not just superior engineering, but a fundamentally different computational paradigm. Note that flapping‑wing robots cluster below 200 MOPS because that’s all a 168 MHz Cortex‑M4 can supply; adding bigger processors blows the weight budget at these sizes.

The race to miniaturize autonomous flight reveals a fundamental truth about computation: raw processing power means nothing without the right architecture. While teams worldwide chase incremental improvements in battery life and chip efficiency, Beijing’s cyborg bee has leverages biology to solve this problem. Just as xAI’s Grok 4 throws trillion-parameter models at language understanding while smaller, cleaner models achieve similar results with careful data curation, bees handle similar complexity with microwatts. The lesson isn’t to abandon silicon for biology, but to recognize that sparse, event-driven architectures trump dense matrix multiplications when every microjoule counts.

Looking forward, the convergence is inevitable: neuromorphic processors like Intel’s Loihi 2 are beginning to bridge the efficiency gap, while cyborg systems like Beijing’s bee point the way toward hybrid architectures that leverage both biological and silicon strengths. The real breakthrough won’t come from making smaller batteries or faster processors—it will come from fundamentally rethinking how we encode, embed, and process information. Whether it’s Scale AI proving that better algorithms beat bigger models, or a bee’s ring-attractor neurons solving navigation with analog elegance, the message is clear: in the contest between brute force and biological intelligence, nature still holds most of the cards.

July 15, 2025 (updated July 15, 2025) By Tim Booher 4 Comments

Engineering & Code

Chinese Researchers Break 22-Bit RSA Encryption with Quantum Computer

A Chinese research team just pushed quantum computing one step closer to breaking the encryption that secures your bank account. The security that protects your credit card, banking, and private messages relies on a simple mathematical bet: it would take classical computers longer than the age of the universe to crack a 2048-bit RSA key. That bet is looking increasingly risky as quantum computers inch closer to breaking the math that secures the internet.

RSA encryption is a widely used asymmetric algorithm crucial for secure digital signatures, web browsing (SSL/TLS), online banking, messaging services, VPNs, and cloud infrastructure. The web depends on RSA and, given some recent news, it’s good to take a couple minutes and get a peek at where this is going.

This month (June 2025), researchers at Shanghai University (Wang, et al) published a study in the Chinese Journal of Computers that used a D-Wave Advantage quantum annealer to factor a 22-bit RSA integer—beating the previous 19-bit record by recasting factoring as a QUBO (Quadratic Unconstrained Binary Optimization) problem. While 22 bits falls far short of the 2048-bit keys securing the internet today, it demonstrates that quantum annealers can scale beyond past limits. The researchers demonstrated that quantum annealing can turn cryptographic attacks into combinatorial optimization problems.

Headlines can be deceptive—another Chinese group “hacked” lightweight block ciphers in 2024, and a D-Wave demo factored a contrived 2048-bit semiprime whose twin primes differed by just two bits—but genuine progress is visible in the research community.

Quantum annealers differ fundamentally from classical computers by utilizing quantum bits (qubits), which exploit phenomena like superposition and entanglement. This enables quantum annealers to efficiently solve certain optimization problems. Although limited in application compared to general-purpose quantum computers, quantum annealers’ recent progress highlights their potential impact on cryptographic security.

Quantum Annealer

Shor’s Algorithm

To make sense of this, I made a visualization to compare quantum annealing to Shor’s Algorithm. The “Quantum Annealer” side shows particles behaving in a fluid, probabilistic manner – they move chaotically and gradually converge toward a central point, representing how quantum annealers explore solution spaces by leveraging quantum superposition and tunneling effects to find optimal solutions through a process of gradual energy minimization. On the right, “Shor’s Algorithm” displays particles organizing into a rigid, structured grid pattern, illustrating the deterministic, step-by-step nature of classical quantum algorithms that follow precise mathematical procedures to solve specific problems like integer factorization. The contrast between the organic, exploratory movement on the quantum annealer side and the methodical, ordered arrangement on the classical algorithm side captures the essential difference between these two quantum computing paradigms: one uses quantum mechanics to probabilistically search for solutions, while the other uses quantum mechanics to execute deterministic algorithms with exponential speedup over classical computers.

Factoring large integers remains the yardstick for quantum progress because RSA’s safety rests on how brutally hard that task is for classical machines. Jumping from a 19-bit to a 22-bit crack looks tiny beside a 2,048-bit key, yet the pace signals that quantum methods—whether Shor’s algorithm or annealing—are gaining real traction.

RSA is safe for the moment, but the danger is time-shifted. Attackers can copy ciphertext today and decrypt it when hardware catches up, so any data that must stay private into the 2030s already needs stronger wrapping. Agencies and corporations are mapping every legacy backup, TLS endpoint, and VPN tunnel that still leans on RSA, then swapping certificates and firmware signatures for post-quantum or hybrid ones as they come up for renewal. The White House, NIST, and NSA’s CNSA 2.0 suite have turned that housekeeping into policy, naming lattice schemes such as CRYSTALS-Kyber, Dilithium, and SPHINCS+ as the new default. Migration is messy only for systems without “crypto agility,” the design principle that lets you change algorithms as easily as you update software.

Elliptic-curve keys used in Bitcoin and Ethereum sit even lower on the future quantum cost curve, but they, too, will fall once hardware scales. The immediate leak risk lies in records with decade-long value—medical histories, merger drafts, cold wallets, long-lived SSL certs—because those files are already being siphoned for eventual decryption.

Quantum road maps show why urgency is justified. Google’s 105-qubit Willow chip has crossed the error threshold for full fault tolerance, and IBM projects two thousand logical qubits by 2033—enough to threaten roughly 1,000-bit RSA keys.

Specifically, IBM’s roadmap targets a fault-tolerant quantum computer with 200 logical qubits by 2029 (Starling) and 2,000 by 2033 (Blue Jay). Under Shor’s algorithm, factoring an $n$-bit RSA key requires roughly $2n + 2$ logical qubits , so IBM’s Blue Jay could break RSA keys up to about 999 bits by 2033. Crucially, Shor also solves discrete-log problems, meaning 256-bit ECC keys—the basis for Bitcoin’s ECDSA and Ethereum’s EdDSA—would fall with far fewer qubits, making ECC instances more vulnerable to future quantum attacks than RSA at comparable classical security levels.

Start-ups betting on photonic qubits promise faster scaling, while skeptics such as Scott Aaronson note that engineering overhead grows faster than headline qubit counts suggest. Regulators aren’t waiting: Washington demands server inventories by 2027, Brussels ties NIS2 fines to quantum-safe readiness, and Beijing is pouring billions into domestic chip fabs.

Researchers track logical-qubit lifetimes, error-corrected cycles, and real factoring benchmarks rather than raw qubit totals. A lab that links thousands of physical qubits into hundreds of long-lived logical ones would mark the tipping point where costs start resembling supercomputers, not billion-dollar prototypes.

History rarely shouts as clearly as a Chinese factoring record and a government migration order in the same quarter. It’s wise to treat post-quantum upgrades as routine maintenance—rotate keys, adopt algorithm-neutral APIs, replace certificates on schedule—and a million-qubit announcement will be just another headline. Delay, and every RSA-protected archive on your network becomes a ticking clock, counting down to disclosure day.

Special thanks to Tom Berson, Brian LaMacchia and Pat Lincoln for insights into this area.

June 26, 2025 (updated June 27, 2025) By Tim Booher 0 Comments

Engineering & Code

Web visualization

Communication is the most important skill to sell your ideas. If the last decade has taught us anything, it’s that ideas don’t win because they’re right—they win because someone makes them impossible to ignore. The best communicators I’ve seen combine advanced graphics with deep understanding of a subject. I start simple and show how to get started in web graphics.

Continue reading →

June 6, 2025 (updated June 26, 2025) By Tim Booher 0 Comments

Personal Projects & Interests

Used Mountain Bike Prices

Note: Check out the app and try the model for yourself.

UPDATE: Need to incorporate Pink Bike!

Fresh off a weekend of riding in Bentonville, I realized I need to replace my 2006 Gary Fisher Cake. But I’m data driven and love figuring out a market before I dive in. I wanted more than crowd-sourced hunches about bike pricing; I wanted numbers I could trust. New mountain bikes shed value fast—roughly 30-40 % disappears in the first year, then depreciation flattens to about 8-12 % per year until the geometry or drivetrain standard goes obsolete. Carbon frames, high-end suspension, and “halo” brands (Yeti, Santa Cruz, Pivot) hold value better than entry-level aluminum builds, yet even they nosedive if a service-heavy fork or out-of-fashion wheel size is involved. Used-bike sites quote asking prices, not what bikes actually clear for, and algorithmic estimates rarely account for regional demand or component mix. So I scraped Craigslist, Facebook Marketplace, and Bicycle Blue Book, built my own price model, and now shop with a spreadsheet instead of wishful thinking—seeing at a glance whether that $2,400 Fuel EX is a bargain.

Getting the Data

To build this bike listings dataset, I used a combination of scraping tools and manual extraction strategies across three major platforms: Craigslist, Facebook Marketplace, and Bicycle Blue Book.

For Craigslist, I automated the process end-to-end. I wrote a script (download_cl_raw.py) to fetch city-specific HTML pages using a custom User-Agent and parsed embedded JSON-LD blocks to extract listing data (which you can see here). This raw data was then processed by analyze_and_load_cl.py, which parses structured fields (e.g., brand, model, year, frame material) using regexes and known brand patterns. Only well-known mountain bike brands were retained to ensure data quality.

Facebook Marketplace posed more challenges due to limited APIs and anti-bot measures. To work around this, I manually saved listing pages via the Chrome Developer Tools (see my data here), then used BeautifulSoup (facebook_parser.py) to extract the price, location, and other specs from the HTML. Brand and model parsing reused similar regex-based logic.

For Bicycle Blue Book, I also manually downloaded the listing HTML (data here) and used a script (bb_extractor.py) to extract structured rows like name, type, size, and price using CSS selectors.

Finally, all listings were normalized, cleaned (e.g., prices cast from “$2,800” strings to numeric), and inserted into a fresh PostgreSQL table (bike_listings_new) using upload_bikes.py.

This multi-pronged approach resulted in 1,861 listings with high coverage of core fields like brand, model, year, and price, though fields like frame_size and suspension remain sparsely populated. The dataset now supports robust price modeling, brand comparisons, and cross-market analysis.

The most represented brands are Specialized (300 bikes), Trek (260), and Giant (118), with most listings concentrated in recent years like 2023 and 2024. Specialized alone accounts for over 100 bikes listed in 2023, showing clear popularity and availability on the secondhand market. Model year coverage spans from 2015 to 2025, with the majority of data coming from the last five years. In terms of data completeness, core fields like title, price, brand, and year are over 95% populated, while others such as frame_size, wheel_size, and drivetrain have much sparser coverage. Notably, only 20% of entries have frame_size and less than 10% have detailed mechanical specs like brake_type or suspension. This makes broad comparisons possible on price and brand, but highlights the challenges in making deeper component-level comparisons—especially since components and condition may vary significantly even within the same model and year. Nonetheless, the dataset offers a strong foundation for analyzing used bike market trends, pricing gaps between platforms, and brand popularity over time.

Some parameters I could get 100% coverage, while there was nearly no data on tires or suspension travel. You should check out this monster query to generate this table.

column_name	populated_count	missing_count	total_rows	percentage populated
id	1861	0	1861	100
city	1861	0	1861	100
post_date	1861	0	1861	100
price	1861	0	1861	100
currency	1861	0	1861	100
title	1861	0	1861	100
brand	1861	0	1861	100
scraped_at	1861	0	1861	100
source	1861	0	1861	100
model	1854	7	1861	99.62
year	1794	67	1861	96.4
frame_material	1735	126	1861	93.23
original_model	1682	179	1861	90.38
location	1679	182	1861	90.22
frame_size	378	1483	1861	20.31
url	237	1624	1861	12.74
wheel_size	173	1688	1861	9.3
drivetrain	95	1766	1861	5.1
brake_type	47	1814	1861	2.53
suspension	12	1849	1861	0.64
tire_brand	2	1859	1861	0.11
travel	1	1860	1861	0.05

Initial Observations

My first question, was how prices compare between facebook, craiglist and bicycle bluebook. Craigslist prices are systematically lower—often by 20–50%, and sometimes by multiples—for the same year+model. eg. in 2019 Switchblade: CL $1,500 vs FB $2,000 and SB150: CL $3,300 vs FB $3,600. BicycleBluebook, when present, sits between Craigslist and Facebook, acting as a mid-market reference. This supercool sql let me compare the sites.

year	model	avg craigslist	avg facebook	avg bb	abs spread	max_min ratio
2024	Marlin 6	$2,800.00	$500.00		$2,300.00	5.6
2024	Stumpjumper	$1,026.25	$2,375.00		$1,348.75	2.31
2023	Tallboy	$1,150.00	$2,600.00		$1,450.00	2.26
2023	Stumpjumper	$1,085.00	$2,371.67		$1,286.67	2.19
2024	Fuel EX 8	$1,108.33	$2,300.00		$1,191.67	2.08
2024	141	$3,500.00	$1,900.00		$1,600.00	1.84
2021	SB95	$1,500.00	$2,500.00		$1,000.00	1.67
2021	SB150	$2,000.00	$3,200.00		$1,200.00	1.6
2022	Trance X 3	$1,200.00	$1,900.00		$700.00	1.58
2023	Fuel EX 5	$856.25		$1,350.00	$493.75	1.58
2022	Spark 960	$1,849.00		$1,200.00	$649.00	1.54

When comparing average bike prices across Craigslist, Facebook, and BicycleBluebook for the same year and model, there are striking disparities. Similar spreads are evident for popular models like the Stumpjumper and Tallboy, where Facebook listings consistently command significantly higher prices. In other cases, such as the Fuel EX 8 and SB150, the Craigslist price is notably lower by over $1,000 on average. While these differences are compelling, it’s important to note that they may reflect variations in bike condition, component specs, and seller expectations rather than pure market inefficiency. Still, the consistent patterns suggest that Craigslist may offer lower-priced listings on average, while Facebook often reflects a more premium price tier.

Does the city matter?

(no, cuz this market is crazy)

From some quick analysis, most brand-model-year combinations appear in only one city, so their local average simply is the national average (100 % rows). There is just not enough clean data to answer this question and the one conclusion I take away is that bike pricing is a super inefficient market. Where a combo shows up in two markets the price gaps are striking: a 2025 “unknown” Specialized lists for $750 on Seattle’s boards— about 50 % above the national mean—while the same mystery build averages only $240 in Chicago (≈ 50 % below). Likewise, 2023 Trek “unknowns” fetch $1,348 in Denver (151 % of national) but just $433 in Los Angeles (49 %). Even with tiny sample sizes (3–5 bikes each), the pattern suggests regional demand and seller optimism can swing asking prices for identical vintage-and-brand bikes by a factor of two or more.

A more sophisticated check backs this up. Only one usable “city” dummy survived the frequency filter, and LightGBM never bothered to split on it—its total gain and split count are both zero. When we rebuilt the model with the city column entirely removed, the median-absolute-error stayed exactly the same ($1,082). In short, regional location adds no predictive power in this data; age, brand, and frame material explain nearly all of the price variation we can capture, while the city a bike is listed in appears irrelevant.

Model

I built a model to sift through thousands of real listings—accounting for brand reputation, frame material, the bike’s age, and even how prices vary from city to city—to predict a fair, middle-of-the-road price in seconds. Think of it as my own personal Kelley Blue Book for bikes.

Under the hood, the valuation engine marries a classic machine-learning preprocessing stack with a modern gradient-boosted quantile regressor. Continuous bike attributes (age, log-age) sail through a median-imputer, while brand, frame material, size, and city are one-hot–encoded with frequency pruning so the feature matrix stays lean even as new makes appear. I trained with GroupKFold keyed on city—crucial for second-hand markets where geography drives pricing—to guarantee our test fold is a truly out-of-town set. A ridge model gives a transparent linear baseline, but the production scorer is a LightGBM quantile model at $\alpha = 0.5$, which directly learns the market median. Boosting captures the steep price cliffs between prestige brands and commodity frames, while quantile loss hedges against outliers that plague classifieds. The result is a file-light pipeline (preprocessor + model serialized at ~ MBs) that returns instant, geographically realistic price medians—ideal for auto-pricing listings, negotiating buys, or flagging bargains the moment they’re scraped.

You can see all the code and results here at my google colab.

Top features by total gain:
                         feature      score
4   cat__frame_material_Aluminum  83.397947
0                       num__age  40.415536
3  cat__brand_infrequent_sklearn  29.515867
5     cat__frame_material_Carbon  15.131043
1                   num__log_age   8.443574
2          cat__brand_Santa Cruz   5.624613
6        cat__frame_size_missing   0.000000
7           cat__city_Fort Worth   0.000000

The LightGBM model’s own score-gain metrics say the single most powerful signal in predicting a used-bike’s median price is simply whether the frame is aluminum (gain ≈ 83). In other words, the algorithm most often chooses to split first on “Aluminum vs. everything else,” because that decision alone lops the most error off its price guesses. Classic depreciation comes next: the bike’s age in years carries roughly half as much influence (gain ≈ 40), confirming that time on the trail is the second-biggest driver of resale value. A close third is an umbrella flag for infrequent or boutique brands—if a listing’s brand falls outside the mainstream, the model adjusts sharply (gain ≈ 30). Carbon frames still matter but noticeably less than aluminum/other (gain ≈ 15), and finally the log-age term (gain ≈ 8) offers the model a gentle curve to fine-tune how price drops level off as bikes get very old. Funny to see the Santa Cruz brand effect too.

Net takeaway: material and time dominate; brand prestige matters mainly at the extremes, and once the model knows those things, everything else is icing.

May 27, 2025 (updated June 15, 2025) By Tim Booher One Comment

Personal Projects & Interests

Tesla Model Y Pricing Model

In today’s crowded used‐EV market, it can be nearly impossible to sift through hundreds of messy web pages and figure out what really drives a Tesla Model Y’s price. That’s why I’m taking a data‐first approach: we’ll pull the full listing text for 250 Long Range Model Ys from CarMax (despite their tangled HTML), clean and organize it into a Google Sheet, then feed it into R. With just a few lines of R code we’ll plot price against both model year and odometer reading, fit a simple linear regression, and package it into an easy-to-use price-estimator function. Finally, we’ll repeat the process on Carvana data and compare the two—to reveal exactly how much “newness” vs. “mileage” each dealer rewards, and help you pinpoint the ideal Year/Mileage combination so you can drive away in your sweetest Model Y deal without ever overpaying.

To do this, I pull up https://www.carmax.com/cars/tesla/model-y/long-range?showreservedcars=false.
The html is super messy, but you can display everything with a couple clicks, select all and copy and give the text on 250 cars to chatgpt to make a nice table in google sheets. (Something I used to write a lot of code and headless browsing to do. Now just copy and paste the mess into an LLM.)

Then with this r script, I could build a little model:

How much does age affect price (about $2000/yr)

And how much does mileage affect price? (every additional mile reduces the predicted price by about 9 cents)

We can make a model that looks at both variables and a linear model fits pretty well.

summary(model)

Call:
lm(formula = Price ~ Year + Mileage, data = df)

Residuals:
    Min      1Q  Median      3Q     Max 
-3726.0  -857.4    86.9   801.9  2871.1 

Coefficients:
              Estimate Std. Error t value Pr(>|t|)    
(Intercept) -3.979e+06  2.191e+05  -18.16   <2e-16 ***
Year         1.986e+03  1.083e+02   18.35   <2e-16 ***
Mileage     -9.353e-02  7.103e-03  -13.17   <2e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

The linear model predicting Tesla Model Y prices based on Year and Mileage shows a very strong fit to the data. The multiple R-squared value is 0.9092, indicating that approximately 91% of the variation in Price is explained by the two predictors. Both Year and Mileage are highly statistically significant (p-values < 2e-16), confirming that newer vehicles and lower mileage are strong predictors of higher prices. The coefficient for Year is approximately $1,986, meaning each additional year (newer) increases the predicted price by about $2,000, holding mileage constant. Conversely, the coefficient for Mileage is approximately -9 cents per mile, meaning every additional mile reduces the predicted price by about 9 cents. The residual standard error is $1,287, suggesting that the typical prediction error is around $1,300, which is relatively small compared to the average vehicle price in the dataset. Overall, the model demonstrates excellent explanatory power and precision for this pricing prediction task.

So then it’s easy to build a function to check if the price is right:

> estimate_price <- function(year, mileage) {
+     predict(model, newdata = data.frame(Year = year, Mileage = mileage))
+ }
> estimate_price(2024, 20000)

We can then build a model to compare carvana and carmax by doing the same thing to Carvana’s web page:

[1] "Model Coefficient Comparison:"
                   Term        Carmax       Carvana    Difference
(Intercept) (Intercept) -3.979085e+06 -3.103468e+06 -8.756172e+05
Year               Year  1.986047e+03  1.551575e+03  4.344724e+02
Mileage         Mileage -9.352694e-02 -8.777679e-02 -5.750151e-03
`geom_smooth()` using formula = 'y ~ x'

When comparing the pricing models between CarMax and Carvana for used Tesla Model Y vehicles, some notable differences emerge. Both models fit a simple linear regression of Price ~ Year + Mileage, but their coefficients tell an interesting story. CarMax vehicles show a slightly higher sensitivity to the vehicle’s year, with a coefficient of $1,986 per year compared to Carvana’s $1,552 — meaning newer cars retain more value at CarMax. Meanwhile, the mileage penalty (the amount price drops per additional mile) is steeper at CarMax, at about 9.35 cents per mile, compared to 8.78 cents at Carvana. Overall, CarMax’s prices tend to start lower. This suggests that CarMax is pricing aggressively lower on older, higher-mileage vehicles, while Carvana offers slightly higher baseline prices but discounts mileage more gently. These differences could reflect strategic positioning: CarMax competing more on price, Carvana offering a convenience premium.

If we anchor both models at a typical vehicle—say a 2022 Model Y with 49 000 miles, this is all pretty clear:

CarMax prediction: > $–3 979 000 + 1 986 × 2022 – 0.0935 × 49 000 ≈ $32 100
Carvana prediction: > $–3 103 500 + 1 552 × 2022 – 0.0878 × 49 000 ≈ $29 500

So on an average 2022, 49,000 mi car, CarMax’s model actually prices it about $2,600 higher than Carvana’s. In practical terms, CarMax seems to lean on year more heavily—charging a steeper premium for newer cars—while also carving off more per mile of wear. Carvana, by contrast, starts a little higher (gentler intercept) but discounts mileage more slowly, resulting in lower predicted prices on higher‐mileage examples. This aligns with CarMax’s more aggressive price‐based positioning on older, higher‐use vehicles and Carvana’s strategy of a slightly higher baseline with more gradual mileage adjustments.

So now we have an estimate_price(2024, 20000) function which tells us: 38803.62

So what should I buy if I’m looking for the sweet spot between value, battery health, and “new‐feel,” my models suggest targeting roughly a 2021–2022 Model Y with 20 000–30 000 miles on the odometer. Here’s why:

Battery life: Tesla batteries typically lose around 2–3% capacity per year plus 2% per 10 k miles. A 2022 car with ~30 k miles will still have around 90–93% of original capacity—plenty of range for daily driving and road trips.
Price:
- CarMax predicts about $34 000 for a 2022/30 k example,
- Carvana predicts about $32 000—so you’re looking at $32–34 k in that neighborhood.
Value boost: Jumping up to 2023 shaves less than $1000 off mileage penalties but adds $1500–2000 on the year premium; dropping down to high‐mileage 2020s saves only ~$3000 but costs you 15–20% battery health.

Bottom line: A 2021–2022 Tesla Model Y with 20,000–30,000 mi strikes the best balance—excellent battery life (≥90%), newer features, and a sweet spot in the $32–34 krange. If you can stretch to 2022 and keep mileage under 25k, you’ll maximize both range and resale value without overpaying.

April 26, 2025 (updated April 27, 2025) By Tim Booher 0 Comments

Personal Projects & Interests

A runner becomes a biker

I can’t get my heart rate up on the bike, even when I feel I’m pushing hard. I grind up hills, spin through flats, and yet it’s hard to get above 120–130 bpm. I run at 160 bpm and race at 170-180.

Cycling is a very muscle‑specific sport. Unlike running, where your whole body (and the impact forces) drive your cardiovascular response, cycling isolates the work to your legs. If your leg muscles—particularly your quads, glutes, and hamstrings—aren’t strong enough to generate high power, you’ll fatigue locally before your heart and lungs get taxed. In other words, your legs give out before your cardiovascular system even gets a chance to climb to higher zones.

The chart shows my average HR on bikes (blue) and runs (red). It’s not completely dominant, but the trend is clear. When I run, my heart rate easily climbs into the 170s, but when I’m biking—even pushing hard—I struggle to get above 110 bpm. I looked into this a bit and it’s a well-documented physiological difference between running and cycling, rooted in both biomechanics and cardiovascular dynamics.

Running is a full-body, weight-bearing activity that recruits a large number of muscle groups: not just the legs, but also the core and upper body for stabilization. That broad muscle recruitment demands more oxygen, more energy, and therefore a higher cardiac output. My heart needs to pump faster and harder to meet that demand, especially when I’m running uphill or accelerating. In contrast, cycling primarily engages the lower body—quads, glutes, hamstrings—and even though those muscles are working, the overall systemic demand is lower.

Then there’s body position. On a bike, I’m seated, often with my torso leaning forward. This posture actually helps venous return—the process of blood returning to the heart—by reducing gravitational resistance. With improved preload, the heart can eject more blood per beat (higher stroke volume), so it doesn’t need to beat as frequently to achieve the same cardiac output. The net result: lower heart rate for the same level of oxygen delivery.

Cycling is also non-weight-bearing. There’s no impact, no ground reaction force, and no constant stabilization with every stride. That reduces overall neuromuscular and cardiovascular load. The metabolic cost of supporting body weight is significantly lower on the bike, which means less activation of the sympathetic nervous system, less catecholamine release (like epinephrine and norepinephrine), and therefore a lower heart rate response.

There’s also something to be said for specificity and conditioning. I’ve trained myself to run hard. My body is used to ramping up HR and oxygen delivery for running efforts. But biking is a different motor pattern, and if I haven’t trained those muscles or systems to handle high-load aerobic work on the bike, the heart rate won’t respond the same way. Even if it feels hard—because my legs are burning from lactate buildup or local muscular fatigue—that doesn’t mean the cardiovascular system is stressed enough to elevate heart rate.

Finally, effort on the bike can be deceptive. I have a power meter and I can keep that up around 200W, but I really want to get to 250 on average. But unlike running, where ground contact and muscle engagement are rhythmic and consistent, cycling effort can be variable and harder to quantify.

So when I’m on the bike and can’t get my heart rate up, it’s not that I’m not working. It’s that the cardiovascular, positional, and neuromuscular dynamics of cycling fundamentally produce a lower heart rate for a given perceived effort. Understanding that helps me train smarter—and recognize that heart rate alone isn’t the full story.

How do I fix this?

I have to boost leg power.

Here’s how I’m thinking about tackling this problem. The issue isn’t just cardiovascular—it’s neuromuscular. My body simply isn’t trained to fire the right motor units efficiently on the bike. Running is second nature by now, but biking demands different recruitment patterns and muscle coordination, especially from muscles like the glutes and vastus lateralis. If the neuromuscular system isn’t trained, I won’t be able to sustain the output needed to drive my heart rate up, regardless of how hard I feel like I’m working.

The second factor is muscular endurance. If my legs tire early, they become the limiter before the heart even gets close to max output. That’s a clear sign I need both more time in the saddle and targeted strength work. The science here is pretty strong: exercises like leg press, lunges, and single-leg squats directly build the muscle groups responsible for power on the bike. They also improve neuromuscular coordination, increase muscle fiber recruitment, and raise fatigue resistance.

From a ride programming perspective, I need to develop the ability to push higher cadences under moderate resistance—specifically 1–2 minute spin-ups at 100–110 RPM. This builds speed and muscle efficiency at higher outputs without requiring massive torque. Over time, it can help train the neuromuscular connection to sustain higher intensities at lower perceived effort.

I’ll also lean hard into hill repeats—4 to 6 sets of 3-minute climbs with full recovery. This kind of session pushes VO2 max systems and helps develop lactate tolerance. It’s the cycling equivalent of running strides uphill. Those 3-minute intervals are long enough to tax both aerobic and anaerobic systems and short enough to allow full engagement without form breakdown. And it’s repeatable, so I can track progress.

But the foundation is really about hitting all energy systems: tempo, threshold, and VO2. I’m planning to ride three times a week: one session focused on tempo or threshold with 8–20 minute intervals; one session focused on VO2 with 2–4 minute intervals; and one longer aerobic ride to build endurance and efficiency. That progression covers the full spectrum of adaptation—from mitochondrial density to lactate clearance to neuromuscular economy.

As for gear, I love my setup right now. My bike felt great today, and honestly, a $30 computer is giving me everything I need at this stage. I’m not yet fit enough to fully benefit from better equipment. The marginal gains would be there, sure—but the main limiter is still my body, not the bike. Fitness comes first.

And on tools—Apple Watch does estimate VO2 max, though it’s more accurate for running than cycling unless paired with a power meter and heart rate strap which are on ant+. But ultimately, the real measure will be how I feel on the bike and whether I can start getting that heart rate up into higher zones consistently. That’s the goal—and this plan gives me a roadmap to get there.

h/t Josh Gordon, Precise Multisport

April 15, 2025 (updated June 26, 2025) By Tim Booher 3 Comments

RESEARCH REFERENCES

Tech Details

The O(n²) Problem

Connectome Evolution

Power Scaling: The Fundamental Constraint

Why Biology Wins: Event-Driven Sparse Computation

Neuromorphic Implementations: Narrowing the Gap

The Micro-Robotics Power Wall

The Dragonfly Algorithm: Proof of Concept

Distributed Control vs. Centralized Bottlenecks

Scaling Constraints Across Morphologies

The Engineering Path Forward

Conclusion: Efficiency is the Constraint

Challenges

Getting the Data

Initial Observations

Does the city matter?

Model

How do I fix this?