Merge pull request 'Revisión del día 1 (inglés y español) y el índice del tutorial (español)' (#3) from jota/compudanzas:tutorial_rev_dia_1_e_indice into main
Reviewed-on: #3
This commit is contained in:
commit
63277cfb66
|
|
@ -9,7 +9,6 @@ el tutorial está dividido en 8 días (o secciones), ya que puede ser seguido ju
|
|||
|
||||
(al día de hoy, este es un trabajo en proceso)
|
||||
|
||||
|
||||
# día 1
|
||||
|
||||
en esta primera sección del tutorial vamos a hablar de los aspectos básicos de la computadora uxn llamada varvara, su paradigma de programación, su arquitectura, y por qué podrías queres aprender a programar en ella.
|
||||
|
|
@ -21,11 +20,11 @@ también vamos a saltar directo a nuestros primeros programas simples para demos
|
|||
# día 2
|
||||
|
||||
en esta sección vamos a empezar a explorar los aspectos visuales de la computadora varvara: ¡hablamos sobre los aspectos fundamentales del dispositivo de pantalla para que podamos empezar a dibujar en ella!
|
||||
|
||||
también discutiremos el trabajo con cortos (2 bytes) además de los números de un sólo byte en uxntal.
|
||||
|
||||
{tutorial de uxn día 2}
|
||||
|
||||
|
||||
# día 3
|
||||
|
||||
aquí introducimos el uso del dispositivo controlador en la computadora varvara: esto nos permite agregar interactividad a nuestros programas, y empezar a implementar control de flujo en uxntal.
|
||||
|
|
@ -36,6 +35,14 @@ también hablamos de instrucciones lógicas y de manipulación de la pila en uxn
|
|||
|
||||
# día 4
|
||||
|
||||
aquí hablamos del bucle de animación del ordenador varvara, a través de su vector de dispositivo de pantalla.
|
||||
|
||||
también hablamos del uso de la memoria del programa como un espacio para datos usando "variables".
|
||||
|
||||
{tutorial de uxn día 4}
|
||||
|
||||
# día 5
|
||||
|
||||
¡proximamente!
|
||||
|
||||
# índice tentativo
|
||||
|
|
@ -129,6 +136,6 @@ modo nuevo: modo de retención
|
|||
|
||||
* comparte lo que has creado :)
|
||||
|
||||
# soporte
|
||||
# apoyo
|
||||
|
||||
si este tutorial te ha sido de ayuda, considera compartirli y brindarle tu {apoyo} :)
|
||||
si este tutorial te ha sido de ayuda, considera compartirlo y brindarle tu {apoyo} :)
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ uxn es el núcleo de la computadora virtual (¿por el momento?) varvara. es lo s
|
|||
|
||||
personalmente, veo en ella las siguientes virtudes:
|
||||
|
||||
* hecha para el largo plazo
|
||||
* hecha para el largo plazo, conforme a la escala humana
|
||||
* hecha para aplicaciones audiovisuales interactivas
|
||||
* arquitectura y set de instrucciones simple (¡sólo 32 instrucciones!)
|
||||
* primero-offline: funciona localmente y sólo necesitas unos pocos archivos de documentación para avanzar
|
||||
|
|
@ -128,11 +128,11 @@ vamos a ir cubriendo lentamente estas instrucciones durante este tutorial.
|
|||
la memoria en la computadora uxn consiste en cuatro espacios separados:
|
||||
|
||||
* memoria principal, con 65536 bytes
|
||||
* memoria de entrada/salida, con 256 bytes dividida en 16 secciines (o dispositivos) de 16 bytes cada uno: 8 bytes para entradas y 8 bytes para salidas.
|
||||
* memoria de entrada/salida, con 256 bytes dividida en 16 secciones (o dispositivos) de 16 bytes cada uno: 8 bytes para entradas y 8 bytes para salidas.
|
||||
* pila de trabajo, con 256 bytes
|
||||
* pila de retorno, con 256 bytes
|
||||
|
||||
cada byte en la memoria principal posee una dirección de 16 bits (2 bytes) de tamaño, mientras que cada byte en la memoria de entrada/salida posee una dirección de 8 bits (1 byte) de tamaño. ambas pueden ser accedidas de manera aleatoria.
|
||||
cada byte en la memoria principal posee una dirección de 16 bits (2 bytes) de tamaño, mientras que cada byte en la memoria de entrada/salida posee una dirección de 8 bits (1 byte) de tamaño. ambos pueden ser accedidos aleatoriamente.
|
||||
|
||||
los primeros 256 bytes de la memoria principal constituyen una sección llamada página cero. esta sección puede ser referenciada por 8 bits (1 byte), y su propósito es almacenar datos durante el tiempo de ejecución de la máquina.
|
||||
|
||||
|
|
@ -154,10 +154,14 @@ la instrucción va a implicar normalmente un cambio en la(s) pila(s), y algunas
|
|||
|
||||
# instalación y toolchain
|
||||
|
||||
¿liste? obtengamos el ensamblador uxn (uxnasm) y emulador (uxnemu) de su repositorio git:
|
||||
##instalación local
|
||||
|
||||
¿liste? para ejecutar varvara localmente y fuera de la red, tendríamos que obtener el ensamblador uxn (uxnasm) y el emulador (uxnemu) de su repositorio git:
|
||||
|
||||
=> https://git.sr.ht/~rabbits/uxn ~rabbits/uxn - sourcehut git
|
||||
|
||||
puedes construir estas herramientas desde el código fuente o descargar binarios precompilados para múltiples plataformas.
|
||||
|
||||
estas instrucciones son para sistemas basados en linux.
|
||||
|
||||
si necesitas una mano, encuéntranos en #uxn en irc.esper.net :)
|
||||
|
|
@ -195,6 +199,7 @@ si todo fué bién, verás varios mensajes en la terminal y una pequeña ventana
|
|||
* F1 itera entre diferentes niveles de zoom
|
||||
* F2 muestra el debugger en pantalla
|
||||
* F3 toma una captura de pantalla de la ventana
|
||||
* F4 carga un boot.rom que permite navegar y abrir roms en el directorio actual
|
||||
|
||||
## usando el toolchain
|
||||
|
||||
|
|
@ -204,17 +209,23 @@ verás que luego de compilar uxn, cuentas con tres nuevos archivos ejecutables e
|
|||
* uxnasm: el ensamblador
|
||||
* uxncli: un emulador de consola no interactivo
|
||||
|
||||
en principio puedes hacer doble clic en uxnemu y que se ejecute. sin embargo, utilizaremos estos programas desde la línea de comandos.
|
||||
|
||||
puedes ajustar tu $PATH para tenerlos disponibles en todos lados.
|
||||
|
||||
la idea es que para correr un programa escrito en uxntal (el lenguaje ensamblador de uxn), primero tienes que ensamblarlo en una "rom", y luego puedes correr esta rom con el emulador.
|
||||
|
||||
por ejemplo, para correr {darena} que se encuentra en projects/examples/demos/ :
|
||||
|
||||
```
|
||||
ensambla darena.tal en darena.rom
|
||||
$ ./bin/uxnasm projects/examples/demos/darena.tal bin/darena.rom
|
||||
ensambla darena.tal en darena.rom:
|
||||
|
||||
correr darena.rom
|
||||
```
|
||||
$ ./bin/uxnasm projects/examples/demos/darena.tal bin/darena.rom
|
||||
```
|
||||
|
||||
corre darena.rom:
|
||||
|
||||
```
|
||||
$ ./bin/uxnemu bin/darena.rom
|
||||
```
|
||||
|
||||
|
|
@ -244,7 +255,7 @@ ahora que estamos en eso, hay una instrucción complementaria, SUB (resta) (opco
|
|||
SUB ( a b -- a-b )
|
||||
```
|
||||
|
||||
nota que el orden de los operandos es similar al de la división que discutimos arriba cuando hablamos de notación postfija.
|
||||
nota que el orden de los operandos es similar al de la división que discutimos arriba cuando hablamos de notación postfija: es como si trasladáramos el operador de entre los operandos, hacia el final, después del segundo operando.
|
||||
|
||||
## un primer programa
|
||||
|
||||
|
|
@ -320,9 +331,9 @@ leyendo el programa de izquierda a derecha, podemos ver el siguiente comportamie
|
|||
|
||||
mirando en la tabla de dispositivos de la referencia varvara, podemos ver que el dispositivo con la dirección 1 en el nibble superior es la consola (entrada y salida estandard), y que la columna con la dirección 8 corresponde a "escritura".
|
||||
|
||||
=> https://wiki.xxiivv.com/site/uxnemu.html uxnemu
|
||||
=> https://wiki.xxiivv.com/site/varvara.html varvara
|
||||
|
||||
asique, el dispositivo 18 corresponde a "escribir en consola", o salida estandard.
|
||||
asique, el dispositivo 18 corresponde a "escribir en consola", o salida estándar.
|
||||
|
||||
¡nuestro programa está enviando el valor hexadecimal 68 (caracter 'h') a la salida estandard!
|
||||
|
||||
|
|
@ -330,6 +341,12 @@ puedes ver los valores hexadecimales de los caracteres ascii en la siguiente tab
|
|||
|
||||
=> https://wiki.xxiivv.com/site/ascii.html ascii table
|
||||
|
||||
### números literales
|
||||
|
||||
observe que los números literales que escribimos, 0100, 18 y 68, se escriben en hexadecimal utilizando 4 dígitos correspondientes a dos bytes, o 2 dígitos correspondientes a un byte.
|
||||
|
||||
en uxntal sólo podemos escribir números de 2 ó 4 dígitos hexadecimales. si, por ejemplo, sólo nos interesara escribir un único dígito hexadecimal, tendríamos que incluir un 0 a su izquierda.
|
||||
|
||||
## rom ensamblada
|
||||
|
||||
podemos ver que el ensamblador reporta que nuestro programa es de 5 bytes de tamaño:
|
||||
|
|
@ -350,7 +367,6 @@ $ hexdump -C bin/hola.rom
|
|||
|
||||
¡osea, efectivamente, nuestro programa ensamblado presenta una correspondencia uno a uno con las instrucciones que acabamos de escribir!
|
||||
|
||||
|
||||
de hecho, podríamos haber escrito nuestro programa con estos números hexadecimales (el código máquina), y hubiera funcionado igual:
|
||||
|
||||
```
|
||||
|
|
@ -374,16 +390,14 @@ podemos expandir nuestro programa para imprimir más caracteres:
|
|||
LIT 6f LIT 18 DEO ( o )
|
||||
LIT 6c LIT 18 DEO ( l )
|
||||
LIT 61 LIT 18 DEO ( a )
|
||||
LIT 0a LIT 18 DEO ( newline )
|
||||
LIT 0a LIT 18 DEO ( nuevalínea )
|
||||
```
|
||||
|
||||
si lo ensamblamos y corremos, tendremos un 'hola' en nuestra terminal, usando 25 bytes de programa :)
|
||||
|
||||
¿ok, y... te gusta?
|
||||
¿ok, y... te gusta? ¿parece sencillo? ¿quizás innecesariamente complejo?
|
||||
|
||||
¿parece innecesariamente complejo?
|
||||
|
||||
veremos ahora algunas virtudes de uxntal que hacen escribir y leer código más "confortable".
|
||||
veremos algunas características de uxntal que hacen escribir y leer su código una experiencia más "cómoda".
|
||||
|
||||
# runas, etiquetas, macros
|
||||
|
||||
|
|
@ -399,7 +413,7 @@ si la dirección es de 2 bytes de longitud, es asumido que es una dirección de
|
|||
|
||||
## runa hex literal
|
||||
|
||||
hablemos de otra: #.
|
||||
hablemos de otra runa: #.
|
||||
|
||||
éste caracter define un "hex literal": es básicamente un atajo para la instrucción LIT.
|
||||
|
||||
|
|
@ -410,8 +424,6 @@ usando esta runa, podemos reescribir nuestro primer programa como:
|
|||
|0100 #68 #18 DEO
|
||||
```
|
||||
|
||||
nota que sólo puedes usar esta runa para escribir los contenidos de uno o dos bytes (dos o cuatro nibbles).
|
||||
|
||||
el siguiente tendría el mismo comportamiento que el programa de arriba, pero usando un byte menos (en la siguiente sección/día veremos por qué)
|
||||
|
||||
```
|
||||
|
|
@ -419,9 +431,13 @@ el siguiente tendría el mismo comportamiento que el programa de arriba, pero us
|
|||
|0100 #6818 DEO
|
||||
```
|
||||
|
||||
importante: recuerda que esta runa (y las otras con la palabra "literal" en su nombre) es un atajo para la instrucción LIT. esto puede prestarse a confusión en algunos casos :)
|
||||
nota que sólo puedes usar esta runa para escribir los contenidos de uno o dos bytes (dos o cuatro nibbles).
|
||||
|
||||
## runa de caracter raw
|
||||
importante: recuerda que esta runa (y las otras con la palabra "literal" en su nombre) es un atajo para la instrucción LIT. esto implica que uxn empujará estos valores hacia abajo en la pila. esto puede prestarse a confusión en algunos casos :)
|
||||
|
||||
si sólo queremos tener un número específico en la memoria principal, sin empujarlo a la pila, simplemente escribiríamos el número tal cual, "crudo". esta es la forma en que lo hicimos en nuestros primeros programas de arriba.
|
||||
|
||||
## runa de caracter "crudo" o "raw"
|
||||
|
||||
ésta es la runa de caracter raw: '
|
||||
|
||||
|
|
@ -435,11 +451,13 @@ nuestro "programa hola" luciría de la siguiente manera, usando las nuevas runas
|
|||
LIT 'o #18 DEO
|
||||
LIT 'l #18 DEO
|
||||
LIT 'a #18 DEO
|
||||
#0a #18 DEO ( newline )
|
||||
#0a #18 DEO ( nuevalínea )
|
||||
```
|
||||
|
||||
el "raw" en el nombre de esta runa indica que no es literal, por ejemplo que no agrega una instrucción LIT.
|
||||
|
||||
por eso debemos incluir una instrucción LIT.
|
||||
|
||||
## runas para etiquetas
|
||||
|
||||
incluso ahora que sabemos que #18 corresponde a empujar la dirección de dispositivo escribir en consola en la pila, por legibilidad y para asegurar nuestro código a futuro es una buena práctica asignar una serie de etiquetas que corresponderán a ese dispositivo y sus sub direcciones.
|
||||
|
|
@ -449,25 +467,25 @@ la runa @ nos permite definir etiquetas, y la runa & nos permite definir sub eti
|
|||
por ejemplo, para el dispositivo de consola, la manera en que verías esto escrito en programas para la computadora varvara es la siguiente:
|
||||
|
||||
```
|
||||
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]
|
||||
|10 @Consola [ &vector $2 &lee $1 &pad $5 &escribe $1 &error $1 ]
|
||||
```
|
||||
|
||||
podemos ver un pad absoluto a la dirección 10, que asigna lo siguiente a esa dirección. dado que la dirección consiste en un sólo byte, uxnasm asume que es para el espacio de memoria de entrada/salida o la página cero.
|
||||
|
||||
luego vemos la etiqueta @Console: ésta etiqueta va a corresponder a la dirección 10.
|
||||
luego vemos la etiqueta @Consola: ésta etiqueta va a corresponder a la dirección 10.
|
||||
|
||||
los corchetes son ignorados, pero incluidos por legibilidad.
|
||||
|
||||
luego tenemos varias sub etiquetas, indicadas por la runa &, y pads relativos, indicados por la runa $. ¿cómo los leemos/interpretamos?
|
||||
|
||||
* la sub etiqueta &vector tiene la misma dirección que su etiqueta madre @Console: 10
|
||||
* la sub etiqueta &vector tiene la misma dirección que su etiqueta madre @Consola: 10
|
||||
* $2 salta dos bytes (podemos leer esto como &vector siendo una dirección a una palabra de dos bytes de longitud)
|
||||
* la sub etiqueta &read tiene la dirección 12
|
||||
* $1 salta un byte (&read sería una dirección para una palabra de 1 byte de longitud)
|
||||
* la sub etiqueta &lee tiene la dirección 12
|
||||
* $1 salta un byte (&lee sería una dirección para una palabra de 1 byte de longitud)
|
||||
* la sub etiqueta &pad tiene la dirección 13
|
||||
* $5 salta el resto de los bytes del primer grupo de 8 bytes del dispositivo: éstos bytes corresponden a las "entradas"
|
||||
* la sub etiqueta &write tiene la dirección 18 (¡la que ya conocíamos!)
|
||||
* $1 salta un byte (&write sería una dirección para una palabra de 1 byte de longitud)
|
||||
* la sub etiqueta &escribe tiene la dirección 18 (¡la que ya conocíamos!)
|
||||
* $1 salta un byte (&escribe sería una dirección para una palabra de 1 byte de longitud)
|
||||
* la subetiqueta &error tiene la dirección 19
|
||||
|
||||
nada de esto sería traducido a código máquina, pero nos asiste al escribir código uxntal.
|
||||
|
|
@ -481,29 +499,29 @@ podemos reescribir nuestro "programa hola mundo" como sigue:
|
|||
```
|
||||
( hola.tal )
|
||||
|
||||
( devices )
|
||||
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]
|
||||
( dispositivos )
|
||||
|10 @Consola [ &vector $2 &lee $1 &pad $5 &escribe $1 &error $1 ]
|
||||
|
||||
( programa principal )
|
||||
|0100 LIT 'h .Console/write DEO
|
||||
LIT 'o .Console/write DEO
|
||||
LIT 'l .Console/write DEO
|
||||
LIT 'a .Console/write DEO
|
||||
#0a .Console/write DEO ( newline )
|
||||
|0100 LIT 'h .Consola/escribe DEO
|
||||
LIT 'o .Consola/escribe DEO
|
||||
LIT 'l .Consola/escribe DEO
|
||||
LIT 'a .Consola/escribe DEO
|
||||
#0a .Consola/escribe DEO ( nuevalínea )
|
||||
```
|
||||
|
||||
ahora esto empieza a parecerse más a los ejemplos que puedes encontrar en línea y/o en el repositorio uxn :)
|
||||
|
||||
## macros
|
||||
|
||||
siguiendo con la herencia de forth (?), en uxntal podemos definir nuestras propias "palabras" que nos permiten agrupar y reutilizar instrucciones.
|
||||
siguiendo con la herencia de FORTH, en uxntal podemos definir nuestras propias "palabras" que nos permiten agrupar y reutilizar instrucciones.
|
||||
|
||||
durante el ensamblado, estos macros son (recursivamente) reemplazados por los contenidos de sus definiciones.
|
||||
|
||||
por ejemplo, podemos ver que el siguiente fragmento de código es repetido varias veces en nuestro programa.
|
||||
|
||||
```
|
||||
.Console/write DEO ( equivalent to #18 DEO, or LIT 18 DEO )
|
||||
.Consola/escribe DEO ( equivalente a #18 DEO, o a LIT 18 DEO )
|
||||
```
|
||||
|
||||
podemos definir un macro llamado EMIT que tomará de la pila un byte correspondiente a un caracter, y lo imprimirá en la salida estandard. para esto, necesitamos la runa %, y llaves para la definición.
|
||||
|
|
@ -512,7 +530,7 @@ podemos definir un macro llamado EMIT que tomará de la pila un byte correspondi
|
|||
|
||||
```
|
||||
( escribe un caracter a la salida estandard )
|
||||
%EMIT { .Console/write DEO } ( caracter -- )
|
||||
%EMIT { .Consola/escribe DEO } ( caracter -- )
|
||||
```
|
||||
|
||||
para llamar a un macro, sólo escribimos su nombre:
|
||||
|
|
@ -536,11 +554,11 @@ usando todos estos macros y runas, nuestro programa puede terminar luciendo como
|
|||
```
|
||||
( hola.tal )
|
||||
( dispositivos )
|
||||
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]
|
||||
|10 @Consola [ &vector $2 &lee $1 &pad $5 &escribe $1 &error $1 ]
|
||||
|
||||
( macros )
|
||||
( imprime un caracter en la salida estandard )
|
||||
%EMIT { .Console/write DEO } ( caracter -- )
|
||||
%EMIT { .Consola/escribe DEO } ( caracter -- )
|
||||
( imprime una nueva línea )
|
||||
%NL { #0a EMIT } ( -- )
|
||||
|
||||
|
|
@ -562,7 +580,7 @@ podemos "mejorar" este programa haciendo que un loop imprima los caracteres, per
|
|||
|
||||
en nuestro programa previo, el macro EMIT es llamado justo después de empujar un caracter a la pila.
|
||||
|
||||
¿cómo reescribirías el programa para empujar primero todos los caracteres, y luego "EMIT"ir todos ellos en una secuencia como ésta?
|
||||
¿cómo reescribirías el programa para que primero empuje todos los caracteres y luego los emita (o haga "EMIT") todos con una secuencia como esta?
|
||||
|
||||
```
|
||||
EMIT EMIT EMIT EMIT EMIT
|
||||
|
|
@ -578,6 +596,12 @@ define un macro IMPRIMIR-DIGITO que toma un número (del 0 al 9) de la pila, e i
|
|||
%IMPRIMIR-DIGITO { } ( número -- )
|
||||
```
|
||||
|
||||
recordemos que el número tendría que ser escrito como un byte completo para que sea uxntal válido. si quisieras probar esta macro con, por ejemplo, el número 2, tendrías que escribirlo como 02:
|
||||
|
||||
```
|
||||
#02 IMPRIMIR-DIGITO
|
||||
```
|
||||
|
||||
# instrucciones del día 1
|
||||
|
||||
éstas son las instrucciones que cubrimos hoy:
|
||||
|
|
|
|||
|
|
@ -160,11 +160,11 @@ the instruction will normally imply a change in the stack(s), and sometimes it m
|
|||
|
||||
in order to run varvara locally and off the grid, we'd have to get the uxn assembler (uxnasm) and emulator (uxnemu) from their git repository:
|
||||
|
||||
=> https://git.sr.ht/~rabbits/uxn ~rabbits/uxn
|
||||
=> https://git.sr.ht/~rabbits/uxn ~rabbits/uxn - sourcehut git
|
||||
|
||||
you can either build these tools from source, or download pre-compiled binaries for multiple platforms.
|
||||
|
||||
you can find the installation instrutions in the repository.
|
||||
you can find the installation instructions in the repository.
|
||||
|
||||
if you need a hand, find us in #uxn on irc.esper.net :)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue