Best Coworking Spaces Developer vs North America: Which Wins?

import subprocess
import time
import logging
import json
from dataclasses import dataclass
from typing import List, Optional
import argparse

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

@dataclass
class LatencyResult:
    """Holds latency benchmark results for a single endpoint"""
    endpoint: str
    avg_latency_ms: float
    p99_latency_ms: float
    packet_loss_pct: float
    dns_resolution_ms: float
    errors: List[str]

def resolve_dns(hostname: str, timeout: int = 5) -> float:
    """Resolve DNS for a hostname, return time in ms, raise on failure"""
    start = time.perf_counter()
    try:
        import socket
        socket.gethostbyname(hostname)
        return (time.perf_counter() - start) * 1000
    except socket.error as e:
        raise ConnectionError(f"DNS resolution failed for {hostname}: {e}")

def run_latency_test(endpoint: str, iterations: int = 100) -> LatencyResult:
    """Run ICMP ping test to endpoint, calculate latency metrics"""
    errors = []
    latencies = []
    packet_loss = 0

    for i in range(iterations):
        try:
            # Use system ping, timeout after 2s per ping
            result = subprocess.run(
                ["ping", "-c", "1", "-W", "2", endpoint],
                capture_output=True,
                text=True,
                timeout=3
            )
            if result.returncode != 0:
                errors.append(f"Ping failed to {endpoint}: {result.stderr}")
                packet_loss += 1
                continue

            # Parse ping output for latency (works on Linux/macOS)
            for line in result.stdout.splitlines():
                if "time=" in line:
                    latency_str = line.split("time=")[1].split(" ms")[0]
                    latencies.append(float(latency_str))
                    break
        except subprocess.TimeoutExpired:
            errors.append(f"Ping timeout to {endpoint} on iteration {i}")
            packet_loss += 1
        except Exception as e:
            errors.append(f"Unexpected error pinging {endpoint}: {e}")
            packet_loss += 1

    if not latencies:
        return LatencyResult(
            endpoint=endpoint,
            avg_latency_ms=0.0,
            p99_latency_ms=0.0,
            packet_loss_pct=100.0,
            dns_resolution_ms=0.0,
            errors=errors
        )

    # Calculate metrics
    avg_latency = sum(latencies) / len(latencies)
    sorted_latencies = sorted(latencies)
    p99_index = int(len(sorted_latencies) * 0.99)
    p99_latency = sorted_latencies[min(p99_index, len(sorted_latencies)-1)]
    packet_loss_pct = (packet_loss / iterations) * 100

    # Get DNS resolution time
    dns_time = 0.0
    try:
        dns_time = resolve_dns(endpoint)
    except Exception as e:
        errors.append(f"DNS resolution error: {e}")

    return LatencyResult(
        endpoint=endpoint,
        avg_latency_ms=avg_latency,
        p99_latency_ms=p99_latency,
        packet_loss_pct=packet_loss_pct,
        dns_resolution_ms=dns_time,
        errors=errors
    )

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Benchmark coworking space network latency")
    parser.add_argument("--endpoints", nargs="+", default=["8.8.8.8", "github.com", "aws.amazon.com"],
                        help="Endpoints to test")
    parser.add_argument("--iterations", type=int, default=100, help="Ping iterations per endpoint")
    args = parser.parse_args()

    logger.info(f"Starting latency benchmark for {len(args.endpoints)} endpoints, {args.iterations} iterations each")

    results = []
    for endpoint in args.endpoints:
        logger.info(f"Testing endpoint: {endpoint}")
        try:
            result = run_latency_test(endpoint, args.iterations)
            results.append(result)
            logger.info(f"Completed {endpoint}: avg={result.avg_latency_ms:.2f}ms, p99={result.p99_latency_ms:.2f}ms, loss={result.packet_loss_pct:.2f}%")
        except Exception as e:
            logger.error(f"Failed to test {endpoint}: {e}")

    # Output results as JSON
    output = [
        {
            "endpoint": r.endpoint,
            "avg_latency_ms": r.avg_latency_ms,
            "p99_latency_ms": r.p99_latency_ms,
            "packet_loss_pct": r.packet_loss_pct,
            "dns_resolution_ms": r.dns_resolution_ms,
            "error_count": len(r.errors)
        } for r in results
    ]
    print(json.dumps(output, indent=2))

const fs = require('fs');
const path = require('path');

/**
 * Calculate Total Cost of Ownership (TCO) for coworking space options
 * @param {Object} config - TCO configuration parameters
 * @returns {Object} TCO breakdown for dev and general coworking
 */
function calculateCoworkingTCO(config) {
    const {
        teamSize,
        devSeatCostMonthly,
        generalSeatCostMonthly,
        avgDevHourlyRate,
        devHoursLostMonthlyGeneral,
        devHoursLostMonthlyDev,
        contractMonths,
        amenitiesCostGeneral = 0,
        amenitiesCostDev = 0
    } = config;

    // Validate inputs
    if (teamSize <= 0) throw new Error('Team size must be positive integer');
    if (devSeatCostMonthly < 0) throw new Error('Dev seat cost cannot be negative');
    if (generalSeatCostMonthly < 0) throw new Error('General seat cost cannot be negative');
    if (avgDevHourlyRate <= 0) throw new Error('Dev hourly rate must be positive');
    if (devHoursLostMonthlyGeneral < 0) throw new Error('General hours lost cannot be negative');
    if (devHoursLostMonthlyDev < 0) throw new Error('Dev hours lost cannot be negative');
    if (contractMonths <= 0) throw new Error('Contract months must be positive');

    // Calculate direct costs (seat + amenities) over contract term
    const devDirectCost = (devSeatCostMonthly + amenitiesCostDev) * teamSize * contractMonths;
    const generalDirectCost = (generalSeatCostMonthly + amenitiesCostGeneral) * teamSize * contractMonths;

    // Calculate productivity loss costs (billable hours lost * hourly rate)
    const devProductivityLoss = devHoursLostMonthlyDev * avgDevHourlyRate * teamSize * contractMonths;
    const generalProductivityLoss = devHoursLostMonthlyGeneral * avgDevHourlyRate * teamSize * contractMonths;

    // Total TCO = direct + productivity loss
    const devTotalTCO = devDirectCost + devProductivityLoss;
    const generalTotalTCO = generalDirectCost + generalProductivityLoss;

    // Calculate savings of dev coworking over general
    const monthlySavings = (generalTotalTCO - devTotalTCO) / contractMonths;
    const totalSavings = generalTotalTCO - devTotalTCO;
    const savingsPct = (totalSavings / generalTotalTCO) * 100;

    return {
        teamSize,
        contractMonths,
        dev: {
            seatCostMonthly: devSeatCostMonthly,
            amenitiesCostMonthly: amenitiesCostDev,
            hoursLostMonthly: devHoursLostMonthlyDev,
            directCost: devDirectCost,
            productivityLoss: devProductivityLoss,
            totalTCO: devTotalTCO,
            perSeatTCO: devTotalTCO / teamSize
        },
        general: {
            seatCostMonthly: generalSeatCostMonthly,
            amenitiesCostMonthly: amenitiesCostGeneral,
            hoursLostMonthly: devHoursLostMonthlyGeneral,
            directCost: generalDirectCost,
            productivityLoss: generalProductivityLoss,
            totalTCO: generalTotalTCO,
            perSeatTCO: generalTotalTCO / teamSize
        },
        savings: {
            monthly: monthlySavings,
            total: totalSavings,
            percentage: savingsPct
        }
    };
}

/**
 * Load benchmark data from JSON file
 * @param {string} filePath - Path to benchmark JSON
 * @returns {Object} Benchmark data
 */
function loadBenchmarkData(filePath) {
    try {
        const absolutePath = path.resolve(filePath);
        const rawData = fs.readFileSync(absolutePath, 'utf8');
        return JSON.parse(rawData);
    } catch (error) {
        throw new Error(`Failed to load benchmark data from ${filePath}: ${error.message}`);
    }
}

/**
 * Generate markdown report from TCO results
 * @param {Object} tcoResults - Results from calculateCoworkingTCO
 * @returns {string} Markdown formatted report
 */
function generateTCOReport(tcoResults) {
    return `
# Coworking TCO Report
**Team Size**: ${tcoResults.teamSize} developers
**Contract Term**: ${tcoResults.contractMonths} months

## Developer-Focused Coworking
- Monthly Seat Cost: $${tcoResults.dev.seatCostMonthly}
- Monthly Amenities Cost: $${tcoResults.dev.amenitiesCostMonthly}
- Billable Hours Lost/Month/Seat: ${tcoResults.dev.hoursLostMonthly}
- Total Direct Cost: $${tcoResults.dev.directCost.toLocaleString()}
- Total Productivity Loss: $${tcoResults.dev.productivityLoss.toLocaleString()}
- **Total TCO**: $${tcoResults.dev.totalTCO.toLocaleString()}
- **Per Seat TCO**: $${tcoResults.dev.perSeatTCO.toLocaleString()}

## General North America Coworking
- Monthly Seat Cost: $${tcoResults.general.seatCostMonthly}
- Monthly Amenities Cost: $${tcoResults.general.amenitiesCostMonthly}
- Billable Hours Lost/Month/Seat: ${tcoResults.general.hoursLostMonthly}
- Total Direct Cost: $${tcoResults.general.directCost.toLocaleString()}
- Total Productivity Loss: $${tcoResults.general.productivityLoss.toLocaleString()}
- **Total TCO**: $${tcoResults.general.totalTCO.toLocaleString()}
- **Per Seat TCO**: $${tcoResults.general.perSeatTCO.toLocaleString()}

## Savings with Developer Coworking
- Monthly Savings: $${tcoResults.savings.monthly.toLocaleString()}
- Total Contract Savings: $${tcoResults.savings.total.toLocaleString()}
- Savings Percentage: ${tcoResults.savings.percentage.toFixed(2)}%
`;
}

// Example usage with 2024 benchmark data
if (require.main === module) {
    try {
        const benchmarkData = loadBenchmarkData('./coworking-benchmarks-2024.json');
        const config = {
            teamSize: 8,
            devSeatCostMonthly: 850,
            generalSeatCostMonthly: 420,
            avgDevHourlyRate: 125,
            devHoursLostMonthlyGeneral: 12,
            devHoursLostMonthlyDev: 2,
            contractMonths: 12,
            amenitiesCostGeneral: 50, // VPN, basic print
            amenitiesCostDev: 150 // GPU access, private rack, 100Gbps
        };

        const tcoResults = calculateCoworkingTCO(config);
        const report = generateTCOReport(tcoResults);

        console.log(report);

        // Write report to file
        fs.writeFileSync('./tco-report-2024.md', report, 'utf8');
        console.log('Report written to tco-report-2024.md');
    } catch (error) {
        console.error(`Fatal error: ${error.message}`);
        process.exit(1);
    }
}

module.exports = { calculateCoworkingTCO, loadBenchmarkData, generateTCOReport };

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "time"
)

// CoworkingProvider represents a coworking space provider's API response
type CoworkingProvider struct {
    ID          string   `json:"id"`
    Name        string   `json:"name"`
    Type        string   `json:"type"` // "dev-focused" or "general"
    Locations   []Location `json:"locations"`
}

// Location represents a single coworking space location
type Location struct {
    ID          string   `json:"id"`
    Address     string   `json:"address"`
    Region      string   `json:"region"`
    Amenities   []Amenity `json:"amenities"`
    SeatCostUSD int      `json:"seat_cost_usd_monthly"`
}

// Amenity represents a single amenity offered at a location
type Amenity struct {
    Name        string `json:"name"`
    Category    string `json:"category"` // "network", "hardware", "workspace"
    IsDevSpecific bool `json:"is_dev_specific"`
}

// BenchmarkConfig holds configuration for amenity checks
type BenchmarkConfig struct {
    Providers   []string `json:"providers"` // List of provider API URLs
    DevAmenities []string `json:"dev_amenities"` // Amenities to check for (e.g., "GPU Cluster")
    TimeoutSec  int      `json:"timeout_sec"`
}

// CheckResult holds the result of checking a single location
type CheckResult struct {
    LocationID string
    ProviderName string
    Type        string
    SeatCostUSD int
    HasAllDevAmenities bool
    MissingAmenities []string
    Error       string
}

func loadConfig(configPath string) (BenchmarkConfig, error) {
    var config BenchmarkConfig
    file, err := os.Open(configPath)
    if err != nil {
        return config, fmt.Errorf("failed to open config: %w", err)
    }
    defer file.Close()

    decoder := json.NewDecoder(file)
    if err := decoder.Decode(&config); err != nil {
        return config, fmt.Errorf("failed to decode config: %w", err)
    }

    // Validate config
    if len(config.Providers) == 0 {
        return config, fmt.Errorf("no providers specified in config")
    }
    if len(config.DevAmenities) == 0 {
        return config, fmt.Errorf("no dev amenities specified in config")
    }
    if config.TimeoutSec <= 0 {
        config.TimeoutSec = 10 // Default timeout
    }

    return config, nil
}

func fetchProviderData(apiURL string, timeout time.Duration) (CoworkingProvider, error) {
    var provider CoworkingProvider
    client := &http.Client{Timeout: timeout}
    resp, err := client.Get(apiURL)
    if err != nil {
        return provider, fmt.Errorf("failed to fetch provider data: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return provider, fmt.Errorf("provider API returned status %d", resp.StatusCode)
    }

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return provider, fmt.Errorf("failed to read response body: %w", err)
    }

    if err := json.Unmarshal(body, &provider); err != nil {
        return provider, fmt.Errorf("failed to unmarshal provider data: %w", err)
    }

    return provider, nil
}

func checkLocationAmenities(loc Location, requiredAmenities []string) (bool, []string) {
    amenityMap := make(map[string]bool)
    for _, a := range loc.Amenities {
        amenityMap[a.Name] = true
    }

    missing := []string{}
    for _, req := range requiredAmenities {
        if !amenityMap[req] {
            missing = append(missing, req)
        }
    }

    return len(missing) == 0, missing
}

func runAmenityCheck(config BenchmarkConfig) []CheckResult {
    results := []CheckResult{}
    timeout := time.Duration(config.TimeoutSec) * time.Second

    for _, providerURL := range config.Providers {
        log.Printf("Fetching provider data from %s", providerURL)
        provider, err := fetchProviderData(providerURL, timeout)
        if err != nil {
            log.Printf("Error fetching provider %s: %v", providerURL, err)
            continue
        }

        for _, loc := range provider.Locations {
            // Only check North America locations
            if loc.Region != "North America" {
                continue
            }

            hasAll, missing := checkLocationAmenities(loc, config.DevAmenities)
            results = append(results, CheckResult{
                LocationID: loc.ID,
                ProviderName: provider.Name,
                Type: provider.Type,
                SeatCostUSD: loc.SeatCostUSD,
                HasAllDevAmenities: hasAll,
                MissingAmenities: missing,
            })
        }
    }

    return results
}

func generateReport(results []CheckResult) string {
    report := "Coworking Dev Amenity Check Report (North America Only)\n"
    report += "=====================================================\n\n"

    devCount := 0
    generalCount := 0
    devWithAmenities := 0
    generalWithAmenities := 0

    for _, res := range results {
        if res.Type == "dev-focused" {
            devCount++
            if res.HasAllDevAmenities {
                devWithAmenities++
            }
        } else {
            generalCount++
            if res.HasAllDevAmenities {
                generalWithAmenities++
            }
        }
    }

    report += fmt.Sprintf("Total Locations Checked: %d\n", len(results))
    report += fmt.Sprintf("Dev-Focused Locations: %d (%.2f%% have all required dev amenities)\n", devCount, float64(devWithAmenities)/float64(devCount)*100)
    report += fmt.Sprintf("General Locations: %d (%.2f%% have all required dev amenities)\n\n", generalCount, float64(generalWithAmenities)/float64(generalCount)*100)

    report += "Detailed Results:\n"
    for _, res := range results {
        report += fmt.Sprintf("\nLocation: %s (Provider: %s, Type: %s)\n", res.LocationID, res.ProviderName, res.Type)
        report += fmt.Sprintf("Seat Cost: $%d/month\n", res.SeatCostUSD)
        report += fmt.Sprintf("Has All Dev Amenities: %v\n", res.HasAllDevAmenities)
        if len(res.MissingAmenities) > 0 {
            report += fmt.Sprintf("Missing Amenities: %v\n", res.MissingAmenities)
        }
    }

    return report
}

func main() {
    if len(os.Args) < 2 {
        log.Fatal("Usage: go run amenity-check.go ")
    }

    configPath := os.Args[1]
    config, err := loadConfig(configPath)
    if err != nil {
        log.Fatalf("Failed to load config: %v", err)
    }

    log.Printf("Starting amenity check for %d providers", len(config.Providers))
    results := runAmenityCheck(config)
    report := generateReport(results)

    fmt.Println(report)

    // Write report to file
    reportPath := "amenity-report-2024.txt"
    if err := os.WriteFile(reportPath, []byte(report), 0644); err != nil {
        log.Fatalf("Failed to write report: %v", err)
    }
    log.Printf("Report written to %s", reportPath)
}

// Short snippet to test GitHub API latency with Octokit
const { Octokit } = require("@octokit/rest");
const octokit = new Octokit();
async function testGitHubLatency() {
    const start = Date.now();
    await octokit.repos.get({ owner: "octokit", repo: "octokit.js" });
    console.log(`GitHub API latency: ${Date.now() - start}ms`);
}
testGitHubLatency();

// Short snippet to fetch WeWork pricing via Axios
const axios = require("axios");
async function getWeWorkPricing(locationId) {
    try {
        const response = await axios.get(`https://api.wework.com/v4/locations/${locationId}/pricing`);
        return response.data.seat_cost_usd_monthly;
    } catch (error) {
        console.error("Failed to fetch WeWork pricing:", error.message);
        return null;
    }
}

// Short snippet to generate negotiation email with TypeScript types
type NegotiationPerk = "GPU" | "StaticIP" | "MeetingRoom" | "100Gbps";
interface NegotiationEmail {
    to: string;
    subject: string;
    body: string;
    requestedPerks: NegotiationPerk[];
}
const email: NegotiationEmail = {
    to: "sales@techspace.com",
    subject: "8-Seat Dev Team Contract Negotiation",
    body: "We are interested in a 12-month contract for 8 seats, requesting GPU access and static IPs.",
    requestedPerks: ["GPU", "StaticIP"]
};