Introducción

Típicamente, cuando estamos desarrollando código, hacemos mucho uso de la terminal para ejecutar distintos comandos que nos permiten, por ejemplo, comprobar que nuestros test pasan, descargar dependencias, arrancar la aplicación en local… Estos comandos suelen ser largos y nos puede resultar difícil recordarlos o simplemente tenemos que ejecutar varios porque encadenan una función que queremos realizar sobre nuestro código.

Es aquí donde nos preguntamos si existía alguna herramienta que nos simplificara esta tarea y que fuera fácil de implementar y usar. La primera que se nos ocurrió debido a su popularidad fue Makefile. Indagando un poco más sobre qué es esta tecnología y para qué fue creada, llegamos a la conclusión de que su propósito principal es describir las dependencias entre los archivos fuente de un proyecto y las reglas para compilarlos, así como generar ejecutables. Esta definición no cuadraba mucho con el tipo de herramienta que estábamos buscando, por lo que decidimos descartarla.

Tras el punto anterior, seguimos con nuestra investigación y consultamos a compañeros. Varios nos recomendaron una herramienta llamada Task que por ahora suplía todas nuestras necesidades.

¿Qué es Task?

La herramienta se describe a sí misma como un runner de tareas o una herramienta de construcción que busca ser más simple y fácil de usar que GNU Make. Como principales ventajas frente a la herramienta con la que se comparan, tenemos que:

• Es una herramienta multiplataforma. Make funciona completamente en las máquinas Unix, pero en Windows hay que hacer algún cambalache como usar Cygwin o WSL para poder usarlo. Para Task, con la instalación ya es totalmente compatible con tu sistema operativo.
• Tiene una sintaxis más simple. Por lo tanto, es más sencillo entenderlo y aplicarlo que Make. Además, los IDE modernos, como IntelliJ o Visual Studio Code, tienen soporte para sugerirte qué sintaxis puedes usar con su debida documentación embebida.
• Tiene muchas más funcionalidades. Como comentamos anteriormente, Make no se pensó como un runner de tareas, por lo que entendemos que no se buscaba tener tantas funcionalidades como tiene Task a la hora de encadenar tareas, definir sus descripciones, entre otras.

Task por defecto buscará en tu proyecto un archivo llamado Taskfile.yml que podría tener una estructura como esta:

version: '3'

tasks:
  hello:
    cmds:
      - echo 'Hello World from Task!'
    silent: true

Algo a remarcar es que no busca un Taskfile.yml en la ruta raíz de tu proyecto, aunque típicamente el archivo se suela ubicar ahí. En su lugar, es capaz de buscar recursivamente por las carpetas de tu proyecto por ese archivo. Gracias a esto no te tienes que preocupar de en qué localización de tu proyecto te encuentras para lanzar una tarea con Task.

Ejemplo

Les mostramos un breve ejemplo propio sobre como se puede usar la herramienta:

version: '3'
silent: true
tasks:
  test:
    desc: "🧪 Run tests"
    cmds:
      - flutter test

  build:
    desc: "🔨 Build application executable"
    preconditions:
      - sh: ls {{ .TASKFILE_DIR }}
        msg: "{{.PRECONDITION_MESSAGE}}"
    cmds:
      - task: my-plugin:generate
      - task: build-to-macos

  build-to-macos:
    internal: true
    platforms: [ darwin ]
    cmds:
      - flutter build macos --release

  default:
    cmds:
      - task -l

vars:
  PRECONDITION_MESSAGE: 🤷‍♀️You need to have a valid Taskfile in your myplugin project
  MY_PLUGIN_DIR: ../my-plugin
  TASKFILE_DIR: "{{ .MY_PLUGIN_DIR }}/Taskfile.yml"

includes:
  my-plugin:
    taskfile: "{{ .MY_PLUGIN_DIR }}"
    dir: "{{ .MY_PLUGIN_DIR }}"
    internal: true
    optional: true

La tarea build construye el ejecutable de una aplicación y se apoya en una tarea de otro Taskfile, estableciendo una precondición que verifica que exista el fichero, y luego utiliza una tarea interna que solo se ejecuta en caso de que tu sistema operativo sea MacOS.

Como se puede ver, se extraen variables para simplificar y reducir la cantidad de texto literal, ya sea rutas u otros textos complejos.

La tarea default es un truco que hemos hecho para que simplemente con ejecutar el comando task sin ningún argumento, te liste las tareas disponibles, lo que normalmente tendrías que hacer ejecutando task -l. Esta seria su salida:

❯ task
task: Available tasks for this project:
* build:          🔨 Build application executable
* test:           🧪 Run tests

Por defecto, cuando ejecutamos task -l se usa una ordenación alfanumérica, por lo que si quieres que se muestren por orden de tu preferencia podrías cambiar la tarea default para que use el comando task -l -sort none. Esto provoca que a la hora de mostrarlos sigan el mismo orden que definiste en el Taskfile.

Nuestra experiencia

En apenas unas pocas horas logramos implementarlo en un proyecto real. Una de las primeras cosas que notamos fue su gran escalabilidad. Con Task, puedes cubrir el espectro completo de las tareas, desde las más simples, como definir un alias para un comando largo, hasta las más complejas, como encadenar diversas operaciones y ejecutarlas según tu sistema operativo.

Un elemento muy simple, pero que nos resulta muy útil, es la posibilidad de ejecutar un comando que muestra todas las tareas configuradas junto con su descripción. Esto agrega una capa de organización y claridad a nuestro flujo de trabajo que simplemente no estaba presente antes.

En el uso que hemos dado a la herramienta, hay varias características poderosas que queremos destacar:

• Taskfile te permite especificar que ciertas tareas se ejecuten en un directorio en particular. Esto es extremadamente útil para mantener separadas las tareas y los contextos en los que se ejecutan.
• Las precondiciones, que verifican si la tarea necesita ser ejecutada o no, han resultado ser una herramienta valiosa para prevenir la redundancia y optimizar el tiempo de trabajo.
• La habilidad de conectar múltiples Taskfiles es otra función que hemos explotado bastante. Puedes importar un Taskfile dentro de otro y usar sus tareas, lo que facilita enormemente la reutilización de código y la organización.
• Nos ha sido muy útil tener tareas que se definen como internas, que no se ejecutan desde fuera, sino que son llamadas por otras tareas que sí son públicas. Esta funcionalidad facilita la extracción de métodos, de la misma manera que lo harías en un lenguaje de programación.
• La opción de definir varios alias para la misma tarea es otra función que hemos disfrutado. Cada persona puede invocar la tarea con el nombre de su elección, lo que ayuda a la personalización y la comodidad del usuario.
• Finalmente, la gestión de errores en Task es sólida y eficiente, permitiéndonos identificar y solucionar problemas con mayor rapidez.

En resumen, nuestra experiencia con Taskfile ha sido muy positiva. Ha mejorado nuestra eficiencia, organización, y nos ha proporcionado un conjunto de herramientas poderosas para manejar nuestras tareas de desarrollo. Sin duda, lo recomendamos a otros equipos de desarrollo que busquen una herramienta de gestión de tareas sólida y flexible.