Continuamos explorando innovación en IA, software personalizado y trucos para optimizar procesos de desarrollo. Inspiración y conocimiento para profesionales y empresas.

Bienvenido a Developer Tooling #006, una edición temática del boletín inspirado en el trabajo de Freek Van der Herten, orientada a ingeniería de software y tecnologías afines. En esta entrega probamos un enfoque centrado en compiladores y bundlers nativos para ECMAScript/TypeScript construidos con Go, Rust u otros lenguajes de sistema. Dinos si prefieres este formato temático o no.

rspack: Compilador moderno escrito en Rust que pretende sustituir a webpack. Lo que nos gusta: conjunto de funciones amplio y en búsqueda de paridad con webpack, formando parte de un ecosistema en crecimiento y bien mantenido. Lo que no nos gusta: hereda una complejidad de configuración similar a la de webpack por buscar esa paridad.

esbuild: Compilador para Javascript, TypeScript y React escrito en Go. Lo que nos gusta: pionero en este espacio y revolucionó la velocidad de compilación y empaquetado cuando apareció. Lo que no nos gusta: ha perdido terreno frente a herramientas más nuevas como bun.

bun: Un paquete todo en uno: bundler, compilador y gestor de paquetes extremadamente rápido. Lo que nos gusta: velocidad espectacular tanto en el bundling como en la instalación de dependencias; bun install es sorprendentemente más rápido que npm y está avanzando hacia paridad de funcionalidades con la cli y API de npm. Lo que no nos gusta: está escrito en Zig, una elección que podría plantear dudas sobre la mantenibilidad a largo plazo.

rolldown: Herramienta basada en Rust que aspira a reemplazar a rollup. Lo que nos gusta: desarrollo muy activo y enfoque en rendimiento para sustituir a rollup, que puede resultar lento en ciertos escenarios. Lo que no nos gusta: la documentación puede mejorar, no es mala pero se echan en falta guías más completas.

farm: Otro bundler construido en Rust. Lo que nos gusta: excelente documentación y desarrollo sostenido a lo largo del tiempo, lo que sugiere una buena posibilidad de mantenimiento continuo. Lo que no nos gusta: las comparativas de velocidad en su web resultan poco transparentes porque declaran ser más rápidos que todo sin ofrecer comparaciones directas con herramientas como bun.

Resumen Este proyecto es un módulo de registro personalizado escrito en Python y diseñado con programación orientada a objetos para ofrecer una forma estructurada, extensible y ligera de capturar, formatear y almacenar mensajes de log en múltiples salidas como consola, archivo y base de datos SQLite

Características principales Tipos de log TRACE, DEBUG, INFO, SUCCESS, WARNING, ERROR, FATAL

Niveles ALL, HIGH, MEDIUM, LOW

Salidas Consola, archivo plano en formato .log y base de datos SQLite

Loggers nombrados Permite crear múltiples loggers con nombres o categorías personalizadas

Configuración de archivos Rutas de archivo configurables para persistencia de logs

Activación dinámica Se puede activar o desactivar el logging a consola, archivo o base de datos en tiempo de ejecución

Integración OOP Diseñado para integrarse fácilmente en proyectos basados en objetos, reutilizable y de baja dependencia

Vista previa En consola el formato es moderno y limpio con colores para facilitar la lectura Formato general [LoggerName] [Timestamp] [Level] Mensaje En archivo el mismo formato sin colores para persistencia En SQLite los registros quedan almacenados en tablas con columnas separadas para facilitar consultas y análisis Actualmente la ubicación por defecto del archivo de base de datos es fija pero se contempla configurarla en el roadmap

Primeros pasos Descargar el módulo logger.py y añadirlo al directorio del proyecto por ejemplo Your-Project/ main.py logger.py Importar la clase Logger y las constantes de nivel y crear una instancia con el nombre del logger Usar métodos como log.fatal log.error log.warning log.success log.information log.debug log.trace para registrar eventos

Activar registro en archivo y base de datos mediante métodos de configuración como set_toggle_file_logging set_toggle_db_logging y definir la ruta de archivos con set_file_path Además es posible ajustar el nivel de log para filtrar el detalle de los mensajes

Pila tecnológica Python 3 módulos estándar inspect os enum datetime sqlite3 herramientas de desarrollo PyCharm DataGrip control de versiones con Git y repositorio en GitHub

Hoja de ruta Soporte completo para logging en MySQL Logging seguro en entornos multi hilo Añadir versiones asíncronas para entornos de alta concurrencia Tipos de mensaje personalizables y mejora de la configuración de la ruta de la base de datos

Introducción: cuando se diseñan objetos complejos en Java, especialmente aquellos con muchos parámetros opcionales, el patrón de diseño Builder ofrece una solución limpia y flexible. En lugar de usar constructores largos con decenas de parámetros, conocido como el problema del constructor telescópico, Builder permite crear objetos paso a paso de forma legible y mantenible.

El problema: imagina una clase User con campos como nombre, segundo nombre, apellidos, edad, email, teléfono y teléfono alternativo. Para cubrir todas las combinaciones posibles con constructores sobrecargados se generan múltiples variantes que complican el código y reducen la claridad. Este desorden hace difícil añadir nuevos campos, validar parámetros o mantener la inmutabilidad del objeto.

La solución con Builder: el patrón Builder separa la construcción de la representación del objeto. Se define una clase User con campos finales y un constructor privado que recibe un Builder. El Builder es una clase anidada que recibe los campos obligatorios en su constructor y ofrece métodos encadenables para asignar campos opcionales y finalmente un método build que crea la instancia. De esta manera se consigue código más expresivo y resiliente ante cambios.

Esquema básico en palabras: clase User con campos finales; constructor privado User que copia valores desde Builder; clase static Builder con constructor para campos requeridos; métodos encadenables para campos opcionales que devuelven this; método build que retorna new User(this). El uso en el cliente queda claro: crear un new Builder con los parámetros obligatorios, encadenar llamados para opcionales y llamar a build para obtener el objeto.

Ventajas: hace la construcción de objetos más legible y mantenible, maneja parámetros opcionales con elegancia, facilita la creación de objetos inmutables y permite validaciones centralizadas antes de crear la instancia. Es ideal cuando una clase tiene muchos parámetros opcionales, cuando los constructores con muchos argumentos son confusos o cuando se busca inmutabilidad limpia.

Casos reales y ejemplos en Java: clases como StringBuilder o DocumentBuilder siguen la idea de construir paso a paso. Herramientas y frameworks como Lombok, Jackson o algunos componentes de Spring implementan o generan builders para simplificar el código. En proyectos de desarrollo de aplicaciones complejas, usar Builder mejora la calidad y reduce errores al escalar requisitos.

Builder y buenas prácticas: validar en el método build los estados incorrectos, mantener inmutables los objetos resultantes, y usar nombres de métodos claros para los setters encadenables. Para objetos con muchas variantes, considerar también la creación de builders específicos para casos de uso frecuentes.

Sobre Q2BSTUDIO: en Q2BSTUDIO somos una empresa de desarrollo de software especializada en aplicaciones a medida y software a medida, con experiencia en inteligencia artificial, ciberseguridad y servicios cloud. Ofrecemos soluciones completas que van desde el desarrollo de productos personalizados hasta la integración con servicios cloud aws y azure y la implementación de estrategias de servicios inteligencia de negocio. Si buscas desarrollar una aplicación robusta y escalable con patrones de diseño sólidos, podemos ayudarte con equipos expertos en arquitectura, programación y seguridad.

Errores y Soluciones de Git

Error 1 - fatal: not a git repository o fatal: not a git repository (or any of the parent directories): .git

Causa: El directorio no está bajo control de versiones Git porque no se inicializó con git init o la carpeta .git fue eliminada.

Solución: Inicializa el repositorio local con git init y vuelve a añadir y confirmar los archivos necesarios.

Error 2 - error: src refspec main does not match any

Causa: Ejecutaste git push origin main pero la rama main no existe localmente porque no se ha hecho ningún commit inicial.

Solución: Crea o renombra la rama y realiza el primer commit: git branch -M main para renombrar la rama si hace falta, git add . para preparar los archivos, git commit -m Initial_commit para crear el primer commit sin necesidad de comillas en el mensaje y git push -u origin main para subirlo a remoto.

Error 3 - fatal: origin does not appear to be a git repository

Causa: El remoto origin no está configurado en el repositorio local.

Solución: Crea el repositorio en GitHub o en tu proveedor preferido y enlaza el remoto con git remote add origin https://github.com/usuario/repositorio.git luego ejecuta git push -u origin main.

Puntos clave

git init pone el proyecto bajo gestión de Git. git remote add origin enlaza el repositorio local con el remoto. git branch -M main alinea el nombre de la rama por defecto entre local y remoto. No se puede hacer push sin commits previos; asegúrate de tener al menos un commit inicial para subir archivos de CI/CD como .github/workflows/main.yml.

Sobre Q2BSTUDIO

Las listas enlazadas parecen sencillas pero un puntero mal colocado puede deshacer toda la cadena. Un único truco la técnica del nodo centinela o dummy puede simplificar casi todos los algoritmos complicados sobre listas enlazadas. Esta guía explica por qué los nodos dummy facilitan el trabajo, los movimientos básicos con punteros, soluciones limpias a problemas clásicos con Java simplificado, análisis de casos límite y notas de complejidad.

Por qué un nodo dummy Un nodo dummy es un nodo extra que insertas al frente de la lista dummy -> head -> ... No forma parte de los datos reales pero garantiza un nodo no nulo antes del head. Beneficios Unificación de la lógica no hay que preguntar estoy eliminando la cabeza Simplificación de actualizaciones de puntero cada operación tiene un predecesor válido Código más seguro reduce comprobaciones nulas y errores de off by one

Movimientos básicos con punteros Todos los algoritmos con dummy se construyen a partir de unos pocos patrones de puntero Memoriza estas maniobras y la mayoría de problemas con listas enlazadas se vuelven mecánicos

Encontrar predecesor Propósito moverse al nodo justo antes del objetivo Ejemplo en pseudocódigo span while count < k prev = prev.next

Splice o eliminar Eliminar un nodo prev.next = prev.next.next

Insertar después Insertar un nodo después de prev node.next = prev.next prev.next = node

Inserción al frente o head insertion Usada para invertir segmentos en sitio next.next = prev.next prev.next = next

Problemas clásicos y soluciones A continuación siete problemas habituales resueltos con la técnica dummy descrita de forma compacta y con complejidad típica O(n) tiempo y O(1) espacio.

A Remover el nodo nth desde el final Idea dos punteros y un dummy Pseudocódigo Java simplificado span ListNode dummy = new ListNode(0); dummy.next = head; ListNode fast = dummy, slow = dummy; for i = 0 i < n i++ fast = fast.next; while fast.next != null fast = fast.next slow = slow.next; slow.next = slow.next.next; return dummy.next;

B Invertir una sublista de left a right Patrón head insertion span ListNode dummy = new ListNode(0); dummy.next = head; ListNode prev = dummy; for i = 1 i < left i++ prev = prev.next; ListNode curr = prev.next; for i = 0 i < right - left i++ ListNode next = curr.next; curr.next = next.next; next.next = prev.next; prev.next = next; return dummy.next;

C Fusionar dos listas ordenadas Adjuntar nodos a un tail que parte de un dummy span ListNode dummy = new ListNode(0); ListNode tail = dummy; while l1 != null && l2 != null if l1.val < l2.val tail.next = l1; l1 = l1.next; else tail.next = l2; l2 = l2.next; tail = tail.next; tail.next = l1 != null ? l1 : l2; return dummy.next;

D Particionar una lista alrededor de un valor x Mantener dos listas con dummy y luego unirlas span ListNode beforeDummy = new ListNode(0), afterDummy = new ListNode(0); ListNode before = beforeDummy, after = afterDummy; while head != null if head.val < x before.next = head; before = head; else after.next = head; after = head; head = head.next; after.next = null; before.next = afterDummy.next; return beforeDummy.next;

E Eliminar duplicados completamente en lista ordenada Borrar todos los nodos con valores repetidos span ListNode dummy = new ListNode(0); dummy.next = head; ListNode prev = dummy; while head != null boolean dup = false; while head.next != null && head.val == head.next.val dup = true; head = head.next; if dup prev.next = head.next; else prev = prev.next; head = head.next; return dummy.next;

F Rotar a la derecha k posiciones Convertir en anillo y romper en el lugar correcto span if head == null || head.next == null return head; ListNode dummy = new ListNode(0); dummy.next = head; int len = 1; ListNode tail = head; while tail.next != null tail = tail.next; len++; k %= len; if k == 0 return head; ListNode newTail = dummy; for i = 0 i < len - k i++ newTail = newTail.next; ListNode newHead = newTail.next; newTail.next = null; tail.next = head; return newHead;

G Intercambiar nodos de dos en dos Swap con ajuste de punteros y dummy span ListNode dummy = new ListNode(0); dummy.next = head; ListNode prev = dummy; while head != null && head.next != null ListNode first = head; ListNode second = head.next; prev.next = second; first.next = second.next; second.next = first; prev = first; head = first.next; return dummy.next;

Checklist de casos límite Antes de dar por válida una solución prueba Always lista vacía head == null lista con un solo nodo la operación afecta al primer nodo la operación afecta al último nodo valores duplicados o iguales si aplica El nodo dummy hace que la mayoría de estos casos se manejen de forma natural

La semana pasada alguien me preguntó si debía presentar el examen AWS Generative AI Practitioner. Aquí mi punto de vista y por qué merece la pena si trabajas en tecnología y quieres impulsar tu carrera hacia la inteligencia artificial.

La IA generativa es la mayor revolución desde Internet. Está transformando empleos y procesos en todos los sectores y apenas estamos al inicio. Si eres desarrollador o arquitecto no puedes limitarte a usar chatbots de forma pasiva. Es clave comprender qué son los LLM, cómo funcionan tokens, temperatura y contexto, y cómo integrarlos en aplicaciones modernas para crear flujos de trabajo más inteligentes y productos diferenciales. Esta certificación cubre los conceptos fundamentales que permiten diseñar soluciones prácticas y seguras.

Empieza ya. Prepararte para este examen despierta apetito por temas avanzados como agentes IA, sistemas agentivos y arquitecturas de orquestación de modelos. También es una rampa de entrada excelente si quieres reorientar tu carrera hacia AI ML. No hace falta ser experto para beneficiarse: basta con tener una base técnica sólida para diseñar e implementar proyectos reales.

Es nivel practitioner, pero no tan sencillo como parece. El alcance es más acotado que el AWS Cloud Practitioner pero más técnico. Espera preguntas sobre servicios de datos de AWS y especialmente sobre SageMaker. Con preparación adecuada puedes aprobar a la primera, pero no lo subestimes.

Lanzamiento 0.1 ¿Vamos

En OSD600 verano 2025 el proyecto Release será en el que dedicaremos la mayor parte del tiempo. Release es una herramienta de linea de comandos que genera un archivo de texto a partir de un repositorio para enviarlo a un modelo de lenguaje grande. De este modo se preserva no solo el contenido de los archivos sino tambien la estructura del repositorio, lo que facilita el analisis por parte de agentes IA y flujos de trabajo automatizados.

La primera decision fue el lenguaje de implementacion. Queria que el usuario no se preocupara por el entorno: abrir la linea de comandos, ejecutar el comando y obtener el resultado sin tener que instalar software adicional. Pense en C++ por su portabilidad, pero finalmente me decidi por Go porque permite compilar ejecutables multiplataforma faciles de distribuir y aprender backend con Go es una gran oportunidad.

Ya instale Go, complete mi primer programa de prueba hello go y aprendi lo basico para empezar a escribir Release. No incluire aqui el codigo literal por simplicidad, pero la experiencia inicial me ha dado confianza para seguir practicando y mejorar la herramienta hasta convertirla en una solucion estable para desarrolladores y equipos que quieran preparar repositorios para analisis por modelos y pipelines de IA.

Lanzamiento 0.1 - Go? En OSD600 Verano 2025, Release es el proyecto en el que concentraremos la mayor parte del tiempo. Se trata de una herramienta CLI capaz de generar un archivo de texto representando un repositorio para enviarlo a un modelo LLM, preservando tanto el contenido de los archivos como la estructura del proyecto.

La decisión sobre el lenguaje fue uno de los primeros retos. Quería que el usuario no tenga que preocuparse por el entorno: abrir la terminal, ejecutar un comando y obtener el resultado sin instalaciones innecesarias. Se valoró C++, pero Go destacó por su facilidad para compilar ejecutables multiplataforma y por permitir distribuir una sola binaria. Además, Go es ideal para aprender conceptos de backend que queremos dominar.

He instalado Go y completado mi primer programa muy sencillo como ejercicio de inicio. Más que el código en sí, lo importante fue comprobar el flujo de trabajo con VS Code, la compilación a ejecutable y sentir que puedo avanzar hasta llegar a una versión funcional de Release. Es una etapa de prototipado y aprendizaje antes de implementar características como recorrido del árbol de directorios, filtrado de ficheros relevantes y generación de entradas optimizadas para agentes IA.

Presentamos Gundam Génesis Morfo, una herramienta creativa que transforma cualquier imagen de personaje en un mecha original y listo para la batalla, junto con su propia caja coleccionable y arte de empaque. Esta propuesta nace de la pasión por el anime, los mechas y el modelismo, y utiliza capacidades multimodales avanzadas para ofrecer resultados que parecen sacados de una tienda de hobby en Akihabara.

Gundam Génesis Morfo toma como punto de partida la imagen que sube el usuario y un conjunto de indicaciones textuales que funcionan como guía de diseño. El sistema analiza la silueta, la paleta de colores y la personalidad percibida del personaje para reinterpretarlo como un robot gigante, a la vez que aplica instrucciones concretas sobre color, arma y estilo artístico para producir una obra completamente nueva.

El flujo creativo se basa en una integración profunda de imagen y texto, pasando de Imagen y Texto a Imagen final fusionada. Gracias a esta fusión, el resultado no es un simple filtro, sino un nuevo concepto visual que conserva rasgos del original y los combina con elementos de diseño específicos solicitados por el usuario.

En el desarrollo de este proyecto se aprovechó el poder de modelos multimodales como gemini-2.5-flash-image-preview, que permiten iteraciones rápidas y afinado de prompts hasta conseguir instrucciones precisas y repetibles. Ese ciclo rápido de prueba y ajuste fue clave para lograr que la IA entendiera indicaciones complejas como transformar al personaje en un mecha, colocarlo junto a la caja y diseñar el arte del empaque con accesorios incluidos.

El proceso para el usuario es sencillo: subir la imagen del personaje, ajustar parámetros como color primario, arma o estilo de caja y recibir en segundos una imagen final donde el mecha aparece pose heroica junto a su empaque diseñado. Este enfoque convierte a la IA en un verdadero compañero creativo, ideal para generar concept art de alta calidad y cajas coleccionables que evocan el mundo del Gunpla.

Gundam Génesis Morfo también es un excelente ejemplo de cómo la inteligencia artificial aplicada puede integrarse en productos y servicios empresariales. En Q2BSTUDIO somos especialistas en desarrollo de software a medida y aplicaciones a medida, y aprovechamos soluciones de IA para crear experiencias únicas y escalables para empresas. Nuestro equipo puede ayudarte a llevar ideas similares a producción, integrando agentes IA, pipelines multimodales y soluciones orientadas a la experiencia del usuario.

Además de desarrollo de aplicaciones y software a medida, Q2BSTUDIO ofrece servicios completos de ciberseguridad y pruebas de intrusión para proteger tus productos digitales, así como servicios cloud para AWS y Azure que facilitan la puesta en marcha y escalado de proyectos con demanda de procesamiento intensivo. Con nosotros puedes diseñar desde prototipos creativos hasta productos empresariales robustos que incorporen ia para empresas y agentes IA.

Si buscas impulsar la capacidad analítica de tu organización, también trabajamos en servicios de inteligencia de negocio y dashboards con power bi que convierten datos en decisiones accionables. Nuestro enfoque combina consultoría técnica y diseño de soluciones a medida para que las empresas obtengan valor real y medible.