{
  "curso": {
    "slug": "consola-de-linux",
    "titulo": "La consola de Linux, de cero a soltura",
    "resumen": "Moverse, buscar, editar y encadenar comandos sin miedo a romper nada.",
    "descripcion": "Un curso para quien abre una terminal y no sabe por dónde empezar, o para quien lleva años copiando comandos de internet sin entender qué hacen.\n\nSe trabaja siempre sobre archivos de práctica, nunca sobre el sistema: nada de lo que se hace acá puede dejar un equipo inservible. Al terminar vas a poder moverte por un servidor, leer un log, encontrar el archivo que buscas y encadenar tres comandos para responder una pregunta concreta.",
    "objetivos": "Moverte por el sistema de archivos sin perderte y saber siempre dónde estás\nLeer, filtrar y contar dentro de archivos de texto grandes\nEncadenar comandos con tuberías para responder una pregunta en una línea\nEntender los permisos de un archivo y arreglarlos cuando fallan\nEditar un archivo en el servidor sin salir de la terminal",
    "nivel": "inicial",
    "duracion_horas": 10,
    "tutor_prompt": "Ayudas a alguien que está aprendiendo la terminal de Linux y le da miedo romper algo. Responde con el comando exacto y explica qué hace cada parte. Si un comando es peligroso —rm, chmod recursivo, redirecciones que sobrescriben— dilo antes de darlo y ofrece la versión segura. No supones que la persona sabe qué es una ruta absoluta o una variable de entorno: si aparece, lo explicas."
  },
  "unidades": [
    {
      "titulo": "Dónde estoy y qué hay aquí",
      "descripcion": "Lo mínimo para no perderse: moverse, mirar y volver.",
      "actividades": [
        {
          "tipo": "lectura",
          "titulo": "Qué es la consola y por qué sigue existiendo",
          "cuerpo": "Una consola es un programa que espera que escribas el nombre de otro programa. Nada más. Cuando escribes «ls» y pulsas Enter, la consola busca un programa llamado ls, lo ejecuta y te muestra lo que imprimió.\n\nSigue existiendo por tres razones muy concretas:\n\n1. Es lo único que hay. En un servidor no existe el escritorio: te conectas por SSH y lo que aparece es esto.\n\n2. Se puede repetir. Un clic no se puede guardar en un archivo; un comando sí. Todo lo que aprendas acá se convierte en una línea que mañana ejecutas igual, o que un script ejecuta por ti a las tres de la mañana.\n\n3. Se puede encadenar. Cada programa hace una cosa y escupe texto. Ese texto puede entrar en el siguiente programa. Eso es lo que en la unidad 3 te va a permitir contestar «cuántos errores distintos hubo hoy» en una sola línea.\n\nEl prompt\n\nLo que ves antes del cursor se llama «prompt» y suele decir quién eres, en qué máquina estás y en qué carpeta:\n\n    diego@servidor:~/proyectos$\n\nEse «~» significa tu carpeta personal, normalmente /home/diego. El «$» del final indica que eres un usuario normal; si fuera «#» estarías como root, que es el usuario que sí puede romper el sistema.\n\nLa regla de oro de este curso: nunca vas a necesitar «#» para nada de lo que hagamos."
        },
        {
          "tipo": "lectura",
          "titulo": "Moverse: pwd, ls y cd",
          "cuerpo": "Tres comandos y ya no te pierdes.\n\npwd — «print working directory»\n\nDice dónde estás. Es la respuesta a «¿y ahora dónde estoy?», que es la pregunta que más vas a hacerte la primera semana.\n\n    $ pwd\n    /home/diego/proyectos\n\nls — listar\n\nMuestra lo que hay en la carpeta actual.\n\n    $ ls              # los nombres, en columnas\n    $ ls -l           # una línea por archivo, con permisos, dueño, tamaño y fecha\n    $ ls -la          # además los ocultos, los que empiezan por punto\n    $ ls -lh          # tamaños legibles: 4,2K en vez de 4300\n\nEsas letras después del guion se llaman «opciones» o «banderas», y se pueden juntar: «ls -lha» es lo mismo que «ls -l -h -a».\n\ncd — cambiar de carpeta\n\n    $ cd proyectos    # entra en «proyectos», que tiene que estar aquí\n    $ cd ..           # sube un nivel\n    $ cd ~            # a tu carpeta personal, estés donde estés\n    $ cd -            # a la carpeta anterior, como el botón «atrás»\n    $ cd /var/log     # a una ruta absoluta, desde la raíz\n\nRutas relativas y absolutas\n\nSi empieza por «/» es absoluta: se lee desde la raíz del sistema y significa lo mismo estés donde estés. Si no empieza por «/» es relativa: se lee desde donde estás ahora.\n\n    /var/log/syslog     ← siempre el mismo archivo\n    log/syslog          ← depende de dónde estés parado\n\nDos teclas que valen el curso entero\n\nTab completa nombres. Escribe «cd pro» y pulsa Tab: si solo hay una carpeta que empiece así, la completa. Si hay varias, pulsa Tab dos veces y te las lista. Usar Tab no es solo comodidad: evita el 90 % de los errores por escribir mal un nombre.\n\nLa flecha arriba trae el comando anterior. Y el anterior a ese. Casi nunca hace falta reescribir nada."
        },
        {
          "tipo": "lectura",
          "titulo": "Mirar sin abrir: cat, less, head y tail",
          "cuerpo": "Los archivos de un servidor suelen ser de texto, y muchos son enormes. Abrirlos enteros no siempre es buena idea.\n\ncat — vuelca el archivo entero en pantalla\n\n    $ cat notas.txt\n\nSirve para archivos cortos. Con un log de 200 000 líneas te va a llenar la pantalla durante un minuto.\n\nless — leer con calma\n\n    $ less /var/log/syslog\n\nAbre el archivo y te deja moverte: flechas para subir y bajar, Espacio para avanzar una pantalla, «/palabra» para buscar, «n» para la siguiente coincidencia, «q» para salir.\n\nSi alguna vez te queda una pantalla que no responde y no sabes cómo salir: prueba «q». Y si no, Ctrl+C.\n\nhead y tail — el principio y el final\n\n    $ head archivo.txt        # las 10 primeras líneas\n    $ head -n 3 archivo.txt   # las 3 primeras\n    $ tail archivo.txt        # las 10 últimas\n    $ tail -n 50 archivo.txt  # las 50 últimas\n\ntail -f — el que vas a usar de verdad\n\n    $ tail -f /var/log/nginx/error.log\n\nSe queda abierto mostrando las líneas nuevas según aparecen. Es lo que se deja en una ventana mientras se prueba algo en otra: reproduces el error y lo ves salir en el momento. Se corta con Ctrl+C.\n\nwc — contar\n\n    $ wc -l archivo.txt    # cuántas líneas\n    $ wc -w archivo.txt    # cuántas palabras\n\nParece poca cosa, pero «cuántas líneas» es la mitad de las preguntas que se le hacen a un log."
        }
      ]
    },
    {
      "titulo": "Archivos: crear, copiar, mover y borrar",
      "descripcion": "Trabajar con archivos de verdad, incluido lo que no tiene vuelta atrás.",
      "actividades": [
        {
          "tipo": "lectura",
          "titulo": "Crear, copiar, mover y borrar",
          "cuerpo": "mkdir — crear carpetas\n\n    $ mkdir practica\n    $ mkdir -p practica/2026/enero    # crea toda la cadena de una vez\n\ntouch — crear un archivo vacío\n\n    $ touch notas.txt\n\ncp — copiar\n\n    $ cp notas.txt notas.bak          # copia con otro nombre\n    $ cp notas.txt practica/          # copia dentro de una carpeta\n    $ cp -r practica copia-practica   # -r para carpetas: «recursivo»\n\nmv — mover Y renombrar\n\nSon la misma operación: renombrar es mover al mismo sitio con otro nombre.\n\n    $ mv notas.txt apuntes.txt        # renombra\n    $ mv apuntes.txt practica/        # mueve\n\nrm — borrar\n\n    $ rm archivo.txt\n    $ rm -r carpeta                   # con todo lo que tenga dentro\n\nEsto es lo importante: en la consola NO hay papelera. Lo que borras con rm no está en ningún sitio del que se pueda recuperar.\n\nTres costumbres que evitan el mal día:\n\n1. Antes de un rm con comodines, ejecuta el mismo patrón con ls. «ls *.log» te enseña exactamente qué va a desaparecer con «rm *.log».\n\n2. Usa «rm -i» mientras te acostumbras: pregunta por cada archivo.\n\n3. Desconfía del espacio de más. «rm -r /home/diego /practica» —con un espacio antes de /practica— no borra una carpeta: borra dos, y una de ellas es tu casa entera.\n\nComodines\n\n    *.log       cualquier nombre terminado en .log\n    log-*       cualquier nombre que empiece por log-\n    archivo?.txt   archivo1.txt, archivoA.txt — una sola posición"
        },
        {
          "tipo": "lectura",
          "titulo": "Permisos: qué significa rw-r--r--",
          "cuerpo": "Cuando haces «ls -l» ves algo así:\n\n    -rw-r--r--  1 diego  equipo   1420 ene 12 09:14  notas.txt\n    drwxr-xr-x  2 diego  equipo   4096 ene 12 09:10  practica\n\nEsa primera columna es el tipo y los permisos.\n\nEl primer carácter\n\n    -   archivo normal\n    d   carpeta («directory»)\n    l   enlace a otra cosa\n\nLos nueve siguientes, en grupos de tres\n\n    rw-    r--    r--\n    dueño  grupo  los demás\n\n    r   se puede leer\n    w   se puede escribir\n    x   se puede ejecutar (en una carpeta: se puede entrar en ella)\n    -   ese permiso no está\n\nAsí que «-rw-r--r--» es: el dueño lee y escribe, el grupo solo lee, el resto solo lee.\n\nchmod — cambiar permisos\n\nLa forma legible:\n\n    $ chmod +x script.sh        # hazlo ejecutable\n    $ chmod -w notas.txt        # quítale la escritura\n    $ chmod u+x,g-w archivo     # al dueño (u) dale x, al grupo (g) quítale w\n\nLa forma numérica, que es la que vas a ver en internet:\n\n    r=4  w=2  x=1, y se suman por grupo\n\n    644  =  6 (4+2, rw) para el dueño, 4 (r) para el grupo, 4 (r) para el resto\n    755  =  7 (4+2+1, rwx) dueño, 5 (4+1, rx) grupo y resto\n\n644 para archivos y 755 para carpetas y scripts es lo normal.\n\nUna advertencia: «chmod 777» le da permiso de todo a todo el mundo. Aparece mucho en respuestas de foros porque «así funciona». Funciona igual que dejar la puerta abierta funciona para entrar: el problema no es que no funcione."
        },
        {
          "tipo": "lectura",
          "titulo": "Editar sin salir de la terminal: nano",
          "cuerpo": "En un servidor vas a tener que cambiar un archivo de configuración. Hay dos editores en toda máquina: vim, que es potentísimo y tiene una curva de aprendizaje seria, y nano, que se usa sin aprender nada.\n\nEmpieza por nano.\n\n    $ nano config.txt\n\nSe abre el archivo y escribes normal: flechas, Enter, Retroceso. Abajo tienes la chuleta, donde «^» significa Ctrl:\n\n    ^O   guardar (te pregunta el nombre: Enter para confirmar)\n    ^X   salir (si hay cambios sin guardar, pregunta)\n    ^K   cortar la línea entera\n    ^U   pegarla\n    ^W   buscar\n    ^_   ir a una línea concreta\n\nEso es todo. Con ^O y ^X ya puedes trabajar.\n\nAntes de tocar una configuración\n\nHaz una copia. Siempre.\n\n    $ cp nginx.conf nginx.conf.bak\n    $ nano nginx.conf\n\nSi algo sale mal, «cp nginx.conf.bak nginx.conf» y vuelves al punto de partida. Cuesta cinco segundos y ahorra tardes enteras.\n\nY si te encuentras dentro de vim sin querer\n\nPasa: algunos programas lo abren por su cuenta. Para salir sin guardar, pulsa Esc, escribe «:q!» y Enter."
        },
        {
          "tipo": "evaluacion",
          "titulo": "Evaluación de la unidad 2",
          "peso": 30,
          "evaluacion": {
            "banco": "Consola de Linux — archivos y permisos",
            "cantidad_items": 5,
            "nota_minima": 60,
            "intentos_max": 3,
            "minutos_limite": 15,
            "preguntas": [
              {
                "tipo": "opcion_unica",
                "enunciado": "Estás en /home/diego/proyectos y quieres ir a /home/diego. ¿Cuál es la forma más corta?",
                "explicacion": "«..» significa «la carpeta de arriba». «cd ~» también llega, pero solo porque en este caso tu carpeta personal coincide con el destino.",
                "opciones": [
                  "cd /home/diego/proyectos",
                  { "texto": "cd ..", "correcta": true },
                  "cd -",
                  "pwd .."
                ]
              },
              {
                "tipo": "verdadero_falso",
                "enunciado": "Un archivo borrado con rm se puede recuperar desde la papelera.",
                "explicacion": "En la consola no hay papelera. Por eso conviene ejecutar el patrón con ls antes de pasárselo a rm.",
                "opciones": [
                  "Verdadero",
                  { "texto": "Falso", "correcta": true }
                ]
              },
              {
                "tipo": "opcion_unica",
                "enunciado": "«ls -l» muestra -rw-r--r-- en un archivo. ¿Quién puede modificarlo?",
                "explicacion": "Los tres grupos son dueño, grupo y los demás. Solo el primero tiene «w».",
                "opciones": [
                  { "texto": "Solo el dueño", "correcta": true },
                  "El dueño y su grupo",
                  "Cualquiera",
                  "Nadie: falta el permiso de ejecución"
                ]
              },
              {
                "tipo": "opcion_multiple",
                "enunciado": "Vas a editar un archivo de configuración en un servidor en producción. ¿Qué conviene hacer?",
                "explicacion": "Copiar antes cuesta cinco segundos. Cambiar permisos a 777 no arregla un error de configuración y abre el archivo a todo el mundo.",
                "opciones": [
                  { "texto": "Copiarlo a un .bak antes de tocarlo", "correcta": true },
                  { "texto": "Saber de antemano cómo salir del editor sin guardar", "correcta": true },
                  "Darle permisos 777 por si acaso",
                  "Borrar el original y escribirlo de nuevo"
                ]
              },
              {
                "tipo": "respuesta_corta",
                "enunciado": "¿Qué comando dice en qué carpeta estás parado?",
                "explicacion": "pwd, de «print working directory». Es la respuesta a la pregunta que más se hace la primera semana.",
                "respuestas": ["pwd", "el comando pwd"]
              },
              {
                "tipo": "opcion_unica",
                "enunciado": "¿Qué hace «cp -r practica copia»?",
                "explicacion": "-r es «recursivo»: sin él, cp se niega a copiar una carpeta.",
                "opciones": [
                  { "texto": "Copia la carpeta practica y todo su contenido a copia", "correcta": true },
                  "Renombra practica como copia",
                  "Mueve practica dentro de copia",
                  "Borra copia y deja practica"
                ]
              },
              {
                "tipo": "ordenar",
                "enunciado": "Ordena los pasos para cambiar una configuración con seguridad.",
                "explicacion": "La copia va primero: después de romper el archivo ya no hay de dónde sacarla.",
                "puntaje": 2,
                "pasos": [
                  "Hacer una copia del archivo con cp",
                  "Abrirlo con nano",
                  "Hacer el cambio y guardar con Ctrl+O",
                  "Salir con Ctrl+X y comprobar que el servicio sigue en pie"
                ]
              }
            ]
          }
        }
      ]
    },
    {
      "titulo": "Encadenar comandos",
      "descripcion": "Donde la consola deja de ser un explorador de archivos incómodo y empieza a servir.",
      "actividades": [
        {
          "tipo": "lectura",
          "titulo": "Buscar dentro de archivos: grep",
          "cuerpo": "grep busca un texto dentro de archivos y te devuelve las líneas donde aparece.\n\n    $ grep error registro.log            # líneas que contienen «error»\n    $ grep -i error registro.log         # sin distinguir mayúsculas\n    $ grep -n error registro.log         # con el número de línea\n    $ grep -c error registro.log         # solo cuántas hay\n    $ grep -v error registro.log         # al revés: las que NO lo contienen\n    $ grep -r error .                    # en todos los archivos de aquí hacia abajo\n\nLas cuatro que vas a usar todo el rato son -i, -n, -c y -v.\n\nBuscar archivos: find\n\ngrep busca DENTRO. find busca los archivos en sí.\n\n    $ find . -name \"*.log\"               # por nombre, desde aquí hacia abajo\n    $ find . -name \"*.log\" -mtime -1     # modificados en las últimas 24 horas\n    $ find /var/log -size +10M           # los que pesan más de 10 MB\n\nEl «.» del principio es dónde empezar a buscar. Con /var/log empieza ahí.\n\nUn matiz que confunde al principio: en find hay que poner el patrón entre comillas. Sin ellas, la consola intenta expandir el * antes de que find lo vea."
        },
        {
          "tipo": "lectura",
          "titulo": "Tuberías: encadenar comandos con |",
          "cuerpo": "Cada programa escupe texto. La barra vertical | toma ese texto y se lo da al siguiente como entrada. Eso es una tubería, y es la idea que hace que la consola valga la pena.\n\nLeer de izquierda a derecha\n\n    $ cat registro.log | grep error | wc -l\n\nSe lee: «toma el archivo, quédate con las líneas que digan error, cuéntalas». Tres programas simples resolviendo algo que ninguno resuelve solo.\n\nLos que se combinan mejor\n\n    sort            ordena líneas\n    sort -n         ordena como números, no como texto\n    uniq            quita duplicados SEGUIDOS (por eso casi siempre va después de sort)\n    uniq -c         además cuenta cuántas veces aparecía cada una\n    head -n 5       quédate con las cinco primeras\n    cut -d\" \" -f1   quédate con el primer campo, separando por espacios\n\nEl ejemplo que resume el curso\n\n    $ cat acceso.log | cut -d\" \" -f1 | sort | uniq -c | sort -rn | head -n 5\n\nLínea a línea:\n\n    cut -d\" \" -f1    quédate con la primera columna: la IP\n    sort             ordénalas, para que las iguales queden juntas\n    uniq -c          agrúpalas y cuenta cuántas veces sale cada una\n    sort -rn         ordena por ese número, de mayor a menor\n    head -n 5        las cinco primeras\n\nResultado: las cinco IPs que más peticiones hicieron. En una línea, sin instalar nada.\n\nGuardar el resultado en un archivo\n\n    $ grep error registro.log > errores.txt     # crea o SOBRESCRIBE\n    $ grep error registro.log >> errores.txt    # añade al final\n\nCuidado con el de una sola flecha: sobrescribe sin preguntar. Si te equivocas de archivo, lo que hubiera dentro se pierde igual que con rm."
        },
        {
          "tipo": "objeto",
          "titulo": "Práctica: arma la tubería",
          "objeto": "rosco_excel"
        },
        {
          "tipo": "evaluacion",
          "titulo": "Evaluación final",
          "peso": 70,
          "evaluacion": {
            "banco": "Consola de Linux — final",
            "cantidad_items": 6,
            "nota_minima": 70,
            "intentos_max": 2,
            "minutos_limite": 25,
            "preguntas": [
              {
                "tipo": "opcion_unica",
                "enunciado": "¿Qué hace «grep -v error registro.log»?",
                "explicacion": "-v invierte la selección: devuelve lo que NO coincide. Es lo que se usa para quitar el ruido de un log.",
                "opciones": [
                  { "texto": "Muestra las líneas que NO contienen «error»", "correcta": true },
                  "Muestra las líneas que contienen «error», en modo detallado",
                  "Cuenta las líneas con «error»",
                  "Borra del archivo las líneas con «error»"
                ]
              },
              {
                "tipo": "opcion_unica",
                "enunciado": "En «cat log | grep error | wc -l», ¿qué recibe wc?",
                "explicacion": "Cada tubería pasa al siguiente comando lo que produjo el anterior. wc solo ve las líneas que grep dejó pasar.",
                "opciones": [
                  { "texto": "Solo las líneas que contienen «error»", "correcta": true },
                  "El archivo completo",
                  "El nombre del archivo",
                  "Nada: wc necesita un archivo, no una tubería"
                ]
              },
              {
                "tipo": "verdadero_falso",
                "enunciado": "«uniq» quita todos los duplicados del archivo, estén donde estén.",
                "explicacion": "Solo quita duplicados SEGUIDOS. Por eso casi siempre se escribe «sort | uniq»: ordenar es lo que los deja juntos.",
                "opciones": [
                  "Verdadero",
                  { "texto": "Falso", "correcta": true }
                ]
              },
              {
                "tipo": "opcion_unica",
                "enunciado": "Quieres añadir resultados a un archivo sin perder lo que ya tenía. ¿Cuál usas?",
                "explicacion": "> sobrescribe sin preguntar; >> añade al final. Es la diferencia entre acumular un registro y perderlo.",
                "opciones": [
                  "grep error log > salida.txt",
                  { "texto": "grep error log >> salida.txt", "correcta": true },
                  "grep error log | salida.txt",
                  "grep error log < salida.txt"
                ]
              },
              {
                "tipo": "emparejar",
                "enunciado": "Relaciona cada comando con lo que hace.",
                "explicacion": "Son los cinco que aparecen en casi toda tubería útil.",
                "puntaje": 2,
                "pares": [
                  { "izquierda": "wc -l", "derecha": "Cuenta líneas" },
                  { "izquierda": "sort -n", "derecha": "Ordena como números" },
                  { "izquierda": "uniq -c", "derecha": "Agrupa iguales y cuenta" },
                  { "izquierda": "tail -f", "derecha": "Sigue mostrando lo que se escriba" },
                  { "izquierda": "find", "derecha": "Busca archivos por nombre o fecha" }
                ]
              },
              {
                "tipo": "respuesta_corta",
                "enunciado": "¿Qué carácter encadena la salida de un comando con la entrada del siguiente?",
                "explicacion": "La barra vertical, |, llamada «tubería» o «pipe».",
                "respuestas": ["|", "pipe", "tuberia", "tubería", "barra vertical"]
              },
              {
                "tipo": "ordenar",
                "enunciado": "Ordena la tubería que devuelve las cinco IPs con más peticiones de un log de acceso.",
                "explicacion": "Sin el sort previo, uniq no agrupa nada: solo quita repetidos seguidos.",
                "puntaje": 3,
                "pasos": [
                  "cut -d\" \" -f1",
                  "sort",
                  "uniq -c",
                  "sort -rn",
                  "head -n 5"
                ]
              },
              {
                "tipo": "opcion_multiple",
                "enunciado": "¿Cuáles de estas costumbres reducen de verdad el riesgo de estropear algo?",
                "explicacion": "Probar el patrón con ls y copiar antes de editar cuestan segundos. Trabajar como root de forma permanente es lo contrario de una precaución.",
                "opciones": [
                  { "texto": "Probar el patrón con ls antes de pasárselo a rm", "correcta": true },
                  { "texto": "Copiar el archivo a un .bak antes de editarlo", "correcta": true },
                  "Trabajar siempre como root para que nada dé error de permisos",
                  "Usar chmod 777 cuando algo no funciona"
                ]
              }
            ]
          }
        }
      ]
    }
  ]
}
