Trad. César Panza
:
Para la teoría de la computación, la utilización de modelos analíticos en la constitución de una teoría matemática del lenguaje ha sido fundamental. El objetivo de establecer reglas para construir un conjunto finito de instrucciones que puedan ser ejecutadas de una manera unívoca y mecánica, encontró en la ausencia de homonímia de los lenguajes formales un paraíso, la utopía del lenguaje universal. Teniendo como consecuencia colateral la separación, definitiva, de las funciones expresivas y las cognoscitivas del lenguaje: la poesía y la metafísica serían entonces desterradas de los discursos que producen conocimiento.
Pero realmente, no fue tan definitiva. Más pronto que tarde «de esa noche original en que andan a tientas dos ciegos de nacimiento, el uno equipado con el instrumental científico, el otro asistido solamente por las fulguraciones de la intuición», ninguno tendría certeza de salir a flote cargado de mayor o menor luminiscencia (Saint John-Perse). El misterio los arropa a ambos por igual y las grandes batallas del espíritu poético no son menos tragicómicas que aquellas de la ciencia contemporánea.
Así mismo, la interrelación entre las herramientas del discurso poético y el científico han demostrado la falsedad de la separación entre las prestaciones expresivas y analíticas del lenguaje. Para muestra de ello, está el OuLiPo de Queneau y Le Lionnais, los experimentos combinatorios de la poesía brasileña concreta, el generador Taroko Gorge de N. Monfort y así hasta llegar al Google Poetics, sin mencionar un sin fín de interesantes experimentos electrónicos que componen lo que se conoce como digital poetry.
En ese sentido, un experimento de particular interés es la code poetry. Técnica que mezcla las nociones básicas de la versificación con la composición en los lenguajes formales de la programación informática, cuyo fin no solo comprende el output de un proceso automatizado, sino sobre todo el «script» final, presentado para la lectura humana, bajo la consideración de que la mayoría de los lenguajes de programación tienen un conjunto de palabras reservadas para designar estructuras de datos, constantes, funciones y relaciones intrínsecas a su sintáxis, con significados bien definidos para determinadas instrucciones: palabras que se convierten no solo en restricción para la creación sino también en herramienta a su servicio.
En 2012 se realizó un extenso proyecto internacional llevado a cabo de Ishac Bertran: se trató de una convocatoria pública a enviar poemas en código a una dirección en la red, para luego ser depurada y publicada en un libro con prefacio de Jamie Allen. La manera de presentar esta técnica compositiva a los lectores de POESIA comprende no solo la traducción de una generosa porción de los textos antologados, sino también la descripción del proyecto en cuestión, así como parte importante del prefacio, donde se discuten con detalle los parámetros creativos, sus enigmas y posiblidades. Aunque el abanico temático de los poemas en código comprende los temas clásicos de la poesía, el criterio de selección no fue uniforme, obedeciendo en primer lugar a una deliberada propensión a temas reflexivos y filosóficos; en segundo lugar, seleccionando todos aquellos que fueron escritos en HTML, por solo el guiño autorreferencial que significa que el editor de texto de esta web se sostenga en dicho lenguaje; y por último, a la propia posibilidad de traducción.
Caben destacarse algunas de las particularidades del proceso de traducción, sus dificultades y sus resultados, al menos en cuanto a que las palabras reservadas de los lenguajes utilizados pertenecen al inglés. Se cedió un par de veces a la tentación de, conociendo la instrucción, traducir también los nombres de las funciones computacionales, realizando lo que se conoce como un pseudo código. De otra forma, no se hubiese logrado la captura del sentido completo del poema. En otros casos se contuvo tal tendencia, obteniendo como resultado un texto en un espanglish aparentemente solo comprensible para programadores, pero no por ello menos valioso como poema en un hipotético lenguaje universal del futuro, capaz de estimular no solo a los humanos, sino también a las máquinas sensibles. Este último oxímoron à la Church-Turing se justifica, quizás, por el hecho de que la ejecución de un programa es propiamente un proceso de traducción de un conjunto de instrucciones simbólicas a sucesiones binarias de impulsos eléctricos. Volcar los code {poems} al castellano resultó ser algo bastante parecido a la compilación, así como lo será su lectura, volviéndose un indicio de prueba para las teorías sobre la maquinalidad de los humanos, de no ser por la convicción de que la poesía es más bien un proceso de desautomatización del lenguaje, la percepción y los comportamientos.
C.P.
λ
La poesía es una forma de arte literario en el cual el lenguaje es usado por tus cualidades estéticas y evocativas. Permite una multiplicidad de interpretaciones y por lo tanto resuena de forma diferente con cada lector.
El código de programación es un conjunto de lenguajes utilizados para comunicarse con y entre las computadoras. Tiene sus propias reglas (sintáxis) y significados (semántica). Como los escritores y poetas, los programadores también tienen su propio estilo que incluye estrategias para optimizar el código mientras es leído por una computadora, y facilitar su comprensión a través de la organización visual y comentarios para otros programadores.
El código puede hablar literatura, lógica, matemática. Contiene diferentes capas de abstracción y las enlaza al mundo físico de los procesadores y los dispositivos de memoria. Todos estos recursos pueden contribuir a expandir las fronteras de la poesía contemporánea; usar el código como un nuevo lenguaje propio. El código puede hablar sobre la vida, la muerte, el amor y el odio. El código que fue hecho para ser leído, no ejecutado.
Con el objeto de explorar el potencial de un código para comunicar al nivel de la poesía, se abrió una convocatoria entre el 22 de febrero y el 31 de mayo del 2012. Las reglas para enviar poemas código eran sencillas: (1) el poema debía tener un tamaño de 0.5 KB, y (2) se requería que compilase.
Un total de 190 poemas fueron recibidos de 30 países diferentes. Los programadores que colaboraron con el proyecto hicieron la selección para ser impresos en este libro, procurando representar la variedad y creatividad de los textos enviados, así como diferentes aproximaciones a la poesía en código.
Los poemas de este libro no tienen por qué ser leídos necesariamente en un orden particular. Dicho esto, el flujo lineal del libro ha sido ordenado con la intención de proveer un tránsito balanceado y disfrutable al lector.
Ishac Bertran
μ
Me siento en una habitación
en esta habitación hay imágenes que no puedo mirar
objetos y personas que no puedo reconocer
códigos que nunca descifraré
libros que nunca leeré
puedo ver, puedo oir
tengo mi propio lenguaje
La poesía y los códigos de las computadoras provienen del lenguaje. Algunas formas de poesía pueden concebirse como un código; como conjuntos de versos encriptados, para ser leídos y releídos, «compilados» en la mente. El poeta siempre ha tenido la libertad de jugar en este sentido porque hemos nacido (al menos) dos veces: una vez en este mundo, y otra vez en el lenguaje. Conocemos a los lenguajes de manera íntima, y somos virtuosos, de acuerdo a nuestros propios términos, en la invocación y conjura que cada uno de ellos permite. code{poems}, como libro, es un experimento sobre el potencial de tal intimidad, pero en el reino de los lenguajes de programación. Es una investigación sobre la explosión de las formas artísticas y los mundos imaginativos que resultan de nuestra cercana comunión con símbolos simples y su disposición en la página impresa.
Los programadores, los «coders», pueden manipular el material del código de la misma forma en que un poeta puede presentar al material del lenguaje, aunque con un conjunto de herramientas lingüísticas más restringidas, esotéricas y matemáticas. Los jeroglíficos de los programadores incluyen frecuentemente frases del inglés, pero estas palabras toman significados sesgados y concentrados. En los códigos de programación, las construcciones como el ciclo «for» o el «if-then-else», son similares a sus connotaciones en inglés, pero adoptan nuevas eficacias, nuevas características, nuevos poderes sobre el control de un dispositivo físico final del hardware. Así, la destreza que los contemporáneos escritores-de-código tienen con sus sistemas simbólicos es diferente, no así menos virtuoso, y para algunos no menos intuitivo (si acaso no más). Hay algunos que sueñan en FORTRAN, y en algún lugar, en este preciso momento, ocurre una apasionada conversación en Python. El compromiso a largo plazo y el tiempo que toma la creación de software cambia los patrones de pensamiento de una persona. Una vida dedicada a la autoría de software puede cambiar la forma en que la mente interactúa con el mundo. Del mismo modo en que cualquier forma expresiva lo hace, el lenguaje de programación cambia las maneras en cómo la gente piensa, y esto tiene efectos masivos en la cultura como un todo. A pesar de las substanciales restricciones formales, y las estandarizaciones intrínsecas, el estilo de programación de un autor en un lenguaje dado siempre está presente en sus códigos. Tal y como los «lenguajes humanos», los lenguajes de máquina no son nunca meramente indicativos o funcionales, sino más bien una condensación escrita del ánimo, la personalidad y la visión-de-mundo de su autor. El diseño de un software profundamente jerárquico puede mostrar un contexto cultural y político en el cual una arquitectura de software-hardware evoluciona. Hay lectores experimentados que pueden diferenciar el código austero de un colaborador de Europa del Este de aquél con un verborreico y accesible estilo de un «coder» de Silicon Valley. Incluso con las estrictas reglas de software, el estilo, las maneras y los métodos son distintivos, variados y personales.
Las simpatías que los programadores manifiestan a sus lectores más orgánicos (las personas) son obvias, en la medida en que usualmente se parecen a lo que todo leemos a diario. La utilización de «comentarios» legibles-por-humanos, como característica de los lenguajes de programación, es algo que se interpreta como signo de generosidad hacia futuros lectores y usuarios de un código. En todos los códigos computacionales, puede haber una intencionalidad hacia una audiencia secundaria de lectores humanos, pero siempre hay una deferencia hacia la audiencia electrónica primaria. La generosidad del autor, o su falta de, hacia las audiencias humanas a menudo se extiende en otra dirección –hacia la computadora misma. ¿Logra el escritor relacionarse elegantemente con el uso de memoria RAM, o acaso permite al programa dejar rastros desordenados de sí mismo en toda la tarjeta madre? ¿Se apega el escritor a las convenciones sobre las interfaces e interacciones que al sistema operativo de la computadora le «gustan»? Y así, con una línea en un archivo de texto, el autor de un valioso pedazo de código habla directamente a la función, a la acción material y al agenciamiento (en la computadora, dirigiendo electrones de un-lado-a-otro). Pero aquí, sustraído de la mirada indiscreta de la consola, el compilador y el CPU –escrito en un libro físico como el que sostienes en tus manos– el código entra en la cultura, la historia y la imaginación. Habla sin rodeos y directamente, a la gente: lectores humanos, y a nuestros mundos.
Una historia apócrifa que la mayoría de nosotros hemos llegado a creer dice que los Inuit tienen una gran cantidad palabras para la «nieve», muchas más que los lenguajes de las culturas Anglo-Americanas. Como resultado, estos pueblos indígenas son capaces de comprender y experimentar a la nieve de formas fantásticamente expansivas. Aunque restringida, la historia le da solidez a la más humana de nuestras intuiciones: que el lenguaje delimita y efectúa a las realidades que las personas son capaces de experimentar. El lenguaje que usamos, y cómo lo usamos, parece ser para nosotros una reflexión directa de la riqueza de nuestra vidas. El lenguaje, sin embargo, nos pone tanto en relación con, como a distancia de, esta vida, nuestros mundos. Describimos, creamos y destruimos significado; simpatizamos, embellecemos y beatificamos, amamos. Mientras que tensionamos y dilatamos nuestra expresión en los intentos, aparentemente vanos, de dar forma, transmitir y atestiguar a través de las palabras. Siempre intentando llegar a una formulación perfecta, peleando para llegar a descripciones del pensamiento y los sentidos, como si estuviésemos escalando una montaña de lenguaje imposiblemente alta (incluso mientras escribo estas palabras sobre el teclado). En ese vaivén, entre la casi impensable infinitud del lenguaje y nuestras expresiones frecuentemente frustradas, yace un poder precario –utilizado en la poesía para sorprender, deleitar y desafiar. Si nuestra casa de lenguaje es también una prisión, la poesía es un túnel de escape. Los code {poems} de este libro operan en esa misma dirección, pero con restricciones que son mucho más estrictas (en la cultura computacional moderna) y con capacidades de accionar el lenguaje que son en muchos sentidos superiores.
La idea de un code {poem} podría interpretarse de muchas formas. Más literalmente, podríamos imaginar a una computadora escribiendo código para nosotros, utilizando su maestría en permutaciones e iteraciones basada en reglas para generar una selección de palabras: prosa infinita, o «un nuevo poema en cada momento.» La historia ha presenciado un montón de colaboraciones entre literatura y cómputo que operaron a lo largo de tales directivas (desde haikus generados-computacionalmente hasta novelas-hipertextuales no lineales). Igualmente, code {poem} podría aludir a un poema en el cual un mensaje encriptado está integrado, como en los «códigos poema» usados como claves para descifrar mensajes en la Segunda Guerra Mundial (con el más famoso ejemplo, «The Life That I Have» de Leo Marks). El acercamiento tomado en la colección de poemas incluidos en este libro es, por el contrario, presentar trabajos que extraen de la forma y el tema de los lenguajes de programación en sí mismos, algo de su poder expresivo.
En la escritura y el habla cotidiana, el lenguaje por sí mismo es casi perceptible. Lo que realmente estás leyendo ahora y luego son simples marcas en una página, que desaparecen ante tus ojos mientras lees. A través de su propia supremacía y ubicuidad, el lenguaje es esquivo, difícil de percibir. Las palabras sobre las que pasamos nuestros ojos son como pequeños y cautelosos criptogramas –secretos mensajes fugaces, que nos hablan en código. Es aquí que la poesía interviene. La poesía es el lenguaje hablando por cuenta propia, y esto no difiere del código computacional. Aquellos que estamos acostumbrados a leer entre fragmentos de código y archivos «.c» casi apenas notamos su estructura, cómo opera la sintaxis, o la compleja belleza o la simple satisfacción encapsulada por cada «{» o «;». Una promesa de los code {poems} es desarrollar nuevas perspectivas en los lenguajes de programación que se presentan, exhibiéndonos la belleza lírica de tales protocolos estructurados. Un code {poem} produce para nosotros, de nuevo, la materialidad de los lenguajes de programación computacional, como instrucciones a la máquina y justo ahí, en la página.
Cuando las cosas se vuelven realmente complejas, como de hecho ya está sucediendo, la distinción entre nosotros, nuestras herramientas, y las cosas que podemos hacer con ellas, comienza a disolverse: los paisajes-de-información que navegamos a diario se llenan de medios que están entretejidos con una abundancia de mensajes e identidades. El significado opera en sentido contrario para borrar al significante; las palabras-mismas se desvanecen al momento en que pasan de la página a la lengua. A través de los code {poems}, somos empujados hacia la reaparición del lenguaje, que lanza luz sobre cómo es creado el significado, para nosotros y para las máquinas. Pero solamente nosotros podemos verdaderamente leer estas codificaciones humanas, estos poemas en código.
Jamie Allen
:
code {poems}
ars poetica
String silencio=» «;
String idea=»Esto no es p0esía.»;
String borrador;
String [ ]poema=new String [idea.length()];
void comenzar(){
borrador=idea;
Escribir();
RePensar();
}
void dibujar(){
ReEscribir();
}
void Escribir(){
println(borrador);
}
void RePensar(){
for(int decomp=0; decomp<borrador.length();decomp++=
{poema[decomp]=borrador.substring(decomp,decomp+1);}
}
void ReEscribir(){
byte seek=byte(random(0, poema.length));
poema[seek]=» «;
String poesía=join(poema,» «);
println(poesía);
if(poesía.equals(silencio)){
println(«.»); noLoop();}
}
………………………………………….Alejandro Corredor
………………………………………….// Processing
:
:
:
cuerpo
<html>
<body>
<!-Algo->que<!-esta->vida<!-me->ha<!-enseñado-><br>
<!–>es <!-que->el<!-cuerpo-><!-perfecto-><!-es-><!-un mito-><br>
<!-y-><!-que no hay->atajo<!-secreto-><!-hacia-><!-la felicidad-><br>
<!-y-><!-que nadie->tiene<!-siempre->la<!-razón-><br>
<!-todos-><!-tenemos-><!-momentos-><!-de-><!-brillo-><br>
<!-arranques-><!-de-><!-R-><!-A-><!-B-><!-I-><!-A-><br>
<!-y-><!-vivir-><!-nuestras vidas-><!-con-><!-belleza->
<!-en-><!-este-><!-imperfecto-><!-nivel-><!-del-><!-
mundo->
</body>
</html>
………………………………………….Carrie Padian
………………………………………….// HTML
:
:
:
disfunción()
Function Disfunción(){
if(NoPodemosComenzar&&NoPodemosDetenernos){
if(yoNoPuedoCaminar&&túNoPuedesCaminar){
if(noHaySalida&&noHayNadie){
if(túLevantasTuBandera&&yoSostengoMiArma){
while(elTiempoPasa&&laEsperanzaMuere){
while(algunosContinúanEnSilencio&&otrosSimplementeCallan){
while(algunosEsperanACristo&&otrosEsperanPorComida){
while(túCambiasTusRopas&&yoCambioMiÁnimo){
try{calmarte | | abrirte;
/ /intenta
escuchar | | !actuar;
/ /inténtalo
[cualquieraCosa,algo,loQueSea, aQuiénLeImporta];}
/ /todo lo que queda cuando tú me
catch(aMí){preguntaQuiénEstáAhí;}}}}}}}}}}
………………………………………….Brad Sorensen
………………………………………….// Javascript
:
:
:
euclides disfrazado
int coma (int guión, int mayor)
{
if (mayor>guión)
{
return coma(mayor – guión, guión);
}
else if (guión > mayor)
{
return coma(guión – mayor, mayor);
}
else
{
return greater, guión;
}
}
………………………………………….Yves Daoust
………………………………………….// C
:
:
:
doblecara
public class DobleCara{
public String saludar(){
return «¡Hola! ¡Qué bueno verte!»;
}
private String pensar() {
return «Maldita puta.»;
}
}
………………………………………….Jason Kopylec
………………………………………….// Java
:
:
:
bits del universo
nulo
pop!
(tiempo())
vacío?
átomo
átomo átomo
átomo átomo átomo átomo átomo
átomo átomo átomo átomo átomo átomo átomo átomo átomo
(vinculando [átomo[átomo[átomo[átomo[átomo]]]]])
hacer-jerarquía
repetir
iterar secuencia repetidamente
entrelazar constantemente
fusionar
replicar
parientes
descendientes
ciclo
7000000000
verdadero? falso?
buscar identidad
buscar nombre
símbolo? número?
racional? impar?
resolver
futuro?
futuro-realizado?
futuro-cancelado?
reversible?
nulo?
………………………………………….Elena Machkasova
………………………………………….// Pseudo de Clojure
:
:
:
la vida es aleatoria
import java.util.*;
public class Vida {
private String cerebro;
private String destino;
public static void main (String[ ] a) {
Vida I = new Vida();
I.vivir();
}
public void vivir() {
mi_destino;
System.out.println(«Yo_soy» «+cerebro+» & «+destino+».»);
}
public void mi_destino() {
Random r = new Random();
String [ ] destinos = {«Afortunado», «Desafortunado»};
String [ ] cerebros = {«Inteligente», «Estúpido»};
destino = destinos [r.nextInt(2)];
cerebro = cerebros [r.nextInt(2)];
}
}
………………………………………….Ubaldo Pescatore
………………………………………….// Java
:
:
:
simplifica
Module Simplicidad
…………..Dim Simplicidad
…………..Dim buena
…………..Sub Main()
……………………….Simplicidad=buena
……………………….‘ Para obtenerla,
……………………….‘ Las distracciones deben ser removidas
……………………….‘ Y el desorden erradicado. Así que,
……………………….‘ Simplica! Borra la basura!
……………………….If Mi.PC.FileSystem.FileExists(«C:
\dataglobal.ini»)= True Then
Mi.PC.FileSystem.DeleteFile(«C:\dataglobal.ini»)
……………………….Console.WriteLine(«Ahora que es has
simplificado, relájate.»)
…………..End Sub
End Module
………………………………………….Josh Fongheiser
………………………………………….// Visual Basic
:
:
:
el rumor
#!/usr/bin/perl
if(verdad){
verdad unless mentira;
}else{
mentira unless verdad;
}
………………………………………….Pall Thayer
………………………………………….// Perl
:
:
:
el juicio
<SCRIPT>
juicio=function(tú){
cnt=’A cuántas cosas te dedicas’
tú.adivinas=prompt(cnt+’adivinas?’,0)
tú.sabes=prompt(cnt+’sabes?’,0)
inducción =’fra’ ;deducción= ‘é’
arrogancia =’ca’ ;humildad =’xi’
perjurio =’so’ ;tolerancia =’to’
ignorancia = inducción+arrogancia+perjurio
sabiduría = deducción+humildad+tolerancia
prudencia = tú.sabes – tú.adivinas
este.method=(prudencia<1)?ignorancia:sabiduría
};
m= new juicio({}).method
document.write(‘Este juicio tiende a’+m)
</SCRIPT>
………………………………………….Guilherme Kerr
………………………………………….// Javascript
:
:
:
anidando
<DIOS>
..<universo>
….<galaxia>
……<sistemasolar>
……..<tierra>
……….<continente>
…………<ciudad>
…………..<jardín>
…………….<vergel>
………………<lirio>
………………..<pétalo>
………………….<molécula>
……………………<protón>
……………………..<quark>
……………………….<DIOS>
……………………..</quark>
……………………</proton>
………………….</molécula>
………………..</pétalo>
………………</lirio>
…………….</vergel>
…………..</jardín>
…………</ciudad>
……….</continente>
……..</tierra>
……</sistemasolar>
….</galaxia>
..</universo>
</DIOS>
………………………………………….Dan Brown
………………………………………….// HTML
:
:
:
n/a
class ic_case {
void de_la_ambición() {
while (true) {
//TODO
}
}
}
………………………………………….Joaquim d’Souza
………………………………………….// Java
:
:
:
el tiempo avanza lentamente
Clase TiempoAvanzaLentamente
Función ParaSalvar(TuVida)
Para Cada Día Mientras el TiempoAvanzaLentamente En TuVida
Sean lasLuces mientras Nuevo TiempoAvanzaLentamente, TómateElTiempo
ParaSalvar(TuVida) ‘y
Devuelve lasLuces ‘hasta el
Nuevo Día
Fin Función
Fin Clase
………………………………………….Chris Boucer
………………………………………….// Pseudo de Visual Basic
:
:
:
HTML = Hello Today Means Later
<html>
<head>
<title> Hola Hoy Significa Luego</>
<style type=»text/css»>
tú{display: block;}
yo{display: block;}
</style>
</head>
<body>
<yo>Oscilo entre tus ojos</yo>
<tú>Rutina de alientos</tú>
<yo>Música</yo>&
<tú>Sexo</tú>
<tiempo>Condición de exposición y latencia</tiempo>
<tú>Una respuesta</tú>
<yo>Tus manos</yo>
<tiempo>Navegaron a la deriva</tiempo>
<tú>En océanos telepáticos</tú>
<yo>Buscando con las olas</yo>
<tiempo>Un ciclo eterno</tiempo>
</body>
</html>
………………………………………….Viviana Álvarez
………………………………………….// HTML
:
:
:
realidad
if (humanos!=robots){
realidad();
}
………………………………………….David Sjunnesson
………………………………………….// Processing
:
:
:
cómo escoger amante con SQL
SELECT [Amor].Nombre,
IIf ([Inteligencia]>[Belleza], «Teatro», «Motel»)
…………..AS [Tipo_de_cita],
IIf ([Amor].[True] como «Verdadero», «Falso»,
…………..IIf ([RompeCorazones] como «Verdadero», «Mala idea»,
…………..«Seguro, ¿por qué no?»))
…………..AS [Bien_Para_Una_Aventura],
IIf ([Altura_En_Mt]>1.68, «S», «N»)
…………..AS [Estatura_Suficiente],
IIf ([Confianza] como «No», «Negado», IIf([Amor].[True],
como «Falso», «Nah», «¡Absolutamente!»))
…………..AS [Material_Para_Matrimonio]
From ([Amor] INNER JOIN Cuerpo ON [Amor].Nombre=
Cuerpo.Nombre)
…………..INNER JOIN Mente ON Cuerpo.Nombre=Mente.Nombre;
………………………………………….David Devanny
………………………………………….// SQL
:
:
:
desap[ ]recer
int luz = int(random(0,100));
int i;
char [] sombra = new char [luz];
…………..//Electrones evanescentes aparecen
…………..//por el vacío construido.
…………..//Una presencia espectral
…………..//se despliega.
void setup()
{
…………..el_yo_interior(i);
…………..//Ejecutar.
}
void el_yo_interior(int i)
{
…………..//Los datos aleatorios fluyen
…………..//dibujan paso a paso
…………..//una copia al carbón
…………..//en la sombra vectorial
…………..sombra[i]= ‘0’;
…………..print(sombra[i]);
…………..if (i<luz-1)
…………..{
……………………….el_yo_interior(i+1);
…………..//El transporte de las partes inamovibles ha comenzado.
…………..}
}
………………………………………….Thibault Autheman
………………………………………….// Processing
:
:
:
la terquedad de Cesare Pavese
String quéSucede;
BufferedReader Hoy;
PImage LasFrutasPequeñasYDulces;
void setup(){
…………..hoy=CreateReader
…………..(«el_mundo_pero_a_qué_cosa_espero.txt»)
…………..LasFrutasPequeñasYDulces = loadImage
…………..(«las_visto_cubriéndolas_de_sal.jpg»);
}
void draw(){
…………..try
…………..{quéSucede = hoy.readLine();
…………../* solamente cosas */ }
catch
(IOException e)
{/* así que no quiero ver */
quéSucede = null;}}
………………………………………….Ruggero Castagnola
………………………………………….// Proccesing
:
:
:
reloj biológico
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace RelojBiológico{
…………..class Program{
…………..static void Main (string[] args){
…………..RelojBiológico();
…………..Console.ReadLine();}
…………..public static void RelojBiológico(){
int n, Día 1, Año 0;
bool Vida=true;
n=1;
while (Vida == true){
Día += 1;
If (Día / 365 * n) == 0){
Año += 1;
n +=1;
Console.WriteLine(«Feliz Cumpleaños número {0}», Año);}
If (Año==78){Vida=false;}}}}}
………………………………………….Dom Slatford
………………………………………….// C#
:
:
:
end-et
function tú(ahora)
! Oh !
logical tú
! ya
ahora=ahora+1
if (ahora==6) tú=.false.
!tú nunca
return
end
program endet
logical sueño
logical noche
logical tú
!!
carácter*3 yo
yo=’enfermo’
ahora=0
noche=.true
! doy vueltas y vueltas
do while (noche)
…………..sueño = tú (ahora)
…………..noche = sueño
…………..! Oh, sí, por favor
…………..write (*,*) sueña, yo
…………..! Entre las sábanas
…………..write (*,*) ‘yo con tu’, noche, ‘fuego:’, ahora
enddo
end
………………………………………….Sylke Boyd
………………………………………….// Fortran 90
:
:
:
code {poems} es un proyecto de Isach Bertran. Está compuesto por 55 poemas en código. Fue editado, revisado y corregido por David Gauthier, Jamie Allen, Joshua Noble y Marcin Ignac. Publicado en Agosto del 2012, bajo licencia Creative Commons 3.0, se imprimieron 400 copias en dos tirajes distintos en la Imprenta Badia, fundada en 1888, en la ciudad de Barcelona, España.
César Panza. Valencia, Venezuela, 1987. Poeta, docente, editor y traductor. Licenciado en Matemáticas por la Universidad de Carabobo, Panza se desempeña como miembro del comité de redacción de La Tuna de Oro y del comité de redacción de POESIA. Ha publicado una traducción del inglés a las Canciones (1962-1970) de Bob Dylan (Fundarte, 2017) y su primer libro de poesía Mercancías (Fundación Editorial El perro y la rana, 2018).
