Del verso al objeto: cómo un poema se convierte en clase

• #Origen
• #Principios
• #Ejecución
• #Manifestaciones

Origen

Desde hace más de una década escribo y guardo notas, versos y fragmentos dispersos. Permanecieron en blocs digitales como registros íntimos, hasta que en los últimos años comenzaron a encontrar una nueva forma de expresión en mi estudio de Python. Allí descubrí que el lenguaje de programación también podía ser un espacio poético: no solo como metáfora, sino como estructura capaz de producir tanto palabras como visuales.

Este cruce me llevó a explorar lo que llamo poesía declarativa: una manera de componer en código donde las emociones, ideas o afectos se formulan como clases, funciones u objetos, y al ejecutarse generan una manifestación visual. Así, el código no es únicamente escritura, sino también detonador de una estética viva.

Principios

Cuando comencé este proyecto, me pregunté si ya había alguien explorando la intersección entre poesía y programación. Así descubrí la práctica del code poetry, un espacio vibrante donde artistas y tecnólogos fusionan versos ejecutables con sensibilidad poética. Encontré charlas como la de Linda Liukas sobre “la poesía de la programación” (TEDxCERN), voces como Lai Yi Ohlsen que plantean el código como forma poética en movimiento, y obras clave como code — poetry, la antología generada por Daiel Holden y Chris Kerr con poemas que compilan y se leen como poesía.

En ese recorrido me di cuenta de que, aunque estas aproximaciones abrían un horizonte fascinante, el gesto que yo buscaba se movía hacia otro lugar. Más que inscribirme en la tradición del code poetry, me interesaba abstraer los afectos como estructuras que pudieran declararse, compartirse y ejecutarse. De allí surgió el nombre de poesía declarativa, como una suerte de desplazamiento y reterritorialización: un intento de pensar el código no solo como lenguaje poético, sino como molde sensible, capaz de recibir variables singulares y devolver manifestaciones que traduzcan lo intangible en visualidad, movimiento y forma.

En la siguiente tabla busco sintetizar los axiomas o principios que sostienen la exploración de la poesía declarativa. Cada fila representa un concepto clave —como fragmento u objeto afectivo— y lo acompaña con una definición breve, una fecha de referencia y una nota que amplía su sentido poético o metodológico.

De esta forma, la tabla cumple varias funciones:

1. Marco conceptual → convierte intuiciones y hallazgos en conceptos nombrados.
2. Registro temporal → señala cuándo fueron pensados o formulados, subrayando su carácter de proceso en construcción.
3. Bitácora expandida → las notas permiten anotar resonancias, ejemplos o metáforas que enriquecen el concepto.
4. Axiomas declarativos → funcionan como “bases” o “módulos” que pueden seguir ampliándose, igual que el código.

Más que un resumen, la tabla es una cartografía inicial: un intento de organizar las piezas del proyecto como si fueran nodos conectados en un mismo territorio, abiertos a futuras transformaciones.

Fragmento	Punto de partida: pequeñas piezas de código/verso que condensan emociones o gestos mínimos.	enero 2025	Microestructuras donde lo íntimo se traduce en sintaxis.
Objeto afectivo	Al ejecutarse, un fragmento se convierte en objeto: instancia que condensa un afecto en atributos y métodos.	mayo 2025	Cada objeto es único porque responde a las variables de quien lo crea.
Declaración	En vez de narrar, se declara. Se nombran estados y se fijan en variables listas para ser compartidas o transformadas.	junio 2025	Ejemplo: class Cuido como declaración del cuidado.
Ejecución	Al correr el código, se activa la dinámica afectiva (la herida sana, el recuerdo se templa).	junio 2025	El print es el inicio, pero la manifestación puede ser visual, sonora, material etc.
Resarcir fuera del lenguaje	Los afectos se expresan más allá de las palabras, a través de código-visual-sonido.	agosto 2025	Una forma de compensar la dificultad de decir lo que se siente.
Dinámica interior	Reconocimiento de la complejidad interna de cada sujeto.	julio 2025	El código se vuelve un espejo de la interioridad.

Ejecución

Del verso al objeto: cómo un poema se convierte en clase

Quisiera explicar cómo funciona para mí esta transición: de versos íntimos, fragmentos y objetos afectivos hacia estructuras que pueden pensarse y ejecutarse en código. No es solo escribir un poema y luego programar algo inspirado en él. Es intentar abstraer el objeto afectivo que guarda el poema y traducirlo a una forma algorítmica que también sea sensible.

Nota Técnica ¿Qué es Python?

Python es un lenguaje de programación creado para ser claro y legible.
A diferencia de otros lenguajes con símbolos extraños, en Python las instrucciones parecen frases sencillas.

Sirve para organizar ideas en tres niveles básicos:

• Clases → moldes o planos que definen un objeto.
• Objetos → versiones concretas de esos moldes.
• Métodos → acciones que los objetos pueden realizar.

La estructura de una clase

Una clase en Python es como una receta: define los ingredientes (atributos) y los pasos (métodos).

Ejemplo simple:

Cómo leer lo anterior

• class Perro: → Declara una clase llamada Perro.
• def __init__(self, nombre): → El método de inicio: se ejecuta cuando nace un nuevo perro.
• self → Significa “este mismo objeto”. Permite que cada perro recuerde sus propios datos.
• self.nombre = nombre → Guarda el nombre del perro como un atributo.
• self.hambre = True → Estado inicial: el perro tiene hambre.
• def comer(self): → Método que cambia el estado de hambre a False.
• print(...) → Escribe un mensaje en pantalla.

¿Qué significa ejecutar?

Ejecutar es usar el molde para crear un objeto y ponerlo en marcha:

En palabras simples:

1. Se crea el objeto (mi_perro).
2. Se llama un método (comer()), que cambia su estado.
3. El resultado se muestra en pantalla con print.

Comentarios: las notas dentro del código

En Python, todo lo que empieza con # es un comentario.
No se ejecuta: es solo una nota para el lector o para el futuro programador.

Ejemplo:

Los comentarios son como márgenes en un libro: anotaciones que acompañan el texto.

El ciclo básico en Python

Podemos resumir la lógica en cuatro pasos:

1. Declarar → se escribe una clase con atributos y métodos.
2. Instanciar → se crea un objeto a partir de esa clase.
3. Ejecutar → se llaman sus métodos y se modifican sus estados.
4. Observar → se imprime, se muestra o se genera un resultado.

¿Y py5?

Mientras Python es general (sirve para web, datos, inteligencia artificial…), py5 es una librería que permite crear visuales y gráficos.
Con ella puedes dibujar círculos, mover líneas, animar formas… en pocas líneas de código.

Ejemplo mínimo:

Otro ejemplo sería crear una sensación de ecos visuales, como si el movimiento dejara huella.

El Poema en Verso

En este caso, el poema Si me cuidas fue el punto de partida. Lo que me interesaba no era reescribirlo en Python tal cual, sino descubrir cuáles eran sus gestos esenciales (cuidar, cubrir, callar, sanar, recordar) y ver cómo esos gestos podían volverse atributos y acciones dentro de una clase llamada Cuido

Este es el verso original que escribí el 04 de Septiembre del 2024:

Si me cuidas 

Si me cuidas, 
Hazlo en silencio, 
Sin la urgencia del tiempo 
Que se nos escapa. 

Cúbreme
Como quien cubre una herida, 
Sin preguntar cómo pasó,
Solo dejando que sane. 

No busques palabras, 
Deja que el gesto hable,
Que tus manos digan lo que yo 
No puedo pedir. 

Cúrame 
Del peso de estos días, 
Donde el frío
Se cuela entre los recuerdos. 

Si me cuidas, 
Será suficiente 
Con estar, 
Con no soltarme. 

Y en tu abrazo, 
Encontraré el rincón 
Que creí perdido. 



Aquí aparece un tiempo no urgente, un gesto de silencio, una herida cubierta, un dolor callado, un recuerdo frío, y un rincón perdido. Cada imagen es un estado, cada acción una instrucción afectiva.

El poema en código (abstracción del objeto afectivo)

Aquí se puede ver cómo cada verso se traduce a un atributo. El tiempo se guarda como estado, el gesto como variable, la presencia como un valor booleano (True/False). También me pareció muy interesante el poder generar un diálogo como las notas de un programador, como una narración, esto lo pensaba en forma de pregunta ¿Cómo se leería esto en voz alta?

Del verso a la acción (métodos como gestos)

El poema no se queda en descripción, también pide acciones: cubrir, hablar, curar, cuidar. En el código, esas acciones son métodos que se ejecutan.

Ejemplo:

• Verso: “Cúbreme / sin preguntar cómo pasó”
• Método en Python:

El método cambia el estado de la herida y devuelve una frase.

En Python, el condicional if es como una puerta que se abre solo si se cumple cierta condición.
Dentro del método cubrir(self), esta línea:

significa: “si existe una herida, entonces haz lo siguiente”.

Si la condición se cumple (es decir, si self.herida tiene algún valor), el código dentro del bloque se ejecuta:

Es como decir: “si hay herida, cámbiala a estado de sanando y muestra la frase”.

En cambio, si no hubiera herida (por ejemplo, si self.herida estuviera vacía o fuera None), el bloque no se ejecutaría y el método no haría nada.

👉 De manera más amplia:

• if en Python funciona como una condición lógica: pregunta “¿esto es verdadero?”.
• Si la respuesta es sí, ejecuta el bloque indentado (con sangría).
• Si la respuesta es no, simplemente lo salta.

En este caso, el condicional actúa como un guardián: se asegura de que solo cuando hay una herida, se inicie el proceso de cubrirla y sanarla.

Otro ejemplo:

• Verso: “No busques palabras, deja que el gesto hable”
• Método:

El gesto sustituye la palabra. El código devuelve exactamente esa imposibilidad.

Ejecución como lectura performativa

Al correr el programa (fragmento):

Se ejecuta una especie de lectura performativa:

• Se cubre la herida.
• Se dice con las manos lo que no se puede pedir.
• Se cura con el abrazo.
• Y al final, se encuentra el rincón perdido.

La ejecución completa del programa devuelve este itinerario mínimo:

• Se cubre la herida.
• Se dice con las manos lo que no se puede pedir.
• Se cura con el abrazo.
• Y al final, se encuentra el rincón perdido.

Este es el objeto afectivo final, el núcleo que se abstrae tanto en el poema como en el código. Una especie de diagrama emocional que, al ser corrido, no solo se lee: también se siente.

Síntesis

El verso, en su forma íntima, guarda una experiencia personal. Pero cuando lo traduzco a una clase en Python, surge otra posibilidad: alguien más podría cambiar las variables y ejecutar el mismo objeto poético, obteniendo un resultado distinto, un desenlace afectivo propio.

Pensemos Freud, que alguna vez intentó describir el aparato psíquico a través de un diagrama, como si la mente pudiera modelarse en niveles y dinámicas. Aquí sucede algo similar: ¿qué tal si los afectos pudieran representarse como clases y métodos, como estructuras capaces de ser instanciadas una y otra vez, con variaciones singulares?

En el fondo, este ejercicio busca mostrar que detrás de cada verso hay atributos, dinámicas y gestos que pueden abstraerse:

• un tiempo no urgente,
• un gesto silencioso,
• una herida cubierta,
• un dolor callado,
• un recuerdo frío,
• un rincón perdido.

Al nombrarlos en código, se vuelven parámetros manipulables: cualquiera podría definir sus propios valores, ejecutar el algoritmo y obtener un desenlace distinto. El poema deja de ser solo una experiencia mía y se abre como una clase compartida de lo afectivo.

Variables nuevas, dan un resultado diferente

Imaginemos que el cuidado no es solo un gesto humano, sino también un sistema que puede representarse en código.
La clase Cuido funciona aquí como un objeto afectivo: una estructura básica que guarda gestos, tiempos, presencias, heridas, recuerdos y umbrales de lo que entendemos como “ser cuidados”.

Lo interesante es que la clase no cambia, lo que cambia son las variables que se le entregan. En una ejecución, la presencia puede estar; en otra, puede faltar. A veces el tiempo se siente elástico y calma, otras veces se vuelve urgente y asfixiante. Los gestos pueden ser un abrazo largo o la indiferencia. Los recuerdos pueden estar helados o cálidos.

Cada conjunto de variables produce un resultado diferente al ejecutar el mismo objeto:

• En un caso, se encuentra el rincón perdido y decimos “Suficiente”.
• En otro, aunque haya intentos de cubrir o curar, el índice de cuidado no alcanza, y el resultado es “Vacío”.

Este experimento busca mostrar que, al igual que en la vida, los afectos no están fijados en una sola forma, sino que son dinámicos y dependen de cómo se configuran sus condiciones. El mismo algoritmo —la misma clase— puede llevarnos a desenlaces distintos, porque lo que cambia no es la estructura sino las circunstancias.

Así, Cuido no es solo un código: es una metáfora de cómo lo íntimo y lo afectivo pueden pensarse como procesos que se activan, se transforman y se reinterpretan en cada ejecución.

Por ejemplo:

Escenario A · Cuidado pleno (ejecución paso a paso)

Qué verías:

• Cubrir baja dolor y pone herida → sanando.
• Dos curaciones llevan recuerdo a calido.
• Con presencia+tiempo elástico+gesto amoroso+recuerdo cálido, el índice supera el umbral → “Suficiente” y rincon="encontrado".

Escenario B · Cuidado ausente (mismas acciones, otras variables)

Qué verías:

• Aunque hay cubrir y curar, sin presencia y con tiempo urgente + gesto indiferente el índice no alcanza → “Vacío”, rincon=None.

Escenario C · Cuidado intermitente (umbral más bajo, gesto tibiamente presente)

Qué verías:

• Con presencia, tiempo elástico y recuerdo que llega a cálido, aunque el gesto no sea el mejor, el umbral más bajo permite declarar “Suficiente”.

Mapa mental (variables → efecto)

Variable	Valores de ejemplo	Efecto directo en el cuidado
presencia	True / False	+0.5 si True (es la palanca principal)
tiempo	"elastico" / "urgente"	+0.2 si es elástico (habilita calma)
gesto	"mirada_que_abraza", "caricia_lenta", "abrazo_largo", "indiferencia", "palabra_tibia"	+0.2 si es un gesto cálido/táctil
recuerdo["temperatura"]	"helado" → "templado" → "calido"	+0.1 si llega a cálido
umbral_de_cuidado	0.3–0.8	Qué tan exigente es declarar “Suficiente”
cubrir()	—	herida→sanando, dolor-2
hablar_con_las_manos()	—	si el gesto es táctil, dolor-1
curar()	—	sube la temperatura del recuerdo

Esta tabla funciona como un mapa mental del objeto afectivo. Al mostrar las variables, sus posibles valores y el efecto que producen, nos permite entender cómo un mismo código (la clase Cuido) puede generar experiencias distintas según los datos que se introduzcan. No se trata de medir literalmente el cuidado, sino de abstraer dinámicas afectivas en forma de variables que cambian el resultado: la presencia como palanca central, el tiempo como modulador, el gesto como mediador sensible, el recuerdo como temperatura que se transforma. Los métodos (cubrir(), hablar_con_las_manos(), curar()) son las acciones que activan cambios internos en el objeto.

Ahora bien, ¿qué pasa si pudiera abstraer mi propia experiencia del cuidado en este molde? Para mí, cuidado significa un rincón seguro, un abrazo cálido, la vivencia íntima de ser sostenido sin condiciones. Ese es mi objeto afectivo. Pero el cuidado, en la vida real, es mucho más difícil de comunicar: lo sentimos, lo necesitamos, y sin embargo pocas veces logramos transmitirlo tal como lo vivimos. ¿Y si existiera una estructura —una especie de armazón o código— que permitiera compartir esa vivencia más allá de las palabras? Al usar esta clase tú podrías agregar tus propios atributos y variables, y al hacerlo, experimentarías cómo yo concibo el cuidado. Al mismo tiempo, si tú crearas tu propio objeto afectivo del cuidado, quizás elegirías otras dinámicas, otros gestos, otras condiciones.

Ese ejercicio abre un espacio de diálogo: hacer tangible lo intangible. Lo que aquí aparece como código se vuelve un metalenguaje, un modo de conversar sobre afectos sin depender únicamente de palabras, que siempre quedan cortas. Si el afecto es complejo, variable y subjetivo, este enfoque permite al menos construir una base compartida: no para reducirlo, sino para visibilizar que incluso lo que parece instintivo, como cuidar o ser cuidado, está lleno de matices que cada quien encarna de manera diferente.

Manifestaciones

Al presentar y contrastar estos fragmentos como abstracciones —a los que llamé objetos afectivos— surgió una pregunta inevitable: si son código, como los que se usan en la programación real, ¿qué sucede cuando se ejecutan? Más allá de un simple print en pantalla, Python y py5 abren la posibilidad de que esos afectos encuentren una forma visual: líneas, colores, movimientos que condensan dinámicas interiores. Y es que los afectos son demasiado complejos para reducirlos solo a palabras; la historia de las relaciones humanas, la sociología, la psicología misma nos muestran lo difícil que resulta comunicar nuestra vida interior sin distorsión o simplificación.

¿Qué pasaría si pudiéramos resarcir esa limitación a través de estos objetos afectivos?

Imagina que la experiencia del cuidado —traducida en la clase Cuido— se manifiesta como un visual donde tus variables y las mías dialogan: donde el tamaño, la forma o el color se vuelven metáforas tangibles de gestos invisibles. Así, la ejecución del código no es solo técnica, sino un ejercicio de empatía: un modo de materializar aquello que sentimos y que a veces el lenguaje verbal no alcanza. En este punto surgen las manifestaciones: cada clase se convierte en un visual que intenta comunicar, desde mi propio set de variables, una vivencia afectiva hecha forma, movimiento y color.

Ejecución de Class Cuido

Aquí podemos ver la transición que hubo al explorar py5 para generar estos visuales a partir del fragmento de código de Class Cuido, primero como imágenes estáticas y luego como movimientos, en este caso como GIF, que si bien permiten empezar a trazar una dinámica de movimiento, circularidad, velocidad, aunada al color, tamaño, forma, por el formato creo que no se logra apreciar de la mejor manera la manifestación visual del objeto afectivo.

A partir de esa limitación, exploré cómo hacer que el resultado fuera más fluido y cercano a la dinámica interior de los objetos afectivos. De ahí surgió el paso hacia el video: cada pieza está formada por miles de imágenes individuales generadas por el código. Al trabajar a 60 cuadros por segundo, un minuto de video equivale a 3,600 imágenes que deben construirse una por una y luego ensamblarse.

Este proceso exige traducir los atributos del objeto afectivo en instrucciones visuales para cada cuadro: posición, color, movimiento o interacción. Lo que parece una animación fluida en pantalla es, en realidad, la suma de miles de microcálculos. El resultado es una representación más clara de la dinámica interior de los objetos afectivos, donde cada video no solo muestra un movimiento, sino también la magnitud del trabajo necesario para que esas variaciones sean visibles.