We Need More Datacenters

Every unoptimized code we ship silently taxes the world.

Billions of requests are processed every minute on the internet. For a billion requests, every millisecond of inefficiency turns into about 12 days of wasted compute per millisecond.

In other words, every day we waste 2730 years. That spans about 91 generations. In a single day, we waste the lifetime of all our grandchildren until the “89-times great-grandchild”. Looking backward, 2700 years ago was still the Iron Age. Humans had fire and the wheel, not much else. In a day, we waste most of the recorded history of humankind.

A very optimistic claim would be that we are paying for twice the data-center capacity, twice the energy, and twice the carbon just to stand still.

Our “good enough” code, is that bad. It costs us the planet.

Let’s run an experiment to test this claim with a function that finds the Nth Fibonacci number.

What Is the Fibonacci Series?

Let’s remind ourselves. The Fibonacci series is a sequence of numbers in which every term after the first two is the sum of the previous two. Formally, F(0) = 0, F(1) = 1, and F(n) = F(n-1) + F(n-2) for n >= 2. The opening terms look like:

• F(0) = 0
• F(1) = 1
• F(2) = 1
• F(3) = 2
• F(4) = 3
• F(5) = 5
• F(6) = 8
• F(7) = 13

Real-world appearances include branching plants, spiraling shells, and certain divide-and-conquer performance analyses.

The Baseline: TypeScript’s Naïve Recursion

I’m not surprised if you say recursion when I say Fibonacci. Great fit. Let’s write it.

1
export function fibNaive(n: number): number {
2
    if (n < 2) return n;
3
    return fibNaive(n - 1) + fibNaive(n - 2);
4
}

fibNaive implements the classical recursive definition: fib(n) = fib(n-1) + fib(n-2). It stops at the base cases (n < 2), returning n. Simple but recomputes overlapping subproblems, so it grows exponentially (O(2^n) time).

Benchmark:

1
fibNaive(50) -> 12586269025, time: 93773.58117 ms

One function call, 93 seconds of CPU time. That’s the exponential O(2^n) waste inflating your power bill. Surely we can do better.

The key to optimization here is dynamic programming (DP)—a technique that solves complex problems by breaking them down into simpler overlapping subproblems and storing their results to avoid redundant computation. Instead of recalculating the same values repeatedly, we compute each value once and reuse it.

1. Memoized Recursion

fibMemo uses recursion combined with a Map to cache values that have already been computed. On each call, it checks memo before recursing; only unseen states trigger deeper calls. When a new value is computed, it is stored in the map for future use. Cuts the time complexity down to O(n) at the cost of O(n) auxiliary memory.

1
export function fibMemo(n: number, memo = new Map<number, number>()): number {
2
    if (n < 2) return n;
3
    if (memo.has(n)) return memo.get(n)!;
4
    const val = fibMemo(n - 1, memo) + fibMemo(n - 2, memo);
5
    memo.set(n, val);
6
    return val;
7
}

Benchmark: fibMemo(50) → 0.03188 ms. Caching gives us a 2.9-million times speedup.

2. Tabulation with a Dynamic Programming Table

fibTabArray uses bottom-up DP but materializes the whole table (table[i] = fib(i)).

1
export function fibTabArray(n: number): number {
2
    if (n < 2) return n;
3
    const table = new Array<number>(n + 1).fill(0);
4
    table[1] = 1;
5
    for (let i = 2; i <= n; i++) {
6
        table[i] = table[i - 1] + table[i - 2];
7
    }
8
    return table[n];
9
}

Benchmark: fibTabArray(50) → 0.04342 ms. Slightly slower than memoization because of array allocation, but illustrates the textbook dynamic-programming build-up. Runs in O(n) time and O(n) extra space; handy when you want to inspect all intermediate Fibonacci numbers (e.g., for debugging or teaching).

3. Constant-Space Tabulation

This is also bottom-up DP, but it stores only the last two Fibonacci values (prev and curr) at each step. Keeps the runtime at O(n) while dropping auxiliary space to O(1). Preferred when the goal is just the final number and you want maximum speed with minimal memory.

1
// demo.ts:40-51
2
export function fibTab(n: number): number {
3
    if (n < 2) return n;
4
    let prev = 0, curr = 1;
5
    for (let i = 2; i <= n; i++) {
6
        const next = prev + curr;
7
        prev = curr;
8
        curr = next;
9
    }
10
    return curr;
11
}

Benchmark: fibTab(50) → 0.01692 ms. Same O(n) time but with O(1) space. That is the fastest we get with TypeScript.

Even in a garbage-collected language, algorithmic care transforms a minute-long run into a few microseconds. That’s the difference between spinning up extra instances and letting one server rest cool.

Who said TypeScript is the best language for this kind of problem? This is where Rust comes into play.

Rust Goes Further

The Rust rewrite (demo.rs) mirrors the same four strategies. The code looks familiar—HashMap for memoization, vectors for tabulation—but the compiled result is leaner:

1
fib_naive(50)     -> 69916.58687 ms
2
fib_memo(50)      -> 0.04804 ms
3
fib_tab_array(50) -> 0.00250 ms
4
fib_tab(50)       -> 0.00054 ms

Even with identical asymptotic complexity, Rust’s constant factors are smaller: the fastest version runs ~30× faster than the fastest TypeScript one, and the DP array version lands in microseconds without JIT warmup.

The Benchmark Table

Baseline = Rust fib_tab(50) at 0.00054 ms

Relative cost = (time ÷ 0.00054 ms).

The spread is staggering: the slowest function is 173 million times more expensive than the fastest.

The fastest Rust function is ~30 times faster than the fastest TypeScript function. A C version would likely be even faster. (In my quick test, the C version took microseconds—it was so fast I thought I’d made a mistake.)

Takeaways

I understand the pressure to deliver features quickly and the need to use a dev stack that most team members are familiar with. That was my stance as well, but things have changed dramatically in the past few years. Now, improving a function is as easy as asking your favorite LLM. The time investment required to optimize beyond the bare minimum has drastically decreased. Even for critical operations, your LLM can easily convert your prototype in Python to a more performant language. If the team doesn’t know Rust, it’s not a big deal anymore; an LLM can explain the code to you line by line.

Do it, not to save money for your company, not to provide a faster experience for your customers but to do more with less.

Earth will thank you by letting your 89th grandchild enjoy real experiences of blue skies and green forests, not just virtual ones powered by massive server farms.

Appendix

TypeScript Code

1
// 1) Naïve recursion
2
// T(n) ≈ T(n-1) + T(n-2) => O(2^n) time, O(n) stack space
3
export function fibNaive(n: number): number {
4
    if (n < 2) return n;
5
    return fibNaive(n - 1) + fibNaive(n - 2);
6
}
7

8
// 2) Memoization (Top-Down DP)
9
// Stores subproblem results in a Map: O(n) time, O(n) space
10
export function fibMemo(n: number, memo = new Map<number, number>()): number {
11
    if (n < 2) return n;
12
    if (memo.has(n)) return memo.get(n)!;
13
    const val = fibMemo(n - 1, memo) + fibMemo(n - 2, memo);
14
    memo.set(n, val);
15
    return val;
16
}
17

18
// 3) Tabulation with full table
19
// Builds the entire DP table: O(n) time, O(n) space, mirrors textbook DP
20
export function fibTabArray(n: number): number {
21
    if (n < 2) return n;
22
    const table = new Array<number>(n + 1).fill(0);
23
    table[1] = 1;
24
    for (let i = 2; i <= n; i++) {
25
        table[i] = table[i - 1] + table[i - 2];
26
    }
27
    return table[n];
28
}
29

30
// 4) Tabulation (Bottom-Up DP, O(1) space)
31
// Iteratively builds from base cases but only keeps last two values
32
export function fibTab(n: number): number {
33
    if (n < 2) return n;
34
    let prev = 0, curr = 1; // fib(0), fib(1)
35
    for (let i = 2; i <= n; i++) {
36
        const next = prev + curr;
37
        prev = curr;
38
        curr = next;
39
    }
40
    return curr;
41
}
42

43
// Benchmark helper
44
function bench<TArgs extends any[], TReturn>(
45
    label: string,
46
    fn: (...args: TArgs) => TReturn,
47
    ...args: TArgs
48
) {
49
    const start = process.hrtime.bigint();
50
    const result = fn(...args);
51
    const end = process.hrtime.bigint();
52
    const ms = Number(end - start) / 1_000_000;
53
    console.log(`${label.padEnd(22)} -> result: ${result}, time: ${ms.toFixed(5)} ms`);
54
}
55

56
// Quick comparison
57
if (require.main === module) {
58
    const N_SMALL = 50; // manageable for all 3 versions
59

60
    bench("fibNaive(50)", fibNaive, N_SMALL);
61
    bench("fibMemo(50)", fibMemo, N_SMALL);
62
    bench("fibTabArray(50)", fibTabArray, N_SMALL);
63
    bench("fibTab(50)", fibTab, N_SMALL);
64

65

66
    // Bigger n to show scalability (skip naïve!)
67
    const N_BIG = 100; // tab can handle this
68
    bench("fibTab(100)", fibTab, N_BIG);
69
}

Rust Code

1
use std::collections::HashMap;
2
use std::fmt::Display;
3
use std::time::Instant;
4

5
fn fib_naive(n: u64) -> f64 {
6
    if n < 2 {
7
        return n as f64;
8
    }
9
    fib_naive(n - 1) + fib_naive(n - 2)
10
}
11

12
fn fib_memo(n: u64, memo: &mut HashMap<u64, f64>) -> f64 {
13
    if n < 2 {
14
        return n as f64;
15
    }
16
    if let Some(&val) = memo.get(&n) {
17
        return val;
18
    }
19
    let val = fib_memo(n - 1, memo) + fib_memo(n - 2, memo);
20
    memo.insert(n, val);
21
    val
22
}
23

24
fn fib_tab(n: u64) -> f64 {
25
    if n < 2 {
26
        return n as f64;
27
    }
28
    let mut prev = 0.0;
29
    let mut curr = 1.0;
30
    for _ in 2..=n {
31
        let next = prev + curr;
32
        prev = curr;
33
        curr = next;
34
    }
35
    curr
36
}
37

38
fn fib_tab_array(n: u64) -> f64 {
39
    if n < 2 {
40
        return n as f64;
41
    }
42
    let mut table = vec![0.0_f64; (n + 1) as usize];
43
    table[1] = 1.0;
44
    for i in 2..=n as usize {
45
        table[i] = table[i - 1] + table[i - 2];
46
    }
47
    table[n as usize]
48
}
49

50
fn bench<F, R>(label: &str, mut f: F) -> R
51
where
52
    F: FnMut() -> R,
53
    R: Copy + Display,
54
{
55
    let start = Instant::now();
56
    let result = f();
57
    let elapsed = start.elapsed().as_secs_f64() * 1_000.0;
58
    println!("{label:<22} -> result: {result}, time: {elapsed:.5} ms");
59
    result
60
}
61

62
fn main() {
63
    let n_small = 50;
64

65
    bench("fib_naive(50)", || fib_naive(n_small));
66
    bench("fib_memo(50)", || {
67
        let mut memo = HashMap::new();
68
        fib_memo(n_small, &mut memo)
69
    });
70
    bench("fib_tab_array(50)", || fib_tab_array(n_small));
71
    bench("fib_tab(50)", || fib_tab(n_small));
72

73
    let n_big = 100;
74
    bench("fib_tab(100)", || fib_tab(n_big));
75
}

Benchmark Results

1
# TypeScript
2
sh-3.2$ ts-node demo.ts
3
fibNaive(50)           -> result: 12586269025, time: 93773.58117 ms
4
fibMemo(50)            -> result: 12586269025, time: 0.03188 ms
5
fibTabArray(50)        -> result: 12586269025, time: 0.04342 ms
6
fibTab(50)             -> result: 12586269025, time: 0.01692 ms
7
fibTab(100)            -> result: 354224848179262000000, time: 0.00363 ms
8

9
# Rust
10
sh-3.2$ rustc demo.rs; ./demo
11
fib_naive(50)          -> result: 12586269025, time: 69916.58687 ms
12
fib_memo(50)           -> result: 12586269025, time: 0.04804 ms
13
fib_tab_array(50)      -> result: 12586269025, time: 0.00250 ms
14
fib_tab(50)            -> result: 12586269025, time: 0.00054 ms
15
fib_tab(100)           -> result: 354224848179262000000, time: 0.00067 ms