Principi Green Software Foundation: Efficienza Carbonica per Developer

# Ricerca INEFFICIENTE: O(n) - scansione lineare su lista non ordinata
def find_user_linear(users: list, target_id: str) -> dict | None:
    """Scansione lineare: consuma energia proporzionale a N."""
    for user in users:
        if user["id"] == target_id:
            return user
    return None

# Ricerca EFFICIENTE: O(1) - lookup su dizionario (hash map)
def build_user_index(users: list) -> dict:
    """Costruzione indice: investimento una tantum O(n)."""
    return {user["id"]: user for user in users}

def find_user_indexed(index: dict, target_id: str) -> dict | None:
    """Lookup O(1): consumo energetico costante."""
    return index.get(target_id)

# Impatto su 1 milione di utenti con 10.000 ricerche:
# - Lineare: ~10 miliardi di confronti = ~15 Wh
# - Indicizzato: ~10.000 lookup = ~0.001 Wh
# Risparmio: 99.99% di energia per la stessa funzionalità

interface CacheEntry<T> {
  readonly data: T;
  readonly timestamp: number;
  readonly ttlMs: number;
}

class GreenCache<T> {
  private readonly cache = new Map<string, CacheEntry<T>>();
  private hits = 0;
  private misses = 0;

  get(key: string): T | undefined {
    const entry = this.cache.get(key);
    if (!entry) {
      this.misses++;
      return undefined;
    }

    const isExpired = Date.now() - entry.timestamp > entry.ttlMs;
    if (isExpired) {
      this.cache.delete(key);
      this.misses++;
      return undefined;
    }

    this.hits++;
    return entry.data;
  }

  set(key: string, data: T, ttlMs: number = 300_000): void {
    // Immutable: creiamo un nuovo entry, non mutiamo
    const entry: CacheEntry<T> = {
      data,
      timestamp: Date.now(),
      ttlMs,
    };
    this.cache.set(key, entry);
  }

  /** Metriche di efficienza: un alto hit rate = meno energia consumata */
  getEfficiencyReport(): object {
    const total = this.hits + this.misses;
    const hitRate = total > 0 ? (this.hits / total) * 100 : 0;
    // Stima: ogni cache hit risparmia ~0.5-2ms di CPU + network I/O
    const estimatedSavedWh = this.hits * 0.000002; // ~2mWh per hit
    return {
      hits: this.hits,
      misses: this.misses,
      hitRate: hitRate.toFixed(1) + '%',
      estimatedSavedWh: estimatedSavedWh.toFixed(6),
    };
  }
}

// Uso:
// const cache = new GreenCache<UserProfile>();
// cache.set('user:123', profile, 600_000); // TTL 10 minuti
// const cached = cache.get('user:123'); // O(1), zero network

class BatchProcessor {
  private readonly queue: Array<{ id: string; resolve: Function }> = [];
  private timer: ReturnType<typeof setTimeout> | null = null;
  private readonly batchSize: number;
  private readonly delayMs: number;

  constructor(batchSize = 50, delayMs = 100) {
    this.batchSize = batchSize;
    this.delayMs = delayMs;
  }

  async fetchItem(id: string): Promise<unknown> {
    return new Promise((resolve) => {
      this.queue.push({ id, resolve });

      if (this.queue.length >= this.batchSize) {
        this.flush();
      } else if (!this.timer) {
        this.timer = setTimeout(() => this.flush(), this.delayMs);
      }
    });
  }

  private async flush(): Promise<void> {
    if (this.timer) {
      clearTimeout(this.timer);
      this.timer = null;
    }

    // Svuota la coda in modo immutabile
    const batch = [...this.queue];
    this.queue.length = 0;

    const ids = batch.map(item => item.id);

    // UNA sola richiesta invece di N richieste separate
    // Risparmio: ~95% overhead TCP/TLS per batch da 50
    const results = await fetch('/api/batch', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ ids }),
    }).then(r => r.json());

    batch.forEach((item, i) => item.resolve(results[i]));
  }
}

/**
 * Pattern Green: Lazy Initialization
 * Calcola risorse costose SOLO quando effettivamente necessarie.
 * Risparmio stimato: 30-70% CPU per richieste che non accedono
 * a tutte le proprietà dell'oggetto.
 */
public final class LazyReport {

    private final String reportId;
    private final Supplier<ReportData> dataSupplier;
    private volatile ReportData cachedData;

    public LazyReport(String reportId, Supplier<ReportData> dataSupplier) {
        this.reportId = reportId;
        this.dataSupplier = dataSupplier;
        // NON calcoliamo i dati nel costruttore
    }

    public ReportData getData() {
        // Double-checked locking: calcolo solo al primo accesso
        ReportData result = cachedData;
        if (result == null) {
            synchronized (this) {
                result = cachedData;
                if (result == null) {
                    cachedData = result = dataSupplier.get();
                }
            }
        }
        return result;
    }

    public String getReportId() {
        return reportId; // Zero CPU: nessun calcolo costoso
    }
}

// Confronto energetico:
// - Eager: 100 report creati, tutti calcolano dati = 100 query DB
// - Lazy: 100 report creati, solo 10 consultati = 10 query DB
// Risparmio: 90% energia per le query non necessarie

import csv
from typing import Generator, Iterator

def process_large_csv_green(filepath: str) -> Generator[dict, None, None]:
    """
    Pattern Green: Streaming con generatore.
    Elabora file da milioni di righe senza caricare tutto in memoria.
    - Memoria: O(1) invece di O(n)
    - Energia: proporzionale solo alle righe effettivamente processate
    """
    with open(filepath, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            # Yield una riga alla volta: zero allocazione bulk
            yield {
                "id": row["id"],
                "value": float(row["amount"]),
                "processed": True,
            }


def aggregate_green(rows: Iterator[dict], limit: int = 1000) -> dict:
    """
    Aggregazione streaming: calcola statistiche senza
    materializzare l'intera collezione in memoria.
    """
    total = 0.0
    count = 0
    max_val = float('-inf')

    for row in rows:
        total += row["value"]
        count += 1
        if row["value"] > max_val:
            max_val = row["value"]
        if count >= limit:
            break  # Early termination: non sprechiamo energia

    return {
        "count": count,
        "total": round(total, 2),
        "average": round(total / count, 2) if count > 0 else 0,
        "max": max_val,
    }


# Confronto:
# Anti-pattern: data = list(csv.DictReader(f))  # Carica TUTTO in RAM
#   - File 2GB = 2GB RAM + swap potenziale + GC overhead
# Pattern green: usa generatore + early termination
#   - File 2GB = ~1KB RAM costante, si ferma appena ha abbastanza dati

interface CarbonIntensityData {
  readonly zone: string;
  readonly carbonIntensity: number; // gCO2eq/kWh
  readonly fossilFuelPercentage: number;
  readonly datetime: string;
}

interface ScheduleDecision {
  readonly shouldRun: boolean;
  readonly currentIntensity: number;
  readonly threshold: number;
  readonly reason: string;
}

const CARBON_THRESHOLD_LOW = 100;   // gCO2eq/kWh
const CARBON_THRESHOLD_HIGH = 400;  // gCO2eq/kWh

async function getCarbonIntensity(zone: string): Promise<CarbonIntensityData> {
  const response = await fetch(
    `https://api.electricitymap.org/v3/carbon-intensity/latest?zone=${zone}`,
    {
      headers: {
        'auth-token': process.env['ELECTRICITY_MAPS_TOKEN'] ?? '',
      },
    }
  );

  if (!response.ok) {
    throw new Error(`Carbon API error: ${response.status}`);
  }

  return response.json();
}

async function shouldRunWorkload(
  zone: string,
  priority: 'low' | 'medium' | 'high'
): Promise<ScheduleDecision> {
  const data = await getCarbonIntensity(zone);
  const intensity = data.carbonIntensity;

  // Alta priorità: esegui sempre (ma logga le emissioni)
  if (priority === 'high') {
    return {
      shouldRun: true,
      currentIntensity: intensity,
      threshold: Infinity,
      reason: 'High priority: executing regardless of carbon intensity',
    };
  }

  // Media priorità: esegui sotto la soglia alta
  if (priority === 'medium') {
    return {
      shouldRun: intensity < CARBON_THRESHOLD_HIGH,
      currentIntensity: intensity,
      threshold: CARBON_THRESHOLD_HIGH,
      reason: intensity < CARBON_THRESHOLD_HIGH
        ? 'Medium priority: intensity acceptable'
        : 'Medium priority: deferring to lower intensity period',
    };
  }

  // Bassa priorità: esegui solo con energia pulita
  return {
    shouldRun: intensity < CARBON_THRESHOLD_LOW,
    currentIntensity: intensity,
    threshold: CARBON_THRESHOLD_LOW,
    reason: intensity < CARBON_THRESHOLD_LOW
      ? 'Low priority: clean energy available'
      : 'Low priority: waiting for cleaner energy window',
  };
}

// Esempio d'uso:
// const decision = await shouldRunWorkload('IT-SO', 'low');
// if (decision.shouldRun) {
//   await runBatchJob();
// } else {
//   scheduleRetry(decision);
// }

# === Dati di Input ===

# E (Energia): il server consuma in media 150W
# Funziona 24h/giorno = 150W * 24h = 3.600 Wh = 3.6 kWh/giorno
E = 3.6  # kWh/giorno

# I (Intensità carbonica): grid tedesca media
I = 350  # gCO2eq/kWh (media Germania 2024-2025)

# M (Embodied carbon): server rack con 5 anni di vita
# Embodied totale: 1.500 kgCO2eq
# Ammortamento giornaliero: 1.500.000 / (5 * 365) = 821.9 gCO2eq/giorno
M = 822  # gCO2eq/giorno

# R (Functional unit): 100.000 richieste API al giorno
R = 100_000

# === Calcolo SCI ===

# Emissioni operative: E * I = 3.6 * 350 = 1.260 gCO2eq/giorno
operational = E * I  # 1.260 gCO2eq

# Totale giornaliero: (E * I) + M = 1.260 + 822 = 2.082 gCO2eq/giorno
total_daily = operational + M  # 2.082 gCO2eq

# SCI = totale / R = 2.082 / 100.000 = 0.02082 gCO2eq per richiesta
SCI = total_daily / R  # 0.02082 gCO2eq/richiesta

# === Confronto: stessa API ospitata in Svezia ===
I_sweden = 12  # gCO2eq/kWh
operational_sweden = E * I_sweden  # 3.6 * 12 = 43.2 gCO2eq
total_sweden = operational_sweden + M  # 43.2 + 822 = 865.2 gCO2eq
SCI_sweden = total_sweden / R  # 0.00865 gCO2eq/richiesta

# Riduzione: da 0.02082 a 0.00865 = -58.4% emissioni
# Solo cambiando la regione di hosting!

from codecarbon import EmissionsTracker
from dataclasses import dataclass

@dataclass(frozen=True)
class SCIResult:
    """Risultato immutabile del calcolo SCI."""
    operational_emissions_g: float  # E * I in gCO2eq
    embodied_emissions_g: float     # M in gCO2eq
    functional_units: int           # R
    sci_score: float                # SCI in gCO2eq/R
    region: str

    @property
    def total_emissions_g(self) -> float:
        return self.operational_emissions_g + self.embodied_emissions_g


def measure_api_sci(
    handler_fn,
    requests_count: int,
    server_embodied_gco2: float = 822.0,  # giornaliero
    country_iso_code: str = "DEU",
) -> SCIResult:
    """
    Misura lo SCI score di una funzione API usando CodeCarbon.
    CodeCarbon traccia automaticamente E e calcola E*I basandosi
    sulla grid locale.
    """
    tracker = EmissionsTracker(
        project_name="api-sci-measurement",
        country_iso_code=country_iso_code,
        log_level="warning",
    )

    tracker.start()

    # Esegui il workload
    for _ in range(requests_count):
        handler_fn()

    # Ottieni emissioni operative (E * I) in kg, convertiamo in grammi
    emissions_kg = tracker.stop()
    operational_g = emissions_kg * 1000

    # Calcola SCI
    total = operational_g + server_embodied_gco2
    sci = total / requests_count if requests_count > 0 else 0

    return SCIResult(
        operational_emissions_g=round(operational_g, 4),
        embodied_emissions_g=server_embodied_gco2,
        functional_units=requests_count,
        sci_score=round(sci, 6),
        region=country_iso_code,
    )


# Esempio d'uso:
# result = measure_api_sci(my_handler, requests_count=10000)
# print(f"SCI Score: {result.sci_score} gCO2eq/request")
# print(f"Total: {result.total_emissions_g} gCO2eq")

# Nginx: configurazione ottimizzata per green networking

# Compressione Brotli (superiore a gzip: -20% dimensioni)
brotli on;
brotli_comp_level 6;
brotli_types text/html text/css application/javascript application/json;

# Cache aggressiva per asset statici (1 anno)
location /assets/ {
    expires 1y;
    add_header Cache-Control "public, immutable";
    add_header Vary "Accept-Encoding";
}

# Cache per API responses con ETag
location /api/ {
    add_header Cache-Control "public, max-age=300"; # 5 minuti
    etag on;
}

# Risparmio stimato su 1M pagine/giorno:
# - Senza compressione: ~2TB/giorno trasferiti
# - Con Brotli + cache: ~200GB/giorno trasferiti
# - Riduzione: ~90% traffico = ~90% energia di rete

interface VideoQualityConfig {
  readonly resolution: '4K' | '1080p' | '720p' | '480p';
  readonly bitrate: number; // kbps
  readonly estimatedKwhPerHour: number;
}

const QUALITY_PROFILES: Record<string, VideoQualityConfig> = {
  ultra: { resolution: '4K', bitrate: 25000, estimatedKwhPerHour: 0.042 },
  high:  { resolution: '1080p', bitrate: 8000, estimatedKwhPerHour: 0.018 },
  medium: { resolution: '720p', bitrate: 5000, estimatedKwhPerHour: 0.012 },
  eco:   { resolution: '480p', bitrate: 2500, estimatedKwhPerHour: 0.007 },
};

function selectQualityByCarbon(
  carbonIntensity: number, // gCO2eq/kWh
  userPreference: string = 'auto'
): VideoQualityConfig {
  // Se l'utente ha scelto manualmente, rispetta la scelta
  if (userPreference !== 'auto') {
    return QUALITY_PROFILES[userPreference] ?? QUALITY_PROFILES['high'];
  }

  // Demand shaping: adatta la qualità all'energia disponibile
  if (carbonIntensity < 50) {
    return QUALITY_PROFILES['ultra'];   // Energia pulita: massima qualità
  }
  if (carbonIntensity < 200) {
    return QUALITY_PROFILES['high'];    // Moderata: alta qualità
  }
  if (carbonIntensity < 400) {
    return QUALITY_PROFILES['medium'];  // Alta: qualità ridotta
  }
  return QUALITY_PROFILES['eco'];       // Critica: modalità eco
}

// Trasparenza: mostra all'utente il motivo della scelta
function getEcoMessage(config: VideoQualityConfig, intensity: number): string {
  const saved = QUALITY_PROFILES['ultra'].estimatedKwhPerHour
    - config.estimatedKwhPerHour;
  const savedPercent = (saved / QUALITY_PROFILES['ultra'].estimatedKwhPerHour * 100)
    .toFixed(0);
  return `Streaming in ${config.resolution} (grid: ${intensity} gCO2/kWh). `
    + `Risparmio energetico: ${savedPercent}% rispetto al 4K.`;
}

from codecarbon import track_emissions, EmissionsTracker
import pandas as pd
import numpy as np

# Metodo 1: Decoratore (più semplice)
@track_emissions(
    project_name="data-pipeline",
    output_dir="./emissions",
    country_iso_code="ITA",
)
def run_data_pipeline(input_path: str) -> pd.DataFrame:
    """Pipeline di elaborazione dati con tracking automatico."""
    df = pd.read_csv(input_path)
    # ... trasformazioni ...
    result = df.groupby("category").agg({
        "revenue": ["sum", "mean"],
        "transactions": "count",
    })
    return result


# Metodo 2: Context manager (più controllo)
def train_model_green(X_train, y_train, X_test, y_test):
    """Training con misurazione granulare delle emissioni."""
    tracker = EmissionsTracker(
        project_name="model-training",
        measure_power_secs=15,     # Campiona ogni 15 secondi
        tracking_mode="process",   # Solo il processo corrente
        country_iso_code="ITA",
        save_to_api=False,         # Salva solo localmente
    )

    tracker.start()

    # Fase 1: Preprocessing
    tracker.start_task("preprocessing")
    X_scaled = preprocess(X_train)
    emissions_preprocess = tracker.stop_task("preprocessing")

    # Fase 2: Training
    tracker.start_task("training")
    model = train(X_scaled, y_train)
    emissions_training = tracker.stop_task("training")

    # Fase 3: Evaluation
    tracker.start_task("evaluation")
    metrics = evaluate(model, X_test, y_test)
    emissions_eval = tracker.stop_task("evaluation")

    total_emissions = tracker.stop()

    return {
        "model": model,
        "metrics": metrics,
        "emissions": {
            "preprocessing_kgCO2": emissions_preprocess,
            "training_kgCO2": emissions_training,
            "evaluation_kgCO2": emissions_eval,
            "total_kgCO2": total_emissions,
        },
    }

# Installazione
npm install -g @cloud-carbon-footprint/cli

# Esecuzione (richiede credenziali cloud configurate)
ccf --startDate 2025-01-01 --endDate 2025-03-31

# Output esempio:
# +------------+----------+-----------+----------+
# | Servizio   | kWh      | kgCO2eq   | Costo    |
# +------------+----------+-----------+----------+
# | EC2        | 1,247.3  | 436.6     | $892.40  |
# | S3         | 89.2     | 31.2      | $45.60   |
# | RDS        | 456.8    | 159.9     | $312.00  |
# | Lambda     | 12.4     | 4.3       | $8.20    |
# +------------+----------+-----------+----------+
# | TOTALE     | 1,805.7  | 632.0     | $1,258.2 |
# +------------+----------+-----------+----------+
#
# Top raccomandazioni:
# 1. Right-size EC2 i3.xlarge (util. 12%) -> risparmio 340 kgCO2/mese
# 2. Migra a Graviton (ARM) -> risparmio 15% energia
# 3. Abilita S3 Intelligent Tiering -> risparmio 40% storage