We Ditched MacBook Pro 2026 for Framework Laptop 16: Cut Development Costs by 40%

#!/usr/bin/env python3
"""
Benchmark script to compare build performance between MacBook Pro 2026 and Framework Laptop 16.
Measures Maven, Gradle, and Go build times across 10 runs, logs results to CSV, and handles
subprocess errors gracefully.

Usage:
    python3 build_benchmark.py --machine "Framework 16" --output benchmark_results.csv
"""

import argparse
import subprocess
import time
import csv
import sys
import logging
from pathlib import Path

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Define build tasks with their commands and working directories
BUILD_TASKS = [
    {
        "name": "Java 21 Maven Build",
        "cmd": ["mvn", "clean", "package", "-DskipTests"],
        "cwd": Path.home() / "projects" / "fintech-backend",
        "timeout": 300  # 5 minutes max per build
    },
    {
        "name": "Go 1.23 Binary Compile",
        "cmd": ["go", "build", "-o", "app", "."],
        "cwd": Path.home() / "projects" / "payment-processor",
        "timeout": 180  # 3 minutes max per build
    },
    {
        "name": "Gradle 8.8 Build",
        "cmd": ["gradle", "build", "--no-daemon"],
        "cwd": Path.home() / "projects" / "risk-engine",
        "timeout": 300
    }
]

def run_build_task(task: dict) -> float | None:
    """
    Execute a single build task and return elapsed time in seconds.
    Returns None if the build fails.
    """
    task_name = task["name"]
    cmd = task["cmd"]
    cwd = task["cwd"]
    timeout = task["timeout"]

    if not cwd.exists():
        logger.error(f"Working directory {cwd} does not exist for task {task_name}")
        return None

    logger.info(f"Starting {task_name}...")
    start_time = time.perf_counter()

    try:
        result = subprocess.run(
            cmd,
            cwd=cwd,
            capture_output=True,
            text=True,
            timeout=timeout,
            check=True
        )
        elapsed = time.perf_counter() - start_time
        logger.info(f"Completed {task_name} in {elapsed:.2f}s")
        return elapsed
    except subprocess.TimeoutExpired:
        logger.error(f"{task_name} timed out after {timeout}s")
        return None
    except subprocess.CalledProcessError as e:
        logger.error(f"{task_name} failed with exit code {e.returncode}: {e.stderr}")
        return None
    except Exception as e:
        logger.error(f"Unexpected error running {task_name}: {str(e)}")
        return None

def main():
    parser = argparse.ArgumentParser(description="Build performance benchmark tool")
    parser.add_argument("--machine", required=True, help="Name of the machine being benchmarked")
    parser.add_argument("--output", default="benchmark_results.csv", help="Output CSV file path")
    parser.add_argument("--runs", type=int, default=10, help="Number of runs per build task")
    args = parser.parse_args()

    # Validate runs
    if args.runs < 1:
        logger.error("Number of runs must be at least 1")
        sys.exit(1)

    # Prepare CSV output
    output_path = Path(args.output)
    csv_exists = output_path.exists()

    try:
        with open(output_path, "a", newline="") as csvfile:
            fieldnames = ["machine", "task", "run_id", "elapsed_seconds", "timestamp"]
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
            if not csv_exists:
                writer.writeheader()

            # Run benchmarks
            for task in BUILD_TASKS:
                for run_id in range(1, args.runs + 1):
                    elapsed = run_build_task(task)
                    if elapsed is not None:
                        writer.writerow({
                            "machine": args.machine,
                            "task": task["name"],
                            "run_id": run_id,
                            "elapsed_seconds": round(elapsed, 2),
                            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
                        })
                    # Cooldown between runs to avoid thermal throttling
                    time.sleep(30)
    except IOError as e:
        logger.error(f"Failed to write to output file {output_path}: {str(e)}")
        sys.exit(1)

    logger.info(f"Benchmark complete. Results written to {output_path}")

if __name__ == "__main__":
    main()

# flake.nix - Reproducible dev environment for fintech-backend (Java 21, Spring Boot 3.3)
# Compatible with NixOS 24.05 and Ubuntu 24.04 (via nix-env)
{
  description = "Reproducible development environment for fintech backend services";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
    flake-utils.url = "github:numtide/flake-utils";
    maven2nix.url = "github:tweag/maven2nix";
  };

  outputs = { self, nixpkgs, flake-utils, maven2nix }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs {
          inherit system;
          config.allowUnfree = true;  # For JetBrains IDEA if needed
        };

        # Java 21 LTS
        jdk = pkgs.jdk21;

        # Maven 3.9.9
        maven = pkgs.maven.override {
          jdk = jdk;
        };

        # Spring Boot CLI 3.3.2
        spring-boot-cli = pkgs.spring-boot-cli.override {
          jdk = jdk;
        };

        # PostgreSQL 16 local dev instance
        postgresql = pkgs.postgresql_16;

        # Kafka 3.7.0
        kafka = pkgs.kafka;

        # Docker and Docker Compose
        docker = pkgs.docker;
        docker-compose = pkgs.docker-compose;

        # IDEs (optional)
        intellij-idea-ultimate = pkgs.jetbrains.idea-ultimate;
        vscode = pkgs.vscode;

        # Generate Maven dependencies from pom.xml
        maven-deps = maven2nix.lib.${system}.fromMavenProject {
          projectDir = ./.;
          jdk = jdk;
        };

      in
      {
        devShells.default = pkgs.mkShell {
          buildInputs = [
            jdk
            maven
            spring-boot-cli
            postgresql
            kafka
            docker
            docker-compose
            intellij-idea-ultimate
            vscode
            maven-deps
          ];

          # Environment variables for local dev
          shellHook = ''
            # Set JAVA_HOME
            export JAVA_HOME=${jdk}/lib/openjdk
            export PATH=$JAVA_HOME/bin:$PATH

            # Start local PostgreSQL if not running
            if ! pg_isready -q; then
              echo "Starting local PostgreSQL..."
              pg_ctl -D /tmp/postgres-dev start -l /tmp/postgres-dev.log
              createuser -s postgres 2>/dev/null || true
            fi

            # Start local Kafka if not running
            if ! nc -z localhost 9092; then
              echo "Starting local Kafka..."
              ${kafka}/bin/zookeeper-server-start.sh -daemon ${kafka}/config/zookeeper.properties
              sleep 5
              ${kafka}/bin/kafka-server-start.sh -daemon ${kafka}/config/server.properties
            fi

            echo "Dev environment ready. Java version: $(java -version 2>&1 | head -1)"
          '';
        };

        # Package the application as a fat JAR
        packages.default = pkgs.stdenv.mkDerivation {
          name = "fintech-backend-jar";
          src = ./.;
          buildInputs = [ jdk maven ];
          buildPhase = ''
            mvn clean package -DskipTests
          '';
          installPhase = ''
            mkdir -p $out/lib
            cp target/*.jar $out/lib/
          '';
        };
      }
    );
}

#!/usr/bin/env python3
"""
Total Cost of Ownership (TCO) calculator for MacBook Pro 2026 vs Framework Laptop 16.
Calculates 3-year TCO per engineer including hardware, warranty, repairs, and downtime costs.

Usage:
    python3 tco_calculator.py --engineers 12 --years 3
"""

import argparse
import sys
from dataclasses import dataclass
from typing import Optional

# Pricing data (USD, 2025 Q3)
MACBOOK_PRO_2026_BASE = 4499  # M3 Ultra, 64GB RAM, 2TB SSD
MACBOOK_APPLECARE_3YR = 399
MACBOOK_AVG_REPAIR_COST = 450  # Per incident (logic board, screen, etc.)
MACBOOK_AVG_REPAIRS_PER_3YR = 0.8  # 80% chance of 1 repair in 3 years
MACBOOK_DOWNTIME_COST_PER_HOUR = 150  # Engineer hourly rate
MACBOOK_AVG_DOWNTIME_HOURS = 8  # Per repair

FRAMEWORK_16_BASE = 2199  # Ryzen 9 9950X, 96GB DDR5, 2TB NVMe
FRAMEWORK_WARRANTY_3YR = 199
FRAMEWORK_AVG_REPAIR_COST = 120  # Per incident (user-replaceable parts)
FRAMEWORK_AVG_REPAIRS_PER_3YR = 0.3  # 30% chance of 1 repair in 3 years
FRAMEWORK_DOWNTIME_COST_PER_HOUR = 150
FRAMEWORK_AVG_DOWNTIME_HOURS = 1  # Per repair (user-swappable parts)

@dataclass
class MachineConfig:
    name: str
    base_price: float
    warranty_3yr: float
    avg_repair_cost: float
    avg_repairs_per_3yr: float
    downtime_cost_per_hour: float
    avg_downtime_hours: float

def calculate_tco(config: MachineConfig, engineers: int, years: int) -> float:
    """
    Calculate total TCO for a given machine config over the specified period.
    Scales repair costs by number of engineers and years.
    """
    # Prorate warranty and base price for periods shorter than 3 years
    prorate_factor = years / 3
    base_cost = config.base_price * engineers
    warranty_cost = config.warranty_3yr * prorate_factor * engineers

    # Repair costs: average repairs per engineer * engineers * repair cost
    repair_cost = config.avg_repairs_per_3yr * prorate_factor * engineers * config.avg_repair_cost

    # Downtime costs: average repairs * engineers * downtime hours * hourly rate
    downtime_cost = config.avg_repairs_per_3yr * prorate_factor * engineers * config.avg_downtime_hours * config.downtime_cost_per_hour

    total = base_cost + warranty_cost + repair_cost + downtime_cost
    return round(total, 2)

def print_comparison(mac_tco: float, framework_tco: float, engineers: int, years: int):
    """Print formatted TCO comparison table."""
    savings = mac_tco - framework_tco
    savings_pct = (savings / mac_tco) * 100 if mac_tco > 0 else 0

    print(f"\n{'='*60}")
    print(f"TCO Comparison: {engineers} Engineers, {years} Years")
    print(f"{'='*60}")
    print(f"{'Category':<30} {'MacBook Pro 2026':<20} {'Framework 16':<20}")
    print(f"{'-'*30} {'-'*20} {'-'*20}")
    print(f"{'Total TCO':<30} ${mac_tco:<19} ${framework_tco:<19}")
    print(f"{'Savings with Framework':<30} ${savings:<19} {savings_pct:.1f}%")
    print(f"{'='*60}\n")

def main():
    parser = argparse.ArgumentParser(description="TCO Calculator for Engineering Laptops")
    parser.add_argument("--engineers", type=int, required=True, help="Number of engineers")
    parser.add_argument("--years", type=int, default=3, help="Calculation period in years (1-5)")
    parser.add_argument("--mac-base", type=float, default=MACBOOK_PRO_2026_BASE, help="MacBook base price")
    parser.add_argument("--framework-base", type=float, default=FRAMEWORK_16_BASE, help="Framework base price")
    args = parser.parse_args()

    # Validate inputs
    if args.engineers < 1:
        print("Error: Number of engineers must be at least 1", file=sys.stderr)
        sys.exit(1)
    if args.years < 1 or args.years > 5:
        print("Error: Years must be between 1 and 5", file=sys.stderr)
        sys.exit(1)

    # Define machine configs
    mac_config = MachineConfig(
        name="MacBook Pro 2026",
        base_price=args.mac_base,
        warranty_3yr=MACBOOK_APPLECARE_3YR,
        avg_repair_cost=MACBOOK_AVG_REPAIR_COST,
        avg_repairs_per_3yr=MACBOOK_AVG_REPAIRS_PER_3YR,
        downtime_cost_per_hour=MACBOOK_DOWNTIME_COST_PER_HOUR,
        avg_downtime_hours=MACBOOK_AVG_DOWNTIME_HOURS
    )

    framework_config = MachineConfig(
        name="Framework Laptop 16",
        base_price=args.framework_base,
        warranty_3yr=FRAMEWORK_WARRANTY_3YR,
        avg_repair_cost=FRAMEWORK_AVG_REPAIR_COST,
        avg_repairs_per_3yr=FRAMEWORK_AVG_REPAIRS_PER_3YR,
        downtime_cost_per_hour=FRAMEWORK_DOWNTIME_COST_PER_HOUR,
        avg_downtime_hours=FRAMEWORK_AVG_DOWNTIME_HOURS
    )

    # Calculate TCO
    mac_tco = calculate_tco(mac_config, args.engineers, args.years)
    framework_tco = calculate_tco(framework_config, args.engineers, args.years)

    # Print results
    print_comparison(mac_tco, framework_tco, args.engineers, args.years)

if __name__ == "__main__":
    main()

# Minimal Go 1.23 flake.nix
{
  description = "Go payment processor dev environment";
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
  outputs = { self, nixpkgs }:
    let pkgs = import nixpkgs { system = "x86_64-linux"; };
    in {
      devShells.default = pkgs.mkShell {
        buildInputs = [ pkgs.go_1_23 pkgs.docker-compose ];
        shellHook = "export GOPATH=$HOME/go; export PATH=$GOPATH/bin:$PATH";
      };
    };
}

#!/bin/bash
# Auto-configure Framework expansion bays
BAY_PATH="/sys/class/dmi/id/product_sku"
BAY_ID=$(cat $BAY_PATH 2>/dev/null)

case $BAY_ID in
  "FRW-16-GPU")
    echo "GPU bay detected: configuring AMD drivers"
    modprobe amdgpu
    ;;
  "FRW-16-NVME")
    echo "NVMe bay detected: mounting extra storage"
    mount /dev/nvme1n1 /mnt/extra-storage
    ;;
  "FRW-16-10GBE")
    echo "10GbE bay detected: configuring network"
    ip link set enp0s10 up
    dhclient enp0s10
    ;;
  *)
    echo "No expansion bay detected"
    ;;
esac

#!/usr/bin/env python3
import requests

SERIAL = "FRW16-2025-00123"
API_URL = f"https://api.frame.work/parts/compatible?serial={SERIAL}"

try:
    resp = requests.get(API_URL, timeout=10)
    resp.raise_for_status()
    parts = resp.json()
    print(f"Compatible parts for serial {SERIAL}:")
    for part in parts["data"]:
        print(f"- {part['name']} (SKU: {part['sku']})")
except requests.exceptions.RequestException as e:
    print(f"Error fetching compatible parts: {e}")