Two phases.
One program.

// STATIC dispatch (compile time): the compiler stamps out one
// version of `area` for every concrete shape that calls it.
// Each call is a direct jump to a known function.
trait Shape { fn area(&self) -> f64; }
struct Circle { r: f64 }
struct Square { side: f64 }
impl Shape for Circle { fn area(&self) -> f64 { 3.14159 * self.r * self.r } }
impl Shape for Square { fn area(&self) -> f64 { self.side * self.side } }

fn area_static<S: Shape>(s: &S) -> f64 { s.area() }   // resolved at build

// DYNAMIC dispatch (runtime): one copy of `area_dyn`. At runtime,
// each call follows a vtable pointer to figure out which method to run.
fn area_dyn(s: &dyn Shape) -> f64 { s.area() }        // resolved at run

fn main() {
    let c = Circle { r: 1.0 };
    let s = Square { side: 1.0 };

    // The compiler emits two area_static specialisations.
    // Each call below is as fast as a direct function call.
    println!("{}", area_static(&c));
    println!("{}", area_static(&s));

    // One area_dyn function, two indirect calls. A few cycles slower
    // per call, but only one binary copy of the code.
    let shapes: Vec<&dyn Shape> = vec![&c, &s];
    for s in &shapes {
        println!("{}", area_dyn(*s));
    }
}

// STATIC dispatch: direct function calls, resolved by the linker.
#include <stdio.h>

double circle_area(double r)    { return 3.14159 * r * r; }
double square_area(double side) { return side * side; }

// DYNAMIC dispatch: function pointers. The address of the function
// to call is decided at runtime, by reading the pointer.
typedef double (*area_fn)(void *self);

typedef struct { double r; }    Circle;
typedef struct { double side; } Square;

double circle_area_fn(void *self) { return circle_area(((Circle*)self)->r); }
double square_area_fn(void *self) { return square_area(((Square*)self)->side); }

typedef struct { void *self; area_fn area; } Shape;

int main(void) {
    Circle c = { 1.0 };
    Square s = { 1.0 };

    // Static: the linker hard-wires the call. No indirection.
    printf("%f\n", circle_area(c.r));
    printf("%f\n", square_area(s.side));

    // Dynamic: the call goes through a pointer. Cheap, but the
    // CPU's branch predictor has to guess the target every call.
    Shape shapes[] = {
        { &c, circle_area_fn },
        { &s, square_area_fn },
    };
    for (int i = 0; i < 2; i++)
        printf("%f\n", shapes[i].area(shapes[i].self));
    return 0;
}

/* Same constants in Rust -
 * const values evaluated at compile time */
const MAX_BLOCK_WEIGHT: u32     = 4_000_000;
const COIN: u64                 = 100_000_000;
const MAX_MONEY: u64            = 21_000_000 * COIN;
const COINBASE_MATURITY: u32    = 100;
const WITNESS_SCALE_FACTOR: u32 = 4;

/* Compile-time assertion: catches
 * any accidental change to the cap */
const _: () = assert!(
    MAX_MONEY == 2_100_000_000_000_000,
    "MAX_MONEY must equal exactly 21 million BTC"
);

/* These compile-time constants define
 * what it means to be a Bitcoin node.
 * Not configuration. Not parameters.
 * The protocol itself. */

/* Bitcoin consensus constants -
 * compile-time, never runtime variables */
#define MAX_BLOCK_WEIGHT     4000000UL
#define COIN                 100000000ULL /* 1 BTC in satoshis */
#define MAX_MONEY            (21000000ULL * COIN)
#define COINBASE_MATURITY    100
#define WITNESS_SCALE_FACTOR 4

/* These are evaluated at compile time.
 * No runtime branch. No configuration file.
 * If you change these you change Bitcoin.
 * You are now on a different blockchain. */

static_assert(MAX_MONEY == 2100000000000000ULL,
    "MAX_MONEY must equal 21 million BTC in satoshis");

fn validate_block(
    header: &BlockHeader,
    transactions: &[Transaction],
) -> Result<(), ValidationError> {

    // Runtime: hash this specific block
    let hash = double_sha256(header);

    // Runtime check against compile-time target
    if !hash.meets_difficulty_target(header.bits) {
        return Err(ValidationError::InsufficientWork);
    }

    // Runtime check against compile-time constant
    let weight: u32 = transactions.iter()
        .map(|tx| tx.weight())
        .sum();

    if weight > MAX_BLOCK_WEIGHT { // compile-time const
        return Err(ValidationError::BlockTooHeavy);
    }

    // Runtime: verify every signature
    for tx in transactions {
        tx.verify_signatures()?;
    }

    Ok(())
}

/* The split is clean:
 *   What IS a valid Bitcoin block: compile time.
 *   Whether THIS block IS valid:   runtime.
 *
 * Change the compile-time rules and you fork Bitcoin.
 * Every node on the old binary rejects your blocks.
 * That is what a hard fork is: changing compile-time
 * consensus rules in a way old binaries reject. */

typedef struct {
    uint32_t version;
    uint8_t  prev_hash[32];
    uint8_t  merkle_root[32];
    uint32_t timestamp;
    uint32_t bits;
    uint32_t nonce;
} BlockHeader;

/* Runtime validation: called when a
 * new block arrives over the network */
int validate_block(const BlockHeader *header,
                   const uint8_t *txdata,
                   size_t txdata_len)
{
    /* 1. Check proof of work (runtime) */
    uint8_t hash[32];
    double_sha256((uint8_t*)header,
                  sizeof *header, hash);
    if (!meets_target(hash, header->bits))
        return 0; /* rejected at runtime */

    /* 2. Check block weight (runtime) */
    uint32_t weight = compute_weight(txdata,
                                     txdata_len);
    if (weight > MAX_BLOCK_WEIGHT) /* compile-time const */
        return 0; /* runtime check vs compile constant */

    /* 3. Validate all transactions (runtime) */
    return validate_transactions(txdata, txdata_len);
}