Calculates the best time to release a daily version

best-daily-release-time.rs

#!/usr/bin/env rust-script
/*!

Shebang is using <https://github.com/fornwall/rust-script>.
Date: 2023-12-08.
Data taken from <https://observablehq.com/@mattdzugan/population-by-time-zone-creating-a-dataset>.
Ideally I'd re-compute it here (and it will probably be faster than their js lol), but I'm too lazy atm.

This is very jank way to find at what point it's the most noon / the most distance from date change.
This is nice for releasing daily versions of software, to prevent off-by-one errors with version naming like Rust's nightly has.

*/

use std::{fs, str};

fn main() {
    let zone_pops = fs::read("./zonePops@1.csv").expect("couldn't read population file :c");
    let zone_pops = str::from_utf8(&zone_pops).expect("non utf-8 population file :c");

    // Ideally we'd have a proper csv parser, which returns proper errors, etc..
    // But again: too lazy, doesn't matter.
    let zone_pops = zone_pops
        .lines()
        .skip(1)
        .map(TimeZonePopulation::parse_csv_line)
        .collect::<Vec<_>>();

    // (utc offset, the range should probably be chosen better because of tz weirdness idk)
    let in_quarter_hour_increments = (-12 * 4..12 * 4).map(|x| x as f64 * 0.25);

    let mut result = in_quarter_hour_increments
        .map(|offset| {
            // When it's 12+offset in UTC, how distant are the people from 12 in their tz
            let total_distance_from_noon = zone_pops
                .iter()
                .map(|p| {
                    // it's 12+offset UTC, so it's 12+offset+p.offset TZ, so the distance from 12 is offset+p.offset
                    let distance = (offset + p.offset as f64).abs();
                    distance * p.pop
                })
                .sum::<f64>();

            (total_distance_from_noon, offset)
        })
        .collect::<Vec<_>>();
    result.sort_by(|(distance_a, _), (distance_b, _)| distance_a.total_cmp(&distance_b));

    println!("Time UTC | Total distance");
    result.into_iter().for_each(|(total_distance, offset)| {
        println!(
            "{time_utc: <9}|{total_distance: >13.0}",
            time_utc = hours_to_time(12. + offset)
        )
    });
}

struct TimeZonePopulation {
    pop: f64,
    offset: f64,
}

impl TimeZonePopulation {
    fn parse_csv_line(l: &str) -> Self {
        // name,pop,number,centroid_lat,centroid_lon
        let mut parts = l.split(',');

        let _name = parts.next().unwrap();
        let pop = parts.next().unwrap().parse().unwrap();
        let number = parts.next().unwrap().parse().unwrap();
        let _centroid_lat: f64 = parts.next().unwrap().parse().unwrap();
        let _centroid_lon: f64 = parts.next().unwrap().parse().unwrap();

        Self {
            pop,
            offset: number,
        }
    }
}

fn hours_to_time(f: f64) -> String {
    if (f.fract() - 0.00).abs() <= f64::EPSILON {
        return format!("{:02}:00", f.floor());
    }

    if (f.fract() - 0.25).abs() <= f64::EPSILON {
        return format!("{:02}:15", f.floor());
    }

    if (f.fract() - 0.50).abs() <= f64::EPSILON {
        return format!("{:02}:30", f.floor());
    }

    if (f.fract() - 0.75).abs() <= f64::EPSILON {
        return format!("{:02}:45", f.floor());
    }

    panic!("time is sad")
}

rust-project.json

{
    "sysroot_src": "/home/waffle/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library",
    "crates": [
        {
            "root_module": "./best-daily-release-time.rs",
            "edition": "2021",
            "deps": []
        }
    ]
}

zonePops@1.csv