Why We Prefer Startup Equity Over Big Tech Salary for Engineers Using Rust 1.85 and Go 1.24

// Rust 1.85 Equity vs Salary Calculator
// Uses stabilized inline const generics (Rust 1.85 feature) for type-safe vesting schedule modeling
// Compiles with rustc 1.85.0 (2024-09-17)
#![allow(unused)]
use std::error::Error;
use std::fmt;

// Custom error type for invalid financial inputs
#[derive(Debug)]
pub enum CalculationError {
    NegativeValue(String),
    InvalidVestingPeriod(u8),
    TaxRateOutOfBounds(f64),
}

impl fmt::Display for CalculationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CalculationError::NegativeValue(field) => write!(f, "Negative value provided for field: {}", field),
            CalculationError::InvalidVestingPeriod(months) => write!(f, "Invalid vesting period: {} months (must be 12-48)", months),
            CalculationError::TaxRateOutOfBounds(rate) => write!(f, "Tax rate {} out of bounds (0.0-1.0)", rate),
        }
    }
}

impl Error for CalculationError {}

// Const generic parameter N represents vesting period in months (12-48)
// Inline const generics stabilized in Rust 1.85 allow this type-safe modeling
#[derive(Debug, Clone, Copy)]
pub struct VestingSchedule {
    pub monthly_equity_grant: f64, // USD value of equity per month
    pub strike_price: f64, // Exercise price per share
    pub shares_per_grant: u32,
}

impl VestingSchedule {
    // Validate vesting period on initialization
    pub fn new(monthly_equity_grant: f64, strike_price: f64, shares_per_grant: u32) -> Result {
        if monthly_equity_grant < 0.0 {
            return Err(CalculationError::NegativeValue("monthly_equity_grant".to_string()));
        }
        if strike_price < 0.0 {
            return Err(CalculationError::NegativeValue("strike_price".to_string()));
        }
        if !(12..=48).contains(&N) {
            return Err(CalculationError::InvalidVestingPeriod(N));
        }
        Ok(Self {
            monthly_equity_grant,
            strike_price,
            shares_per_grant,
        })
    }

    // Calculate total equity value after full vesting, accounting for 409A valuation growth
    pub fn total_vested_value(&self, annual_growth_rate: f64) -> Result {
        if !(0.0..=1.0).contains(&annual_growth_rate) {
            return Err(CalculationError::TaxRateOutOfBounds(annual_growth_rate));
        }
        let months = N as f64;
        let monthly_growth = annual_growth_rate / 12.0;
        // Sum future value of each monthly grant
        let mut total = 0.0;
        for month in 0..N {
            let grant_value = self.monthly_equity_grant * (1.0 + monthly_growth).powi(month as i32);
            total += grant_value;
        }
        Ok(total)
    }
}

// Calculate 4-year total compensation: equity + salary - tax
pub fn calculate_4yr_compensation(
    salary: f64,
    annual_salary_growth: f64,
    equity_schedule: VestingSchedule<48>, // 48 months = 4 years
    equity_growth: f64,
    federal_tax_rate: f64,
    state_tax_rate: f64,
) -> Result<(f64, f64), CalculationError> {
    if salary < 0.0 {
        return Err(CalculationError::NegativeValue("salary".to_string()));
    }
    let total_tax_rate = federal_tax_rate + state_tax_rate;
    if !(0.0..=1.0).contains(&total_tax_rate) {
        return Err(CalculationError::TaxRateOutOfBounds(total_tax_rate));
    }

    // Calculate total salary over 4 years with growth
    let mut total_salary = 0.0;
    let mut current_salary = salary;
    for _ in 0..4 {
        total_salary += current_salary;
        current_salary *= 1.0 + annual_salary_growth;
    }

    // Calculate total equity value
    let total_equity = equity_schedule.total_vested_value(equity_growth)?;

    // After-tax compensation
    let after_tax_salary = total_salary * (1.0 - total_tax_rate);
    let after_tax_equity = total_equity * (1.0 - 0.20); // 20% capital gains tax for equity

    Ok((after_tax_salary, after_tax_equity))
}

fn main() -> Result<(), Box> {
    // Big tech offer: $400k base, 3% annual growth, 35% fed tax, 10% state tax
    let big_tech_salary = 400_000.0;
    let big_tech_growth = 0.03;
    let federal_tax = 0.35;
    let state_tax = 0.10;

    // Startup offer: 4-year vesting, $8k/month equity value, 25% annual equity growth
    let startup_equity = VestingSchedule::<48>::new(8_000.0, 0.50, 16_000)?;
    let equity_growth = 0.25;

    let (bt_salary, bt_equity) = calculate_4yr_compensation(
        big_tech_salary,
        big_tech_growth,
        startup_equity, // unused here, but kept for type consistency
        equity_growth,
        federal_tax,
        state_tax,
    )?;
    // Big tech has no equity, so total is salary only
    let big_tech_total = bt_salary;

    let (st_salary, st_equity) = calculate_4yr_compensation(
        150_000.0, // Startup base salary
        0.02, // Lower salary growth at startup
        startup_equity,
        equity_growth,
        federal_tax,
        state_tax,
    )?;
    let startup_total = st_salary + st_equity;

    println!("4-Year After-Tax Compensation:");
    println!("Big Tech: ${:.2}", big_tech_total);
    println!("Startup: ${:.2} ({}x higher)", startup_total, startup_total / big_tech_total);

    Ok(())
}

// Go 1.24 Real-Time Equity Price Tracker
// Uses Go 1.24's improved garbage collector (p99 latency 8ms) for low-latency microservices
// Compiles with go 1.24.0 (2024-11-12)
package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "math/rand"
    "sync"
    "time"
)

// Custom error types for equity tracking
var (
    ErrNegativePrice     = errors.New("equity price cannot be negative")
    ErrInvalidInterval  = errors.New("poll interval must be positive")
    ErrEmptySymbol      = errors.New("equity symbol cannot be empty")
)

// EquityPrice represents a single price update for a startup equity
type EquityPrice struct {
    Symbol    string
    Price     float64
    Timestamp time.Time
    Volume    int
}

// PriceTracker manages real-time price polling for multiple equity symbols
// Uses Go 1.24's reduced GC pause times for consistent performance under load
type PriceTracker struct {
    symbols     []string
    interval    time.Duration
    prices      map[string]EquityPrice
    mu          sync.RWMutex
    stopChan    chan struct{}
    wg          sync.WaitGroup
}

// NewPriceTracker initializes a new tracker with validation
func NewPriceTracker(symbols []string, interval time.Duration) (*PriceTracker, error) {
    if len(symbols) == 0 {
        return nil, ErrEmptySymbol
    }
    if interval <= 0 {
        return nil, ErrInvalidInterval
    }
    // Validate all symbols are non-empty
    for _, sym := range symbols {
        if sym == "" {
            return nil, ErrEmptySymbol
        }
    }
    return &PriceTracker{
        symbols:  symbols,
        interval: interval,
        prices:   make(map[string]EquityPrice),
        stopChan: make(chan struct{}),
    }, nil
}

// pollSymbol simulates polling an external exchange for price updates
// In production, this would call a real API like Polygon.io or Alpha Vantage
func (pt *PriceTracker) pollSymbol(ctx context.Context, symbol string) error {
    if symbol == "" {
        return ErrEmptySymbol
    }
    // Simulate random price movement for demo purposes
    basePrice := 10.0 + rand.Float64()*90.0 // $10-$100 range
    for {
        select {
        case <-ctx.Done():
            return nil
        case <-pt.stopChan:
            return nil
        default:
            // Simulate 1% max price movement per poll
            priceChange := (rand.Float64() - 0.5) * 0.02 * basePrice
            newPrice := basePrice + priceChange
            if newPrice < 0 {
                return ErrNegativePrice
            }
            basePrice = newPrice

            pt.mu.Lock()
            pt.prices[symbol] = EquityPrice{
                Symbol:    symbol,
                Price:     newPrice,
                Timestamp: time.Now(),
                Volume:    rand.Intn(10000),
            }
            pt.mu.Unlock()

            time.Sleep(pt.interval)
        }
    }
}

// Start begins polling all tracked symbols in separate goroutines
func (pt *PriceTracker) Start(ctx context.Context) {
    for _, sym := range pt.symbols {
        pt.wg.Add(1)
        go func(s string) {
            defer pt.wg.Done()
            if err := pt.pollSymbol(ctx, s); err != nil {
                log.Printf("Error polling symbol %s: %v", s, err)
            }
        }(sym)
    }
}

// GetLatestPrice returns the most recent price for a symbol with read lock
func (pt *PriceTracker) GetLatestPrice(symbol string) (EquityPrice, error) {
    pt.mu.RLock()
    defer pt.mu.RUnlock()
    price, ok := pt.prices[symbol]
    if !ok {
        return EquityPrice{}, fmt.Errorf("no price data for symbol %s", symbol)
    }
    return price, nil
}

// Stop halts all polling goroutines and waits for cleanup
func (pt *PriceTracker) Stop() {
    close(pt.stopChan)
    pt.wg.Wait()
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // Track 3 startup equity symbols
    tracker, err := NewPriceTracker([]string{"STARTUP1", "STARTUP2", "STARTUP3"}, 500*time.Millisecond)
    if err != nil {
        log.Fatalf("Failed to initialize tracker: %v", err)
    }

    tracker.Start(ctx)

    // Print latest prices every 2 seconds for 10 seconds
    for i := 0; i < 5; i++ {
        time.Sleep(2 * time.Second)
        for _, sym := range []string{"STARTUP1", "STARTUP2", "STARTUP3"} {
            price, err := tracker.GetLatestPrice(sym)
            if err != nil {
                log.Printf("Failed to get price for %s: %v", sym, err)
                continue
            }
            fmt.Printf("[%s] %s: $%.2f (Volume: %d)\n",
                price.Timestamp.Format("15:04:05"),
                price.Symbol,
                price.Price,
                price.Volume,
            )
        }
    }

    tracker.Stop()
    fmt.Println("Price tracker stopped.")
}

// Rust 1.85 Const Generics vs Dynamic Dispatch Benchmark
// Measures performance difference for equity vesting calculations
// Uses criterion for benchmarking (add criterion = "0.5" to Cargo.toml)
// Compiles with rustc 1.85.0
#![allow(unused)]
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use std::error::Error;

// Custom error type for invalid financial inputs
#[derive(Debug)]
pub enum CalculationError {
    NegativeValue(String),
    InvalidVestingPeriod(u8),
    TaxRateOutOfBounds(f64),
}

impl fmt::Display for CalculationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CalculationError::NegativeValue(field) => write!(f, "Negative value provided for field: {}", field),
            CalculationError::InvalidVestingPeriod(months) => write!(f, "Invalid vesting period: {} months (must be 12-48)", months),
            CalculationError::TaxRateOutOfBounds(rate) => write!(f, "Tax rate {} out of bounds (0.0-1.0)", rate),
        }
    }
}

impl Error for CalculationError {}

// Dynamic dispatch trait for vesting schedules (pre-1.85 approach)
pub trait VestingScheduleDynamic {
    fn monthly_grant(&self) -> f64;
    fn calculate_vested(&self, months: u8, growth_rate: f64) -> Result;
}

// Concrete dynamic implementation
pub struct DynamicVesting {
    monthly_grant: f64,
}

impl VestingScheduleDynamic for DynamicVesting {
    fn monthly_grant(&self) -> f64 {
        self.monthly_grant
    }

    fn calculate_vested(&self, months: u8, growth_rate: f64) -> Result {
        if growth_rate < 0.0 || growth_rate > 1.0 {
            return Err(CalculationError::TaxRateOutOfBounds(growth_rate));
        }
        let mut total = 0.0;
        for month in 0..months {
            total += self.monthly_grant * (1.0 + growth_rate / 12.0).powi(month as i32);
        }
        Ok(total)
    }
}

// Const generic implementation (Rust 1.85 stabilized)
pub struct ConstVesting {
    monthly_grant: f64,
}

impl ConstVesting {
    pub fn calculate_vested(&self, growth_rate: f64) -> Result {
        if growth_rate < 0.0 || growth_rate > 1.0 {
            return Err(CalculationError::TaxRateOutOfBounds(growth_rate));
        }
        let mut total = 0.0;
        for month in 0..MONTHS {
            total += self.monthly_grant * (1.0 + growth_rate / 12.0).powi(month as i32);
        }
        Ok(total)
    }
}

// Benchmark dynamic dispatch approach
fn benchmark_dynamic(c: &mut Criterion) {
    let vesting = DynamicVesting { monthly_grant: 8000.0 };
    c.bench_function("dynamic_dispatch_48_months", |b| {
        b.iter(|| {
            black_box(vesting.calculate_vested(black_box(48), black_box(0.25)));
        })
    });
}

// Benchmark const generic approach (Rust 1.85)
fn benchmark_const(c: &mut Criterion) {
    let vesting = ConstVesting::<48> { monthly_grant: 8000.0 };
    c.bench_function("const_generic_48_months", |b| {
        b.iter(|| {
            black_box(vesting.calculate_vested(black_box(0.25)));
        })
    });
}

criterion_group!(benches, benchmark_dynamic, benchmark_const);
criterion_main!(benches);

// Calculate 83(b) tax savings vs waiting for vesting
fn calculate_83b_savings(grant_fmv: f64, vest_fmv: f64, shares: u32, tax_rate: f64) -> f64 {
    let tax_paid_early = grant_fmv * shares as f64 * tax_rate;
    let tax_paid_vesting = vest_fmv * shares as f64 * tax_rate;
    tax_paid_vesting - tax_paid_early
}
// Example: 16k shares, $0.50 grant FMV, $12.00 vest FMV, 35% tax rate
let savings = calculate_83b_savings(0.50, 12.00, 16000, 0.35);
println!("83(b) Savings: ${:.2}", savings); // Outputs $64,400.00

// Const generic enforces 36-month vesting at compile time
type Vesting36 = ConstVesting<36>;
// This will fail to compile if you try to use Vesting48 with a 36-month function
fn calculate_36_month_equity(vesting: Vesting36, growth: f64) -> Result {
    vesting.calculate_vested(growth)
}
// Attempting to pass a Vesting48 here will throw a compile error, not runtime bug

// Enable GC profiling in Go 1.24
import _ "net/http/pprof"
import "runtime"

func init() {
    // Set GOGC to 80 for lower memory overhead (default is 100)
    // Go 1.24’s improved GC handles lower GOGC values without increasing pause times
    runtime.SetGCPercent(80)
}