jueves, 25 de junio de 2026

¿Cómo emulo el SAIL WAITS en Ubuntu?

Interrogado por el director Pino Solanas en Puerta de Hierro, Juan Perón expone cómo instalar y emular el mítico sistema operativo de tiempo de cómputo compartido WAITS, del Laboratorio de Inteligencia Artificial de Stanford en Ubuntu.

(...) 

¡Trabajadores!

Los movimiento revolucionarios suelen ser gregarios, construidos por un realizador tras el cual cien mil predicadores caminan, que es como lo hemos hecho nosotros. En eso - sin que yo perdiese la conducción - me he preocupado de ir conformando, por simbiosis, una organización  para que en el momento en que yo desaparezca, quienes desean la organización y los grupos que desean ser gregarios, puedan elegir su método de conducción en el momento oportuno.

Si aparece un hombre que pueda reemplazarme a mí, no habrá problema. Si ese hombre no aparece, será necesario reemplazarlo con una organización revolucionaria que permita al Movimiento - a través de organismos - ir conformando y cumpliendo los objetivos que nosotros hemos trazado hace muchos años, más los objetivos que las nuevas circunstancias vayan planteando. Hemos tratado de alcanzarlo y creo que - en este momento - tenemos una organización.

El hombre no vece al tiempo, lo único que puede vencer al tiempo es la organización. Pues bien, un sistema de cómputo responde a las mismas premisas. Por este motivo yo he creado los sistemas operativos de tiempo compartido, que sí pueden vencer al tiempo, merced de la organización de sus tareas de cómputo.

WAITS fue precisamente uno de los sistemas de tiempo de cómputo compartido concebido como extensión del software MONITOR que corría en las minicomputadoras DEC PDP-6, y luego ampliado a lo largo de sucesivas versiones en el rango de máquinas PDP-10 con memoria virtual. Fue concebido orgánicamente en la primer encarnación del Laboratorio de Inteligencia Artificial de Stanford (SAIL) a partir de 1966 tras un cisma producido por John McCarthy, Lester Earnest y Arthur Samuel. Merced de la organización, pudo sobrevivir a estos y la comunidad hacker crearon, funcionando de manera continuada incluso hasta 1991. Fue así que las particularidades de este entorno de cómputo en mainframe dieron apoyo a lo que podríamos llamar "la Era de Oro de la investigación de la Inteligencia Artificial", donde la telemática, la robótica, la síntesis de sonido y voz colocaron a Stanford como frontispicio, y unieron a esta a otras instituciones a través de la red de datos Arpanet.

Podríamos decir que esto coloca a WAITS - retrónimo de Western Artificial Intelligence Time Sharing - en el mismo pedestal que otros míticos sistemas operativos de tiempo de cómputo compartido aplicables a los 36 bits de la PDP-10 de los que ya os he hablado, tales como el ITS, o el TOPS-20 "TWENEX". A diferencia de aquellos y de manera única, el sistema de archivo de SAIL WAITS ha sido preservado al completo como imagen de sistema, y - gracias a los esfuerzos de varios investigadores - es capaz de correr, aún bajo emulación en un sistema del Tercer Mundo, como nuestro moderno GNU.

Os demostraré entonces como obtener la imagen 6.17 del SAIL WAITS (1974) y ejecutarla con SIMH, así como correr un programa de inteligencia artificial de dicha época, escribir un programa corto, y utilizar su consola de operación para presentar gráficas vectoriales del período.

Primero instalamos las dependencias en nuestro sistema GNU con Linux. Para ello abrimos una terminal con Ctrl+Alt+t e ingresamos:

sudo apt install cmake unzip libsdl2-dev git

En segundo término, clonamos el repositorio y nos dirigimos a él y lo compilamos mediante el siguiente bloque de comandos de organización:

mkdir ~/.simh/ ;
cd ~/.simh/ ;
git clone https://github.com/timereshared/stanford-waits-simh-quickstart.git ;
mv stanford-waits-simh-quickstart/ waits/ ;
cd ~/.simh/waits/ ;
./build.sh

Esto guion de intérprete de comandos se encargará de preparar el emulador OpenSimH para funcionar como una DEC PDP-10-ka virtualizada, tras lo cual descargará una copia de las imágenes de disco con el sistema operativo WAITS del SAIL, y le aplicará algunos ficheros de sistema faltantes. Todo se indicará como salida en la pantalla del terminal de GNU:

Una vez finalizado la compilación nos lo advertirá indicando algo como:

DART VERSION 5  TAPE TRAILER
Goodbye

simh and WAITS have been set up.. 

Concluido esta puesta en forma, podremos dar arranque al mítico entorno multiusuario de la Costa Oeste en nuestro emulador. Para ello lo ejecutamos con:

cd ~/.simh/waits/ ;
./run.sh 

Aparecerá una ventana con una pantalla de terminal III que funcionará como consola gráfica de framebuffer para la operación del WAITS en la DEC PDP-10. Esta indicará el incentivo a los hackers natural a este tipo de entornos multiusuario ("Tómame, soy toda tuya").

En tanto, en la consola de GNU nos aparecerá la consola de administración del Stanford WAITS.

Como esta es una imagen de un sistema WAITS vivo, ya tiene configuradas varias cuentas de usuarios históricos. Usemos por ejemplo la cuenta REG otrora perteneciende al usuario Ralph Gorin (programador de sistemas en el Laboratorio de Inteligencia Artificial de Stanford durante el período). Podremos loguearnos a ella usando el comando LOGIN, que bien podremos abreviar con L. Para ello, presionamos la tecla de Retorno de Carro - la actual tecla Intro - para que WAITS nos presente su prompt de comandos consistente en un punto ".". Ante él, ingresamos:

L 1, REG

...y presionamos Intro.

Nos será posible apreciar que la ausencia de contraseñas demostraba por entonces  la liberalidad del entorno de programación hacker de mediados de los setentas. Si nos logueamos sin errores, SAIL imprimirá EXIT y ^C, denotando la finalización del proceso de logueo, y presentará el punto del prompt de comandos.

Para permitir el ingreso de mayúsculas y minúsculas en nuestra terminal, ingresamos el comando:

TTY FULL

Ante cualquier eventualidad podremos cerrar la sesión de usuario que estamos empleando con:

logout

En tal caso, nos volvemos a loguear. Si somos peritos en el uso de TOPS-10, veremos que la interfaz de WAITS opera de manera familiar. La mayoría de los comandos de éste operan de hecho, de forma similar. Tipeando DIR obtendremos un listado de directorio, al cualk podremos operar con comodines para expander o limitar la búsqueda. Ante la noción de desear encontrar todos los programas de SAIL (cuya extensión es .sai) podríamos ingresar:

dir *.sai 

De la misma forma, nos será posible contemplar los contenidos de los ficheros recurriendo al comando type. De este modo, para ver el contenido del programa fortune.sai del WAITS, podremos indicar:

type fortun.sai 

Esta operatoria influyó a TOPS-10, éste a CP/M, y este al QDOS, que afectaría de manera similar al MS-DOS y sus interfaces gráficas posteriores, permeando incluso a GNU. Podremos ver el listado de comandos asignado a WAITS simplemente ingresando HELP.
Y no solo eso, también podremos ver qué hacen cada uno de ellos (en una breve descripción en línea, claro), con HELP HELPER
Esta imagen histórica de WAITS contiene un sistema operativo WAITS de 1974 con varios comandos disponibles para correr, creados por los investigadores del Laboratorio de Inteligencia Artificial de Stanford. Un ejemplo clásico entre ellos es Parry, un intento del psiquiatra Kenneth Colby para simular el comportamiento de un paciente con paranoia esquizoide. Podremos invocarlo con el comando de ejecución r. Realizará algunas interrogantes para configurar los parámetros de interacción y nos dejará hablarle a Parry. Para salir del mismo debemos presionar Ctrl+c.
El ambiente WAITS tenía como misión primordial la de volverse una incubadora de programación, y a tal fin incorporaba un ensamblador de macros con depurador en vivo, intérpretes de Fortran, y múltiples facilidades que le fueron montando y lo volvieron famoso (LISP, RAID, FAIL, DART, y otros entornos de programación. Usaremos el ambiente de WAITS para crear un programa de Hola Tercer Mundo en Fortran 4. Para eso daremos empleo al editor SOS con el fin de redactar el código fuente, lo guardaremos, y luego lo compilamos y lo ejecutamos.

Para ello ingresamos

create holam.f4

y creamos un nuevo fichero y nos podrá en el editor. Como es un fichero nuevo, el editor SOS nos permitirá ingresarle texto de manera inmediata. Precederá automáticamente toda línea con un número de línea (el cual no es una etiqueta de Fortran, por cierto). De modo que la pantalla adquirirá esta apariencia:

.create holam.f4
00100

Le introducimos el siguiente programa (donde vemos el signo  debemos presionar la tecla Tab).

	DO 1 J=1,5
1 	WRITE(5, 2)
2 	FORMAT(' HOLA TERCER MUNDO!')
	END

Presionando la tecla Esc sandrá del modo de entrada de texto indicándolo con un "$", y nos pasará al modo Alt (de comandos), presentándonos el prompt de comandos "*". En él, presionamos g para activar el Generador Rápido de Programas de WAITS, encargado de guardar el fichero e invocar la correcta secuencia de comandos que compilarán y ejecutarán el programa. La pantalla debería parecer algo así:

.create holam.f4

00100           DO 1 J=1,5
00200   1       WRITE(5, 2)
00300   2       FORMAT(' HOLA TERCER MUNDO!')
00400           END
00500   $
*g


FORTRAN:  HOLAM.F4
LOADING

LOADER 5K CORE
EXECUTION

HOLA TERCER MUNDO!
HOLA TERCER MUNDO!
HOLA TERCER MUNDO!
HOLA TERCER MUNDO!
HOLA TERCER MUNDO!
EXIT
^C
.

El programa aún permanecerá en la memoria de núcleo, por lo que si queremos conservar una copia permanente en el tambor (disco) debemos recurrir al comando save que allí la depositará (en este caso, de manera emulada en nuestro disco duro).

.save HOLAM
JOB SAVED IN 4K

^C

Si deseamos usar el comando dir, ahora podremos ver los ficheros creados por el proceso de compilación de WAITS:

.dir HOLAM.*

26-JUL-74  1122
FILNAM  EXT   SIZE LAST WRITTEN

   [1,REG]
HOLAM   F4      19  26-JUL-74
HOLAM   DMP    3.5  26-JUL-74
HOLAM   REL     57  26-JUL-74
        TOTAL=   3.6

EXIT
^C

El fichero .rel es el código objeto y el fichero .dmp es el ejecutable, que puede correrse nuevamente ingresando:

run HOLAM

(en WAITS debemos recurrir RUN en lugar de R, puesto que R se utiliza para dar ejecución a los programas incorporados con el sistema operativo).

Usando la terminal de operación

Hasta ahora, hemos hecho uso de la consola de gestión, pero probablemente hayamos notado la terminal de vectores que ha aparecido al iniciar SIMH, con el prompt de bienvenida: 

/images/waits/waits-iii-prompt.png  

Ahora nos loguearemos nuevamente como REG en la terminal vectorial de operación, de la misma manera que en el caso anterior. El WAITS permitía para esta varias tipografías vectoriales escalables.

Veremos que en lugar de cursor actual, en la pantalla vectorial el WAITS indica la posición del caracter recurriendo a un índice visual de estilo teletipo (formado por un triángulo pequeño que se desplaza lateralmente).  

Todos los programas de línea de comandos y de inicio de sesión que hemos utilizado hasta el momento funcionarán también en esta terminal. Pero esta es una terminal de vectores que puede dibujar texto y gráficos junto con un teclado, que puede ingresar más caracteres que los típicos de los teletipos.

Esta vez nos loguearemos con BGB, el archivista principal del sitio saildart.org. Ingresamos:

L 1, BGB 

y luego intentaremos algunos comandos.


Notaremos que al presionar Delete, borraremos propiamente el último caracter en lugar de reimprimirlo como lo hacían las teletipos; de hecho, existe un editor de líneas de comando extensible que observaremos más adelante. Aún así, el sistema emulado no maneja los buffers de forma prístina como lo hace UNIX, y resulta mejor mecanografiar lentamente.

El terminal de video puede hacer más que ofrecer una mera interacción con el monitor de líneas de comando. Presionando F2,w  aparecerá un presentador dinámico del uso de sistema en la parte superior de la pantalla, la que se conoce como línea WHO. Si presionamos F3,w la apagamos. También podremos invocar WHO para ofrecernos un conjunto más extenso de información del sistema (debemos presionar cualquier tecla para salir).


A continuación, ingresaremos:

copy mon  moncom.sh[s,doc]

(La flecha  podremos obtenerla presionando la tecla Flecha Izquierda de Cursor, y luego mecanografiar tv mon.

Esto abrirá el editor TV en una copia del manual del comando monitor. Presionando Ctrl+p avanzaremos página a página y con Ctrl+- y luego Ctrl+p retrocedemos. Presionamos Ctrl+Alt+e para volver al Prompt de WAITS.

/images/waits/waits-tv-editor.png

También tendremos varias demos gráficas de WAITS, incluyendo la del brazo robot de McCarthy. Podremos probar ejecutarlas con el comando r, por ejemplo, r dazzle. Probemos estas:

  • armdpy
  • dazzle
  • hypno
  • petal
  • repent

Cuando termine de ver cada una de las demos, presione F1,F1 y luego escriba core 0 y presione la tecla Intro a fin de borrar el buffer de video.

El WAITS no era ajeno a algunos juegos para divertir a los desarrolladores del Laboratorio de Inteligencia Artificial. Que mejor que una partida para dos jugadores en la red de datos ARPANET. Para ello podremos recurrir al Go con el comando r IIIGO o bien al Monopolio IA, con el comando r monply.


Detener WAITS 

No existe un procedimiento para desconectar el sistema operativo, que quedó encendido ininterrumpidamente desde 1966 hasta 1991. Para desloguearnos de cualquier terminal, podremos ingresar k, abreviación de kjob, o tal vez podramos obtener un deslogueado más personalizado ingresando:

k/me 

Esto presentará en el terminal de operación el indicador de asesinato de procesos del usuario.

Para hacerlo desde nuestra consola de control, podemos presionar Ctrl+e para interrumpir la emulación, y cuando aparezca el prompt del emulador SIM>, presionar la letra q para salir de él (lo que nos devolverá a nuestro intérprete de comandos de GNU).

Para mayor información, podremos recurrir a la documentación corta del Monitor de Comandos del Laboratorio de Inteligencia Artificial de Stanford (SAIL).

De esta manera ¡habremos logrado Vencer al Tiempo, convirtiéndonos en uno de los Amos del Mainframe, reviviendo el mítico Stanford WAITS, cenáculo de la Inteligencia Artificial!

No hay comentarios:

Publicar un comentario