   ╔════════════════════════════════════════════════════════════════════════════╗
   ║         ¿QUÉ ES https://sh.rustup.rs? - EL BOOTSTRAP COMPILER             ║
   ╚════════════════════════════════════════════════════════════════════════════╝

   ANTES DE ENTENDER sh.rustup.rs, NECESITAS SABER:

   El Problema Fundamental del Bootstrap
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

   Para compilar Rust necesitas:
     ├─ rustc (compilador)
     └─ cargo (gestor de dependencias)

   Pero rustc y cargo están ESCRITOS EN RUST

   Entonces: ¿Cómo compilo Rust si necesito Rust para compilarlo?

     ┌─────────────────────┐
     │  El Huevo y Gallina │
     ├─────────────────────┤
     │  Necesito Rust →    │
     │  Para compilar →    │
     │  Rust               │
     │                     │
     │  ¿Cómo empiezo?     │
     └─────────────────────┘

   LA SOLUCIÓN: Bootstrap Compiler (Compilador Pre-Compilado)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

   Rust proporciona binarios precompilados LISTOS PARA EJECUTAR:

     https://sh.rustup.rs
        ↓
     Script que descarga:
        ├─ rustc precompilado
        ├─ cargo precompilado
        └─ Para tu sistema específico

     Estos binarios están compilados EN LENGUAJE MÁQUINA
     (no en Rust, sino en 1s y 0s para tu CPU)

     Por eso puedes ejecutarlos sin tener Rust instalado!

   ════════════════════════════════════════════════════════════════════════════

   ¿QUÉ EXACTAMENTE ES https://sh.rustup.rs?

   Es una URL que apunta a:
     ├─ Un SCRIPT bash
     ├─ Alojado en: https://sh.rustup.rs
     ├─ Descargable con: curl https://sh.rustup.rs
     └─ Ejecutable con: bash

   Cuando haces:
     $ curl https://sh.rustup.rs | sh

   Pasa esto:

     1. curl descarga el archivo
     2. bash lo ejecuta

   El script contiene:

     ┌─────────────────────────────────────────────────────┐
     │ #!/bin/bash                                         │
     │                                                     │
     │ # 1. Detecta tu arquitectura                        │
     │ ARCH=$(uname -m)                                    │
     │ OS=$(uname -s)                                      │
     │                                                     │
     │ # 2. Descarga el toolchain precompilado             │
     │ if [ $ARCH = "arm64" ] && [ $OS = "Darwin" ]; then  │
     │   curl https://static.rust-lang.org/dist/           │
     │        rust-stable-aarch64-apple-darwin.tar.gz \    │
     │     -o rust.tar.gz                                  │
     │ fi                                                  │
     │                                                     │
     │ # 3. Descomprime                                    │
     │ tar xzf rust.tar.gz                                 │
     │                                                     │
     │ # 4. Instala                                        │
     │ ./rust-installer/install.sh --prefix=$HOME/.rustup  │
     │                                                     │
     │ # 5. Configura PATH                                 │
     │ echo 'export PATH=$HOME/.cargo/bin:$PATH' >>        │
     │      ~/.bashrc                                      │
     │                                                     │
     └─────────────────────────────────────────────────────┘

   ════════════════════════════════════════════════════════════════════════════

   PASO A PASO: QUÉ OCURRE CUANDO EJECUTAS

   $ curl https://sh.rustup.rs | sh

   PASO 1: Tu máquina descarga el script
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

     Tu máquina (sin Rust)
           ↓
     Ejecuta: curl https://sh.rustup.rs
           ↓
     Se conecta a: sh.rustup.rs (servidor en internet)
           ↓
     Descarga: Un archivo bash (~150 KB)
           ↓
     Pasa a: bash (el shell de tu sistema)

   PASO 2: El script detecta tu arquitectura
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

     El script bash hace:

     ├─ uname -s      → "Darwin" (si es macOS)
     ├─ uname -m      → "arm64" (si es M1/M2/M3)
     ├─ Concatena:    → "aarch64-apple-darwin"
     └─ Determina:    → "Necesito descargar Rust para aarch64-apple-darwin"

   PASO 3: Descarga el toolchain precompilado
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

     El script ejecuta:

     curl https://static.rust-lang.org/dist/rust-stable-aarch64-apple-darwin.tar.gz \
       -o /tmp/rust.tar.gz

     Descarga:
     ├─ rustc (binario compilado para ARM64)
     ├─ cargo (binario compilado para ARM64)
     ├─ std library (librerías estándar compiladas para ARM64)
     └─ ~500-700 MB

     Esto NO es código fuente (.rs)
     Esto es BINARIO EJECUTABLE (lenguaje máquina)

   PASO 4: Descomprime el archive
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━

     tar xzf /tmp/rust.tar.gz
       ↓
     Crea directorio con:
     ├─ rust/
     │  ├─ rustc (ejecutable)
     │  ├─ cargo (ejecutable)
     │  ├─ rust-std-aarch64-apple-darwin/ (librerías precompiladas)
     │  └─ install.sh (script de instalación)

   PASO 5: Ejecuta el instalador
   ━━━━━━━━━━━━━━━━━━━━━━━━━

     ./rust/install.sh --prefix=$HOME/.rustup
       ↓
     Mueve archivos:
     ├─ ~/.rustup/toolchains/stable-aarch64-apple-darwin/bin/rustc
     ├─ ~/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo
     └─ ~/.rustup/toolchains/stable-aarch64-apple-darwin/lib/...

   PASO 6: Configura PATH
   ━━━━━━━━━━━━━━━━━━━

     El script añade a ~/.bashrc o ~/.zshrc:

     export PATH=$HOME/.cargo/bin:$PATH
       ↓
     Esto hace que cargo esté accesible globalmente

   PASO 7: LISTO! Ahora tienes Rust
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

     $ rustc --version
     rustc 1.75.0 (2024-02-13)
     ✅ FUNCIONA!

   ════════════════════════════════════════════════════════════════════════════

   ¿DÓNDE SE DESCARGAN ESTOS BINARIOS PRECOMPILADOS?

   https://static.rust-lang.org/dist/

   Este servidor tiene binarios precompilados para TODOS los targets:

     rust-stable-aarch64-apple-darwin.tar.gz     (Mac M1/M2/M3)
     rust-stable-x86_64-apple-darwin.tar.gz      (Mac Intel)
     rust-stable-x86_64-unknown-linux-gnu.tar.gz (Linux x86_64)
     rust-stable-aarch64-unknown-linux-gnu.tar.gz (Linux ARM64)
     rust-stable-x86_64-pc-windows-gnu.tar.gz    (Windows GNU)
     rust-stable-x86_64-pc-windows-msvc.tar.gz   (Windows MSVC)
     ... (más de 50 targets diferentes)

   Cada archivo contiene:
     ├─ rustc compilado PARA ESE TARGET
     ├─ cargo compilado PARA ESE TARGET
     └─ std library compilada PARA ESE TARGET

   ════════════════════════════════════════════════════════════════════════════

   ¿PERO ESPERA... ¿CÓMO SE COMPILARON ESOS BINARIOS?

   Gran pregunta! Respuesta corta:

     La Rust Foundation mantiene CI/CD servers que:

     ├─ Clonan el repo de Rust
     ├─ Compilan Rust CON Rust anterior
     └─ Crean binarios para cada target

   Ejemplo:

     Rust 1.75.0 se compiló con:
       Rust 1.74.0 (precompilado)
         ↓
       Que se compiló con Rust 1.73.0
         ↓
       Que se compiló con Rust 1.72.0
         ↓
       ... (hacia atrás en el tiempo)
         ↓
       Hasta el primer Rust compilado con C++ (hace 10+ años)

   Esto se llama "bootstrapping chain" (cadena de bootstrap)

   ════════════════════════════════════════════════════════════════════════════

   DIAGRAMA VISUAL: EL FLUJO COMPLETO

   Tu máquina sin Rust:

     $ curl https://sh.rustup.rs | sh
           ↓
     [Script 1: sh.rustup.rs - 150 KB bash script]
           ├─ Detecta: aarch64-apple-darwin
           ├─ Descarga: rust-stable-aarch64-apple-darwin.tar.gz
           ↓
     [Descarga: 700 MB - Binarios precompilados ARM64]
           ├─ rustc (ejecutable ARM64)
           ├─ cargo (ejecutable ARM64)
           ├─ std library (compilada para ARM64)
           ↓
     [Script 2: rust/install.sh - Installer]
           ├─ Descomprime
           ├─ Mueve a ~/.rustup/
           ├─ Configura PATH
           ↓
     ✅ Rust 1.75.0 instalado!

     Ahora puedes:
     $ rustc --version
     rustc 1.75.0

     $ cargo build --release
     (Compila Rust projects desde source)

   ════════════════════════════════════════════════════════════════════════════

   ¿POR QUÉ PRECOMPILADOS Y NO DESDE FUENTE?

   Razones:

   1. VELOCIDAD
      ├─ Compilar Rust desde fuente toma 30+ minutos
      └─ Descargar binario precompilado: 2-5 minutos

   2. COMPLEJIDAD
      ├─ Compilar requiere: C++, LLVM, cmake, etc.
      └─ Descargar es trivial: solo necesitas curl

   3. ACCESIBILIDAD
      ├─ No todos tienen compilador C/C++
      └─ Todos tienen curl

   4. CONSISTENCIA
      ├─ Mismos binarios para todos (reproducibilidad)
      └─ Sin variaciones por diferente compilador

   ════════════════════════════════════════════════════════════════════════════

   ANALÓGÍA PARA ENTENDERLO MEJOR

   Imagina que necesitas instalar un coche:

   OPCIÓN 1: Compilar desde fuente (NO SE HACE)
     ├─ Necesitas: fábrica de coches, tornos, herramientas
     ├─ Necesitas: metales, cauchos, vidrios crudos
     ├─ Tiempo: 6 meses
     └─ Complejo: casi imposible sin experiencia

   OPCIÓN 2: Descargar precompilado (LO QUE RUST HACE)
     ├─ Ya existe: un coche terminado
     ├─ Solo necesitas: bajarlo de la grúa
     ├─ Tiempo: 2 horas
     └─ Fácil: cualquiera puede hacerlo

   Rust elige OPCIÓN 2 para bootstrap:
     ├─ Los desarrolladores de Rust compilan Rust
     ├─ Lo suben a sh.rustup.rs
     ├─ Tú descargas el binario terminado
     └─ Tu máquina ya puede compilar código Rust

   ════════════════════════════════════════════════════════════════════════════

   AHORA ENTIENDES EL FLUJO COMPLETO:

   1. Sin Rust:
      $ curl https://sh.rustup.rs | sh
        ↓
      Descarga binario precompilado

   2. Con Rust instalado:
      $ cargo build --release
        ↓
      Compila Rust projects desde SOURCE
        ↓
      Genera binarios COMPILADOS POR TI para tu máquina

   3. En install.sh:
      # Fase 2:
      curl https://sh.rustup.rs | sh
        ↓ (Rust se instala)

      # Fase 4:
      cargo build --release --workspace
        ↓ (Ahora cargo está disponible)

      # Compila workspace desde source
      target/release/workspace (binario compilado localmente)

   ════════════════════════════════════════════════════════════════════════════

   RESUMEN EN UNA FRASE:

   "https://sh.rustup.rs es un script que descarga binarios precompilados
    de Rust para tu arquitectura y los instala en tu máquina,
    rompiendo el ciclo infinito de 'necesito Rust para instalar Rust'"

   ════════════════════════════════════════════════════════════════════════════


   ╔════════════════════════════════════════════════════════════════════════════╗
   ║              DEMO EN VIVO: Qué es realmente sh.rustup.rs                   ║
   ╚════════════════════════════════════════════════════════════════════════════╝

   Vamos a ver el primer kilobyte del script real:

   EOF

   echo ""
   echo "1. Descargando las primeras líneas del script:"
   echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
   echo ""

   curl -s https://sh.rustup.rs | head -50 | cat
