@icarusmx/creta 1.5.4 → 1.5.7

package/lib/papers/bitcoin/bitcoin.md

@@ -0,0 +1,92 @@
+# Bitcoin: A Peer-to-Peer Electronic Cash System
+**Satoshi Nakamoto (2008)**
+
+<!--
+Vim Tips Nivel 2:
+- <leader>ff: Busca archivos en el proyecto (crear blockchain.js)
+- gd: Go to definition (si usas LSP)
+- <leader>ca: Code actions
+- gcc: Comentar/descomentar línea
+- gcap: Comentar párrafo
+-->
+
+---
+
+## 📚 Contexto: Crisis del 2008
+
+**31 de Octubre 2008**: Un email anónimo llega a una lista de criptografía...
+
+> "I've been working on a new electronic cash system that's fully
+> peer-to-peer, with no trusted third party."
+> — Satoshi Nakamoto
+
+### El Mundo en 2008
+
+- **Lehman Brothers colapsa** → crisis financiera global
+- **Bancos rescatados** con dinero público
+- **Desconfianza masiva** en instituciones centrales
+- **Pregunta clave**: ¿Puede existir dinero sin bancos?
+
+---
+
+## 🤔 El Problema del Doble Gasto
+
+<!-- Usa } para saltar entre párrafos rápido -->
+
+### Dinero Digital = Archivos
+
+```
+archivo_dinero.txt: "10 BTC"
+```
+
+Pero los archivos se pueden **copiar**:
+
+```bash
+cp archivo_dinero.txt copia1.txt
+cp archivo_dinero.txt copia2.txt
+```
+
+¿Qué impide gastar el mismo dinero 2 veces?
+
+### Solución Tradicional
+
+```
+Banco Central verifica cada transacción
+    ↓
+❌ Punto único de falla
+❌ Requiere confianza
+❌ Puede censurar
+❌ Puede imprimir dinero infinito
+```
+
+### La Visión de Bitcoin
+
+```
+✅ Red peer-to-peer sin autoridad
+✅ Historial público e inmutable
+✅ Consenso descentralizado
+✅ Nadie puede imprimir bitcoins
+```
+
+---
+
+## 💡 Los 3 Pilares de Bitcoin
+
+### 1. BLOCKCHAIN
+Cadena de bloques enlazados criptográficamente
+
+### 2. PROOF-OF-WORK
+Minería costosa → atacar es más caro que participar
+
+### 3. CONSENSO
+La cadena más larga (más trabajo) gana
+
+<!-- Ejercicio en blockchain.js próximamente... -->
+
+---
+
+## 🏆 Próximamente
+
+Contenido completo de Bitcoin paper en desarrollo.
+
+Por ahora, explora MapReduce y regresa después para blockchain!

package/lib/papers/mapreduce/mapreduce.md

@@ -0,0 +1,476 @@
+# MapReduce: Simplified Data Processing on Large Clusters
+**Jeffrey Dean y Sanjay Ghemawat, Google (2004)**
+
+<!--
+Vim Tips para este documento:
+- zM: Cierra todos los folds (empieza aquí para ver solo títulos)
+- za: Abre/cierra el fold donde está el cursor
+- }: Salta al siguiente párrafo
+- ]]: Salta a la siguiente sección
+- <leader>e: Abre el file explorer (crear borrador.js para ejercicios)
+- <leader>ff: Buscar archivos en el proyecto
+-->
+
+---
+
+## 📚 Cómo Google Se Convirtió en Google
+
+### 1998: Dos Estudiantes en un Garage
+
+Larry Page y Sergey Brin tienen una idea simple pero poderosa:
+
+**"¿Y si rankeas páginas web como papers académicos?"**
+
+→ Papers citados frecuentemente = importantes
+→ Páginas enlazadas frecuentemente = relevantes
+
+Nace **PageRank**. Google indexa la web y hace búsqueda **ultra rápida**.
+
+### El Problema del Éxito (2000-2004)
+
+Google crece explosivamente:
+
+```
+1998: 26 millones de páginas indexadas
+2000: 1 billón de páginas
+2004: PETABYTES de datos
+
+La web crece más rápido que el haardware
+```
+
+### El Muro: Escalabilidad
+
+**Tareas diarias en Google (2004)**:
+
+1. **Crawling**: Descargar millones de páginas web/día
+2. **Indexing**: Construir índice invertido (palabra → documentos)
+3. **PageRank**: Calcular relevancia de billones de enlaces
+4. **Log Analysis**: Procesar terabytes de clicks, búsquedas, ads
+
+**Problema**:
+- Una máquina → ❌ Imposible, tardaría meses
+- Comprar supercomputadora → ❌ Demasiado caro
+- Cluster de máquinas baratas → ✅ pero... ¿cómo programarlo?
+
+### El Dilema del Programador
+
+Cada ingeniero en Google escribía el mismo código una y otra vez:
+
+```javascript
+// Split data across machines
+// Handle network failures
+// Re-run failed tasks
+// Aggregate results
+// Monitor progress
+// ...
+```
+
+**El insight**: Estos problemas son INFRAESTRUCTURA, no lógica de negocio.
+
+**La pregunta**: ¿Existe un patrón común que abstraiga la distribución?
+
+---
+
+## 🤔 El Problema
+
+Imagina tres tareas diferentes:
+
+### 1. Word Count
+Contar palabras en 1 millón de documentos
+
+### 2. Log Analysis
+Encontrar las URLs con más errores 404 en logs gigantes
+
+### 3. Inverted Index
+Construir un índice de búsqueda (palabra → documentos)
+
+**¿Qué tienen en común?**
+
+Todas siguen el mismo patrón:
+1. Procesar cada elemento independientemente (paralelizable)
+2. Agrupar resultados por alguna clave
+3. Combinar/agregar valores para cada grupo
+
+---
+
+## 💡 El Insight de MapReduce
+
+<!-- Vim tip: Usa 'za' para expandir esta sección -->
+
+La mayoría de problemas de big data se pueden expresar en **2 funciones**:
+
+### 1. MAP: Transforma
+```
+Input:  (key1, value1)
+Output: lista de (key2, value2)
+```
+
+Transforma cada elemento en pares clave-valor.
+
+### 2. REDUCE: Agrega
+```
+Input:  (key2, lista de values)
+Output: (key2, value_final)
+```
+
+Combina todos los valores para cada clave.
+
+### 3. SHUFFLE (automático)
+El framework agrupa automáticamente todos los valores por clave.
+
+**✨ Magia**: Google maneja distribución, fallas, y balanceo por ti.
+
+---
+
+## 🗺️ La Función Map
+
+<!--
+Vim tip:
+- yy: copiar línea completa
+- p: pegar debajo
+- ciw: cambiar palabra bajo cursor (útil para renombrar)
+-->
+
+Map transforma cada input independientemente:
+
+```javascript
+// Firma de Map
+function map(key, value) {
+  // Procesa el input
+  // Emite cero o más pares (k2, v2)
+  return [[k2, v2], [k2, v2], ...]
+}
+```
+
+### Ejemplo: Word Count
+
+```javascript
+function map(documentId, content) {
+  const words = content.split(/\s+/)
+  const results = []
+
+  for (const word of words) {
+    results.push([word.toLowerCase(), 1])
+  }
+
+  return results
+}
+
+// Input:  (doc1, "MapReduce es genial")
+// Output: [
+//   ["mapreduce", 1],
+//   ["es", 1],
+//   ["genial", 1]
+// ]
+```
+
+**Propiedad clave**: Cada documento se procesa **independientemente**.
+→ Se puede ejecutar en N máquinas en paralelo.
+
+---
+
+## 📦 La Función Reduce
+
+<!-- Vim tip: Ctrl+d para scroll down rápido -->
+
+Reduce combina todos los valores para una clave:
+
+```javascript
+// Firma de Reduce
+function reduce(key, values) {
+  // Agrega/combina los valores
+  // Retorna resultado final
+  return finalValue
+}
+```
+
+### Ejemplo: Sumar conteos
+
+```javascript
+function reduce(word, counts) {
+  let sum = 0
+
+  for (const count of counts) {
+    sum += count
+  }
+
+  return sum
+}
+
+// Input:  ("mapreduce", [1, 1, 1, 1])
+// Output: 4
+
+// Input:  ("genial", [1])
+// Output: 1
+```
+
+**El framework agrupa automáticamente**:
+- "mapreduce" → [1, 1, 1, 1]
+- "genial" → [1]
+- "es" → [1, 1]
+
+---
+
+## 🔨 Ejercicio 1: Word Count Completo
+
+<!--
+LazyVim tips:
+1. <leader>e: Abre neo-tree (file explorer)
+2. Crea archivo: borrador.js (presiona 'a' en neo-tree)
+3. Copia el código de abajo
+4. <leader>`: Abre terminal flotante
+5. node borrador.js para ejecutar
+-->
+
+### Paso 1: Copia este código a `borrador.js`
+
+```javascript
+// Word Count con MapReduce
+
+const documents = [
+  { id: 'doc1', content: 'MapReduce es genial' },
+  { id: 'doc2', content: 'MapReduce procesa big data' },
+  { id: 'doc3', content: 'Big data es el futuro' }
+]
+
+// ==================== MAP ====================
+function map(doc) {
+  const words = doc.content.toLowerCase().split(/\s+/)
+  return words.map(word => [word, 1])
+}
+
+console.log('📍 FASE MAP:\n')
+
+const mapResults = []
+for (const doc of documents) {
+  const pairs = map(doc)
+  console.log(`${doc.id}: ${doc.content}`)
+  console.log(`  →`, pairs)
+  console.log('')
+
+  mapResults.push(...pairs)
+}
+
+// ==================== SHUFFLE ====================
+console.log('🔀 FASE SHUFFLE (agrupación):\n')
+
+const grouped = {}
+for (const [word, count] of mapResults) {
+  if (!grouped[word]) {
+    grouped[word] = []
+  }
+  grouped[word].push(count)
+}
+
+for (const [word, counts] of Object.entries(grouped)) {
+  console.log(`"${word}": [${counts.join(', ')}]`)
+}
+
+// ==================== REDUCE ====================
+console.log('\n📊 FASE REDUCE:\n')
+
+function reduce(word, counts) {
+  return counts.reduce((a, b) => a + b, 0)
+}
+
+const results = {}
+for (const [word, counts] of Object.entries(grouped)) {
+  results[word] = reduce(word, counts)
+}
+
+console.log('✅ Resultado Final:\n')
+const sorted = Object.entries(results).sort((a, b) => b[1] - a[1])
+for (const [word, count] of sorted) {
+  console.log(`  ${word}: ${count}`)
+}
+```
+
+### Paso 2: Ejecuta y observa
+
+Abre el terminal (<leader>\`) y corre:
+```bash
+node borrador.js
+```
+
+**Observa** las 3 fases:
+1. MAP: Cada doc → pares (palabra, 1)
+2. SHUFFLE: Agrupa por palabra
+3. REDUCE: Suma conteos
+
+---
+
+## 🚀 Ejercicio 2: Log Analysis
+
+Ahora tú implementas MapReduce desde cero.
+
+### El Problema
+
+Tienes logs de un servidor. Encuentra las URLs con más errores 404.
+
+```javascript
+const logs = [
+  '192.168.1.1 GET /home 200',
+  '192.168.1.2 GET /api/users 404',
+  '192.168.1.3 GET /home 200',
+  '192.168.1.1 GET /api/users 404',
+  '192.168.1.4 GET /about 200',
+  '192.168.1.2 GET /api/products 404',
+  '192.168.1.5 GET /api/users 404'
+]
+```
+
+### Tu Tarea
+
+<!-- Vim tip: Visual mode (V) + y para copiar bloque -->
+
+1. **Map**: Si status es 404, emite (URL, 1)
+2. **Shuffle**: Agrupa por URL (el framework lo hace)
+3. **Reduce**: Suma los conteos
+4. **Output**: Top 3 URLs con más 404s
+
+### Código Base (complétalo)
+
+```javascript
+const logs = [
+  '192.168.1.1 GET /home 200',
+  '192.168.1.2 GET /api/users 404',
+  '192.168.1.3 GET /home 200',
+  '192.168.1.1 GET /api/users 404',
+  '192.168.1.4 GET /about 200',
+  '192.168.1.2 GET /api/products 404',
+  '192.168.1.5 GET /api/users 404'
+]
+
+function map(log) {
+  const parts = log.split(' ')
+  const url = parts[2]
+  const status = parts[3]
+
+  // TODO: Si status === '404', retorna [[url, 1]]
+  // Sino, retorna []
+}
+
+function reduce(url, counts) {
+  // TODO: Suma los conteos
+}
+
+// Ejecuta MapReduce aquí...
+```
+
+### Solución (no hagas trampa 😉)
+
+<details>
+<summary>Click para ver solución</summary>
+
+```javascript
+function map(log) {
+  const parts = log.split(' ')
+  const url = parts[2]
+  const status = parts[3]
+
+  if (status === '404') {
+    return [[url, 1]]
+  }
+  return []
+}
+
+function reduce(url, counts) {
+  return counts.reduce((a, b) => a + b, 0)
+}
+
+// Map phase
+const mapResults = logs.flatMap(map)
+
+// Shuffle phase
+const grouped = {}
+for (const [url, count] of mapResults) {
+  if (!grouped[url]) grouped[url] = []
+  grouped[url].push(count)
+}
+
+// Reduce phase
+const results = {}
+for (const [url, counts] of Object.entries(grouped)) {
+  results[url] = reduce(url, counts)
+}
+
+// Top 3
+const top3 = Object.entries(results)
+  .sort((a, b) => b[1] - a[1])
+  .slice(0, 3)
+
+console.log('Top 3 URLs con más 404s:')
+top3.forEach(([url, count]) => {
+  console.log(`  ${url}: ${count} errores`)
+})
+
+// Output:
+//   /api/users: 3 errores
+//   /api/products: 1 errores
+```
+</details>
+
+---
+
+## 🎯 Reflexión Final
+
+### Lo que aprendiste
+
+1. **MapReduce = 2 funciones simples**
+   - Map: transforma elementos independientemente
+   - Reduce: agrega valores por clave
+
+2. **Paralelización automática**
+   - Map se ejecuta en N máquinas
+   - Reduce procesa grupos en paralelo
+
+3. **Abstracción poderosa**
+   - Word count
+   - Log analysis
+   - Inverted index
+   - Todo sigue el mismo patrón
+
+### Tecnologías basadas en MapReduce
+
+```
+📦 Hadoop        → Implementación open-source de MapReduce
+⚡ Spark         → MapReduce en memoria (10-100x más rápido)
+☁️  BigQuery     → SQL sobre MapReduce (Google Cloud)
+🌊 AWS EMR       → MapReduce managed en AWS
+🐘 Hive          → SQL sobre Hadoop
+```
+
+### El Paper Original
+
+Si quieres leer el paper completo:
+```
+https://static.googleusercontent.com/media/research.google.com/en//archive/mapreduce-osdi04.pdf
+```
+
+---
+
+## 🏆 Completado
+
+Has recreado uno de los papers más influyentes en la historia de la computación.
+
+**Próximo paso**: Desbloquea **Bitcoin** completando 1 proyecto en Creta.
+
+---
+
+<!--
+Vim tips que usaste hoy:
+✅ zM - cerrar todos los folds
+✅ za - toggle fold
+✅ } - saltar párrafos
+✅ ]] - saltar secciones
+✅ <leader>e - file explorer
+✅ <leader>` - terminal
+✅ yy/p - copiar/pegar
+✅ ciw - cambiar palabra
+
+Próximos tips (Bitcoin paper):
+- <leader>ff - fuzzy find files
+- gd - go to definition
+- <leader>ca - code actions
+- gcc - comentar línea
+-->

package/lib/papers/spark/spark.md

@@ -0,0 +1,49 @@
+# Spark: Resilient Distributed Datasets
+**Matei Zaharia et al., UC Berkeley (2010)**
+
+<!--
+Vim Tips Nivel 3:
+- <leader>sg: Search with grep
+- <leader>sr: Search and replace
+- %s/foo/bar/g: Replace en todo el archivo
+- :%norm A;: Agrega ; al final de cada línea
+-->
+
+---
+
+## 📚 Contexto: 6 Años Después de MapReduce
+
+**2010**: Hadoop se volvió estándar... pero era **lento**.
+
+### El Problema
+
+Machine Learning requiere **muchas iteraciones**:
+
+```
+Iteración 1: Leer disco → Map → Reduce → Escribir disco
+Iteración 2: Leer disco → Map → Reduce → Escribir disco
+...
+Iteración 100: Leer disco → Map → Reduce → Escribir disco
+```
+
+**Disco es 100-1000x más lento que RAM** 🐌
+
+---
+
+## 💡 La Solución: In-Memory Computing
+
+```
+Primera carga: Disco → RAM
+Iteración 1-100: Todo en RAM ⚡
+Final: RAM → Disco
+```
+
+**Resultado: 10-100x más rápido**
+
+---
+
+## 🏆 Próximamente
+
+Contenido completo de Spark en desarrollo.
+
+Completa MapReduce y Bitcoin primero!