# Ruta de empleabilidad con SiPi (12 proyectos, ~1 año)

Este documento no promete magia: nadie te contrata por "saber SiPi", te
contratan por poder resolver problemas reales, trabajar con datos,
bases de datos, APIs, seguridad basica y trabajo en equipo (tests,
control de versiones). SiPi te deja practicar TODO eso en español,
desde el primer día, sin pelearte con la sintaxis -- y lo que
aprendés se transfiere directo, porque:

- Los conceptos (variables, funciones, POO, SQL, APIs REST, hilos,
  seguridad) son los mismos en cualquier lenguaje. Cambia la sintaxis,
  no la idea.
- `compilar_a_python` transpila un programa SiPi entero a un `.py`
  real y legible -- podés literalmente mostrarle a un reclutador "esto
  lo escribi en SiPi, y esto es el Python equivalente que genera".
- `compilar_a_js` hace lo mismo para funciones puntuales que corran en
  el navegador.
- El motor mismo (`src/sipi.py`) esta escrito en Python y es codigo
  real de mas de 9000 lineas -- leerlo (o el codigo de cualquiera de
  sus herramientas en `herramientas/`) ya es leer Python de produccion.

La propuesta concreta: 12 proyectos, uno por mes, cada uno agregando
una habilidad nueva y con una entrega verificable (no solo "lo hice").
Al terminar el año corrés `herramientas/generar_portfolio.py` sobre tu
carpeta de proyectos y tenés un portfolio verificado para mandar.

## Como se verifica cada proyecto

Al final de cada mes:
1. `python3 src/sipi.py --revisar tu_proyecto.sipi` -- 0 hallazgos de
   seguridad antes de dar por terminado el mes.
2. Corré el programa de punta a punta vos mismo, sin errores.
3. Guardalo en su propia carpeta bajo tu carpeta de portfolio.
4. (Opcional pero recomendado) `compilar_a_python` el proyecto una vez
   y guardá el `.py` generado al lado -- doble prueba de que el codigo
   funciona y de que entendés lo que hace por dentro.

## Los 12 proyectos

| Mes | Proyecto | Habilidad nueva | Palabra clave para el CV |
|---|---|---|---|
| 1 | Calculadora de gastos por consola | variables, funciones, condicionales, bucles | Logica de programacion |
| 2 | Agenda de contactos con archivo CSV | lectura/escritura de archivos, listas, `intentar/capturar` | Manejo de errores, I/O |
| 3 | Sistema de inventario con `clase`/`hereda_de` | POO real | Programacion orientada a objetos |
| 4 | Libreta de notas con SQLite (`sqlite_*`) | modelar datos, CRUD real | Bases de datos, SQL |
| 5 | La misma libreta, pero con `*_parametrizado` en TODAS las consultas | SQL seguro | Seguridad, prevencion de inyeccion SQL |
| 6 | API REST de tareas (`iniciar_api_web`, `escuchar_ruta`, `responder_json`) | backend HTTP real | Desarrollo de APIs, REST |
| 7 | La misma API + `requerir_autenticacion`, `hash_seguro_contrasena`, `limitar_peticiones` | seguridad de backend | Autenticacion, hashing, rate limiting |
| 8 | Dashboard web de esa API con `pagina_web`/`formulario` | frontend basico conectado a un backend real | Frontend, integracion full-stack |
| 9 | Version con `postgres_conectar`/`mysql_conectar` en vez de SQLite | portar entre motores de base de datos | PostgreSQL, MySQL |
| 10 | Bot o scraper con `hilo_crear`/`peticion_http` corriendo en paralelo | concurrencia real | Multithreading, integracion con APIs externas |
| 11 | Suite de tests con `iniciar_pruebas`/`afirmar` para los proyectos 6-10 | testing | Testing automatizado |
| 12 | Empaquetado: `generar_dockerfile` de la API + `compilar_a_python` de dos proyectos anteriores | despliegue | Docker, deployment |

No hace falta hacerlos en este orden exacto ni uno por mes clavado --
la tabla es una guia de progresion (de logica pura a un sistema con
base de datos, API, seguridad, concurrencia, tests y despliegue), no
un cronograma rigido. Lo que importa es terminar con los 12 y que
`generar_portfolio.py` los pueda verificar a todos.

## Que mostrarle a un reclutador al terminar

1. El `portfolio.html` generado por `herramientas/generar_portfolio.py`
   -- proyectos reales, ejecutados de verdad, con hallazgos de
   seguridad en 0 (no una lista de "tecnologias" sin pruebas).
2. Un `.py` transpilado de al menos un proyecto (con `compilar_a_python`)
   como evidencia de que el conocimiento se traduce fuera de SiPi.
3. El repo con los 12 proyectos, cada uno en su carpeta, con su propio
   `README` corto (una tabla asi: que hace, que comandos nuevos usa,
   que aprendiste).

## Lo que esto NO reemplaza

- Ningun lenguaje de moda (Python, JS, Go, Java) especifico que pida
  una oferta puntual -- si el aviso pide "2 años de Python", mostrar
  proyectos SiPi + su version transpilada ayuda a demostrar que
  entendés los conceptos, pero segui practicando en el lenguaje que
  pide el puesto.
- Estructuras de datos y algoritmos a nivel de entrevista tecnica
  (arboles, grafos, complejidad) -- eso se estudia aparte, en
  cualquier lenguaje.
- Trabajo en equipo real con Git/control de versiones colaborativo --
  practicalo con estos mismos 12 proyectos, subiendolos a un repo y
  usando ramas/PRs aunque trabajes solo.
