Introducción
La carpeta node_modules es, sin exagerar, uno de los mayores problemas del ecosistema JavaScript moderno. En 2018, Ryan Dahl —el propio creador de Node.js— subió al escenario de la JSConf EU para dar su famosa charla “10 Things I Regret About Node.js”. ¿Y adivina qué estaba en lo más alto de la lista? node_modules. La forma en que las dependencias se resuelven, se almacenan y se duplican dentro de esa carpeta es un vestigio de decisiones de diseño de 2009 que nunca se corrigieron.
Si eres desarrollador JavaScript o TypeScript, seguramente ya ejecutaste npm install en un proyecto Angular aparentemente sencillo y viste, atónito, cómo cientos de megabytes de dependencias transitivas se volcaban en tu disco. El meme “node_modules es la carpeta más pesada del universo” existe por un motivo muy real. Pero el problema va más allá del tamaño: seguridad permisiva, phantom dependencies, ataques de supply chain y una resolución de módulos que desafía la lógica son solo algunos de los síntomas.
La buena noticia es que surgieron dos runtimes modernos para resolver estos problemas, cada uno con su propia filosofía. Deno, creado por el propio Ryan Dahl como corrección de los errores de Node.js, simplemente eliminó node_modules. Bun, creado por Jarred Sumner y escrito en Zig, mantuvo node_modules, pero lo optimizó radicalmente con hardlinks y un lockfile binario.
En este artículo vas a entender a fondo qué tiene de malo node_modules, conocer las historias y motivaciones detrás de Deno y Bun, ver una comparativa detallada de los tres runtimes y —lo más importante— probarlo en la práctica con dos proyectos Angular reales: uno ejecutándose con Bun y otro con Deno, sin node_modules. Si ya leíste mi artículo pip Es Lento, Poetry Complejo: UV Llegó Resolviendo Python, notarás que el mundo JavaScript está viviendo una revolución análoga.
Empecemos por entender cómo llegamos hasta aquí.
El Legado de Node.js — Y Sus Problemas
Para entender por qué node_modules es un problema, tenemos que volver a 2009. Ese año, Ryan Dahl presentó Node.js al mundo. La idea era revolucionaria: usar el motor V8 de Chrome para ejecutar JavaScript fuera del navegador, con un modelo de I/O no bloqueante basado en un event loop. De repente, los desarrolladores frontend podían escribir código de servidor con el mismo lenguaje. Nació el JavaScript fullstack.
npm (Node Package Manager) llegó con él y rápidamente se convirtió en el mayor registro de paquetes del mundo. Cualquier desarrollador podía publicar y consumir bibliotecas con un simple npm install. El ecosistema explotó. Frameworks como Express, Koa, Hapi y, más tarde, NestJS convirtieron a Node.js en la opción por defecto para APIs y microservicios. El modelo de callbacks, aunque criticado por el infame callback hell, evolucionó hacia Promises y después hacia async/await, lo que hizo el código asíncrono mucho más legible. Si programas en C#, reconocerás este patrón: el async/await de JavaScript se inspiró directamente en lo que Microsoft implementó en C# 5.0, como comenté en el artículo sobre programación asíncrona.
Pero mientras el lenguaje y el runtime evolucionaban, una pieza fundamental permaneció intacta durante más de una década: node_modules. La forma en que Node.js resuelve dependencias se definió en sus inicios y nunca recibió una revisión de diseño. El resultado es una serie de problemas estructurales que afectan a proyectos de todos los tamaños, desde el hello world hasta la aplicación enterprise.
Node.js abrió el camino a toda una generación de desarrolladores. Pero las decisiones de diseño de 2009 pasaron factura. Y eso es exactamente lo que voy a mostrar a continuación.
El Agujero Negro Llamado node_modules
Si existe un símbolo universal de los problemas del ecosistema JavaScript, ese símbolo es la carpeta node_modules. Vamos a diseccionar por qué merece el apodo de “agujero negro”.
Tamaño absurdo
Un proyecto Angular sencillo —como mi search-ui/ en el repositorio blog-zocateli-sample— contiene solo 4 archivos de código fuente: models.ts, cliente.service.ts, clientes-grid.component.ts y clientes-grid.component.html. Juntos, esos archivos suman menos de 5 KB de código real. Pero al ejecutar npm install, la carpeta node_modules generada ocupa entre 200 y 500 MB. Así es: la proporción entre código útil y dependencias puede llegar a 1:100.000.
Dependencias transitivas
Cuando instalas 10 paquetes en tu package.json, en realidad estás trayendo 800 o más dependencias transitivas. Cada paquete trae sus propias dependencias, que traen otras, en un efecto cascada que se descontrola rápidamente. Confías en tus 10 paquetes, pero ¿confías en los otros 790 que vinieron de regalo?
Resolución de módulos compleja
El algoritmo de resolución de módulos de Node.js es una búsqueda en cascada por las carpetas padre. Cuando haces require('lodash'), Node.js busca en ./node_modules/lodash, después en ../node_modules/lodash, después en ../../node_modules/lodash, y así sucesivamente, hasta la raíz del sistema de archivos. Este mecanismo es lento, difícil de depurar y fuente de bugs sutiles.
Duplicación de paquetes
La misma biblioteca puede existir en varias versiones dentro del árbol de node_modules. Un paquete puede depender de [email protected] mientras otro depende de [email protected], y ambas versiones se instalan por separado, ocupando el doble de espacio.
Phantom dependencies
Este es un problema insidioso. Paquetes que no aparecen en tu package.json pueden ser accesibles desde tu código simplemente porque se instalaron como dependencia transitiva de otro paquete. Tu código funciona en local, pero falla misteriosamente en otro entorno donde el árbol de dependencias es ligeramente distinto.
Supply chain attacks
La facilidad para publicar y consumir paquetes en npm tiene un lado oscuro. Los ataques de supply chain se volvieron recurrentes: el caso event-stream (2018) inyectó código malicioso de robo de criptomonedas en una biblioteca popular; ua-parser-js (2021) fue comprometido para incluir mineros de cripto; y el episodio colors.js/faker.js (2022) demostró que un único mantenedor frustrado puede sabotear miles de proyectos. node_modules, al no tener ningún modelo de sandbox de seguridad, ejecuta cualquier código que haya dentro con los mismos permisos que el proceso de Node.js.
Rendimiento e incompatibilidades
npm install es notoriamente lento. Los lock files como package-lock.json generan conflictos frecuentes en equipos grandes. Los symlinks se comportan de forma diferente entre Windows y Unix. Las rutas largas en Windows (más de 260 caracteres) pueden romper proyectos enteros.
💡 Comparación de escala: El proyecto
search-ui/tiene ~5 KB de código real y ~350 MB denode_modules. Es como llevar una mochila de 70 kg para cargar un bolígrafo.
node_modules no es solo un inconveniente: es un problema de diseño fundamental. Y dos runtimes decidieron enfrentarlo de formas radicalmente distintas.
Deno: El Arrepentimiento de Ryan Dahl Que Se Convirtió en Producto
En mayo de 2018, Ryan Dahl subió al escenario de la JSConf EU con una presentación que sacudió el ecosistema JavaScript. En la charla “10 Things I Regret About Node.js”, el creador de Node.js admitió públicamente que había cometido graves errores de diseño, y que node_modules era el peor de ellos. Pero Dahl no se limitó a señalar problemas: presentó Deno, un nuevo runtime construido desde cero para corregir esos errores.
Qué es Deno
Deno es un runtime para JavaScript y TypeScript, escrito en Rust, que ejecuta código en el motor V8 (el mismo de Chrome y Node.js). Pero las similitudes con Node.js terminan ahí. Deno se diseñó con una filosofía completamente diferente.
Qué resuelve Deno
TypeScript nativo. En Node.js necesitas configurar tsconfig.json, instalar el compilador de TypeScript y, por lo general, configurar un build step separado. En Deno, TypeScript simplemente funciona, sin configuración y sin dependencias adicionales.
Sin node_modules. Este es el punto central. Deno resuelve dependencias de tres formas alternativas: imports vía URL, import maps en deno.json o caché global. En ningún caso se crea una carpeta node_modules en el proyecto. Las dependencias quedan en una caché global compartida (~/.cache/deno/ en Linux/macOS, %LOCALAPPDATA%/deno en Windows), lo que significa que varios proyectos reutilizan las mismas dependencias sin duplicación.
Seguridad sandbox. A diferencia de Node.js, que da acceso sin restricciones al sistema de archivos, a la red y a las variables de entorno, Deno funciona en un sandbox por defecto. Para leer un archivo necesitas la flag --allow-read. Para hacer una petición HTTP, --allow-net. Para acceder a variables de entorno, --allow-env. Esto mitiga drásticamente el riesgo de supply chain attacks: aunque se importe un paquete malicioso, no puede acceder a nada sin permiso explícito.
Toolchain built-in. Deno incluye formateador (deno fmt), linter (deno lint), test runner (deno test), benchmark runner (deno bench) e incluso un generador de documentación. En Node.js, cada una de estas herramientas es una devDependency separada —Prettier, ESLint, Jest—, cada una con sus propios archivos de configuración y cientos de dependencias.
Web Standard APIs. Deno implementa APIs web estándar como fetch, Web Crypto y Streams. El código que funciona en el navegador funciona en Deno con cambios mínimos, algo que nunca fue cierto en Node.js.
Compatibilidad con Node.js en Deno 2.x
Cuando se lanzó Deno 1.x, el enfoque era purista: sin npm, sin node_modules, sin compatibilidad. Eso limitó gravemente su adopción, ya que el ecosistema npm tiene millones de paquetes que los desarrolladores necesitan usar a diario.
Deno 2.x trajo un cambio pragmático: ahora es posible importar paquetes npm directamente con el prefijo npm:. Esto significa que frameworks como Angular y React y bibliotecas como RxJS pueden usarse en Deno sin reescribir nada, manteniendo la ventaja de no tener node_modules en el proyecto.
⚠️ Nota: Deno 2.x añadió compatibilidad con npm por pragmatismo: el purismo cedió ante la realidad del ecosistema. Pero la filosofía de diseño se mantiene: las dependencias viven en la caché global, no en la carpeta del proyecto.
Pros y contras de Deno
Pros: TypeScript sin configuración, seguridad granular mediante sandbox, Web Standards, toolchain completo built-in, sin node_modules, Deno Deploy para desplegar en el edge.
Contras: ecosistema más pequeño que el de Node.js (aunque crece rápidamente), cambios de enfoque entre Deno 1.x y 2.x que generaron confusión en la comunidad, adopción corporativa todavía en crecimiento y algunos frameworks sin soporte oficial completo.
Bun: Velocidad Absurda Escrita en Zig
Si Deno nació de un arrepentimiento filosófico, Bun nació de una frustración con el rendimiento. Creado por Jarred Sumner, ex ingeniero de Stripe, en 2022, Bun 1.0 se lanzó oficialmente en septiembre de 2023 con una propuesta audaz: ser el runtime JavaScript más rápido del planeta y, de paso, sustituir npm, webpack y Jest con un único binario.
Qué es Bun
Bun es un runtime JavaScript escrito en Zig (un lenguaje de sistemas de bajo nivel) que utiliza el motor JavaScriptCore de Safari en lugar del V8 que usan Node.js y Deno. Además de runtime, Bun es a la vez package manager, bundler y test runner, todo en un único ejecutable.
Qué resuelve Bun
Velocidad brutal. Bun está diseñado para un rendimiento extremo. bun install es hasta 25x más rápido que npm install en benchmarks reales. El arranque del runtime es significativamente más rápido que el de Node.js, lo que marca la diferencia sobre todo en CLIs y scripts. El motor JavaScriptCore, aunque está menos documentado que V8, está optimizado para un arranque rápido.
Drop-in replacement. A diferencia de Deno, que exigió rediseñar los proyectos, Bun funciona como sustituto directo de Node.js. En la mayoría de los casos, basta con cambiar node por bun y npm por bun en tus scripts, y todo sigue funcionando. La compatibilidad con el ecosistema npm es altísima.
TypeScript y JSX nativos. Al igual que Deno, Bun entiende TypeScript y JSX sin configuración adicional. Sin transpilación manual y sin build step extra.
APIs nativas optimizadas. Bun ofrece APIs propias de alto rendimiento: Bun.serve() para servidores HTTP, Bun.file() para leer archivos de forma eficiente e incluso un driver SQLite built-in. Estas APIs son significativamente más rápidas que sus equivalentes en Node.js.
node_modules en Bun
Aquí está la diferencia fundamental entre Bun y Deno: Bun todavía usa node_modules. Es una decisión de diseño consciente: mantener la máxima compatibilidad con el ecosistema existente. Pero Bun optimiza node_modules de formas importantes:
- Hardlinks en lugar de copias. En sistemas de archivos que admiten hardlinks (ext4, APFS, NTFS), Bun crea hardlinks a los archivos de los paquetes en lugar de copiarlos. Esto significa que, si dos proyectos usan la misma versión de React, el archivo físico en disco se comparte entre ellos, lo que reduce significativamente el espacio en disco.
- Lockfile binario.
bun.lockbes un archivo binario, no JSON comopackage-lock.json. Eso lo hace mucho más rápido de generar y de leer, aunque no sea legible por humanos. - Resolución optimizada. El algoritmo de resolución de dependencias de Bun está implementado en Zig y es significativamente más rápido que el de npm.
Pros y contras de Bun
Pros: velocidad absurda (install, arranque, runtime), drop-in replacement de Node.js, APIs nativas de alto rendimiento, TypeScript/JSX nativos, arranque rápido ideal para CLIs.
Contras: todavía usa node_modules (aunque optimizado), el motor JavaScriptCore está menos documentado y se comporta de forma distinta a V8, el soporte para Windows todavía está madurando y la comunidad es menor que las de Node.js y Deno.
💡 Consejo práctico: Bun es el camino de menor resistencia: cambia npm por bun en tu proyecto existente y gana velocidad de inmediato, sin reescribir nada.
Comparativa: Node.js vs Deno vs Bun
Ahora que conoces las motivaciones y arquitecturas de cada runtime, voy a ponerlos lado a lado en una comparativa detallada.
| Aspecto | Node.js | Deno | Bun |
|---|---|---|---|
| Creador | Ryan Dahl (2009) | Ryan Dahl (2018) | Jarred Sumner (2022) |
| Motor | V8 (Chrome) | V8 | JavaScriptCore (Safari) |
| Escrito en | C++ | Rust | Zig |
| TypeScript | Requiere config | Nativo | Nativo |
| node_modules | Obligatorio | No (caché global) | Sí (optimizado/hardlinks) |
| Seguridad | Permisivo | Sandbox por defecto | Permisivo |
| Velocidad de install | Base | Rápido | Muy rápido (~25x npm) |
| Toolchain built-in | No | Sí (fmt, lint, test) | Sí (bundler, test) |
| Compat. Node.js | N/A | Alta (Deno 2.x, prefijo npm:) | Muy alta (drop-in) |
Análisis de la comparativa
Motor y lenguaje base. Node.js y Deno comparten V8, lo que significa un comportamiento idéntico al ejecutar JavaScript. Bun, al usar JavaScriptCore, puede presentar diferencias sutiles en edge cases, pero en el 99% de los escenarios el comportamiento es compatible.
Node_modules. Esta es la diferencia de mayor impacto en el día a día. Node.js crea cientos de MB en cada proyecto. Bun crea la misma estructura, pero con hardlinks que reducen el uso real de disco. Deno no crea nada: todo queda en la caché global.
Seguridad. Solo Deno implementa un modelo de seguridad mediante sandbox. Node.js y Bun confían en que todo el código importado tiene buenas intenciones, un riesgo real dado el historial de supply chain attacks en npm.
Toolchain. Node.js exige ESLint, Prettier, Jest y webpack/Vite como dependencias separadas. Deno y Bun incluyen gran parte de esas herramientas en el propio runtime.
Cuándo usar cada uno
- Node.js: proyectos legados, entornos enterprise con un ecosistema consolidado, cuando el equipo ya domina el tooling. No hay razón para migrar proyectos estables en producción sin un análisis cuidadoso.
- Deno: proyectos nuevos en TypeScript que priorizan la seguridad (APIs, CLIs sensibles), cuando quieres evitar
node_modulesy sus complejidades, o cuando necesitas un toolchain mínimo. - Bun: cuando la velocidad es la prioridad, en proyectos Node.js existentes que quieren una ganancia inmediata cambiando solo el package manager, o para CLIs y scripts que necesitan un arranque rápido.
Ejemplo Práctico: Angular Con Bun
Basta de teoría: veámoslo en la práctica. En el repositorio blog-zocateli-sample creé el proyecto frontend/search-ui-bun/ como una versión de mi grid de clientes ejecutándose con Bun.
El package.json con scripts de Bun
El package.json es prácticamente idéntico al de un proyecto Node.js, con scripts adaptados para usar bunx:
| |
Observa que los scripts usan bunx en lugar de npx. bunx es el equivalente de Bun a npx: ejecuta binarios de paquetes sin necesidad de instalarlos globalmente.
Configuración de Bun (bunfig.toml)
El archivo bunfig.toml configura el comportamiento de Bun:
| |
Ejecutando el proyecto
| |
bun install resuelve todas las dependencias de Angular en segundos, donde npm install tardaría minutos. El lockfile generado es bun.lockb, un archivo binario compacto.
El componente Angular standalone
ClientesGridComponent se convirtió en un standalone component (el estándar de Angular 19+), importando CommonModule y ReactiveFormsModule directamente en el decorador:
| |
La configuración de la app usa provideRouter y provideHttpClient, el patrón moderno de Angular:
| |
El código Angular es idéntico: no importa si se ejecuta en Node.js o en Bun. La diferencia está por completo en el runtime y en el package manager.
ℹ️ Sobre node_modules: Bun genera la carpeta
node_modules, pero con hardlinks. En la práctica, la carpeta ocupa menos espacio y la instalación es casi instantánea.
Ejemplo Práctico: Angular Con Deno
Ahora vamos al proyecto más revelador: frontend/search-ui-deno/, que ejecuta Angular sin node_modules.
deno.json: import maps y tasks
En lugar de package.json, Deno usa deno.json para mapear dependencias mediante import maps y definir tareas:
| |
La clave es la configuración "nodeModulesDir": "none". Le indica a Deno que no cree la carpeta node_modules: todas las dependencias se resuelven en la caché global de Deno. Los import maps del campo "imports" mapean los paquetes de Angular a sus versiones npm usando el prefijo npm:, una feature de Deno 2.x.
Ejecutando el proyecto
| |
Después de ejecutar deno install, mira el directorio del proyecto. No hay carpeta node_modules. No hay package-lock.json. Solo los archivos de código fuente y configuración. Las dependencias se descargaron en la caché global en ~/.cache/deno/ y se comparten con todos los demás proyectos Deno de la máquina.
El código Angular sigue siendo el mismo
app.config.ts, ClienteService, ClientesGridComponent: todos son idénticos al proyecto Bun y al original en Node.js. Angular no necesita saber qué runtime lo está ejecutando. Los imports siguen las mismas rutas:
| |
Deno resuelve @angular/core consultando el import map de deno.json, que apunta a npm:@angular/core@^19.2.0, que se obtiene de la caché global. No se crea ninguna carpeta local.
💡 El punto clave: Con Deno, el proyecto entero ocupa solo tus archivos de código, sin 300 MB parásitos. La caché global es compartida, así que la segunda vez que usas Angular en otro proyecto, la resolución es instantánea.
Estructura de Carpetas: La Diferencia Visual
Nada ilustra mejor la diferencia entre los tres runtimes que una comparación visual de la estructura de carpetas de cada proyecto.

search-ui/ (Node.js original)
| |
search-ui-bun/ (Bun)
| |
search-ui-deno/ (Deno — SIN node_modules)
| |
Comparativa de tamaño en disco
| Proyecto | Código fuente | Dependencias | Total en disco |
|---|---|---|---|
| search-ui (Node.js) | ~5 KB | ~350 MB (node_modules) | ~350 MB |
| search-ui-bun (Bun) | ~20 KB | ~150 MB (hardlinks) | ~150 MB* |
| search-ui-deno (Deno) | ~20 KB | 0 (caché global) | ~20 KB** |
* El tamaño real en disco de Bun depende de cuántos proyectos compartan hardlinks. Si es el único proyecto, el tamaño es similar al de npm; si hay varios proyectos, el espacio se reutiliza.
** Las dependencias de Deno existen en la caché global (~/.cache/deno/), compartida entre todos los proyectos. El tamaño total no desaparece, pero no se duplica por proyecto.
La diferencia es visual y brutal. El proyecto Deno es limpio: solo código. El proyecto Bun tiene node_modules, pero optimizado. El proyecto Node.js carga con el peso de una década de decisiones de diseño sin revisar.
Consejos y Buenas Prácticas
A partir de lo que mostré, aquí van seis recomendaciones prácticas para incorporar Deno y Bun a tu flujo de desarrollo.
1. Empieza probando Bun como package manager
La forma más segura de experimentar es usar Bun solo como sustituto de npm en proyectos Node.js existentes. Cambia npm install por bun install y npx por bunx. El riesgo es cero: si algo sale mal, vuelve a npm. Pero la probabilidad de que algo salga mal es mínima, y la ganancia de velocidad es inmediata.
2. Usa Deno en proyectos nuevos de TypeScript que necesiten seguridad
Si estás empezando una API, una CLI o un servicio que maneja datos sensibles, el modelo de sandbox de Deno es un diferencial real. La necesidad de flags explícitas para acceder a la red, al sistema de archivos y a las variables de entorno añade una capa de protección que no existe en Node.js ni en Bun.
3. No abandones Node.js en producción sin pruebas exhaustivas
Migrar un proyecto estable en producción a Deno o Bun debe ser una decisión técnica bien fundamentada, no una decisión emocional. Prueba de forma exhaustiva, verifica la compatibilidad de todas las dependencias y ten un plan de rollback.
4. Aprovecha el toolchain built-in para reducir devDependencies
Con Deno puedes eliminar ESLint (deno lint), Prettier (deno fmt), Jest (deno test) e incluso el benchmarking (deno bench) de tus devDependencies. Menos paquetes = menos superficie de ataque = un node_modules más ligero (o inexistente).
5. Verifica el soporte oficial antes de migrar frameworks
No todos los frameworks JavaScript admiten oficialmente Deno o Bun. Antes de migrar, consulta la documentación oficial. Angular, por ejemplo, funciona con ambos mediante la CLI, pero el soporte oficial puede variar en edge cases. El ecosistema NestJS tiene buen soporte para Bun, pero el soporte para Deno todavía está evolucionando.
6. Estrategia híbrida: bun install + node para la ejecución
Un enfoque pragmático es usar bun install por su velocidad (generando node_modules con hardlinks) y mantener node como runtime de ejecución. Eso te da lo mejor de ambos mundos: instalación rápida y máxima compatibilidad. Es una transición suave antes de adoptar Bun como runtime completo.
Conclusión
node_modules es más que una carpeta pesada: es el síntoma más visible de decisiones de diseño tomadas en 2009 que nunca se revisaron. Node.js revolucionó el desarrollo web al llevar JavaScript al servidor, pero dejó un legado estructural que le cuesta tiempo, disco y seguridad a toda la comunidad.
Deno, creado por el propio Ryan Dahl como corrección de sus arrepentimientos, eliminó node_modules por completo. Las dependencias van a una caché global, TypeScript funciona de forma nativa y un modelo de sandbox protege contra código malicioso. Bun, creado por Jarred Sumner con un enfoque obsesivo en el rendimiento, mantuvo node_modules por pragmatismo, pero lo optimizó con hardlinks y un lockfile binario, logrando velocidades de instalación hasta 25x superiores a las de npm.
La competencia entre Node.js, Deno y Bun es sana y beneficia a todos los desarrolladores JavaScript. Node.js sigue siendo el runtime más maduro y estable para producción. Deno ofrece la visión más moderna de cómo debería funcionar un runtime. Bun ofrece ganancias inmediatas de rendimiento con una fricción mínima de adopción.
Si usas Angular, React, Vue o cualquier framework JavaScript, prueba los proyectos prácticos que creamos: search-ui-bun/ muestra cómo ejecutar Angular con Bun en segundos, y search-ui-deno/ demuestra un proyecto Angular funcionando completamente sin node_modules. Clona el repositorio blog-zocateli-sample, ejecuta los comandos y comprueba con tus propios ojos la diferencia que marca un runtime moderno. Puede que el futuro de node_modules no sea su extinción total, pero desde luego ya no será un agujero negro.
Lee También
- pip Es Lento, Poetry Complejo: UV Llegó Resolviendo Python — un tema análogo: un gestor de paquetes moderno frente al legado, escrito en Rust, que transformó el ecosistema Python
- BFF: El Patrón Que Tu Frontend Necesita — el proyecto Angular
bff-spadel mismo repositorio, que aborda la seguridad en SPAs - Makefile: Automatizando tareas para Python, Hugo y Docker — automatización del toolchain de desarrollo con un Makefile

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.