🧠 Developer Cookbook - FASE 9: Meta-aprendizaje
Recetas prácticas para aprender a aprender y adaptarse constantemente en tecnología
📚 Tabla de Contenidos
Aprendizaje Continuo
Receta 9.1: Técnica Feynman - Aprender Explicando
¿Qué es? Método de aprendizaje donde explicas un concepto como si le enseñaras a alguien sin conocimientos previos. Si no puedes explicarlo simple, no lo entiendes.
Los 4 pasos de Feynman:
class FeynmanTechnique:
"""Framework para aprender cualquier concepto técnico"""
@staticmethod
def step_1_choose_concept():
"""Paso 1: Elegir el concepto a aprender"""
guide = """
PASO 1: ELIGE UN CONCEPTO
==========================
Escribe el nombre del concepto en la parte superior de una hoja
Ejemplos:
• "Closures en JavaScript"
• "Docker containers"
• "REST vs GraphQL"
• "Big O notation"
• "Async/await"
Tip: Empieza pequeño. No "Machine Learning" sino "Gradient Descent"
❌ Demasiado amplio: "Bases de datos"
✅ Específico: "ACID transactions"
❌ Demasiado amplio: "React"
✅ Específico: "React hooks: useState"
"""
print(guide)
@staticmethod
def step_2_teach_it():
"""Paso 2: Explicarlo como a un niño de 12 años"""
guide = """
PASO 2: ENSÉÑALO (Como a un niño de 12 años)
=============================================
Escribe una explicación del concepto como si se lo explicaras
a alguien que NUNCA ha programado.
Reglas:
• NO jerga técnica
• Usa analogías del mundo real
• Dibuja diagramas
• Ejemplos concretos
---
EJEMPLO: Explicar "Closures"
❌ MAL (jerga técnica):
"Un closure es una función que retiene acceso al scope
léxico de su función externa después de que esta haya
retornado, manteniendo referencias a las variables libres."
✅ BIEN (analogía simple):
"Un closure es como una mochila.
Imagina que tienes una función (una persona) que va de viaje.
Antes de irse, empaca algunas cosas en su mochila (variables).
Cuando la persona se va lejos (la función retorna),
sigue teniendo su mochila con ella. Puede usar las cosas
de la mochila incluso después de salir de su casa.
Ejemplo en código:
function crearContador() {
let cuenta = 0; // Esto es la mochila
return function() { // Esta persona se va de viaje
cuenta++; // Pero puede usar lo de la mochila
return cuenta;
}
}
const contador = crearContador();
contador(); // 1
contador(); // 2
contador(); // 3
Incluso después de que crearContador() terminó,
la función interna sigue teniendo acceso a 'cuenta'."
---
EJEMPLO: Explicar "Docker"
❌ MAL:
"Docker es una plataforma de containerización que utiliza
namespaces del kernel de Linux para aislar procesos."
✅ BIEN:
"Docker es como un contenedor de envío (shipping container).
Problema sin Docker:
• Tu código funciona en tu laptop
• No funciona en el servidor de producción
• Porque tienen diferentes versiones de Python, librerías, etc.
Solución con Docker:
• Metes tu código + todas sus dependencias en un 'contenedor'
• El contenedor funciona igual en todas partes
• Como los contenedores de envío: funcionan en barcos, trenes, camiones
docker run mi-app
↑ Ejecuta tu app dentro de un contenedor aislado"
---
Test de la abuela:
¿Podrías explicárselo a tu abuela? Si no, simplifica más.
"""
print(guide)
@staticmethod
def step_3_identify_gaps():
"""Paso 3: Identificar lagunas en el conocimiento"""
guide = """
PASO 3: IDENTIFICA LAGUNAS
===========================
Al intentar explicar, encontrarás partes donde te trabas:
• "Hmm, ¿por qué funciona así?"
• "No sé cómo explicar esto"
• "¿Cuál es la diferencia entre X y Y?"
MARCA ESTAS LAGUNAS con un ❓
Ejemplo explicando "Async/await":
"Async/await hace que el código asíncrono se vea síncrono...
❓ Espera, ¿por qué async/await es mejor que Promises?
❓ ¿Qué pasa si hay un error en await?
❓ ¿Puedo usar await fuera de una función async?
...entonces usas await para esperar el resultado..."
---
AHORA ve a aprender específicamente esas lagunas:
1. ❓ "¿Por qué async/await es mejor que Promises?"
→ Lee: MDN docs sobre async/await benefits
→ Escribe: Ejemplo comparando .then() vs await
2. ❓ "¿Qué pasa si hay error en await?"
→ Prueba: Escribe código que falla
→ Aprende: try/catch con async/await
3. ❓ "¿Puedo usar await sin async?"
→ Experimenta: Inténtalo y ve qué error da
→ Aprende: Top-level await (ES2022)
---
Señales de lagunas:
• Usas palabras vagas: "algo así como...", "básicamente..."
• Saltaste pasos en la explicación
• Copias-pegaste definición sin entenderla
• No puedes dar un ejemplo concreto
"""
print(guide)
@staticmethod
def step_4_review_and_simplify():
"""Paso 4: Revisar y simplificar"""
guide = """
PASO 4: REVISA Y SIMPLIFICA
============================
Después de llenar lagunas, reescribe tu explicación:
• Más simple
• Más clara
• Con mejores analogías
• Con ejemplos concretos
---
ANTES (primera explicación):
"Git branches son como líneas alternativas de desarrollo...
cuando haces merge... hay conflicts... ❓ ¿cómo se resuelven?"
DESPUÉS (después de investigar):
"Git branches son como Save States en videojuegos.
Guardas tu progreso (commit en main branch)
Quieres probar algo experimental sin romper tu progreso
Creas un nuevo Save State (git branch experimento)
Haces cambios en el experimento
Si funciona → Merge (combinas los cambios con main)
Si no funciona → Borras el branch (descartaste ese Save State)
Conflicts = cuando cambiaste las mismas líneas en ambos branches
Git dice: 'Hey, no sé cuál versión quieres, tú decide'
Ejemplo:
git checkout -b experimento # Crear Save State
# hacer cambios
git add .
git commit -m 'experimento funcionó'
git checkout main # Volver a main
git merge experimento # Combinar cambios"
---
Test final:
Lee tu explicación en voz alta. ¿Suena natural?
¿Podrías explicarlo así en una entrevista?
"""
print(guide)
@staticmethod
def practice_examples():
"""Ejemplos de aplicación"""
examples = """
PRÁCTICA: APLICAR FEYNMAN
=========================
EJERCICIO 1: Closures en JavaScript
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Escribe "Closures" en el título
2. Explícalo con analogía (mochila, caja, etc.)
3. Da ejemplo de código comentado línea por línea
4. Identifica lagunas:
❓ ¿Por qué no se libera la memoria?
❓ ¿Cuándo es útil esto en producción?
5. Investiga y reescribe
EJERCICIO 2: Docker vs VM
━━━━━━━━━━━━━━━━━━━━━━━
1. Explica diferencia Docker vs Virtual Machine
2. Usa analogía (apartment building vs houses)
3. Dibuja diagrama
4. Identifica lagunas:
❓ ¿Por qué Docker es más rápido?
❓ ¿Qué es una "image" vs "container"?
5. Llena lagunas y simplifica
EJERCICIO 3: OAuth 2.0
━━━━━━━━━━━━━━━━━━━━━━
1. Explica OAuth como si fuera acceso a un hotel
2. Analogía: Token = llave de hotel temporal
3. Diagrama del flujo
4. Lagunas:
❓ ¿Diferencia entre access token y refresh token?
❓ ¿Por qué es más seguro que dar password?
5. Reescribe con ejemplos concretos
---
TEMPLATE DE NOTAS:
# [Concepto]
## Explicación simple
[Tu explicación con analogías]
## Código ejemplo
[Ejemplo mínimo comentado]
## Por qué importa
[Caso de uso real]
## Lagunas encontradas
❓ Pregunta 1
❓ Pregunta 2
## Respuestas
✅ Respuesta 1 (con fuente)
✅ Respuesta 2 (con fuente)
## Versión final
[Explicación mejorada]
"""
print(examples)
@staticmethod
def print_all():
print("\n" + "🎓 " * 20)
print("TÉCNICA FEYNMAN - APRENDER EXPLICANDO")
print("🎓 " * 20 + "\n")
FeynmanTechnique.step_1_choose_concept()
print("\n" + "-" * 70 + "\n")
FeynmanTechnique.step_2_teach_it()
print("\n" + "-" * 70 + "\n")
FeynmanTechnique.step_3_identify_gaps()
print("\n" + "-" * 70 + "\n")
FeynmanTechnique.step_4_review_and_simplify()
print("\n" + "-" * 70 + "\n")
FeynmanTechnique.practice_examples()
FeynmanTechnique.print_all()Receta 9.2: Spaced Repetition - Retención a Largo Plazo
¿Qué es? Sistema de repaso espaciado que te hace repasar conceptos justo antes de olvidarlos. Basado en la curva del olvido de Ebbinghaus.
La Curva del Olvido:
class SpacedRepetition:
"""Sistema de repetición espaciada para retener conocimiento"""
@staticmethod
def forgetting_curve():
"""Explicar la curva del olvido"""
explanation = """
LA CURVA DEL OLVIDO
===================
Sin repaso:
Retención
100% │●
│ ╲
75% │ ╲
│ ●
50% │ ╲
│ ╲
25% │ ●
│ ╲
0% │ ●────────────►
└────────────────────── Tiempo
Day1 Day2 Day7 Day30
Después de aprender algo:
• Día 1: Recuerdas 100%
• Día 2: Recuerdas ~70% (si no repasas)
• Día 7: Recuerdas ~30%
• Día 30: Recuerdas ~5%
---
Con spaced repetition:
Retención
100% │● ● ● ● ● ● ●
│ ↑ ↑ ↑ ↑
75% │ │ │ │ │
│ │ │ │ │
50% │ │ │ │ │
│ │ │ │ │
25% │ │ │ │ │
│ │ │ │ │
0% │ │ │ │ │
└──────────────────────►
Day Day Day Day Day
1 2 7 15 30
Repaso en intervalos óptimos
Cada repaso "resetea" la curva
Cada vez recuerdas más tiempo
---
Intervalos óptimos (algoritmo SM-2):
1. Primera revisión: 1 día después
2. Segunda revisión: 3 días después
3. Tercera revisión: 7 días después
4. Cuarta revisión: 16 días después
5. Quinta revisión: 35 días después
6. Y así exponencialmente...
Fórmula: Next interval = Previous interval × 2.5
(si respondiste correctamente)
"""
print(explanation)
@staticmethod
def implementation():
"""Cómo implementar spaced repetition"""
guide = """
CÓMO IMPLEMENTAR SPACED REPETITION
===================================
OPCIÓN 1: ANKI (Recomendado)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
App gratuita que automatiza todo
Setup:
1. Descarga Anki (apps.ankiweb.net)
2. Crea un deck: "JavaScript Concepts"
3. Agrega tarjetas (flashcards)
Formato de tarjeta:
FRENTE:
¿Qué es un closure en JavaScript?
ATRÁS:
Una función que tiene acceso a variables de su
función externa, incluso después de que esta retornó.
Ejemplo:
function outer() {
let count = 0;
return function inner() {
return ++count;
}
}
Uso diario:
• Abres Anki
• Te muestra ~20 tarjetas para repasar
• Respondes cada una
• Calificas qué tan fácil fue (Again/Hard/Good/Easy)
• Anki ajusta siguiente revisión automáticamente
---
OPCIÓN 2: NOTION DATABASE
━━━━━━━━━━━━━━━━━━━━━━━━
Para quien prefiere manual
Template de database:
| Concept | Last Review | Next Review | Interval | Confidence |
|---------|-------------|-------------|----------|------------|
| Closures| 2024-02-20 | 2024-02-23 | 3 days | 4/5 |
| Promises| 2024-02-19 | 2024-02-26 | 7 days | 5/5 |
| Async/await| 2024-02-18| 2024-02-21 | 3 days | 3/5 |
Process:
1. Cada mañana: filtrar "Next Review = Today"
2. Repasar esos conceptos (5-10 min)
3. Actualizar "Last Review" a hoy
4. Calcular "Next Review":
• Si Confidence 5/5: +7 días
• Si Confidence 4/5: +3 días
• Si Confidence <3/5: +1 día
---
OPCIÓN 3: PHYSICAL FLASHCARDS
━━━━━━━━━━━━━━━━━━━━━━━━━━━
Old school pero efectivo
Sistema Leitner:
[Box 1] [Box 2] [Box 3] [Box 4] [Box 5]
Daily Day 3 Week 1 Week 2 Month 1
• Tarjeta nueva → Box 1
• Respondes correctamente → mueve a siguiente box
• Respondes incorrectamente → vuelve a Box 1
• Repasas cada box según su frecuencia
Ejemplo:
Day 1: Repaso Box 1 (todas las tarjetas nuevas)
Day 2: Repaso Box 1
Day 3: Repaso Box 1 + Box 2
Day 7: Repaso Box 1 + Box 2 + Box 3
---
OPCIÓN 4: CÓDIGO (Build your own)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Para desarrolladores que quieren automatizar
"""
print(guide)
@staticmethod
def build_your_own():
"""Construir tu propio sistema de SRS"""
code = '''
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import List
import json
@dataclass
class Flashcard:
"""Una tarjeta de estudio"""
question: str
answer: str
last_review: datetime
next_review: datetime
interval_days: int
ease_factor: float # 2.5 = default
review_count: int
def review(self, quality: int):
"""
Revisar la tarjeta
quality: 0-5
0 = No recordé nada
5 = Perfecto, muy fácil
"""
self.review_count += 1
self.last_review = datetime.now()
# Actualizar ease_factor
if quality < 3:
# Difícil, reduce ease
self.ease_factor = max(1.3, self.ease_factor - 0.2)
self.interval_days = 1 # Resetear a 1 día
else:
# Fácil, aumenta ease
self.ease_factor += (0.1 - (5 - quality) * (0.08 + (5 - quality) * 0.02))
# Calcular nuevo intervalo
if self.review_count == 1:
self.interval_days = 1
elif self.review_count == 2:
self.interval_days = 6
else:
self.interval_days = int(self.interval_days * self.ease_factor)
# Calcular próxima revisión
self.next_review = datetime.now() + timedelta(days=self.interval_days)
class SpacedRepetitionSystem:
"""Sistema de repetición espaciada"""
def __init__(self):
self.cards: List[Flashcard] = []
def add_card(self, question: str, answer: str):
"""Agregar nueva tarjeta"""
card = Flashcard(
question=question,
answer=answer,
last_review=datetime.now(),
next_review=datetime.now() + timedelta(days=1),
interval_days=1,
ease_factor=2.5,
review_count=0
)
self.cards.append(card)
print(f"✅ Added: {question[:50]}...")
def get_due_cards(self) -> List[Flashcard]:
"""Obtener tarjetas que toca repasar hoy"""
now = datetime.now()
return [card for card in self.cards if card.next_review <= now]
def study_session(self):
"""Sesión de estudio"""
due_cards = self.get_due_cards()
if not due_cards:
print("🎉 No cards due today! You're all caught up.")
return
print(f"\\n📚 {len(due_cards)} cards to review today\\n")
for i, card in enumerate(due_cards, 1):
print(f"\\n{'='*60}")
print(f"Card {i}/{len(due_cards)}")
print(f"{'='*60}")
print(f"\\nQ: {card.question}\\n")
input("Press Enter to see answer...")
print(f"\\nA: {card.answer}\\n")
print("How well did you remember?")
print("0 = Completely forgot")
print("1 = Hard, barely remembered")
print("2 = Hard, but got it")
print("3 = Good, with some hesitation")
print("4 = Good, no hesitation")
print("5 = Easy, perfect recall")
while True:
try:
quality = int(input("\\nYour rating (0-5): "))
if 0 <= quality <= 5:
break
print("Please enter 0-5")
except ValueError:
print("Please enter a number")
card.review(quality)
print(f"\\n✅ Next review: {card.next_review.strftime('%Y-%m-%d')}")
print(f" Interval: {card.interval_days} days")
def stats(self):
"""Estadísticas del sistema"""
total = len(self.cards)
due = len(self.get_due_cards())
print(f"\\n📊 STATISTICS")
print(f"{'='*40}")
print(f"Total cards: {total}")
print(f"Due today: {due}")
print(f"Up to date: {total - due}")
if total > 0:
avg_interval = sum(c.interval_days for c in self.cards) / total
print(f"\\nAverage interval: {avg_interval:.1f} days")
print(f"\\nUpcoming reviews:")
upcoming = {}
for card in self.cards:
date = card.next_review.date()
upcoming[date] = upcoming.get(date, 0) + 1
for date in sorted(upcoming.keys())[:7]:
count = upcoming[date]
print(f" {date}: {count} cards")
def save_to_file(self, filename: str):
"""Guardar a archivo JSON"""
data = []
for card in self.cards:
data.append({
'question': card.question,
'answer': card.answer,
'last_review': card.last_review.isoformat(),
'next_review': card.next_review.isoformat(),
'interval_days': card.interval_days,
'ease_factor': card.ease_factor,
'review_count': card.review_count
})
with open(filename, 'w') as f:
json.dump(data, f, indent=2)
print(f"💾 Saved {len(self.cards)} cards to {filename}")
def load_from_file(self, filename: str):
"""Cargar desde archivo JSON"""
with open(filename, 'r') as f:
data = json.load(f)
self.cards = []
for item in data:
card = Flashcard(
question=item['question'],
answer=item['answer'],
last_review=datetime.fromisoformat(item['last_review']),
next_review=datetime.fromisoformat(item['next_review']),
interval_days=item['interval_days'],
ease_factor=item['ease_factor'],
review_count=item['review_count']
)
self.cards.append(card)
print(f"📂 Loaded {len(self.cards)} cards from {filename}")
# Ejemplo de uso
if __name__ == "__main__":
srs = SpacedRepetitionSystem()
# Agregar tarjetas
srs.add_card(
"¿Qué es un closure en JavaScript?",
"Una función que tiene acceso a variables de su función externa, "
"incluso después de que esta haya retornado."
)
srs.add_card(
"¿Diferencia entre let y const?",
"let permite reasignar el valor, const no. Ambos tienen block scope."
)
srs.add_card(
"¿Qué es event loop en Node.js?",
"Mecanismo que permite a Node.js realizar operaciones no-bloqueantes "
"delegando operaciones al sistema operativo cuando es posible."
)
# Ver estadísticas
srs.stats()
# Sesión de estudio
srs.study_session()
# Guardar progreso
srs.save_to_file('flashcards.json')
# Próxima vez:
# srs.load_from_file('flashcards.json')
# srs.study_session()
'''
print(code)
@staticmethod
def what_to_memorize():
"""Qué vale la pena memorizar"""
guide = """
QUÉ MEMORIZAR (Y QUÉ NO)
=========================
✅ VALE LA PENA MEMORIZAR:
1. CONCEPTOS FUNDAMENTALES
• Big O notation (O(1), O(n), O(log n), O(n²))
• Data structures (array, linked list, hash table, tree)
• Design patterns (singleton, factory, observer)
• HTTP status codes (200, 404, 500, 401, 403)
2. SINTAXIS COMÚN
• Array methods (.map, .filter, .reduce)
• String methods (.split, .join, .substring)
• Common APIs (fetch, axios)
3. COMANDOS FRECUENTES
• Git commands (commit, push, pull, branch, merge)
• Docker commands (run, build, ps, logs)
• SQL queries (SELECT, JOIN, WHERE, GROUP BY)
4. KEYBOARD SHORTCUTS
• VS Code (Cmd+P, Cmd+Shift+P, Cmd+D)
• Terminal (Ctrl+R, Ctrl+C, Ctrl+Z)
• Chrome DevTools (Cmd+Opt+I, Cmd+Opt+J)
5. PROBLEMAS COMUNES Y SOLUCIONES
• CORS errors → Solución
• Merge conflicts → Cómo resolver
• Memory leaks → Cómo detectar
---
❌ NO VALE LA PENA MEMORIZAR:
1. SINTAXIS ESPECÍFICA
• Parámetros exactos de funciones (usa docs)
• Orden de argumentos (usa IDE autocomplete)
• Nombres exactos de todas las APIs
2. DETALLES OBSCUROS
• Edge cases muy específicos
• Versiones exactas de librerías
• Configuraciones complejas (guárdalas, no memorices)
3. COSAS QUE CAMBIAN RÁPIDO
• Framework-specific APIs (cambian cada versión)
• Herramientas que evolucionan rápido
---
REGLA: Memoriza CONCEPTOS, no DETALLES
✅ Memoriza: "Array.reduce() acumula valores"
❌ No memorices: "Array.reduce(callback, initialValue)
donde callback es (accumulator, currentValue, index, array)"
✅ Memoriza: "Git merge combina branches"
❌ No memorices: "git merge --no-ff --no-commit branch-name"
Cuando necesites detalles → Google/Docs
Los conceptos deben estar en tu cabeza
"""
print(guide)
@staticmethod
def print_all():
print("\n" + "🔄 " * 20)
print("SPACED REPETITION - RETENCIÓN A LARGO PLAZO")
print("🔄 " * 20 + "\n")
SpacedRepetition.forgetting_curve()
print("\n" + "-" * 70 + "\n")
SpacedRepetition.implementation()
print("\n" + "-" * 70 + "\n")
SpacedRepetition.build_your_own()
print("\n" + "-" * 70 + "\n")
SpacedRepetition.what_to_memorize()
SpacedRepetition.print_all()Receta 9.3: Construcción de Proyectos Personales
¿Qué es? Aprender haciendo. Construir proyectos reales (no tutoriales) que te obliguen a resolver problemas de verdad.
Framework para proyectos de aprendizaje:
class PersonalProjectFramework:
"""Cómo elegir y ejecutar proyectos de aprendizaje"""
@staticmethod
def project_selection():
"""Cómo elegir un buen proyecto"""
guide = """
CÓMO ELEGIR UN PROYECTO
=======================
CRITERIOS (todos deben cumplirse):
1. TE INTERESA PERSONALMENTE
━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ "Quiero un dashboard para tracking mis finanzas"
✅ "Quiero automatizar mi lista de tareas"
❌ "Haré un TODO app porque todos lo hacen"
Por qué: Si no te interesa, lo abandonarás al 30%
2. ESTÁ LIGERAMENTE ARRIBA DE TU NIVEL
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ 70% sabes hacer, 30% nuevo
❌ 100% sabes hacer (no aprendes)
❌ 100% nuevo (te frustras)
Sweet spot: Te estira pero no te rompe
3. TIENE SCOPE DEFINIDO
━━━━━━━━━━━━━━━━━━━━━━
✅ "App para trackear hábitos con gráficas"
❌ "Red social como Facebook" (demasiado amplio)
MVP en 2-4 semanas es ideal
4. USA TECNOLOGÍA QUE QUIERES APRENDER
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ Quiero aprender GraphQL → Proyecto usa GraphQL
✅ Quiero aprender Docker → Proyecto requiere containerization
❌ Quiero aprender todo (React + GraphQL + Docker + K8s + ...) ← demasiado
Máximo 1-2 tecnologías nuevas por proyecto
5. PUEDES USARLO EN LA VIDA REAL
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ Lo usarás tú mismo después de terminar
✅ Resuelve un problema que tienes
❌ Es solo para aprender, nunca lo usarás
Por qué: Te motiva mantenerlo y mejorarlo
---
EJEMPLOS DE BUENOS PROYECTOS:
Para aprender Backend:
• Personal API para agregar bookmarks desde cualquier app
• Sistema de notificaciones para monitorear tus servers
• Bot que te avisa de deals en productos que quieres comprar
Para aprender Frontend:
• Dashboard de tus métricas personales (ejercicio, finanzas, etc.)
• Extension de Chrome que mejora tu workflow
• Pomodoro timer con estadísticas
Para aprender DevOps:
• Automatizar deployment de tus side projects
• Monitoring dashboard para tus apps
• CI/CD pipeline para tus repos
Para aprender Data:
• Análisis de tus propios datos (Spotify, Twitter, etc.)
• Dashboard de visualización de datos públicos
• Script que genera reportes automáticos
---
ANTI-PATTERNS:
❌ "Haré un clon de [app famosa]"
Problema: Ya existe, no lo usarás, se siente vacío
❌ "Seguiré este tutorial de 50 horas"
Problema: No es TU proyecto, solo copias-pegas
❌ "Construiré la app perfecta desde el inicio"
Problema: Nunca terminas (scope creep infinito)
❌ "Usaré 10 tecnologías nuevas a la vez"
Problema: Te abrumas, abandonas
✅ MEJOR:
"Haré una versión simple de X que YO usaré,
aprenderé Z en el proceso, estará listo en 3 semanas"
"""
print(guide)
@staticmethod
def project_phases():
"""Fases de un proyecto de aprendizaje"""
phases = """
FASES DEL PROYECTO
==================
FASE 1: PLANNING (1 día)
━━━━━━━━━━━━━━━━━━━━━━━━
□ Define el problema
"Quiero trackear cuántas horas programo por día"
□ Lista features del MVP
• Timer start/stop
• Guardar sessions en DB
• Ver total horas por día/semana
• Gráfica simple
□ Define tecnologías
Frontend: React
Backend: Node.js + Express
Database: PostgreSQL
NEW: GraphQL (esto quiero aprender)
□ Dibuja arquitectura básica
[Sketch simple de componentes]
□ Estima tiempo: 3 semanas
---
FASE 2: SETUP (Día 2-3)
━━━━━━━━━━━━━━━━━━━━━━━
□ Create repo
□ Setup linter/formatter
□ Setup dev environment
□ Hello World funcionando
□ DB connection funcionando
Tip: No pases >1 día en setup
---
FASE 3: BUILD MVP (Semanas 1-2)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Orden recomendado:
Week 1:
□ Backend: Basic CRUD API
□ Database: Schema + migrations
□ Frontend: Basic UI (no styling)
□ Integration: Frontend ↔ Backend
Week 2:
□ Core feature 1: Timer functionality
□ Core feature 2: Data visualization
□ Basic styling (make it usable)
□ Bug fixes
Tip: Commit diario, push a GitHub
---
FASE 4: LEARNING CHALLENGES (Semana 3)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Aquí tackleás lo NUEVO que querías aprender
□ Implement GraphQL (la tech nueva)
□ Struggle, debug, read docs
□ Make it work
□ Document what you learned
Espera frustrarte aquí. Es normal.
---
FASE 5: POLISH & DEPLOY (Días finales)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
□ Fix obvious bugs
□ Add basic error handling
□ Write README
□ Deploy somewhere (Vercel, Heroku, etc.)
□ Use it yourself for 1 week
---
FASE 6: REFLECTION (Post-proyecto)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Escribe un post-mortem:
# Project: Coding Time Tracker
## What I learned
• GraphQL resolver patterns
• React hooks (useState, useEffect)
• PostgreSQL migrations
## Challenges faced
• GraphQL N+1 queries (solved with DataLoader)
• CORS issues (solved with proxy)
• Date handling across timezones (still messy)
## What I'd do differently
• Start with simpler state management
• Write tests from the beginning
• Deploy earlier to catch issues
## Next steps
• Add mobile app
• Add team collaboration
• Better data viz
Esto es ORO para entrevistas
"""
print(phases)
@staticmethod
def avoiding_tutorial_hell():
"""Cómo evitar tutorial hell"""
guide = """
EVITANDO TUTORIAL HELL
======================
TUTORIAL HELL = Hacer 100 tutoriales pero nunca builds nada solo
Síntomas:
• Has hecho 20 cursos de React
• Pero no puedes build una app sin tutorial
• Tienes 50 repos de "curso-X-parte-3"
• Cuando te piden hacer algo, buscas "tutorial de [eso]"
---
ESCAPE PLAN:
REGLA 1: 70/30
━━━━━━━━━━━━━━
• 30% del tiempo: Tutorials
• 70% del tiempo: Building
REGLA 2: NO COPY-PASTE
━━━━━━━━━━━━━━━━━━━━━
• Si sigues tutorial, NO copies código
• Escríbelo tú mismo
• Cambia nombres de variables
• Agrega comments explicando QUÉ hace
REGLA 3: TUTORIAL → PROYECTO
━━━━━━━━━━━━━━━━━━━━━━━━━━
Después de cada tutorial:
1. Haz el tutorial
2. Cierra el tutorial
3. Reconstruye de memoria
4. Agrega UNA feature nueva que NO estaba en tutorial
Ejemplo:
Tutorial: "Build a TODO app"
Tú: Agrega "categorías", "deadlines", "export to CSV"
REGLA 4: APRENDE A DEBUGGEAR
━━━━━━━━━━━━━━━━━━━━━━━━━━
• Cuando algo no funciona, NO busques "tutorial fix"
• Lee el error
• Google el error específico
• Entiende POR QUÉ pasó
REGLA 5: README-DRIVEN LEARNING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
• Antes de empezar proyecto, escribe el README
• Lista features que quieres
• LUEGO empieza a codear
• Si necesitas tutorial, búscalo para feature específica
---
EJEMPLO DE TRANSICIÓN:
❌ TUTORIAL HELL:
"Voy a hacer el curso de Next.js de 40 horas"
[40 horas después]
"Ahora haré el curso de Next.js + TypeScript de 50 horas"
[Nunca builds nada original]
✅ LEARNING BY BUILDING:
"Quiero build un blog personal con Next.js"
Week 1: Busco "Next.js basics tutorial" (3 horas)
Week 2: Build el blog (10 horas, mucho googling)
Week 3: Despliego y escribo primer post
Week 4: Agrego comments (aprendo autenticación)
[Tienes algo real + aprendiste haciendo]
---
PROJECTS > TUTORIALS
1 proyecto propio > 10 tutoriales
"""
print(guide)
@staticmethod
def project_portfolio():
"""Construir portfolio de proyectos"""
guide = """
PORTFOLIO DE PROYECTOS
======================
QUALITY > QUANTITY
❌ MAL PORTFOLIO:
• 50 repos de "tutorial-X"
• Todos incomplete
• README vacíos
• Código sin comentarios
• Deployed: 0
✅ BUEN PORTFOLIO:
• 5-8 proyectos COMPLETOS
• Cada uno resuelve problema real
• README profesionales
• Código limpio
• Deployed y funcionando
• 1-2 son proyectos grandes (1+ mes)
---
TEMPLATE DE README PROFESIONAL:
# Project Name
[Badge: Build Status] [Badge: Live Demo]
## 🎯 What it does
[1 paragraph explaining the problem it solves]
## 🚀 Demo
[Link to live demo]
[Screenshot or GIF]
## ✨ Features
- Feature 1
- Feature 2
- Feature 3
## 🛠️ Tech Stack
- Frontend: React, TypeScript
- Backend: Node.js, Express
- Database: PostgreSQL
- Deployment: Vercel
## 🏃 Run Locally
git clone ...
cd project
npm install
npm run dev
## 📸 Screenshots
[Include 2-3 screenshots]
## 🤔 Challenges
[1-2 paragraphs about interesting problems you solved]
## 🚧 Future Improvements
- [ ] Feature X
- [ ] Feature Y
## 📝 License
MIT
---
PROYECTOS QUE IMPRESIONAN:
1. PROYECTO CON USUARIOS REALES
• "Built X, 500+ users in first month"
• Demuestra: Puedes ship y validar
2. CONTRIBUCIÓN OPEN SOURCE
• "Contributed to [famous project]"
• PR merged: [link]
• Demuestra: Puedes trabajar en codebase grande
3. PROYECTO TÉCNICAMENTE COMPLEJO
• "Real-time multiplayer game with WebSockets"
• "Machine learning model deployed to production"
• Demuestra: Puedes tackle problemas difíciles
4. PROYECTO DE IMPACTO SOCIAL
• "Non-profit website for local charity"
• "Tool that helps [specific community]"
• Demuestra: Usas tech para bien
5. PROYECTO DE SCALE
• "Handles 10K+ requests/second"
• "Processes 1M+ records"
• Demuestra: Entiendes performance
---
DONDE HOSTEAR PORTFOLIO:
• GitHub README (minimalista, profesional)
• Personal website (custom domain)
• Notion page (rápido de setup)
DEBE incluir:
✅ Links a repos
✅ Links a demos live
✅ Screenshots/videos
✅ Descripción de tech stack
✅ Link a tu GitHub/LinkedIn
NO incluyas:
❌ Proyectos de tutoriales
❌ Código de cursos
❌ TODOs apps básicos
❌ Proyectos que no funcionan
"""
print(guide)
@staticmethod
def print_all():
print("\n" + "🔨 " * 20)
print("CONSTRUCCIÓN DE PROYECTOS PERSONALES")
print("🔨 " * 20 + "\n")
PersonalProjectFramework.project_selection()
print("\n" + "-" * 70 + "\n")
PersonalProjectFramework.project_phases()
print("\n" + "-" * 70 + "\n")
PersonalProjectFramework.avoiding_tutorial_hell()
print("\n" + "-" * 70 + "\n")
PersonalProjectFramework.project_portfolio()
PersonalProjectFramework.print_all()Receta 9.4: Lectura de Código Fuente Open Source
¿Qué es? Aprender leyendo código de proyectos exitosos. Es como ver la “cocina” de grandes chefs.
Cómo leer código ajeno:
class CodeReadingFramework:
"""Framework para leer y aprender de código open source"""
@staticmethod
def why_read_code():
"""Por qué leer código es valioso"""
explanation = """
POR QUÉ LEER CÓDIGO DE OTROS
=============================
BENEFICIOS:
1. VER PATRONES REALES
━━━━━━━━━━━━━━━━━━━━
• Libros enseñan teoría
• Código real muestra práctica
• Ves cómo se usa en producción
2. APRENDER MEJORES PRÁCTICAS
━━━━━━━━━━━━━━━━━━━━━━━━━━━
• Estructura de proyectos
• Naming conventions
• Error handling
• Testing strategies
3. ENTENDER HERRAMIENTAS QUE USAS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
• "¿Cómo funciona React internamente?"
• Lee el source code
• Entiendes magia → No más magia
4. PREPARACIÓN PARA CONTRIBUIR
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
• Antes de contribuir a proyecto
• Debes entender su codebase
• Reading es prerequisito
5. ENTREVISTAS
━━━━━━━━━━━━━
• "Explica cómo funciona [librería X]"
• Si leíste el source, puedes responder
---
QUÉ NO ES:
❌ Leer línea por línea todo el repo
❌ Memorizar cada función
❌ Entender TODO de una vez
✅ Buscar patrones
✅ Entender arquitectura high-level
✅ Aprender técnicas específicas
"""
print(explanation)
@staticmethod
def how_to_start():
"""Cómo empezar a leer código"""
guide = """
CÓMO EMPEZAR A LEER CÓDIGO
==========================
PASO 1: ELIGE EL PROYECTO CORRECTO
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Criterios:
✅ Usa lenguaje/framework que conoces
✅ Tamaño mediano (not too big, not too small)
✅ Activamente mantenido
✅ Buena documentación
✅ Te interesa el dominio
Buenos proyectos para empezar:
JavaScript:
• lodash (utils library, ~15K LOC)
• axios (HTTP client, ~3K LOC)
• express (web framework, ~5K LOC)
Python:
• requests (HTTP library, ~10K LOC)
• flask (web framework, ~8K LOC)
• click (CLI framework, ~5K LOC)
Go:
• cobra (CLI framework, ~8K LOC)
• gorilla/mux (router, ~2K LOC)
Evita inicialmente:
❌ React (too big, 100K+ LOC)
❌ Linux kernel (too big, millions LOC)
❌ Proyectos sin docs
---
PASO 2: SETUP LOCAL
━━━━━━━━━━━━━━━━━━
# Clone
git clone https://github.com/axios/axios
cd axios
# Instala deps
npm install
# Corre tests (para ver que funciona)
npm test
# Abre en tu editor
code .
---
PASO 3: ORIENTACIÓN (30 min)
━━━━━━━━━━━━━━━━━━━━━━━━━━━
Lee en este orden:
1. README.md
• Qué hace el proyecto
• Cómo usarlo
2. CONTRIBUTING.md
• Estructura del proyecto
• Convenciones
3. package.json / setup.py
• Dependencias
• Scripts disponibles
4. /docs folder
• Arquitectura overview
5. Estructura de carpetas
/src
/core ← Core functionality
/utils ← Helpers
/adapters ← Platform-specific
/tests
/examples
---
PASO 4: ENCUENTRA EL ENTRY POINT
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
¿Por dónde empieza la ejecución?
• package.json → "main": "index.js"
• setup.py → entry point
• main.go → func main()
Empieza ahí y sigue el flujo
---
PASO 5: USA EL DEBUGGER
━━━━━━━━━━━━━━━━━━━━━━
NO leas pasivamente
EJECUTA y debuggea
// En VS Code:
// 1. Pon breakpoint en línea interesante
// 2. F5 (Start debugging)
// 3. Step through (F10)
// 4. Inspecciona variables
Esto es 10x más efectivo que solo leer
---
PASO 6: TOMA NOTAS
━━━━━━━━━━━━━━━━━
Crea un archivo NOTES.md:
# Reading axios source code
## Architecture
- Core is in /lib/core
- Adapters for Node vs Browser in /lib/adapters
- Uses interceptors pattern (like middleware)
## Interesting patterns
- Promise chaining for requests
- Adapter pattern for platform compatibility
- Config merging with defaults
## Questions
- ❓ How does request cancellation work?
- ❓ Why use transform functions?
## Learnings
- ✅ Learned about interceptor pattern
- ✅ Saw how to handle browser vs Node
"""
print(guide)
@staticmethod
def reading_strategies():
"""Estrategias de lectura"""
strategies = """
ESTRATEGIAS DE LECTURA
======================
ESTRATEGIA 1: FEATURE-DRIVEN READING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
NO leas todo el repo
ELIGE una feature específica
Ejemplo: axios
Feature: "¿Cómo funciona request cancellation?"
1. Busca en docs sobre cancellation
2. Encuentra código ejemplo
3. Pon breakpoint en el ejemplo
4. Sigue el flujo step by step
5. Lee solo archivos relacionados
Así en 2 horas entiendes UNA feature bien
vs 20 horas leyendo TODO y entendiendo nada
---
ESTRATEGIA 2: BUG-DRIVEN READING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Encuentra un bug en Issues
2. Trata de reproducirlo localmente
3. Lee código para entender por qué pasa
4. Intenta fixearlo
5. Compara con el fix oficial
Aprendes:
• Cómo debuggear en codebase grande
• Patrones del proyecto
• Testing strategy
---
ESTRATEGIA 3: TEST-DRIVEN READING
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Los tests son DOCUMENTACIÓN ejecutable
1. Ve a /tests
2. Lee test file por feature
3. Entiende qué se espera
4. Lee implementación
5. Vuelve al test
Ejemplo:
// test/core/Axios.spec.js
it('should make GET request', () => {
axios.get('/user') // ← Start here
})
Sigue axios.get() → lee implementación → vuelve
---
ESTRATEGIA 4: COMPARE AND CONTRAST
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Lee 2 librerías similares, compara
Ejemplo: axios vs fetch API
| Feature | axios | fetch |
|---------|-------|-------|
| Syntax | axios.get() | fetch().then() |
| JSON parsing | Automático | Manual |
| Errors | Reject on 4xx/5xx | Solo network errors |
Preguntas:
• ¿Por qué axios auto-parse JSON?
• ¿Cómo lo implementa?
• ¿Podría fetch hacer lo mismo?
---
ESTRATEGIA 5: REFACTORING EXERCISE
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Elige una función
2. Pregúntate: "¿Cómo la refactorizaría?"
3. Intenta refactorizar
4. Corre tests (¿siguen pasando?)
5. Compara con original
Aprendes:
• Por qué está escrito así
• Trade-offs que consideraron
• Edge cases
---
ESTRATEGIA 6: RUBBER DUCK TO YOURSELF
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Explícate el código a ti mismo:
"OK, entonces cuando llamo axios.get()...
1. Primero crea un config object
2. Luego mergea con defaults
3. Luego elige adapter (Node o Browser)
4. Luego ejecuta interceptors...
❓ Wait, ¿por qué interceptors ANTES del request?
[Investiga]
✅ Ah, para modificar config antes de enviar"
Hablar en voz alta ayuda
"""
print(strategies)
@staticmethod
def projects_to_read():
"""Proyectos recomendados para leer"""
recommendations = """
PROYECTOS RECOMENDADOS
======================
NIVEL BEGINNER (< 5K LOC)
━━━━━━━━━━━━━━━━━━━━━━━━━
JavaScript:
• is-promise (30 LOC) - Aprende: Type checking
• chalk (500 LOC) - Aprende: Terminal colors
• ms (200 LOC) - Aprende: Time parsing
Python:
• howdoi (1K LOC) - Aprende: CLI tools
• httpie (3K LOC) - Aprende: HTTP clients
• pendulum (4K LOC) - Aprende: Date handling
---
NIVEL INTERMEDIATE (5K-15K LOC)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
JavaScript:
• lodash (15K LOC) - Aprende: Functional programming
• express (5K LOC) - Aprende: Middleware pattern
• commander.js (3K LOC) - Aprende: CLI frameworks
Python:
• requests (10K LOC) - Aprende: HTTP libraries
• click (5K LOC) - Aprende: Decorators
• pytest (12K LOC) - Aprende: Testing frameworks
Go:
• cobra (8K LOC) - Aprende: CLI apps
• viper (4K LOC) - Aprende: Config management
---
NIVEL ADVANCED (15K+ LOC)
━━━━━━━━━━━━━━━━━━━━━━━━
Solo cuando ya hayas leído 5+ proyectos pequeños
• React (100K+ LOC) - Aprende: Virtual DOM, Fiber
• Vue (30K LOC) - Aprende: Reactivity system
• Django (100K+ LOC) - Aprende: Framework architecture
• Kubernetes (1M+ LOC) - Aprende: Distributed systems
---
PROYECTOS POR TEMA:
Aprende TESTING:
• Jest (source code)
• pytest
Aprende ASYNC:
• async.js
• asyncio (Python)
Aprende ARCHITECTURE:
• express (middleware)
• Redux (state management)
Aprende PERFORMANCE:
• V8 engine (parcialmente)
• NumPy
---
CÓMO ENCONTRAR PROYECTOS:
1. GitHub Trending
2. "Awesome [language]" lists
3. Librerías que usas daily
4. Proyectos con "good first issue" labels
"""
print(recommendations)
@staticmethod
def contributing():
"""De leer a contribuir"""
guide = """
DE LEER A CONTRIBUIR
====================
ESCALERA DE CONTRIBUCIÓN:
Nivel 1: FIX TYPOS
━━━━━━━━━━━━━━━━━
• Typos en docs
• Broken links
• Mejoras en README
Por qué empezar aquí:
• Bajo riesgo
• Aprendes el flow de PR
• Conoces maintainers
---
Nivel 2: ADD TESTS
━━━━━━━━━━━━━━━━━
• Encuentra código sin tests
• Escribe tests
• Aumenta coverage
Por qué:
• Aprendes el código
• Bajo riesgo de romper cosas
• Siempre necesario
---
Nivel 3: FIX "GOOD FIRST ISSUE"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
• Busca label "good first issue"
• Bugs pequeños
• Features simples
Process:
1. Comenta: "I'd like to work on this"
2. Espera OK de maintainer
3. Fork → Branch → Fix → PR
---
Nivel 4: MAJOR FEATURES
━━━━━━━━━━━━━━━━━━━━━━
• Features grandes
• Refactors
• Performance improvements
IMPORTANTE:
✅ Crea issue PRIMERO
✅ Discute approach
✅ Get approval
❌ No codes 3 semanas y luego PR
---
PR CHECKLIST:
Antes de submit:
□ Tests pass locally
□ Follows code style
□ Added tests for new code
□ Updated docs
□ Commits have clear messages
□ PR description explains WHY
□ Linked to issue number
Después de submit:
□ Respond to feedback quickly
□ Make requested changes
□ Don't take criticism personally
□ Thank reviewers
---
ETIQUETA DE OPEN SOURCE:
✅ DO:
• Be patient (maintainers are volunteers)
• Be respectful
• Follow contribution guidelines
• Test your changes thoroughly
• Provide context in PR
❌ DON'T:
• Demand fast review
• Get defensive about feedback
• Submit huge PRs without discussion
• Change unrelated code
• Ping maintainers repeatedly
---
TU PRIMER PR:
1. Busca proyecto que uses
2. Lee CONTRIBUTING.md
3. Busca "good first issue"
4. Comenta que lo harás
5. Fork y clone
6. Crea branch: git checkout -b fix-issue-123
7. Haz el cambio
8. Testea locally
9. Commit con mensaje claro
10. Push y crea PR
11. Espera review
12. Itera según feedback
13. 🎉 MERGED!
Tu primera PR merged es un milestone importante
"""
print(guide)
@staticmethod
def print_all():
print("\n" + "📖 " * 20)
print("LECTURA DE CÓDIGO OPEN SOURCE")
print("📖 " * 20 + "\n")
CodeReadingFramework.why_read_code()
print("\n" + "-" * 70 + "\n")
CodeReadingFramework.how_to_start()
print("\n" + "-" * 70 + "\n")
CodeReadingFramework.reading_strategies()
print("\n" + "-" * 70 + "\n")
CodeReadingFramework.projects_to_read()
print("\n" + "-" * 70 + "\n")
CodeReadingFramework.contributing()
CodeReadingFramework.print_all()Receta 9.5: Networking y Comunidades Técnicas
¿Qué es? Conectar con otros desarrolladores para aprender, compartir conocimiento y crecer profesionalmente.
Por qué networking importa:
class DeveloperNetworking:
"""Framework para networking técnico efectivo"""
@staticmethod
def why_networking():
"""Por qué networking es importante"""
explanation = """
POR QUÉ NETWORKING IMPORTA
==========================
BENEFICIOS TANGIBLES:
1. OPORTUNIDADES DE TRABAJO
━━━━━━━━━━━━━━━━━━━━━━━
• 70% de jobs se llenan por referidos
• Tu network = tu net worth
• Alguien te refiere → Skip initial screening
2. APRENDIZAJE ACELERADO
━━━━━━━━━━━━━━━━━━━━━━
• "¿Cómo resolviste X?"
• Aprendes de experiencias ajenas
• Evitas errores que otros ya cometieron
3. ACCOUNTABILITY
━━━━━━━━━━━━━━━
• Compartes goals públicamente
• Peer pressure positiva
• "Build in public"
4. MOTIVACIÓN
━━━━━━━━━━━━
• Ver a otros aprender te motiva
• No estás solo en el journey
• Celebran tus wins
5. VALIDACIÓN DE IDEAS
━━━━━━━━━━━━━━━━━━━━━
• "Estoy pensando en X"
• Community da feedback
• Evitas meses en mala dirección
---
LO QUE NO ES NETWORKING:
❌ Pedir favores a desconocidos
❌ Spam en LinkedIn
❌ Coleccionar contactos sin relación real
❌ Solo contactar cuando necesitas algo
✅ Networking real:
• Dar valor primero
• Construir relaciones genuinas
• Ayudar sin esperar retorno inmediato
• Mantener contacto long-term
"""
print(explanation)
@staticmethod
def online_communities():
"""Dónde encontrar comunidades online"""
guide = """
COMUNIDADES ONLINE
==================
TWITTER / X
━━━━━━━━━━━
Por qué es valioso:
• Desarrolladores comparten learnings daily
• Discusiones técnicas en tiempo real
• Descubres nuevas tech rápido
Cómo usarlo:
1. Sigue a devs que admiras
2. Responde con insights útiles (no spam)
3. Comparte lo que aprendes (#100DaysOfCode)
4. Haz preguntas técnicas
Gente a seguir:
• Kent C. Dodds (@kentcdodds) - React
• Dan Abramov (@dan_abramov) - React core
• Sarah Drasner (@sarah_edo) - Performance
• Guillermo Rauch (@rauchg) - Vercel
• [Busca en tu nicho específico]
---
DISCORD SERVERS
━━━━━━━━━━━━━━━
Más íntimo que Twitter, menos formal
Servers populares:
• The Coding Den (general)
• Reactiflux (React)
• Python Discord
• [Tu framework favorito probablemente tiene uno]
Cómo participar:
✅ Lee #rules primero
✅ Búsqueda antes de preguntar (avoid duplicates)
✅ Da contexto en tus preguntas
✅ Agradece las respuestas
✅ Ayuda a otros cuando puedas
❌ No hagas:
• Preguntar "alguien sabe X?" (just ask)
• "No funciona" sin código
• DM a gente random
• Ping @everyone
---
REDDIT
━━━━━━━
Subreddits útiles:
• r/learnprogramming (beginners)
• r/webdev
• r/reactjs
• r/python
• r/cscareerquestions (career advice)
• r/ExperiencedDevs (senior topics)
Tips:
• Search first (tu pregunta probablemente ya existe)
• Sigue las reglas del sub
• Provide MCVE (Minimal Complete Verifiable Example)
---
DEV.TO / HASHNODE
━━━━━━━━━━━━━━━━
Plataformas para escribir technical blogs
Por qué escribir:
• Solidifica tu aprendizaje (Feynman technique)
• Builds tu brand
• Ayuda a otros
• Portfolio de conocimiento
Qué escribir:
✅ Tutoriales step-by-step
✅ "TIL" (Today I Learned)
✅ Problemas que resolviste
✅ Comparaciones (X vs Y)
❌ Evita:
• Copiar contenido existente
• Posts sin sustancia
• Clickbait
---
GITHUB
━━━━━━
No solo para código
Networking opportunities:
• Contribuir a open source
• Issues & discussions
• Sponsors (support creators)
• Follow developers you admire
Tu GitHub ES tu portfolio
---
SLACK COMMUNITIES
━━━━━━━━━━━━━━━━
Más profesional que Discord
Communities:
• Rands Leadership Slack (senior devs)
• TechMasters
• Indie Hackers
• [Industry-specific groups]
---
STACK OVERFLOW
━━━━━━━━━━━━━━━
No solo para preguntar
También:
• Responde preguntas (builds reputation)
• Aprende de otras respuestas
• Ve problemas comunes
Cómo hacer buenas preguntas:
1. Busca primero (80% ya está respondido)
2. MCVE (minimal reproducible example)
3. Muestra lo que intentaste
4. Código formateado
5. Error messages completos
---
LINKEDIN
━━━━━━━━
Profesional, menos técnico
Uso estratégico:
• Connect con gente que conoces
• Escribe posts ocasionales
• Comparte wins y learnings
• Participa en comments
❌ NO:
• Auto-promoción constante
• "Agree?" posts
• Copy-paste motivational quotes
✅ SÍ:
• Comparte projects
• Learnings concretos
• Ayuda en comments
"""
print(guide)
@staticmethod
def offline_communities():
"""Networking offline (presencial)"""
guide = """
NETWORKING OFFLINE
==================
MEETUPS
━━━━━━━
Encuentra en: meetup.com, eventbrite, luma
Tipos:
• Tech talks (1-2 speakers)
• Workshops (hands-on)
• Networking socials
• Hackathons
Cómo aprovechar meetups:
ANTES:
□ RSVP temprano
□ Lee sobre speakers/tema
□ Prepara 1-2 preguntas
DURANTE:
□ Llega temprano (easier to socialize)
□ Habla con 3+ personas nuevas
□ Toma notas del talk
□ Haz preguntas inteligentes
□ Ofrece ayuda si puedes
DESPUÉS:
□ Connect en LinkedIn/Twitter
□ Mensaje de follow-up (si hubo conversación interesante)
□ Implementa algo que aprendiste
---
CONFERENCIAS
━━━━━━━━━━━━
Caras pero valiosas
Cómo maximizar ROI:
1. PLANIFICA
• Revisa schedule antes
• Marca talks de interés
• Researcha speakers
2. NETWORKING > TALKS
• Talks se graban (verás después)
• Conversations no se repiten
• Hallway track = más valioso
3. INICIA CONVERSACIONES
• "¿Qué talk te gustó más?"
• "¿En qué trabajas?"
• "¿Qué tech estás aprendiendo?"
4. EXCHANGE CONTACTS
• Twitter handles
• LinkedIn
• Business cards (old school but works)
5. FOLLOW UP
• Mensaje en 48 horas
• Reference algo específico de la conversación
• Mantén contacto
---
HACKATHONS
━━━━━━━━━━━
Build + Network al mismo tiempo
Estrategia:
• Forma equipo con gente nueva
• No te obsesiones con ganar
• Focus en aprender + network
• Ayuda a otros equipos
Post-hackathon:
• Stay in touch con teammates
• Ship el proyecto (no lo abandones)
• Comparte learnings
---
COWORKING SPACES
━━━━━━━━━━━━━━━━
Para remote workers
Beneficios:
• Otros devs around
• Informal networking
• Menos lonely que home
---
LOCAL USER GROUPS
━━━━━━━━━━━━━━━━━
JavaScript User Group
Python User Group
Ruby Brigade
etc.
Más íntimo que conferences
Mismo grupo cada mes = builds relationships
---
CONVERSATION STARTERS:
En tech events:
✅ "What brings you here?"
✅ "What are you working on?"
✅ "What tech are you excited about?"
✅ "Any recommendations for [X]?"
❌ Evita:
• "Can you help me get a job at your company?"
• Monologues sobre tu proyecto
• Only talking about yourself
• Selling immediately
"""
print(guide)
@staticmethod
def giving_value():
"""Cómo dar valor a la comunidad"""
guide = """
DAR VALOR A LA COMUNIDAD
========================
"How to Win Friends" by Dale Carnegie:
"You can make more friends in two months by becoming
interested in other people than you can in two years
by trying to get other people interested in you."
WAYS TO GIVE VALUE:
1. ANSWER QUESTIONS
━━━━━━━━━━━━━━━━━━
• Stack Overflow
• Discord/Slack
• Twitter
Incluso si eres junior:
• Alguien sabe menos que tú
• Tu "obvious" answer no es obvious para todos
---
2. WRITE TUTORIALS
━━━━━━━━━━━━━━━━━
• Blog posts
• Documentation
• README improvements
"Best way to learn is to teach"
---
3. OPEN SOURCE CONTRIBUTIONS
━━━━━━━━━━━━━━━━━━━━━━━━━━━
• Fix bugs
• Add features
• Improve docs
• Triage issues
---
4. SHARE LEARNINGS
━━━━━━━━━━━━━━━━━
• "TIL: You can do X in JavaScript"
• "Just discovered Y, game changer"
• Weekly learnings thread
---
5. CREATE RESOURCES
━━━━━━━━━━━━━━━━━━
• Cheat sheets
• Curated lists
• Templates
• Tools
---
6. MENTOR OTHERS
━━━━━━━━━━━━━━━
• 1-on-1 calls
• Code reviews
• Career advice
---
7. ORGANIZE EVENTS
━━━━━━━━━━━━━━━━━
• Local meetup
• Study group
• Hackathon
---
8. CURATE CONTENT
━━━━━━━━━━━━━━━━
• Newsletter
• Twitter thread of best articles
• Weekly roundup
---
9. BUILD IN PUBLIC
━━━━━━━━━━━━━━━━━
• Share progress daily
• Explain decisions
• Document learnings
Benefits:
• Helps others
• Creates accountability
• Builds audience
---
10. GIVE FEEDBACK
━━━━━━━━━━━━━━━━
• Review PRs
• Test beta products
• Provide constructive criticism
---
RULE: Give 10x more than you ask
Before asking for help:
• Have you helped 10 people?
• Have you answered 10 questions?
• Have you contributed 10 times?
Build karma first
"""
print(guide)
@staticmethod
def maintaining_relationships():
"""Mantener relaciones a largo plazo"""
guide = """
MANTENER RELACIONES
===================
Networking ≠ Collecting contacts
Networking = Building relationships
STRATEGIES:
1. CRM FOR RELATIONSHIPS
━━━━━━━━━━━━━━━━━━━━━━
Usa Notion/Spreadsheet:
| Name | Met At | Last Contact | Notes | Next Action |
|------|--------|--------------|-------|-------------|
| Alice | React Conf | 2024-01-15 | Works at Stripe | Check in Q2 |
| Bob | Twitter | 2024-02-01 | Building X | Reply to thread |
---
2. REGULAR CHECK-INS
━━━━━━━━━━━━━━━━━━━
Set reminders:
• Monthly: Close connections
• Quarterly: Medium connections
• Yearly: Loose connections
Message examples:
"Hey! Saw you launched X, congrats!"
"Thought of you when I read this article [link]"
"How's [project they mentioned] going?"
---
3. SHARE WINS
━━━━━━━━━━━━
When you succeed:
• Thank people who helped
• Share publicly
• Give credit
---
4. CELEBRATE OTHERS
━━━━━━━━━━━━━━━━━━
When they succeed:
• Congratulate genuinely
• Share their work
• Introduce them to others
---
5. PROVIDE VALUE CONTINUOUSLY
━━━━━━━━━━━━━━━━━━━━━━━━━━━
Don't only contact when you need something
✅ Regular touchpoints:
• Share relevant article
• Introduce to useful contact
• Answer their question
• Invite to event
❌ Only contact to ask favor
---
6. ORGANIZE VIRTUAL HANGOUTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━
• Coffee chats (30 min)
• Study sessions
• Code reviews
• Mastermind groups
---
7. IN-PERSON WHEN POSSIBLE
━━━━━━━━━━━━━━━━━━━━━━━━━
Online is scalable
But in-person builds deeper bonds
When traveling:
"Hey, I'll be in SF next week, coffee?"
---
SAMPLE CADENCE:
New connection:
Day 1: Meet at event
Day 2: Connect on LinkedIn/Twitter
Day 3: Send follow-up message
Week 2: Share something relevant
Month 1: Check in
Month 3: Another touchpoint
Month 6: Schedule call
Then: Maintain quarterly
---
QUALITY > QUANTITY
Better:
• 10 real relationships
• Regular contact
• Mutual value exchange
Than:
• 1000 LinkedIn connections
• Never talk
• No real relationship
"""
print(guide)
@staticmethod
def print_all():
print("\n" + "🤝 " * 20)
print("NETWORKING Y COMUNIDADES TÉCNICAS")
print("🤝 " * 20 + "\n")
DeveloperNetworking.why_networking()
print("\n" + "-" * 70 + "\n")
DeveloperNetworking.online_communities()
print("\n" + "-" * 70 + "\n")
DeveloperNetworking.offline_communities()
print("\n" + "-" * 70 + "\n")
DeveloperNetworking.giving_value()
print("\n" + "-" * 70 + "\n")
DeveloperNetworking.maintaining_relationships()
DeveloperNetworking.print_all()