commit 3c4e9af476557b2a21338338d2c35bbe5bacef3f Author: sejo Date: Mon Jun 14 22:03:28 2021 -0500 initial migration diff --git a/gemtext2html.awk b/gemtext2html.awk new file mode 100644 index 0000000..c840abe --- /dev/null +++ b/gemtext2html.awk @@ -0,0 +1,341 @@ +# gemtext2html +# convierte un archivo en gemtext a html de acuerdo a la spec +# excepción: enlaces a imagen (jpg, png, gif) se vuelven +# TODO actualizar descripción +# TODO h2 en nav? +# +# importante: solo un {wikilink} (con o sin espacios) por línea +# +# modo de uso: +# awk -f gemtext2html.awk archivo.gmo > archivo.html +# + +BEGIN{ + sitio = "compudanzas" + # para poder abrir y cerrar " ) + } + else if( modo_parrafo ){ # cierra el párrafo + modo_parrafo = 0 + appendContenido( "

" ) + } + + bloque = 1 #empieza bloque porque es

+ + # borra flecha del inicio + sub("^=>","",$0) + # ahora $1 es el path, $2 a $NF el texto + + # concatena todo el texto + texto = $2 + for(i=3; i<=NF; i++){ + texto = texto" "$i + } + + if( match($1, /^\.\//)) { # si es link local + # si el path es imagen + if( match($1, /(png|jpg|gif)$/) ){ + # crea imagen + if( !modo_galeria ){ + appendContenido("") + modo_galeria = 1 + } + appendContenido(""texto"") + } + # si el path no es imagen y es .gmi + else if( match($1, /gmi$/) ){ + # convierte enlace de .gmi a .html ! + sub(".gmi$",".html",$1) + + # crea link + appendContenido("

"texto"

") + } + else{ + appendContenido("

"texto"

") + } + } + else{ # link externo + appendContenido("

"texto"

") + } + } + else{ + appendContenido( $0 ) + } + next +} + +/^* /{ # lista + if(!modo_pre){ + if(!modo_lista){ # inicia la lista + if(modo_parrafo){ + modo_parrafo = 0 + appendContenido( "

" ) + } + modo_lista = 1 + appendContenido( "" ) + } + else if( modo_parrafo ){ # cierra el párrafo + modo_parrafo = 0 + appendContenido( "

" ) + } + + # abre preformatted + modo_pre = 1 + appendContenido( "
" )
+	}
+	next
+}
+
+/^> /{ # blockquote
+	if(!modo_pre){
+		sub(">[[:blank:]]+","
",$0)
+		sub("$","
",$0)
+		bloque = 1
+	}	
+	appendContenido(  $0 )
+	next
+}
+
+/^# /{ # h1
+	if(!modo_pre){
+		sub("#[[:blank:]]+","",$0) #prefijo
+		sub("$","",$0) #sufijo
+		bloque = 1
+
+		if( !en_section ){ # si no se ha iniciado una sección antes
+			appendContenido( "
" )
+			en_section = 1
+		}
+		else{
+			appendContenido( "
" )
+		}
+
+		# crea header con id
+		appendContenido(  "
"$0"
" )
+
+		# agrega header a navegación
+		appendNav(  "
  • "$0"
    • " )
+	}	
+	else{
+		appendContenido(  $0 )
+	}
+	next
+
+}
+
+/^## /{ # h2
+	if(!modo_pre){
+		sub("##[[:blank:]]+","",$0)
+		sub("$","",$0)
+		# crea header con id
+		appendContenido(  "
    "$0"
    " )
+		bloque = 1
+	}
+	else{
+		appendContenido(  $0 )
+	}
+	next
+}
+
+/^### /{ # h3
+	if(!modo_pre){
+		sub("###[[:blank:]]+","",$0)
+		sub("$","",$0)
+		appendContenido(  "
    "$0"
    " )
+		bloque = 1
+	}
+	else{
+		appendContenido(  $0 )
+	}
+	next
+}
+
+#$0 !~ /^(=>|```|#{1,3} |* |\+|>|[[:blank:]]*$)/{ # líneas de texto (no "especiales")
+{ # cualquier otra línea de texto
+	if(!modo_pre){
+		if(!modo_parrafo){
+			modo_parrafo = 1
+			appendContenido( "
    " )
+		}
+		else # nueva línea en el mismo párrafo
+			appendContenido( "
    " )
+		
+		# busca y convierte wikiLink (máx uno por línea)
+		appendContenido( wikiLink($0) )
+	}
+	else{
+		gsub("<","\\<",$0)
+		gsub(">","\\>",$0)
+		appendContenido( $0 )
+	}
+}
+
+END{
+	# imprime y cierra nav
+	if(navcount){
+		print nav
+		print ""
+	}
+
+	# imprime contenido
+	print contenido
+	# cierra tags que pudieron haber quedado abiertas
+	if(modo_pre)
+		print "
    " + else if(modo_parrafo) + print "

    " + else if(modo_lista) + print "" + + # finaliza... + print "" + print "" + print "" + print "" + print "" +} diff --git a/generasitio.sh b/generasitio.sh new file mode 100755 index 0000000..321bc92 --- /dev/null +++ b/generasitio.sh @@ -0,0 +1,68 @@ +#!/bin/sh + +mkdir -p web/static +mkdir -p gem + + +fecha=$(date +"%s") + +echo "empezando conversión, estamos en ${fecha}" + +echo "revisando y copiando imágenes..." +for f in $(find src/ -regextype awk -regex ".*(jpg|png|gif)") +do + path="web/${f#src/}" # quita el prefijo de src/ y agrega web/ + gempath="gem/${f#src/}" # quita el prefijo de src/ y agrega gem/ + mkdir -p $(dirname $path) # crea directorio si no existe + mkdir -p $(dirname $gempath) # crea directorio si no existe + cp -vu $f $path + cp -vu $f $gempath +done + +#cp src/tw.txt web/ +#cp src/tw.txt gem/ + +#cp src/llave_sejo.asc web/ +#cp src/llave_sejo.asc gem/ + +cp src/estilo.css web/static/ + +# limpia +echo "limpiando archivos previos..." + +rm web/*html +rm gem/*gmi + +# crea índice +echo "generando índice..." +rm src/pages.gmo +ls -t src/*gmo | awk -f genindice.awk > src/pages.gmo + +echo "revisando y convirtiendo archivimos gmo a html y gmi..." + + + +i=0 +# convierte y actualiza archivos gmi a html +for f in $(find src/ -iname *.gmo) +do + + path=${f#src/} # quita el prefijo de "src/" + htmlpath="web/${path%gmo}html" # agrega "web/" y cambia el sufijo + gempath="gem/${path%gmo}gmi" # agrega "gem/" + + fecha=$(date -r $f --rfc-3339=date) + + +# echo "${f}" +# echo "${f} -> ${htmlpath}" +# echo "${f} -> ${gempath}" + # haz la conversión + awk -v fecha=$fecha -f gemtext2html.awk $f > $htmlpath + awk -v fecha=$fecha -f gmo2gmi.awk $f > $gempath + + (( i++ )) + +done + +echo "convertidas ${i} páginas!" diff --git a/genindice.awk b/genindice.awk new file mode 100644 index 0000000..ff157c5 --- /dev/null +++ b/genindice.awk @@ -0,0 +1,23 @@ +# ls src/*gmo | awk -f genindice.awk + +function link2nombre( t ){ # convierte un nombre con "_" a uno con espacios + gsub("_"," ",t); + sub(".gmo", "", t) + return t +} + +BEGIN{ + print "# index of pages" + print + print "last modified, above:" + print +} + +{ + sub("src/","",$0) + nombre = link2nombre($0) # convierte _ a espacios + sub(".gmo",".gmi",$0) + + if(nombre!="index") # no imprimas el índice + print "=> ./"$0" {"nombre"}" +} diff --git a/gmo2gmi.awk b/gmo2gmi.awk new file mode 100644 index 0000000..4a2c0c6 --- /dev/null +++ b/gmo2gmi.awk @@ -0,0 +1,43 @@ +function nombre2Link( t, r ){ # convierte un nombre con espacios, a uno con r (e.g. "_" + gsub(" ",r,t); + return t +} + +/^+ /{ # literal html + next # salta la línea +} + +/^& /{ # literal gemtext + sub(/^& /,"",$0) + print $0 + next + +} + +# imprime líneas normamlmente + +{ + print $0 +} + +# si tienen sintaxis de wikilink, y no son líneas de enlace, agrega el link +# (el % es por las líneas de uxn jaja) +/^[^=%].+{.+}/{ + i = match( $0, /{.+}/) + ifinal = index($0, "}") # índice del } final + + link = substr($0, i, ifinal-i+1) # {link} + nombre = substr($0, i+1, ifinal-i-1) # link + nombre = nombre2Link( nombre, "_" ) + + print "=> ./" nombre ".gmi " link +} + +# agrega footer + +END{ + print "" + print "most recent update on: 1" fecha + print "=> ./index.gmi {compudanzas}" + print "=> ./license.gmi {license}" +} diff --git a/src/about.gmo b/src/about.gmo new file mode 100644 index 0000000..c9de8f1 --- /dev/null +++ b/src/about.gmo @@ -0,0 +1,23 @@ +# about + +compudanzas is a research project aimed at the development of alternative modes of computation. + +# mission + +we enlarge to a human-scale and slow down to a human-speed the processes that give rise to what is understood as computing. + +through our experiments we ask: what happens when computers are dances, rituals, games, instead of closed electronic boxes with a high environmental and social cost? + +to what extent can we reappropriate these logics to inspire other ways of being in the world? + +what can be the role of non-electronic, very slow, human-scale, and seemingly useless computers, in a world that seems to be in {collapse}? + +are they alternative and empowering didactic materials? performances? puzzles? passtimes? magic tricks? marvelous pursuits? + +# meta + +read our updates in the {log} + +visit the index of {pages} in the site + +=> ./contact.gmi {contact} diff --git a/src/ciclo_de_memoria.gmo b/src/ciclo_de_memoria.gmo new file mode 100644 index 0000000..c28fc74 --- /dev/null +++ b/src/ciclo_de_memoria.gmo @@ -0,0 +1,54 @@ +# ciclo de memoria + +imaginemos la construcción de una memoria que existe en función el tiempo, como las antiguas líneas de retardo de mercurio, pero en el campo; un juego; un grupo de personas en {las danzas}. + +un "dispositivo"-danza que almacena información binaria, con capacidad de ser escrita y leída. + +=> ./img/ilustracion_ciclo-de-memoria.png pequeña ilustración del ciclo de memoria + +# guía + +cada persona ve a alguien más, y es vista por otra distinta. + +para iniciar, podemos acomodarnos en círculo. nuestra red es un ciclo. + +cada persona ve a alguien más, poniendo atención en cuál de las tres señales / movimientos realiza: + +* corte +* alto +* bajo + +hay música con pulso. + +en cada beat, la persona replica la señal que vio adelante. + +así, poco a poco, un dato palabra, número, o lo que sea, se recorre, circula, da vueltas. + +# la lectura + +para leer el dato almacenado, una persona-lectora fuera del ciclo se sintoniza a la frecuencia de pulsos. + +la persona-lectora se enfoca en observar a una sola persona dentro, que se convierte en la persona-salida. + +al observar la señal de corte, la persona-lectora empieza a anotar, repetir, transmitir, las señales de alto o bajo que vengan después. + +así continúa hasta observar de nuevo el corte: el dato habrá sido leído, y se mantiene en circulación. + +# la escritura + +ya sea que se decida de antemano la persona-entrada al ciclo, o todas las personas estén atentas para poder serlo, para escribir en la memoria hace falta una persona afuera, la persona-escritora. + +ella se sincroniza con los pulsos, y le avisa a la persona-entrada que viene a escribir. + +la persona-entrada espera a recibir y replicar la señal de corte de la persona a la que estaba siguiendo. + +justo cuando eso sucede, la persona-entrada empezará a ver y seguir a la persona-escritora. + +la persona-escritora, paso a paso, pulso a pulso, da las señales de alto o bajo a escribir, hasta llegar al corte. + +y así, paso a paso, pulso a pulso, poco a poco, el ciclo ahora tendrá un nuevo dato. + + + +## llega(n) aquí +=> ./las_danzas.gmi {las danzas} diff --git a/src/collapse.gmo b/src/collapse.gmo new file mode 100644 index 0000000..390bf8e --- /dev/null +++ b/src/collapse.gmo @@ -0,0 +1,44 @@ +# collapse + +how to live life when ecological and social collapse are coming in the short term? + +# textos + +que escribo para ir procesando, aprendiendo y compartiendo: + +=> ./después_ahora.gmi {después ahora} + + +# notes + +## deep adaptation + +deep adaptation agenda, the 4 Rs: + +* resilience: how do we keep what we really want to keep? +* relinquishment: what do we need to let go of in order to not make matters worse? +* restoration: what can we bring back to help us with the coming difficulties and tragedies? +* reconciliation: with what and whom can we make peace with as we face our mutual mortality? + +=> https://jembendell.com/2019/05/15/deep-adaptation-versions/ versions of the deep adaptation paper - jem bendell + +## how to live like the world is ending + +* act like we’re about to die. +* act like we might not die right away. +* act like we might have a chance to stop this. +* act like everything will be okay. + +=> http://birdsbeforethestorm.net/2019/12/how-to-live-like-the-world-is-ending/ how to live the world is ending - margaret killjoy + +## more references + +=> https://theanarchistlibrary.org/library/margaret-killjoy-take-what-you-need-and-compost-the-rest-an-introduction-to-post-civilized-theo take what you need and compost the rest: an introduction to post-civilized theory - margaret killjoy +=> https://www.resilience.org/stories/2019-05-10/loving-a-vanishing-world/ loving a vanishing world - emily johnston +=> https://deepgreenresistance.org/ deep green resistance +=> https://stopfossilfuels.org/ stop fossil fuels +=> http://viznut.fi/texts-en/permacomputing.html permacomputing | viznut + + +## incoming links +=> ./about.gmi {about} diff --git a/src/coloring_computers.gmo b/src/coloring_computers.gmo new file mode 100644 index 0000000..2d2be16 --- /dev/null +++ b/src/coloring_computers.gmo @@ -0,0 +1,48 @@ +# coloring computers + +non-electronic computers that work when you color them according to a simple set of rules. + +an exploration of computation without electricity and semiconductors, an attempt to reinvent digital systems away from efficiency and productivity, and hopeful prototypes to expose the inner workings of computers. + +# 4-bits to 7-segment display hexadecimal decoder (12020) + +=> ./img/foto_20201130_hex7segdecoder_01.png the coloring computer/decoder, waiting to be activated +=> ./img/foto_20201130_hex7segdecoder_02.png a human coloring the wires according to the logic rules +=> ./img/foto_20201130_hex7segdecoder_03.png the coloring computer/decoder, with an input of 0011, and an output that can be read as 3 + +a coloring decoder built with NOT (triangle), AND (semicircle), and OR (the other shape (?)) gates, based on a manual design. + +=> ./img/dibujo_20201207_hex7segdecoder_small.png the complete decoder + +=> https://opguides.info/engineering/digitallogic/ colored and animated version by Vega +=> https://ipfs.io/ipfs/QmZv53hr7QEzxrPaRNpiyU9VUNHw9UgyaTUqYD9x9iFpNA/dibujo_20201207_hex7segdecoder.png download the decoder in full size 1487x3057 (png, ~446KB) + +# computadora no(r)pal (12019) + +=> ./img/dibujo_20190715-norpalera-fulladder_blanco_small.png logic circuit in the shape of nopal + +a full-adder built with NOR gates in the shape of no(r)pales + +=> https://ipfs.io/ipfs/QmPz2D3bZRYFi1HnfiNJB8o9TZZvH8atuYpFixMKccYCYP/dibujo_20190715-norpalera-fulladder_blanco.png download computadora no(r)pal in full size 1200x1600 (png, ~429KB) + +# coloring computers (12018) + +the original ones + +=> ./img/foto_coloring-computers_cover-lee.png photo of the cover of the zine, colored +=> ./img/foto_coloring-computers_7seg-lee.png photo of a pair of colored pages of the zine, with a 7 segment display showing the digits 2 and 3 +=> ./img/foto_coloring-computers_pcd2019.png photo of a pair of colored pages of the zine, showing a digital circuit answering if two colors are the same + +the booklet contains three series of computers: computers that compare, computers that count, and computers that play. they are all NOR-based logic circuits designed by using truth tables, karnaugh maps, and maxterm expansions. + +=> https://ipfs.io/ipfs/QmYz7DPRWypGQcbAHr7Mi8EKB6ntSPsEnUsCXbAhBiHQZP/ original site and resources +=> https://ipfs.io/ipfs/QmYz7DPRWypGQcbAHr7Mi8EKB6ntSPsEnUsCXbAhBiHQZP/coloringcomputers_pages.pdf download the page-by-page zine (pdf, ~1.5MB) +=> https://ipfs.io/ipfs/QmYz7DPRWypGQcbAHr7Mi8EKB6ntSPsEnUsCXbAhBiHQZP/coloringcomputers.pdf download the ready-to-print-and-cut zine (pdf, ~1.4MB) + +CC-BY-SA 4.0 + +for the print and cut zine: print double-sided, cut in half, fold the pages and assemble + + +## incoming links +=> ./talks_and_workshops.gmi {talks and workshops} diff --git a/src/compuertas.gmo b/src/compuertas.gmo new file mode 100644 index 0000000..882cc22 --- /dev/null +++ b/src/compuertas.gmo @@ -0,0 +1,101 @@ +# compuertas lógicas + +las bases de los circuitos digitales. + +estos incluyen, claro está, a las {danzas compuertas} + +usamos la convención de utilizar dos valores posibles: 1 para denominar arriba, o verdadero, y 0 para denominar abajo, o falso. + + +# una entrada + +## buffer + +la salida es igual a la entrada + +## NOT + +la salida es lo opuesto a la entrada. + +también podríamos decir que la salida es lo que no es la entrada. + + +# dos entradas + +con dos entradas binarias, hay cuatro posibles combinaciones. + +## AND + +la salida es verdadera únicamente cuando todas sus entradas son verdaderas. + +en cualquier otro caso, la salida es falsa. + + +## OR + +la salida es verdadera cuando aunque sea una de sus entradas sea verdadera. + +únicamente cuando todas las entradas son falsas, su salida es falsa. + + +## XOR + +la salida es verdadera cuando una y solo una de sus entradas sea verdadera. + +en cualquier otro caso, la salida es falsa. + +también la podemos describir así: la salida es verdadera cuando las entradas son diferentes, y es falsa cuando las entradas son iguales. + + +## NOR + +la salida es verdadera cuando ninguna de sus entradas es verdadera. + +que es lo mismo que decir que su salida es verdadera cuando todas sus entradas son falsas. + +en cualquier otro caso, su salida es falsa. + +NOR es una de las compuertas universales: con ella se puede construir a todas las demás. + +esto se debe en parte a que NOR se convierte en NOT si sus dos entradas están conectadas como una sola. + +por otro lado, NOR es equivalente a negar con NOT la salida de una compuerta OR. + +por cómo funciona, también la podemos considerar como un AND que funciona con 0 en vez de con 1. + + +## NAND + +la salida es verdadera cuando aunque sea una de sus entrada es falsa. + +únicamente cuando todas sus entradas son verdaderas, su salida es falsa. + +NAND es la otra compuerta universal. esto se debe en parte a que se convierte en NOT si sus dos entradas están conectadas como una sola. + +por otro lado, NAND es equivalente a negar con NOT la salida de una compuerta AND. + +por cómo funciona, también la podemos considerar como un OR que funciona con 0 en vez de con 1. + + +# más entradas + +todas las compuertas funcionan igual para más de dos entradas, excepto XOR. + +importante: AND y OR poseen la propiedad distributiva. + +por ejemplo, un AND de tres entradas (a, b, c) es equivalente a un AND de dos entradas (a, b), con su salida (x) conectada a la entrada de otro AND de dos entradas (x, c) + +esto no sucede así ni en NOR ni en NAND. en su caso, hay que agregar un NOT entre las dos compuertas. + + +# demorgan + +una compuerta AND es equivalente a una compuerta NOR con sus entradas negadas. + +una compuerta OR es equivalente a una compuerta NAND con sus entradas negadas. + + + +## llega(n) aquí +=> ./danzas_compuertas.gmi {danzas compuertas} +=> ./logiteca.gmi {logiteca} diff --git a/src/contact.gmo b/src/contact.gmo new file mode 100644 index 0000000..c968763 --- /dev/null +++ b/src/contact.gmo @@ -0,0 +1,7 @@ +# contact + +e-mail: sejo at posteo dot net +=> ./llave_sejo.asc [pgp key] + +fediverse: +=> https://merveilles.town/@chirrolafupa chirrolafupa in merveilles.town diff --git a/src/d-turing.gmo b/src/d-turing.gmo new file mode 100644 index 0000000..02818c9 --- /dev/null +++ b/src/d-turing.gmo @@ -0,0 +1,85 @@ +# d-turing + +bailando los inicios, una máquina de turing + +parte de las {las danzas} + +# componentes + +## participantes + +la siguiente descripción depende de tres personas / roles: + +* cabeza en cinta +* semáforo de estado +* instructora + +la dinámica podría adaptarse fácilmente para dos o una persona(s), pero es más divertido bailarla en grupo. + +## materiales + +como materiales tangibles se requiere lo siguiente: + +* un conjunto de objetos flexibles para crear una fila con ellos: por ejemplo cordones, calcetines, bloques de madera... +* una tabla de reglas en papel o arcilla; al menos en lo que se memoriza + +## elementos + +una máquina en específico consiste de los siguientes elementos: + +* un conjunto finito de símbolos posibles a colocar en la cinta, con un conjunto de movimientos que correspondan uno-a-uno. +* una cinta con dichos símbolos, acomodados en una configuración inicial según sea el caso. +* un conjunto finito de estados posibles, cada uno con un movimiento correspondiente. +* un estado inicial. +* un par de movimientos que indiquen dirección en un eje; por ejemplo izquierda y derecha. +* una tabla de reglas, que responde lo siguiente: dado un símbolo encontrado en la cinta, y un estado actual: ¿por cuál símbolo hay que reemplazarlo, a qué dirección hay que mover la cabeza, y cuál ha de ser el nuevo estado? + +# guía + +## preparación + +es necesario que la cabeza en cinta conozca los símbolos posibles en la cinta, y sus movimientos correspondientes. además, ha de conocer los movimientos de dirección. + +el semáforo ha de conocer los estados posibles y sus movimientos correspondientes. + +la instructora tiene que conocer todos los movimientos nombrados arriba. + +## inicialización + +hay que acomodar la cinta de símbolos en una configuración inicial adecuada. + +la cabeza en cinta se coloca al lado del primer símbolo. + +el semáforo empieza a moverse con el estado inicial. + +la instructora se prepara. + +## el ciclo + +la cabeza en cinta se empieza a mover transmitiendo en qué símbolo se encuentra. + +la instructora observa el movimiento del semáforo y el movimiento de la cabeza en cinta, y busca en su tabla de reglas la entrada correspondiente: + +¿qué acciones hay que tomar a partir del estado actual y del símbolo leído por la cabeza en cinta? + +### con respuesta + +si la tabla tiene una respuesta, la instructora empieza a moverse para transmitir las acciones a tomar: + +* primero realiza un movimiento de símbolo: la cabeza en cinta lo recibe y lo usa para reemplazar al símbolo en el que se encuentra actualmente. +* cuando concluye la transformación, la instructora realiza un movimiento de dirección: la cabeza en cinta lo recibe y lo sigue para dirigirse al siguiente símbolo que se encuentra en esa dirección. +* finalmente, la instructora realiza un movimiento de estado: el semáforo lo recibe, y lo ha de empezar a realizar como indicación del estado actual. + +terminando esas acciones, el ciclo vuelve a comenzar. + +### sin respuesta + +si la tabla no tiene una respuesta, entonces la máquina se detiene. el cómputo ha terminado. + +# algunas máquinas + +próximamente + + +## llega(n) aquí +=> ./las_danzas.gmi {las danzas} diff --git a/src/danza_papier.gmo b/src/danza_papier.gmo new file mode 100644 index 0000000..65bfaa7 --- /dev/null +++ b/src/danza_papier.gmo @@ -0,0 +1,199 @@ +# danza papier + +baile colaborativo que ejemplifica una arquitectura computacional común, basada en la wdr papiercomputer + +=> https://wiki.xxiivv.com/site/papier.html papier computer + +parte de las {las danzas} + + +# componentes + +## participantes + +la arquitectura base consta de al menos 6 personas: + +* PC: apuntadora del programa (program counter) +* Memoria: quien administra la lista de números correspondiente al programa +* CU: la directora, unidad de control +* Rn: al menos dos registros, R0 y R1 +* LU: la que responde preguntas lógicas + + +## materiales + +como materiales tangibles solo se requiere la lista de números que administra la Memoria. + +como sea, si el grupo cuenta con suficientes personas, cada uno de esos números puede ser cuerpeado por una persona distinta. + +opcionalmente, puede existir una tabla en papel que sirva de recordatorio a la CU de las operaciones a seguir: el microcódigo. + + +## movimientos + +se necesita contar con, y conocer, el siguiente conjunto de movimientos. + +### todas las personas + +* dígito-movimiento: un movimiento por cada digito en la base elegida (por ejemplo, del 0 al 9 para trabajar en base 10) +* posición: una forma de indicar si un dígito es el primero o el segundo +* finalización: un movimiento que indique que el cómputo ha terminado + +será importante conocer cuál es el movimiento siguiente y anterior a cada dígito-movimiento. + +### Registros y CU: + +* indicación de incremento +* indicación de decremento + +### LU y CU: + +* pregunta: ¿el contenido del Registro es 0? +* respuestas: sí, no + +### PC y CU: + +* indicación de incremento sencillo +* indicación de incremento doble + + +## instrucciones + +la computadora cuenta con los 5 siguientes códigos de operación (entre paréntesis su mnemónico) + +* 0: Fin del programa (FIN) +* 1: Condicional (CND) +* 2: Salta a (SLT) +* 3: Incrementa (INC) +* 4: Decrementa (DEC) + +una instrucción completa consiste de ese código de operación, acompañada de un dígito llamado argumento. + +ese argumento tiene un significado distinto según la instrucción: + +* FIN: argumento ignorado +* CND: el argumento es el número de Registro al cual preguntarle si es 0: si la respuesta es sí, hay que saltarse una instrucción, y si la respuesta es no, hay que continuar normalmente +* SLT: el argumento es el número de línea a la cual saltar a continuación +* INC: el argumento es el número de Registro que ha de incrementarse +* DEC: el argumento es el número de Registro que ha de decrementarse + + +# ciclo de instrucción + +la máquina estará en el llamado ciclo de instrucción hasta encontrar a una instrucción FIN. + +este ciclo consiste de dos partes, fetch (buscar) y execute (ejecutar). + +antes de comenzar, hay que realizar una inicialización: + +* PC toma el dígito-movimiento correspondiente a 0, y se mueve transmitiéndolo +* Registros toman el dígito-movimiento inicial que se les indique, y se mueven transmitiéndolo + +## fetch (buscar) + +* todes les Registros se mueven con una amplitud normal, transmitiendo sus dígitos-movimientos +* PC se mueve transmitiendo el dígito-movimiento que tiene almacenado +* Memoria recibe el dígito, y busca en su lista de números al par de dígitos que se encuentran en esa posición. +* Memoria se mueve transmitiendo esos dos dígitos-movimientos, con cuidad de indicar cuál es el primero y cuál es el segundo +* CU recibe esos dos dígitos +* la máquina pasa a la etapa execute + + +## execute (ejecutar) + +* CU identifica al primer dígito recibido como código de operación, y al segundo como argumento +* de acuerdo al código de operación, suceden las siguientes operaciones: + +### FIN: Fin del programa (0) + +* CU se mueve indicando finalización +* todes se detienen excepto Registros que continúan con sus dígitos-movimientos + +les Registros ahora pueden ser inspeccionados para leer los resultados del cómputo. + +### CND: Condicional (1) + +* CU se mueve dirigiéndose a les Registros, transmitiendo el dígito-movimiento que recibió como argumento +* Registros reciben el dígito +* Registro que tiene a ese dígito en su nombre, hace más evidente el dígito-movimiento que estaba realizando +* les demás Registros reducen la amplitud de su propio dígito-movimiento. +* CU se mueve preguntando a LU si el Registro es 0. +* LU recibe la pregunta, y observa al Registro con movimiento amplio +* LU se mueve respondiendo sí o no +* CU recibe la respuesta de LU +* CU se mueve dirigéndose a PC: si la respuesta que recibió de LU fue sí, entonces se mueve indicando un doble incremento; si la respuesta fue no, entonces se mueve indicando un incremento sencillo +* PC recibe la indicación, y pasa al siguiente dígito-movimiento, ya sea una o dos veces según lo recibido. +* la máquina pasa a la etapa fetch + + +### SLT: Salta a (2) + +* CU se mueve dirigéndose a PC, transmitiendo el dígito-movimiento que recibió como argumento +* PC recibe el dígito y lo almacena, reemplazando al dígito-movimiento que estaba realizando antes. +* la máquina pasa a la etapa fetch + + +### INC: Incrementa (3) + +* CU se mueve dirigiéndose a les Registros, transmitiendo el dígito-movimiento que recibió como argumento +* Registros reciben el dígito +* Registro que tiene a ese dígito en su nombre, hace más evidente el dígito-movimiento que estaba realizando +* les demás Registros reducen la amplitud de su propio dígito-movimiento. +* CU se mueve dirigiéndose a les Registros, transmitiendo la indicación de incremento +* Registro con el movimiento amplio, pasa al dígito-movimiento siguiente al que estaba realizando (incrementa en 1 al valor que estaba almacenando) +* les demás Registros hacen caso omiso +* CU se mueve dirigéndose a PC, indicando un incremento sencillo +* PC recibe la indicación, y pasa al siguiente dígito-movimiento +* la máquina pasa a la etapa fetch + + +### DEC: Decrementa (4) + +* CU se mueve dirigiéndose a les Registros, transmitiendo el dígito-movimiento que recibió como argumento +* Registros reciben el dígito +* Registro que tiene a ese dígito en su nombre, hace más evidente el dígito-movimiento que estaba realizando +* les demás Registros reducen la amplitud de su propio dígito-movimiento. +* CU se mueve dirigiéndose a les Registros, transmitiendo la indicación de decremento +* Registro con el movimiento amplio, pasa al dígito-movimiento anterior al que estaba realizando (decrementa en 1 al valor que estaba almacenando) +* les demás Registros hacen caso omiso +* CU se mueve dirigéndose a PC, indicando un incremento sencillo +* PC recibe la indicación, y pasa al siguiente dígito-movimiento +* la máquina pasa a la etapa fetch + + +# ejemplo de programa + +este programa suma los dígitos en R0 y R1, colocando el resultado en R0 + +## lista de números + +este es el programa en formato de lista de números para que administre Memoria. + +* 0: 2 3 +* 1: 4 1 +* 2: 3 0 +* 3: 1 1 +* 4: 2 1 +* 5: 0 0 + +el primer dígito en la lista es el número de línea. + +los dos dígitos siguientes son el primer y segundo dígitos de instrucción + + +## ensamblador + +usando las palabras clave (mnemónicos) para indicar los códigos de operación, el programa se vería así: + +* 0: SLT 3 (salta a la línea 3) +* 1: DEC 1 (decrementa R1) +* 2: INC 0 (incrementa R0) +* 3: CND 1 (¿R1 es 0? si sí, salta una instrucción, si no, continúa) +* 4: SLT 1 (salta a la línea 1) +* 5: FIN 0 (fin del programa) + +(esta forma de programar es a la que se refiere la práctica de {s-camino}) + + +## llega(n) aquí +=> ./las_danzas.gmi {las danzas} diff --git a/src/danzas_compuertas.gmo b/src/danzas_compuertas.gmo new file mode 100644 index 0000000..4263e58 --- /dev/null +++ b/src/danzas_compuertas.gmo @@ -0,0 +1,39 @@ +# danzas compuertas + +antiguas historias hablaban de computar en conjunto, en comunidad. ¿{las danzas}? + +tareas sencillas y divertidas (requeridas de atención y presencia) que combinadas dan paso a complejidad, a olas, a cambios. + +# guía + +o se está de pie o se está en descanso. + +a cada quien se le asigna un rol: + +* simplemente decidir en qué posición colocarse +* colocarse siempre en oposición a tal persona +* o ponerse de pie solo cuando ni tal persona ni cual persona están de pie. + +(o alguna otra de las {compuertas} lógicas) + +la complejidad surge de quién ve a quién, quién depende de quién. + +cinco personas para multiplicar dos dígitos binarios... nada mal. + +más circuitos posibles, en la {logiteca} + +# posibilidades + +qué tal un sumador completo, aprovechando la idea de {ciclo de memoria} + +aquí un diagrama animado que muestra un par de ciclos de memoria como entrada a un full-adder. + +el resultado del full-adder está conectado a otro ciclo de memoria. todos los componentes conformados por personas. + +=> https://ipfs.io/ipfs/QmSKnbCUGj3FR5hRG5UAgfXxjyp7aTQoRCeJ9G4MENxNNG/20190718-sumadanza_600.gif suma danza (gif, 187KB ) + + +## llega(n) aquí +=> ./las_danzas.gmi {las danzas} +=> ./compuertas.gmi {compuertas} +=> ./logiteca.gmi {logiteca} diff --git a/src/danzasistemas-tag.gmo b/src/danzasistemas-tag.gmo new file mode 100644 index 0000000..742de0f --- /dev/null +++ b/src/danzasistemas-tag.gmo @@ -0,0 +1,78 @@ +# danzasistemas-tag + +una compudanza basada en máquina abstracta (tag systems, o bien, máquina de post) + +=> ./las_danzas.gmi {las danzas} + +# descripción + +las danzasistemas-tag consisten en "batallas" de baile en las que alternamos recibiendo y respondiendo secuencias de movimiento. + +las secuencias que respondemos son producto de procesar elementos de la secuencia que recibimos. + +# indicaciones + +necesitamos los siguientes elementos: + +* A: alfabeto finito de símbolos/movimientos identificables y replicables +* P: las reglas de producción: qué símbolos/movimientos hay que agregar al final de la nueva secuencia, de acuerdo al primer símbolo/movimiento de la secuencia recibida. +* m: número de eliminación: cuántos símbolos/movimientos hay que eliminar del inicio de la secuencia recibida. + +al recibir una secuencia de movimiento, hemos de poner atención y realizar lo siguiente para construir nuestra respuesta: + +* notar el primer símbolo/movimiento, que nos indica qué regla de producción seguir al final de la secuencia. +* descartar la cantidad de símbolos/movimientos del inicio de la secuencia de acuerdo al número de eliminación. (esto incluye al primer símbolo/movimiento). +* memorizar y replicar la secuencia recibida a partir de ese punto, en orden y hasta el final. +* agregar el o los símbolos/movimientos al final de la secuencia, de acuerdo a la regla de producción. + +según la danzasistema-tag, la dinámica de respuestas continúa hasta llegar al símbolo/movimiento que indique detenerse, o hasta que la secuencia de movimiento quede vacía. + +# ejemplo + +cómputo de secuencias de collatz, tomado de wikipedia + +=> https://en.wikipedia.org/wiki/Tag_system#Example:_Computation_of_Collatz_sequences Tag system - Example: Computation of Collatz sequences (web) + +los elementos de nuestra danzasistema-tag serían los siguientes: + +## A: alfabeto finito de símbolos/movimientos + +tres símbolos/movimientos: a, b, c + +## P: reglas de producción + +si primer símbolo/movimiento es 'a', agrega 'bc' al final. + +si primer símbolo/movimiento es 'b', agrega 'a' al final. + +si primer símbolo/movimiento es 'c', agrega 'aaa' al final. + +nota cómo cada regla de producción agrega una cantidad distinta de símbolos/movimientos al final. + +## m: número de eliminación + +en este caso, siempre descartaremos 2 símbolos/movimientos del inicio de la secuencia. + +## desarrollo + +partiendo de una secuencia inicial 'aaa'... + +``` +inicio: aaa +respuesta: abc +respuesta: cbc +respuesta: caaa +respuesta: aaaaa +respuesta: aaabc +respuesta: abcbc +respuesta: cbcbc +etc... +``` + +siempre se descartan los 2 símbolos/movimientos del inicio, pero la cantidad de símbolos/movimientos que se agregan al final cambian de acuerdo a la regla de producción. + +esta dinámica de respuestas a partir de esa secuencia inicial, eventualmente termina descartando a la secuencia completa. + + +## llega(n) aquí +=> ./las_danzas.gmi {las danzas} diff --git a/src/después_ahora.gmo b/src/después_ahora.gmo new file mode 100644 index 0000000..97e349d --- /dev/null +++ b/src/después_ahora.gmo @@ -0,0 +1,57 @@ +# después ahora + +textos hacia una práctica post-civilización. + +# La invitación + +Primero que nada, te invito, nos invito, a estar presentes. + +Respirar profundo, y de ser posible, mirar por alguna ventana. Notar el espacio de posibilidades que nos presenta lo que llamamos cielo. + +Espero que no fuera hace mucho la vez más reciente que le habías visto. + +Ahora bien, en este texto, partimos de la noción de que algo grande se está terminando. No solo grande, sino enorme; tal vez inabarcable, tal vez inconcebible. + +Partimos de la noción de que la civilización se está terminando. + +O de que ya se terminó, según desde dónde le veamos. + +Partimos de que vale la pena permitirse sentirlo y expresarlo. La intención es imaginar, encontrar, crear cómo queremos vivir mientras lo aceptamos. + +Por un lado siento las ganas de argumentarlo, de convencerte. Pero por otro lado sé que ya lo sabes: no se ve salida al desastre exponencial que se ha (¿hemos? ¿han?) desencadenado. + +Crecer por crecer y por siempre, dejando de lado los cuidados: probablemente no fue la mejor idea, forma de vivir impuesta. Hay y hubo quien se opuso, claro; pero ahí no se permiten alternativas. + +La duda es si esperamos y dejamos que la civilización como la conocemos, eso que se está terminando, caiga, colapse por su propio peso. A mí, esa espera me parece muy riesgosa. ¿Qué tal si al dejarle continuar, antes cae, colapsa la biósfera y su capacidad para mantener vida? + +¿Cuál de los dos finales nos resultará peor, el de la civilización o el de la vida en la Tierra? Los páneles solares y autos eléctricos no nos llevan a una tercera opción, realmente. + +¿Y entonces? ¿La decisión es retirarse? ¿La decisión es tirarla? ¿Qué tal vivir como si ya no existiera? + +Cualquier opción me suena incómoda, pero llena de energía vital. + +Personalmente, prefiero dejármelo sentir. No me va eso de hacerme creer que no está pasando nada, de hacer como si todo fuera a seguir normal, bien, "sin problema". + +Ya no me creo el cuento del progreso, de las soluciones tecnocéntricas. + +Vivir como si la civilización ya no existiera es lo que mejor me suena. Requiere creatividad, curiosidad, disposición, compasión y paciencia. Es alcanzable. No hay una fórmula específica, homogénea. + +Es plantar semillas de lo que pueda venir después: puede que no germinen, ¿pero realmente me veo haciendo otra cosa? + +Me queda claro que no es fácil. Además, no tengo mucha idea de cómo. + +Estas letras llegan a ti con miras a que exploremos, sintamos, conectemos, practiquemos. + +Por el momento usamos internet, después ya veremos. Si los cables seguirán plantados, ¿qué decidiremos hacer con ellos? + +--- + +Te invito a respirar de nuevo. A moverte con cómo te sientes ahora. + +Te invito a acompañarnos en esta búsqueda. + +Está bien si todavía no es el momento. Ya sabes dónde me encuentro. + + +## incoming links +=> ./collapse.gmi {collapse} diff --git a/src/estilo.css b/src/estilo.css new file mode 100644 index 0000000..56b973f --- /dev/null +++ b/src/estilo.css @@ -0,0 +1,100 @@ +/* links en el sitio */ +a[href^="./"]{ + text-decoration:none; +} +/* links externos */ +a[rel=external]:after{ +/* content:"↝";*/ + content: "↗"; +} +a{ + color: #575; +} +a:hover{ + background-color: #575; + color: #fff; + border-radius:3px; +} +a:visited{ + color: #552; +} +a:visited:hover{ + background-color: #552; + color: #fff; + border-radius:3px; +} + +body{ + color: #010; + max-width:40em; + margin:0 auto; + font-size:18px; + padding: 1em; +} + +nav,footer,section{ +/* border-top: 2px solid;*/ +} +footer{ + font-size: x-small; + text-align: center; +} + +pre{ + background-color: #fee; + color: #433; + padding:1em; + border-radius:5px; + overflow-x: auto; +} + +main h1{ + padding-top: 2.0em; + font-size: 30px; +} +main h2{ + font-size: 25px; +/* border-top: 1px dashed;*/ + padding-top: 1em; + margin-left:0.3em; +} +main h3{ + font-size: 18px; + padding-top: 1em; + margin-left:1em; +} + +gallery{ + display:flex; + flex-direction:row; + flex-wrap:wrap; + justify-content:space-evenly; + align-content:center; +} +img{ + margin:10px; + border-radius:5px; +} + +nav{ + font-size:smaller; +} + +nav li{ + list-style-type:square; +} + +table,th,td{ + border-style:inset; + border-width: 1px; +} +table{ + margin:10px; + overflow-x: auto; +} + +#count{ /* para tiempo */ +word-wrap:break-word; +font-size:9px; +font-family:monospace; +} diff --git a/src/img/dibujo_20190715-norpalera-fulladder_blanco_small.png b/src/img/dibujo_20190715-norpalera-fulladder_blanco_small.png new file mode 100644 index 0000000..9973637 Binary files /dev/null and b/src/img/dibujo_20190715-norpalera-fulladder_blanco_small.png differ diff --git a/src/img/dibujo_20201207_hex7segdecoder_small.png b/src/img/dibujo_20201207_hex7segdecoder_small.png new file mode 100644 index 0000000..7651a7d Binary files /dev/null and b/src/img/dibujo_20201207_hex7segdecoder_small.png differ diff --git a/src/img/foto_20201130_hex7segdecoder_01.png b/src/img/foto_20201130_hex7segdecoder_01.png new file mode 100644 index 0000000..ff00341 Binary files /dev/null and b/src/img/foto_20201130_hex7segdecoder_01.png differ diff --git a/src/img/foto_20201130_hex7segdecoder_02.png b/src/img/foto_20201130_hex7segdecoder_02.png new file mode 100644 index 0000000..9bf243e Binary files /dev/null and b/src/img/foto_20201130_hex7segdecoder_02.png differ diff --git a/src/img/foto_20201130_hex7segdecoder_03.png b/src/img/foto_20201130_hex7segdecoder_03.png new file mode 100644 index 0000000..355f64b Binary files /dev/null and b/src/img/foto_20201130_hex7segdecoder_03.png differ diff --git a/src/img/foto_coloring-computers_7seg-lee.png b/src/img/foto_coloring-computers_7seg-lee.png new file mode 100644 index 0000000..8233a54 Binary files /dev/null and b/src/img/foto_coloring-computers_7seg-lee.png differ diff --git a/src/img/foto_coloring-computers_cover-lee.png b/src/img/foto_coloring-computers_cover-lee.png new file mode 100644 index 0000000..f61f61b Binary files /dev/null and b/src/img/foto_coloring-computers_cover-lee.png differ diff --git a/src/img/foto_coloring-computers_pcd2019.png b/src/img/foto_coloring-computers_pcd2019.png new file mode 100644 index 0000000..0267ccb Binary files /dev/null and b/src/img/foto_coloring-computers_pcd2019.png differ diff --git a/src/img/foto_laconsagracion-riley-11.gif b/src/img/foto_laconsagracion-riley-11.gif new file mode 100644 index 0000000..6c02799 Binary files /dev/null and b/src/img/foto_laconsagracion-riley-11.gif differ diff --git a/src/img/foto_laconsagracion-riley-14.gif b/src/img/foto_laconsagracion-riley-14.gif new file mode 100644 index 0000000..5992b27 Binary files /dev/null and b/src/img/foto_laconsagracion-riley-14.gif differ diff --git a/src/img/foto_laconsagracion-riley-19.gif b/src/img/foto_laconsagracion-riley-19.gif new file mode 100644 index 0000000..0d0242c Binary files /dev/null and b/src/img/foto_laconsagracion-riley-19.gif differ diff --git a/src/img/foto_laconsagracion-riley-3.gif b/src/img/foto_laconsagracion-riley-3.gif new file mode 100644 index 0000000..87364e3 Binary files /dev/null and b/src/img/foto_laconsagracion-riley-3.gif differ diff --git a/src/img/foto_laconsagracion-riley-4.gif b/src/img/foto_laconsagracion-riley-4.gif new file mode 100644 index 0000000..8b79e54 Binary files /dev/null and b/src/img/foto_laconsagracion-riley-4.gif differ diff --git a/src/img/foto_laconsagracion-riley-6.gif b/src/img/foto_laconsagracion-riley-6.gif new file mode 100644 index 0000000..134b13d Binary files /dev/null and b/src/img/foto_laconsagracion-riley-6.gif differ diff --git a/src/img/ilustracion_ciclo-de-memoria.png b/src/img/ilustracion_ciclo-de-memoria.png new file mode 100644 index 0000000..393d4d9 Binary files /dev/null and b/src/img/ilustracion_ciclo-de-memoria.png differ diff --git a/src/index.gmo b/src/index.gmo new file mode 100644 index 0000000..d0fed34 --- /dev/null +++ b/src/index.gmo @@ -0,0 +1,7 @@ +# compudanzas + +human-powered explorations of emergent complexity + +=> ./about.gmi {about} +=> ./coloring_computers.gmi {coloring computers} +=> ./las_danzas.gmi {las danzas} diff --git a/src/la_consagración_de_la_computadora.gmo b/src/la_consagración_de_la_computadora.gmo new file mode 100644 index 0000000..4ef2373 --- /dev/null +++ b/src/la_consagración_de_la_computadora.gmo @@ -0,0 +1,46 @@ +# la consagración de la computadora + +a dance that +becomes computer, +machine, +organism... + +# archive + +=> ./img/foto_laconsagracion-riley-11.gif foto: dos personas en el suelo manipulando piezas de madera +=> ./img/foto_laconsagracion-riley-14.gif foto: una persona le muestra a otra un símbolo en una pieza de cartón + +danza que se convierte en +computadora, +máquina, +organismo... + +=> ./img/foto_laconsagracion-riley-19.gif foto: tres personas en el suelo, manipulando piezas de cartón y rodeadas de piezas de madera +=> ./img/foto_laconsagracion-riley-3.gif foto: dos personas cerca del suelo, al lado una fila de símbolos conformados con piezas de madera + +la consagración de la computadora es una ceremonia, colaboración y celebración entre elementos humanos y no-humanos: una máquina computacional lenta, sudorosa, orgánica, ineficiente, bailada, turing completa; realizando un proceso de vida potencialmente infinito... + +=> ./img/foto_laconsagracion-riley-4.gif foto: una persona rueda por el suelo observando una pieza de cartón, al lado de la fila de símbolos de piezas de madera + +the rite of computing is a ceremony, a collaboration and celebration between human and non-human elements: a slow, sweaty, organic, locally-grown, inefficient, danced, turing-complete, computational machine; performing a potentially endless process of life. + +=> ./img/foto_laconsagracion-riley-6.gif foto: una persona en el suelo, cercana a la fila de símbolos de madera, en contraluz + +photos: Riley Stenehjem +featuring: August Luhrs, Isa Vento, sejo + +adapted page from the original at chsnec +=> https://ipfs.io/ipfs/QmYYqFXowEuak9NVNMHexrwZQkEnfH4J6weSPpv3kjFP94/mub/laconsagracion.html chsnec: la consagración de la computadora + +premiere invite: +=> https://ipfs.io/ipfs/QmYYqFXowEuak9NVNMHexrwZQkEnfH4J6weSPpv3kjFP94/mub/show.html la consagración de la computadora (the rite of computing) - world premiere! + +# and more + +an implementation of the máquina universal bailable {mub} + +dance accompanied by {the rite of computing} + + +## llega(n) aquí +=> ./the_rite_of_computing.gmi {the rite of computing} diff --git a/src/las_danzas.gmo b/src/las_danzas.gmo new file mode 100644 index 0000000..b762cf8 --- /dev/null +++ b/src/las_danzas.gmo @@ -0,0 +1,54 @@ +# las danzas + +colección de actividades y planteamientos bailables + +# ciclo de memoria + +un dispositivo-danza que almacena información binaria, con capacidad de ser escrita y leída. + +nos volvemos un registro de corrimiento (shift register) síncrono para almacenar de manera activa una secuencia de símbolos. + +=> ./ciclo_de_memoria.gmi {ciclo de memoria} + +# par y danza + +estrategia básica para detectar posibles errores de transmisión / recepción de una secuencia binaria. + +=> ./par_y_danza.gmi {par y danza} + +# danzas compuertas + +en la que nos convertimos en red de compuertas lógicas para resolver en conjunto operaciones aritméticas o lógicas. + +comportamiento asíncrono, que podemos sincronizar para procesos más complejos. + +=> ./danzas_compuertas.gmi {danzas compuertas} + + +# reglas de wolfram + +danzas en las que nuestro nuevo estado individual depende de nuestro estado propio y del de dos personas más. + +# danzasistemas-tag + +“batallas” en las que respondemos procesando elementos de la secuencia anterior. + +=> ./danzasistemas-tag.gmi {danzasistemas-tag} + +# d-turing + +en donde bailamos con y a partir de una fila / tira / cinta de objetos / símbolos y una tabla específica de estados. + +=> ./d-turing.gmi {d-turing} + +# máquina universal bailable + +en donde bailamos con y a partir de una fila / tira / cinta de objetos y una tabla específica de estados, en un acomodo tal que nos permite simularnos bailando con y a partir de una fila / tira / cinta de objetos y cualquier tabla específica de estados + +=> ./mub.gmi {mub} + +# danza papier + +en donde nuestras acciones toman la forma de las operaciones de una computadora con una arquitectura similar a la de las que conocemos. + +=> ./danza_papier.gmi {danza papier} diff --git a/src/license.gmo b/src/license.gmo new file mode 100644 index 0000000..f6a98e2 --- /dev/null +++ b/src/license.gmo @@ -0,0 +1,5 @@ +# license + +unless otherwise noted, the compudanzas materials are shared under the + +=> https://wiki.p2pfoundation.net/Peer_Production_License peer production license diff --git a/src/llave_sejo.asc b/src/llave_sejo.asc new file mode 100644 index 0000000..302737a --- /dev/null +++ b/src/llave_sejo.asc @@ -0,0 +1,65 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFye12YBEADgYlrJUTu56t6yCP6Usec0SjKuioG7hOdcRiIThP4No6IZTL2I +vnc++4kDH7scTBJIf7nVvzNo84SV4cQ4jBmuo9u10c5o4GatEMtzaVjHkXYDIzQh +5wxb0osMwxdHyRw/6M0BGDHWQehBlfW5B+xrRWTLlzo5CGLAPCbu2HIDLs6hyzZK +VRB9CzkGLagPMZSJ2GeaS1HvZtVMB5AGxQzIPjWgf46DIWN3av3h7Ui/aQ2D71FV +pU6GJK6tjAoh6uWdnIVZGXsY0aytxRd7R6xzfdsBXqKpgc3ZSu7lmjucTnK+pnR0 +3AizDW+ED6J72OYorZm43ZWZ7W6PbGqE6S0/rzK7aInb2+nLibv+JpLQexWNTcP0 +zNufwF9EO/b9bqPagVtwz1w0k1Gchh39byDULT8mdDz/rP5oBTUTeBuFJ3XJBZ8f +kzyElnRhl7CEdSdXOcsvO/jH+4dVaHSKJ/ynYst73dGcrN6qWHrpD+lYayOmu2p8 +PUH6Yf1FsU/ZSy6uKc6dwfFLLTXTFpTpR+Bkpl1Yv+Mhfb7ZNFjCvYGnlpGdzZkI +4l71QFgmmAQW2fYO2iOzVlq5WNDLrDZEEC/NTlbx7sFauICujW3aaALqfyDQ2zhH +rtxYQVlD13SRlT84u1R+GB2TSgGlsJLo1Mokf7Ny+hf2Fb3mFGVKBswWLwARAQAB +tBZzZWpvIDxzZWpvQGVjY3Mud29ybGQ+iQJUBBMBCAA+AhsjBQsJCAcCBhUKCQgL +AgQWAgMBAh4BAheAFiEEVBen1Y7Dl6iHB8t9sSydTJvPqtYFAl/NpqcFCQUQAsEA +CgkQsSydTJvPqtZtKg/8CypjuTCwVjBkEZCVdyVuxlB//AK0zA03itrfksvrpHwz +NqxeiCrGdt6pKz5jI/AkFAXq+aIZF9hGLjY6AoIUKdNs+qP27j2TD0Xbvh7/AjDo ++2pPTzOMFTjOXmvXrfY0I0LfMAVWV3gXule6oqWaqj09rQSX8kV/xormIcZv96Os +okEHta+e7AVNs8+dw529VTbuDSiiaWfNne5+P3vwndKKbHdvWQBVKoOVRfYkZWSJ +5eUzrGxjJNKYToTFW8XRv1fxLZuTQJTusbuCUeSMaPSGMPhnuzp7LRYgKjO4sTHM +Jqnbae9PDLCHAWmcjUbQEdZbNnGDvDQZdtFfoOQxsoVuawLhnwabRB4secKxF14V +peQ9cCG22Rj2o9Yi1UbPmQqXdQXkBEBdacZeIgXXHHxuwuXFH7iNBaCVvtAcQKVo +YWmcjk7XCrf+diZbiIkZFpdlcqoo2gKhcaP5SMKgKoqwUmidoG4auN1I6dYLONhI +IlWHwNVPQX0zPr1/1f/3RumwDfsBfxMsZWK2xKm51i/Ptt86pJdWuOH1FUVF0wlF +p9ADYGUYG2B6klaD4oGYX7o+6Yrga8BgjHGTHvFXOUk4UCDzGGd+hvffrxyyXYb7 +ngd8KAIzdKZVxwmNMhgPPWpfPhQzfU+2H2IoGvv4DvlbYgbzN3pHcjevJH5R3a20 +G3Nlam8gc2VqbyA8c2Vqb0Bwb3N0ZW8ubmV0PokCVAQTAQgAPgIbIwULCQgHAgYV +CgkICwIEFgIDAQIeAQIXgBYhBFQXp9WOw5eohwfLfbEsnUybz6rWBQJfzaanBQkF +EALBAAoJELEsnUybz6rWpDUQAKD8VeIZZ/Q1xsFWgxJ2cJ59ZeCU1Zu0AyVWjOne +8T5rPmde/k6tWXM9nvZu6WcVUiDef/Bg3PsYx6dwwS241Y+lMibZ+TMCXiu0Jj5s +YfwHIda0K5ZET5Jh8ilDTHjW8uVyyJWlbgsQBSX5E8i1q+SGvMDRjxa+auD20gJE +Rmb4h/AUISUdJcBUqmPfx21JnfPrVscB1+eiHGpujuaajXrSpqBdqNS6f9aIwnYt +jKLCw7ZsDcxZ5MfYpIVn2KqgZnsVyqxupvtWm5qbp5/YBc9MhGmCc033d8fu2RrH +l3iaEziK+yjJdwiUUgaznxoVOZQzCvCJ0cFsvXKAD2+1ea2MInDmNreukMcqoYkh +pQjP9Ybsj7qzdUnCveT6MmC1557tJTpQam/8+yk9Xskg+X82V78M3U+29rvGOAz/ +6u21UBX9nZXuyhTdIBS9sq0tNrf8xzTwwUW/CdwHyVO31CvZsF+ye31WLwYlPWD6 +RmfEBJDWZ5J4atD1dayObUh6maGNbXaqddd6jtsjmU9wasUpzDmE449xvYv+FMsi +IrRROwPsPUzOazE9wwBSBOk2Plt+ihz1bdjvIa1b5Cbii6gMJK8d2JBiAlxsnnYP +EMErg7I4U8CC5EnXX8isr7VYKUUYrrTmECaZJq7Sp4CVOCrWH/XiS1wSEYcg8OXy +l2yJuQINBFye12YBEACqWc3xTmYJKtzT1zbYAbM0ODcZEzZP/4hWCyjBgwfMV5Wt +w2s3kV7NH6uv+SL50iXkjtuOSieiukrw7lT8HcW481U7BO1lLpwK8vUETmgK5cd9 +DLz+CHajTft+QalDrDEbF186eyeoXlU4A9xKIZtbuVPQGPje9APljoM66tyZp7HO +X2oZkrE2ejM9nxqkwDFAC8iksytY6WiyiLh0i0UEIvIStKXOy3CQU5VnCFVMN93d +YtQikQ4o1WmFm0N0E2TxOYmUTZyVDg2Mogpn6VHc4MvASFgOX0oLLB6ciEyEC48/ +MZ0zmPAgbKTA5TPOC7jZipdpjj88Z1iOZbE5NfPIzlFJfFH3BXA7D9fq/Q76mHSm +h6k9R/cL+m4z0/5zD5RtfqS+E2+kCD1GPR5agwgje+DP53mQm8dfKNgNh+wRj5N6 +4iJzCWfPhfpZ3XFbgEFDZ/VaDl99f1c1kmMcZi0P28TOKXTfmYMx0Jdkt1Fi0J8L +MqNyhUJXyw3FzaK/Xh3Zw6dPuvFY6ZV1p7lsSUROheWCbJGTtuHwQT2+vGjZXeUJ +16Ybgr0dEpCvm+QqBGwtdp+iznyehCSEXezw10st5kq9qKY4+DR5CCWs1wc5iWzE +gt6f2JNfFU7T6UIDOvEzpJxegnQg+rbwFxHJliQbgtFAOgG7NMwi7IDCdz1txwAR +AQABiQI8BBgBCAAmAhsMFiEEVBen1Y7Dl6iHB8t9sSydTJvPqtYFAl/NpuIFCQUQ +AvwACgkQsSydTJvPqtar2BAAyjckjQIcr09BitU6wEW3mF9cARMK2CI8sUU4qtVU +NFdKZybTq98Mq6dfpj1t1g1k5b2hYEgU7yuF6dQAQEMEwo+AYG3fOZJA1YvnLyYY +YBqk22e+/bySE5ount4xzcB7WCTEOKZUz3Xt9LCWkTLxlOiLooCl4IvnXZpEy5V/ +zFcHXlfwtUngIaEUpejPALwhgvLTienK18rdtEdbdyvj8bYZyOb83P0wKqNkHqaC +8ODnFs0/yH6XbOaEuTWOV8y3G8zgDMqk+hb3uC1OuS7Xj2ig+laEGmYB3oFTYhDi ++g62TZHglfu42R18MCFiEx0b4gZ0BnN0bX+7QuJl18BnKfE4O2Bjt2YU0RPE126e +KeoOgvHO5oZCDWgVB+Lul4uCNwH3N59Z0XEuI45ZWQ/7qOYHSQ95vG8b9V7gGeG9 +wp90qfC5cmHMGrsGFUZ/+h23Zdg8Sx76ylZRVf1jwg9h5YvHGBXCIvhY9LctBUdr +OWRjhXsTRTnaSDqrS/zOlVRut/vZv9ZGj4br+4x4hnJ5jM2eLKeCEyfRCRWCmxKh +wM+MknYIygwu608uBjZOT7SPX2QGKZgspvUOnzbvBkAX5R7xM40+E41KizjRPewg +7AcB/9dt4vBwsk0vjrRA8T5TA+LlwA2Hje1FXYyKmKqfNwRf3WP36amKTJoMBouE +39c= +=I3+J +-----END PGP PUBLIC KEY BLOCK----- diff --git a/src/log.gmo b/src/log.gmo new file mode 100644 index 0000000..61c2f7e --- /dev/null +++ b/src/log.gmo @@ -0,0 +1,19 @@ +# the log + +what's happening with compudanzas + +## 12021-06-14 the beginning or not + +we started building this site, from previous blocks of executable and non-executable texts. + +there's an upcoming talk in the weekend. + +for a while it was seen as the closure of this project, and a recap of its history. + +now it is seen as a new beginning. + +=> ./talks_and_workshops.gmi {talks and workshops} + + +## incoming links +=> ./about.gmi {about} diff --git a/src/logiteca.gmo b/src/logiteca.gmo new file mode 100644 index 0000000..e00455b --- /dev/null +++ b/src/logiteca.gmo @@ -0,0 +1,288 @@ +# logiteca + +compendio de circuitos lógicos que pueden implementarse en las {danzas compuertas}. + +material de referencia para las {las danzas} + +# acerca de + +este es un compendio de circuitos lógicos que pueden implementarse en las {danzas compuertas}. + +están descritos en *verilog*, un lenguaje descriptor de hardware. esto con la idea de estandarizarlos, de facilitar simularlos e implementarlos en otros materiales, y de indicar su cualidad de *red abstracta*. + +utilizamos el lenguaje a nivel de {compuertas} lógicas solamente: cada compuerta se expresa como una función (`and()`, `not()`, `or()`, `nor()`, `nand()`, etc) donde el primer argumento es el nombre de la *salida* de la compuerta, y el o los otros argumentos son los nombres de las *entradas*. + +el número de participantes asignado por circuito está contado como el *número de entradas* más el *número de compuertas*, donde alguna(s) de ella(s) incluyen las compuertas cuyas salidas son también la(s) del circuito. si se tienen más participantes, se pueden agregar el *número de salidas*: persona(s) que copien el resultado de la compuerta correspondiente. + +# multiplicador de 1 bit + +circuito que multiplica a dos números de 1 bit y da el resultado en 1 bit. + +## multiplicador de 1 bit con compuertas habituales (3 o 4 participantes) + +``` +// multiplicador construido con compuertas habituales +// entradas (2): a,b +// salidas (1): r (resultado) +// compuertas (1): 1 de 2 entradas + +module multiplicador( a, b, r); + +input wire a, b; +output wire r; + +and C1(r, a, b); + +endmodule +``` + +## multiplicador de 1 bit con nor (5 o 6 participantes) + +``` +// multiplicador construido con nor's +// entradas (2): a,b +// salidas (1): r (resultado) +// compuertas (3): 2 de 1 y 1 de 2 entradas + +module multiplicador( a, b, r); + +input wire a, b; +output wire r; +wire p1,p2; + +// negadas +nor C1(p1, a); +nor C2(p2, b); + +// resultado +nor C3(r, p1, p2); + +endmodule +``` + +# contadores + +circuitos que incrementan 1 al número binario colocado en la entrada, con el mismo número de bits a la entrada que a la salida. + +si la salida se "conecta" a la entrada, entonces con cada paso se obtiene el +número siguiente en la secuencia, es decir se "cuenta". + +al llegar al último número, se regresa a 0. + +## contador de 2 bits con compuertas habituales (4 o 6 participantes) + +``` +// contador de 2 bits con compuertas habituales +// entradas (2): a, b +// salidas (2): x, y +// compuertas (2): 1 de 1 y 1 de 2 entradas + +module contador(a, b, x, y); + +input wire a,b; +output wire x,y; + +not C1(y, b); +xor C2(x, a,b); + +endmodule +``` + +## contador de 2 bits con nor (7 o 9 participantes) + +``` +// contador de 2 bits con nor +// entradas (2): a, b +// salidas (2): x, y +// compuertas (5): 2 de 1 y 3 de 2 entradas + +module contador(a, b, x, y); + +input wire a,b; +output wire x,y; +wire p1, p2, p3; + +// negaciones +nor C1(y, b); +nor C2(p1, a); + +// para x +nor C3(p2, a,b); +nor C4(p3, y,p1); +nor C5(x, p2,p3); + +endmodule +``` + + +## contador de 3 bits con nor (13 o 16 participantes) + +``` +// contador de 3 bits con compuertas habituales +// entradas (3): a, b, c +// salidas (3): x, y, z +// compuertas (10): 3 de 1, 4 de 2, 3 de 3 entradas + +module contador(a, b, c, x, y, z); + +input wire a,b,c; +output wire x,y,z; +wire p1, p2, p3, p4, p5, p6, p7; + +// negaciones +nor C1(p1, a); +nor C2(p2, b); +nor C3(z, c); + +// para y +nor C4(p3, b,c); +nor C5(p4, p2,z); +nor C6(y, p3,p4); + +// para x +nor C7(p5, a,b); +nor C8(p6, p1, p2, z); +nor C9(p7, a, p2, c); +nor C10(x, p5, p6, p7); + +endmodule +``` + + +# half adder + +circuito que suma dos bits y da el resultado en dos bits (resultado y *carry*) + +## half adder con compuertas habituales (4 o 6 participantes) + +``` +// half adder construido con compuertas habituales +// entradas (2): a,b +// salidas (2): r, c (resultado, carry) +// compuertas (2): 2 de 2 entradas + +module halfadder( a, b, r, c); + +input wire a, b; +output wire r,c; + +// carry +and C1(c, a, b); + +// resultado +xor C2(r, a, b); + +endmodule +``` + +## half adder usando nor (7 o 9 participantes) + +``` +// half adder construido usando nor's +// entradas (2): a,b +// salidas (2): r, c (resultado, carry) +// compuertas (5): 2 de 1 y 3 de 2 entradas + +module halfadder( a, b, r, c); + +input wire a, b; +output wire r,c; +wire p1,p2,p3; + +// negadas +nor C1(p1, a); +nor C2(p2, b); + +// carry +nor C3(c, p1, p2); + +// resultado +nor C4(p3, a, b); +nor C5(r, c, p3); + +endmodule +``` + + +# full adder + +circuito que suma tres bits y da el resultado en dos bits (resultado y *carry*). + +## full adder con compuertas habituales (14 o 16 participantes) + +``` +// full adder construido con compuertas habituales +// entradas (3): a, b, c +// salidas (2): carry, r (resultado) +// compuertas (11): 2 de 1 y 9 de 2 entradas + +module fulladder( a, b, c, r, carry); + +input wire a, b, c; +output wire r, carry; +wire p1, p2, p3, p4, p5, p6, p7, p8, p9; + +// negadas +not C1(p1, a); +not C2(p3, p2); + +// diferencias b,c +xor C3(p2, b, c); +or C4(p4, b, c); +and C5(p5, b, c); + +// armado de resultado +and C6(p6, p1, p2); +and C7(p7, a, p3); +or C8(r, p6, p7); + +// armado de carry +and C9(p8, p1, p5); +and C10(p9, a, p4); +or C11(carry, p8, p9); + +endmodule +``` + +## full adder usando nor (15 o 17 participantes) + +``` +// full adder construido usando nor's +// entradas (3): a, b, c +// salidas (2): carry, r (resultado) +// compuertas (12): 3 de 1, 3 de 2, 4 de 3 y 1 de 4 entradas + +module fulladder( a, b, c, r, carry); + +input wire a, b, c; +output wire r, carry; +wire p1, p2, p3, p4, p5, p6, p7, p8, p9, p10; + +// negadas +nor C1(p1, a); +nor C2(p2, b); +nor C3(p3, c); + +// pa'l carry +nor C4(p4, a, b); +nor C5(p5, a, c); +nor C6(p6, b, c); + +// pa resultado +nor C7(p7, a, b , c); +nor C8(p8, p1, b, p3); +nor C9(p9, a, p2, p3); +nor C10(p10, p1, p2, c); + +// salidas +nor C11(carry, p4, p5, p6); +nor C12(r, p7, p8, p9, p10); + +endmodule +``` + + + +## llegan aquí +=> ./danzas_compuertas.gmi {danzas compuertas} +=> ./coloring_computers.gmi {coloring computers} diff --git a/src/mub.gmo b/src/mub.gmo new file mode 100644 index 0000000..dd97cff --- /dev/null +++ b/src/mub.gmo @@ -0,0 +1,20 @@ +# máquina universal bailable + +una de las {las danzas} en donde bailamos con y a partir de una fila / tira / cinta de objetos y una tabla específica de estados, en un acomodo tal que nos permite simularnos bailando con y a partir de una fila / tira / cinta de objetos y cualquier tabla específica de estados. + +implementación especial de una máquina de turing {d-turing}, con la capacidad de simular, emular, ser, cualquier otra máquina de turing. + +# la máquina + +próximamente + +# en escena + +una versión de la máquina universal bailable se presentó como acto escénico + +=> ./la_consagración.gmi {la consagración de la computadora} + + +## llega(n) aquí +=> ./las_danzas.gmi {las danzas} +=> ./la_consagración_de_la_computadora.gmi {la consagración de la computadora} diff --git a/src/par_y_danza.gmo b/src/par_y_danza.gmo new file mode 100644 index 0000000..59827d1 --- /dev/null +++ b/src/par_y_danza.gmo @@ -0,0 +1,106 @@ +# par y danza + +estrategia básica para detectar posibles errores de transmisión / recepción de una secuencia binaria, en modalidad {las danzas}. + +implementamos el cómputo y detección de la llamada paridad: dada una secuencia de dos tipos de símbolos, ¿la cantidad de símbolos de uno de esos tipos, es par o impar? + + +# componentes + +usaremos el concepto de estados y tiempos discretos. + +## participantes + +necesitamos al menos dos personas: + +* transmisora de secuencia +* calculadora de paridad + +## movimientos + +necesitamos un alfabeto de dos movimientos: + +* un movimiento "alto" +* un movimiento "bajo" + +y un conteo de tiempos discretos. + +cada uno de esos tiempos que contiene a un movimiento, lo podemos considerar un "bit": unidad mínima de información. + +para transmitir información más compleja, necesitamos varios "bits": una secuencia de tiempos con uno de estos dos movimientos. + + +## estados y transiciones + +en cada unidad de tiempo, estamos ya sea en el estado que corresponde al movimiento alto, o en el que corresponde al movimiento bajo. + +inicialmente estamos en el movimiento bajo. + +tenemos dos tipos de transiciones: + +* continúa: sigue en el mismo estado +* invierte: cambia al otro estado + + +# guía + +## cálculo de paridad + +de acuerdo al mensaje binario a transmitir, en cada tiempo la persona transmisora envía uno de los dos movimientos posibles. + +cuando la cantidad de movimientos que envía en una transmisión son 8, estará enviando un "byte". + +la persona calculadora inicialmente está en el movimiento bajo. + +en cada tiempo de transmisión, la persona calculadora ha de actuar de la siguiente forma: + +* si el movimiento transmitido es bajo, ella ha de continuar su movimiento. +* si el movimiento transmitido es alto, ella ha de invertir su movimiento. + +al concluir la transmisión, la persona calculadora habrá terminado: + +* en el movimiento alto si la cantidad de movimientos altos transmitidos fue impar. +* en el movimiento bajo si la cantidad de movimientos altos transmitidos fue par + +comprobemos que sí sea así, con secuencias de diferente longitud y paridad. + + +## detección de error con paridad + +### conceptos + +el estado en el que terminó la persona calculadora puede llamarse el bit de paridad. + +un aspecto interesante y no obvio de este sistema, es que si este bit de paridad se agrega a la secuencia original para formar una nueva secuencia completa, entonces la cantidad total de movimientos altos siempre será un número par: + +* cuando la cantidad era impar (por ejemplo, 3), el bit de paridad es alto, y al sumarse da un total par (por ejemplo, 4) +* cuando la cantidad era par (por ejemplo, 2), el bit de paridad es bajo y no se suma al total, que queda par (por ejemplo, 2) + +### actividad + +después de calcular localmente la paridad de la secuencia a transmitir, podemos pasar a transmitir a mayor distancia la nueva secuencia con el bit de paridad al final: + +en cada tiempo, la persona transmisora envía el movimiento correspondiente para transmitir la secuencia completa. + +la persona calculadora inicialmente está en el movimiento bajo. + +en cada tiempo de transmisión/recepción, la persona calculadora ha de actuar de la siguiente forma: + +* si el movimiento recibido es bajo, ella ha de continuar su movimiento. +* si el movimiento recibido es alto, ella ha de invertir su movimiento. + +al terminar la transmisión de la secuencia completa, revisamos el estado de la persona calculadora: + +* si se encuentra en movimiento alto (paridad impar), hubo algún error en la comunicación +* si se encuentra en movimiento bajo (paridad par), probablemente no hubo error en la comunicación + +probemos con secuencias de diferente longitud, a diferentes velocidades, y también a diferentes distancias. + +¿llega a suceder que detectamos un error? + +¿qué pasa cuando hay dos errores en la comunicación? ¿es posible que el sistema no lo detecte? + + + +## llega aquí: +=> ./las_danzas.gmi {las danzas} diff --git a/src/poetry.gmo b/src/poetry.gmo new file mode 100644 index 0000000..560038f --- /dev/null +++ b/src/poetry.gmo @@ -0,0 +1,3 @@ +# poetry + +=> ./the_rite_of_computing.gmi {the rite of computing} diff --git a/src/talks_and_workshops.gmo b/src/talks_and_workshops.gmo new file mode 100644 index 0000000..569188c --- /dev/null +++ b/src/talks_and_workshops.gmo @@ -0,0 +1,28 @@ +# talks and workshops + +public appearances of the project. + +# upcoming + +## june 12021 + +compudanzas talk and {coloring computers} workshop in processing community day quito, june 19th + +=> http://pcdquito.com/ pcd quito 2021 + + +compudanzas workshop in cuna school + +=> https://www.cunamex.com/compudanzascursoonline compudanzas - cuna + +# past + +## 12019 + +{coloring computers} workshop in the processing community day nyc + +=> https://processing.nyc/2019/#workshops processing community day nyc 2019 + + +## incoming links +=> ./log.gmi {log} diff --git a/src/the_rite_of_computing.gmo b/src/the_rite_of_computing.gmo new file mode 100644 index 0000000..4c073f1 --- /dev/null +++ b/src/the_rite_of_computing.gmo @@ -0,0 +1,291 @@ +# the rite of computing + +we saw the tipping points being crossed, and yet the same behavior +destruction was all around, even in the use of our tools of creation +what could we do? how could we engage? how could we disengage? +we thought of reinventing computers +homegrown, homemade… +a game, a party, a dance +maybe in that way we would understand? +maybe in that way we would know if we want to keep them? +the following are some of our notes, thoughts, conversations, actions… + +# r + +– i wonder what happens when you remove efficiency, speed +– the machine doesn’t seem to complain +– it comes with a great cost +– some beings at the service of others, is that the natural order? +– you thought and asked, until you realized you put yourself on fire +– the higher one gets, and the more one on others depends… +– how bad you think the fall will be? +– how long will the internet live once the humans are gone? + +# u + +the person is given a ruleset +a table +current configuration +encountered symbol +what to put instead +where to move +next configuration + +the floor is prepared +a row of symbols +mosaic of colors +in a spiral +around the fire + +the person enters the space +drums start playing +the person starts moving +repeating +a configuration becomes a state of being +a sequence of movements +the mosaics are replaced +(make sure you don’t lose track) +transitions from a state to another +the spiral becomes another +we expect the process +we expect the result + +after hours of a body +becoming a body +emulating a body +who moves and sweats +losing (but not really) breath +the iteration is complete + +# w + +– can we talk about rewilding computers? +– were they wild to start with? +– how wild or not is a division +– of time and space in slots +– ever-decreasing measures +– changes of state? +– the revolution, the transcription, life +– no boundaries, really, but in our self +– and that one, really, also emerges +– maybe you mean getting rid of the rigid cover +– curving the interconnections +– the differences are fluid +– with or without extremes? +– i lost you +– destroying the shiny, embracing the earth +– a cracked screen carried away by the sea? +– that would probably kill us +– with emergence we understand we can’t understand +– is it a useful model? +– model? useful? it? +– number of processors versus grains of sand? +– and if we become just a probe? +– i dissolve, the computer +– the transformation carries on + +# n + +– think about the apparently unnatural… +– creating vacuum… +– manipulating beams of charge and light… +– wiring thousands, cooling their surrounding air… +– later inserting billions in a little block of sand +– why not just chill and enjoy the beach? +– there was a war +– and then the promise of productivity +– why not just chill and enjoy the beach? + +# t + +a tape in the form of a series of objects in some kind of slots +each object a symbol +maybe pieces of cloth in a clothesline +or pieces of paper on the floor +soft and flexible +an object signals the current position of the head +maybe a stool to reach above +or a long stick that rests and points + +a group of people is engaged +each one of them with a different command: +if you encounter the short object in the tape +replace it with the thin +move the head to the left + +and get the long-haired person to continue +different combinations +fragments of behavior +nobody knows what is really happening +and yet, the computation occurs + +# i + +– can you tell me again about your project? +– project, ceremony, dance, choreography… computer! +– i wonder how can someone end up there +– it’s just about imagining alternatives, trying to reinvent… +– is this a solution to a problem? what if everybody does as you? +– they originated with war in body and mind +– and they have very good uses despite that; they saved me! +– what about realizing they are made through destruction? +– it might be practical: destroying the old and the weak +– and we will drown by powering them +– i hope we can upload our consciousness by then? +– you might emulate yourself in rocks + +# c + +a group of people arrives to the floor that suddenly becomes a stage +bare feet, skin in the air with no layers in between +they move without the code that you would expect +(but with a different set of rules, what do they encode?) +eye contact, spatial awareness, flow +a self-generated oscillation +one of them observes other two +based on the three states, this one responds +repeat the same for each body +a cell made of cells +the pulse that reminds of a distant past +sweat that would short-circuit your board +yet information travels, proceeds, evolves +unpredictable behavior except by simulation +the bodies stomp, they clap, they sing +becoming another +above? (where?) below? (where?) +it’s there! +no need to channel the earth + +# e + +– i like computers +– why? they make more sense? +– maybe. complex but fabricated with heavy logic constraints… +– do you know how they work? +– that’s the question, do they work or do they just exist… +– following a hardwired behavior, filtering out noise +– only a fixed amount of values in space and time +– and yet embedded in an apparently continuous world +– where to put them in the organic-inorganic spectrum +– extracting minerals, sculpting them… +– marks are left, one at a time +– … modulating the electromagnetic spectrum all around +– wait! why are you talking about electricity, semiconductors? +– do you want to develop further? +– i’d prefer to do a backwards somersault and take a non-violent path + +# x + +– the idea is that you, as an individual, follow a simple set of rules +– these rules make me depend to some extent on other individuals +– your state of being based on my state of being +– we feel a pulse arriving, and we change +– how predictable you would think a system like that is? +– i wouldn’t expect it to be completely chaotic… +– complexity… how can you think about it if it was not for it? + +– each component can be part of the whole without knowing about it +– “it” being the whole or the component? +– or any of them? +– then can only one of these pieces bring the whole system down? +– the state of that answer depends on the state of your purpose +– i guess an undirected, chaotic behavior will always be alright +– the order, the function, the control are the ones that you can break +– why would we want a math-machine that doesn’t do the math right? +– there’s the poetry! +– but what about the rigor? the experience of following constraints? +– you think that is important? +– maybe it’s part of my identity +– we don’t have to do right math right +– less about me, more about the connections? +– in any case, it would be arbitrary and not too easy to get + +# d + +– i’m having trouble putting the finger in the point +– is your self-protective awareness in action? +– maybe. who will want to question electronic computers. +– or productive computers, for that matter. + +# s + +– i don’t know what’s a computer +– don’t worry, neither do i +– but you see it… +– i see it and i marvel +– it is only a machine +– i see how arithmetic can be done mechanically +– no need to learn, no need to understand? +– isn’t that amazing? doing something without knowing you are doing it +– small components contributing with small actions to a whole that no one knows? +– only the designer? +– and what if there is no one? +– what if they also emerged as a whole? +– and what kind of whole emerges from us? +– or where does that whole exist? +– if simple models acquire complexity so quickly… +– yes, say hi to the chaos of nature + +# p + +– has lightning been captured twice, so far? +– fire, electricity, what are they? +– probably it’s the same here with computing +– one thing is to describe them working… +– visualizations, metaphors… leading to understanding what i can’t see? +– but you don’t have to, to use them +– how convenient! +– in many ways, knowing about computer architecture is completely useless +– digital circuit design as some kind of poetry? +– unless you are in one of the few companies, of course +– forcing the rocks until they can’t hold it anymore? +– the magic doesn’t disappear even if you know how to combine transistors +– magic? the mystery of computation? +– how can dead matter appear to be alive? +– and how can it replicate and build new versions of itself? + +# l + +a group of people walk in the space +you see one person: +if they rise you fall +if they fall you rise +respond immediately +(as fast as your body can) +they in turn see two, +not including you +they rise only if both fall +otherwise they fall +some others see them +some others see you + +every once and then +a new change occurs in the beginning +people rise +people fall +the wave propagates +there is an end +no more people rise +no more people fall +and there is a result + +they take note +someone in the audience remembers +and then, +after a pause +the beginning feeds from the end +a change again +the machine is counting + + +originally published in adjacent, issue 5, as lengua partida (2019) +CC BY-SA 4.0 + +=> https://itp.nyu.edu/adjacent/issue-5/the-rite-of-computing/ the rite of computing (la consagración de la computadora) - ADJACENT Issue 5 (web) + +text accompanied by {la consagración de la computadora} + + +## incoming links +=> ./poetry.gmi {poetry} +=> ./la_consagración_de_la_computadora.gmi {la consagración de la computadora}