archivo

Archivo de la etiqueta: Things

En esta última parte vamos a estudiar de una forma más atenta los Things en tu sistema, cómo se organizan en la memoria y la forma en la que están vinculados.

Te mostraré un programa SBASIC bastante corto al final de éste artículo (listado 1), que puedes teclear o copiar, y que te mostrará algunos detalles de los Thing en tu sistema. Cuando lo ejecutes, probablemente listará todos los Things que tienes actualmente disponibles. A modo de ejemplo, puedes ver en la tabla 2 los Things cargados en mi sistema.

Debería mencionar en primer lugar, que el “hacking” a través de una lista como la de los Things (u otra lista, como la de los controladores de dispositivos etc.) debería hacerse en ensamblador mientras el programa se está ejecutando en modo Supervisor. Esto asegura, que otros jobs no pueden enlazar o des-enlazar Things mientras nosotros examinamos la lista. Esto no lo podemos hacer en SBASIC, pero siempre y cuando tú no añadas y quietes Thigs durante la ejecución del propio programa no pasará nada. Además, dudo que estés continuamente añadiendo o eliminando Things mientras estás probando esto.

Los Things se guardan en una lista enlazada y los nuevos Things se añaden en la parte superior de esta lista. Una variable de sistema

sys_thgl equ $b8

apunta a la primera entrada en la lista. El extraño PEEK_L con los dos signos de exclamación lee una palabra larga desde las variables del sistema en un desplazamiento B8 en hexadecimal desde el inicio de dichas variables del sistema.

En lugar de eso puedes escribir en QDOS “ordinario” lo siguiente:

PEEK_L(HEX("280B8"))

La dirección leída desde esta variable es un puntero al primer Thing en la lista de Things. Cada uno de ellos apunta al siguiente, así que es muy fácil rastrear la lista de arriba abajo. La lista termina cuando el siguiente puntero no apunta a un sitio válido, en este caso contiene un 0. Si observas la tabla 1 que está más abajo, verás una explicación de la estructura a la que estos punteros apuntan.

Las tres direcciones siguientes serán llenadas por: la rutina que vincula el Thing en la lista, de esta manera no necesitas preocuparte de ellos cuando se crea un Thing, un puntero que apunta a una lista enlazada de todos los jobs que están usando este Thing en un momento dado, y otro puntero a rutinas que no debería ser tocadas en absoluto. El puntero al Thing en si mismo necesita contener un valor, pero nadie sabe exactamente donde está realmente situado el Thing.

Las siguientes cuatro punteros apuntan a rutinas deben ser suministradas por ti para que hagas lo que quieras cuando el job intenta usarlo, liberarlo o eliminar este Thing específico. Además se puede suministrar una rutina de limpieza (por ejemplo para des-enlazar drivers o eliminar rutinas desde una lista de interrupciones, etc.).

Si el Thing puede solamente ser usado por un job al mismo tiempo, entonces deberías establecer el bit superior de un flag que indica no-compartido (marcado con un “-” en el listado de salida de nuestro programa BASIC).

La omisión de la comprobación del byte se hace para ejecutar una comparación de nombre más rápida. Sin embargo, el ID de la versión (o lista de características) debería ser llenada por el programador.

El programa BASIC lee unos bits muy interesantes de cada una de las entradas de los Thing. En mi ejemplo (tabla 2 otra vez), puedes ver que el último Thing que ha sido añadido al Sistema es “Calculator” (está especificado el último en mi definición HOTKEY en mi programa BOOT). Es interesante ver que “Calculator” no tiene número de versión. QD, que está más abajo, ha sido cargado con LRESPR anteriormente, pero después de QPAC2 (que aparece como un montón de Things likados desde “Button Frame” hasta “Things” …)

Todo lo que está por debajo hasta “HOTKEY” es linkado por el sistema operativo SMSQ/E, esto explica el orden.

En la parte más inferior puedes encontrar un thing especial llamado “THING” que define la entrada al sistema Things, pero esto ya lo he explicado. Verás cómo usarlo en el futuro.

La tabla que muestra la salida de mi sistema después de ejecutar el programa BASIC, en mi caso, el sistema de variables Thing apunta a $C3810, que apunta a $91E30, que apunta a $917C0 … y así hasta $56C10, que apunta a “0”.

Nosotros tenemos también el número de versión de cada Thing. Se corresponde con lo que el programador defina como etiqueta de versión – la mayoría de la gente lo llena con cuatro caracteres ASCII que define la versión-. SBASIC, por ejemplo, tiene como número de versión etiquetas como “HBA”.

También es posible ver en los 4 caracteres que ocupan 32 bits, especifican “características” soportadas por el Thing. Esto significa que no puedes ver realmente una secuencia de caracteres sino una serie de patrones o caracteres extraños. En el ejemplo de la lista de Things de mi sistema lo podrás ver en el Thing llamadao “FileInfo”.

El nombre del thing se reduce a 20 caracteres en caso de ser más largo. Tienes que especificar el nombre correcto del Thing si quieres usarlo o eliminarlo.

Seguramente has notado que la estructura de las lista enlazada de los Things contienen menos información de la que hemos listado, por ejemplo el nombre del Thing no está almacenado en la estructura sino en el Thing en sí mismo (th_thing que apunta al Thing). Hemos hecho alguna trampa por ahora pero léelo desde ahí.

Para terminar el tema, echemos un vistazo a las diversas estructuras para varios tipos posible de Things en las siguientes Tablas. También te muestro el listado del programa Basic que hemos comentado en el artículo y la salida producida en mi sistema.

TABLA 1
-------

; Thing linkage block

th_nxtth  equ $00 ; long link to NeXT THing
th_usage  equ $04 ; long thing' s USAGE list
th_frfre  equ $08 ; long address of "close" routine for FoRced FREe
th_frzap  equ $0c ; long address of "close" routine for FoRced ZAP
th_thing  equ $10 ; long pointer to THING itself
th_use    equ $14 ; long code to USE a thing
th_free   equ $18 ; long code to FREE a thing
th_ffree  equ $1c ; long code to Force FREE a thing
th_remov  equ $20 ; long code to tidy before REMOVing thing
th_nshar  equ $24 ; byte Non-SHAReable Thing if top bit set
th_check  equ $25 ; byte CHECK byte --- set by LTHG
th_verid  equ $26 ; long version ID
th_name   equ $2a ; string name of thing
th.len    equ $2c ;        basic length of thing linkage_

TABLA 2
-------

LINK      VERS S ADDRESS  TYPE NAME
--------  ---- - -------- ---- ---------------------
000C381O       + 000C386E EXEC Calculator
00091E30  2.25 + 00091E62 EXEC Sernet
000917C0  1.30 + 00100BB4 EXEC Pic Viewer
00091760  3.31 + 00100B80 EXEC FileInfo II thread
00091700  3.31 + 0010091C EXTN FileInfo II extensio
000916A0  3.31 + 001008FE DATA FileInfo II history
00091640  FIv3 + 001008E0 DATA FileInfo II database
000915E0  ###0 + 001008BA UTIL FileInfo
00090FE0  1.00 - 000FC2D2 DATA DATAdesign mutex
00091890  3.14 + 000918CE EXTN DATAdesign.engine
0008B970  A.05 + 000E6D22 EXEC QD
0008B920  1.13 + 000DB5B6 EXTN Scrap Extensions
0008B8D0  7.57 + 000D8B1A EXTN Menus
00091320  1.03 + 00091360 UTIL Button Frame
000911F0  1.03 + 000CC6C2 EXTN Button Extensions
000911A0  1.04 + 000CF1BE EXEC Button_Sleep
00091150  1.02 + 000CF168 EXEC Button_Pick
00091100  1.01 + 000CF0B0 EXEC Hotjobs
000910B0  1.01 + 000CF098 EXEC Hotkeys
00091060  1.04 + 000CEE78 EXEC Channels
0008E7D0  1.02 + 000CEA44 EXEC Jobs
0008E780  1.25 + 000CCDB2 EXEC Files
0008E730  1.05 + 000CCAFC EXEC Sysdef
0008E6E0  1.02 + 000CCA26 EXEC Rjob
0008BBD0  1.02 + 000CC928 EXEC Pick
0008BB80  1.02 + 000CC7E6 EXEC Wake
0008BAA0  1.02 + 000CC7CE EXEC Exec
0008BA50  1.02 + 000CC2C6 EXEC Button
0008BA00  1.01 + 000CC068 EXEC Things
000580C0  2.15 + 000B8AD2 EXTN Jmon
0008A910  2.29 + 0008A948 UTIL HOTKEY
0008B4B0  2.05 + 007EAEAE EXTN DEV
0008A1A0  3.00 + 007EAC14 EXTN WIN Control
0008A050  3.08 + 0008A050 UTIL DV3
00089920  2.00 + 007F64E8 EXTN QVME
000898D0  2.09 + 0000AA6E EXTN Ser_Par_Prt
000581F0  2.11 + 0000A91E EXTN KBD
00059250  HBA  + 007F9E9E UTIL SBAS/QD
000591B0  HBA  + 007F9D5C EXEC SBASIC
00056C10  0.05 + 00056C42 VECT THING
  TH_ENTRY 00002FDA
  TH_EXEC  00002F40_

Programa SuperBASIC
-------------------
100 REMark List Things
110 :
120 listptr = PEEK_L( !! $B8)
130 chan = 3 : OPEN #chan, con
140 PRINT #chan;LINK     VERS S ADDRESS  TYPE NAME"
150 REPeat loop
160   IF listptr = 0 THEN EXIT loop
17O   cr_thgaddr = PEEK_L(listptr+$10)
18O   PRINT #chan;HEX$(listptr,32)!
190   IF PEEK_L(listptr+$26)  O
200     PRINT #chan; ! PEEK$(listptr+$26,4)!
210   ELSE
215     PRINT #chan;'     ';
220   END IF
230   PRINT #chan; ! "+-"((PEEK(listptr+$24) > $7F)+1)!
240   PRINT #chan; !HEX$(cr_thgaddr,32);" ";
250   cr_thgtyp = PEEK_L(cr_thgaddr+$4)
260   th_nam$ = PEEK$(listptr+$2C, PEEK_W(listptr+$2A)) : namlen = LEN(th_nam$)
280   IF namlen 2O THEN th_nam$=tt_nam$( TO 20)
320   END IF
330   SELect ON cr_thgtyp
340     =0:PRINT #chan;'UTIL'!th_nam$!
350     =1:PRINT #chan;'EXEC'!tt_nam$!
360     =2:PRINT #chan;'DATA'!th_nam$!
370     =$1000003 : PRINT #chan;'EXTN'!th_nam$!
380     =$1000004 : PRINT #chan;'EXTS'!th_nam$!
390     =-1:PRINT#chan;'VECT'!th_nam$_TH_ENTRY'!HEX$(PEEK_L(cr_thgaddr+$8),32)_TH_EXEC'!HEX$(PEEK_L(cr_thgaddr+$C),32)!
400     =REMAINDER:PRINT #chan;'    ';th_nam$!'UNKNOWN TYPE('!HEX$(cr_thgtyp,32)!') '
410   END SELect
420   PRINT #chan
430   listptr = PEEK_L(listptr)
440 END REPeat loop
450 CLOSE #chan


Artículo reproducido en “The Dilwyn Jones Sinclair QL Pages” con permiso de QL Today Volúmen 4, número 5.
Autor: Jochen Merz.
Traducción y adaptación: afx.

Anuncios


Artículo reproducido en “The Dilwyn Jones Sinclair QL Pages” con permiso de QL Today Volúmen 4, número 3.
Autor: Jochen Merz.
Traducción y adaptación: afx.

En la primera parte de esta serie, yo espero haberte dado una idea de lo que son los Things. Pero ahora, ¿cómo podemos acceder a ellos, cómo crearlos, cómo funciona el sistema de control para poderlos manejar? QDOS y Minerva no tiene llamadas del sistema operativo para añadir o eliminar Things, así que debernos encontrar alguna manera diferente para hacerlo,

Permíteme que empiece el artículo de una forma un poco técnica, en breve relajaremos los tecnicismos. Prometo que mantendré la sección técnica lo más corta posible. Las llamadas al sistema operativo como la reserva de memoria, la vinculación en los drivers, etc. se agrupan todos bajo el “Trap #1”. Éste es el método usado para hacer una llamada al sistema operativo en código máquina. Un registro (D0) contiene el “código de función”. La llamada a los Thing pertenece al mismo grupo, pero hay que tener en cuenta que el sistema operativo del QL está en ROM, no se puede modificar. Además, la lista en ROM no puede ser extendida, no hay un mecanismo para “ganchos” (hooks), etc. Cuando un programador intenta llamar al Trap #1 con un código de función de una llamada a un Thing, el sistema operativo retorna “not implemented” (no implementado). (Sólo para los curiosos: algunas implementaciones de SMS, principalmente SMS2, contienen llamadas a Things como una llamada real Trap#1). Cuando el programador intenta ejecutar una llamada a un Thing y obtiene un “not implemented”, entonces él debe usar un método alternativo de hacerlo -que debería funcionar siempre-. La extensión del sistema “HOTKEY System II” no solo añade mejoras en las facilidades HOTKEY de los sistemas QDOS y Minerva, sino que también añade llamadas a los Thing de una forma ligeramente diferente. No voy a entrar en los detalles ahora, pero un programador puede fácilmente encontrar las llamadas de los Things y ejecutar dicha llamada con los mismos parámetros y códigos de función en DO de forma que se puede trabajar con ellos de la misma manera que otras llamadas al sistema. Ahora ya acabamos con los tecnicismos.

Así, con el fin de obtener Things, tú necesitas tener cargado el HOTKEY System II. Éste está integrado dentro de SMSQ/E, pero si usas QDOS o Minerva entonces necesitas cargarlo separadamente. Además, si deseas ver una lista de Things cargados en tu sistema para verlos en acción deberías también cargar QPAC2. QPAC2 está formado por un conjunto de Things y además te permite listarlos, así que tiene una doble utilidad.
…………
Nota del traductor: A continuación un recorte de código para tu boot, de esta manera puedes cargar HOTKEY y QPAC (se presupone que estás usando Toolkit 2).

100 REMark --- Cargar PE, HOTKEY System II y QPCA2
110 LRESPR "flp1_ptr_gen"
120 LRESPR "flp1_wman"
130 LRESPR "flp1_hot_rext"
140 LRESPR "flp1_qpac2"

Puedes encontrar varias de estas utilidades en los siguientes sitios:
http://www.bytemaniacos.com/sinclairql/
http://www.dilwyn.me.uk/
……….

Bueno, teclea ahora la siguiente instrucción desde el BASIC

EXEP "Things"

Aparecerá una ventana mostrando una lista con los Things de tu sistema. Y …. ¡tú ya habrás usado un Thing llamado “Things”!. Éste último es un Thing ejecutable instalado por QPAC2 el cual te proporciona un job que lista los Things de tu sistema. Así que tú ahora puedes iniciar programas sin acceder al sistema de ficheros para cargarlos. Si ahora estás un poco confuso, entonces por favor lee otra vez la parte 1 de estas entregas – tal vez lo hayas leído hace algún tiempo por lo que habrás olvidado la teoría que explicamos allí-.

Lista de Things

Lista de Things

Si nos fijamos en los Things disponibles, encontraremos Things como “Button”, “Exec”, “Jobs”, “HOTKEY”, y más abajo al final de la lista ordenada alfabéticamente, “Things”. ¡¡ Esto es todo !!

Intenta otra cosa, por ejemplo

EXEP "Pick"

y otra ventana aparece dándote la lista de todos los jobs con CONsolas abiertas que pueden ser seleccionadas (“picked”) en la parte superior de la pila de ventanas.

Intenta ahora

EXEP "Button Frame"

… no ocurre nada. Seguramente habrás notado que el sistema ha intentado acceder al disco floppy y/o al disco duro. “Button Frame” no es un Thing ejecutable, por lo que el comando EXEP intenta abrir entonces un fichero llamado “Button Frame” en el dispositivo predefinido de programas (el cual se puede configurar con PROG_USE).

Bien, regresemos al menú “Things” anterior y hagamos clic en la palabra “Things” en la lista. La ventana cambiará y tú podrás ver que hay (al menos) un job registrado como usuario de este Thing, que es (poco sorprendente) “Things”. ¿Confuso?, presiona ESC para volver a la lista y selecciona Pick. Esto debería ser menos confuso.

Si tú tienes botones en la zona de botones de QPAC2, entonces puedes ver qué job están registrados como usuarios – vuelve hacia atrás, a la lista de Things y selecciona “Button Frame”, podrás comprobar entonces los distintos jobs que hacen uso de este último Thing.

Jobs que usan un Thing

Jobs que usan un Thing

QPAC2 viene con muchos Things pero hay un problema: muchos Things tienen el mismo nombre en diferentes idiomas, pero otros no. Nosotros, los traductores, (Wolfgang Lenerz para la versión en francés y yo para el alemán) decidimos independientemente uno de otro que “Button_Sleep” no era muy significativo para los usuarios en Alemán o en Francés y lo tradujimos. ¡Gran problema! A partir de entonces no fue posible reemplazar una versión Inglesa por una Alemana y viceversa. Pero supongo que ahora es demasiado tarde para cambiar las cosas (o los Things !!). La solución es probablemente tener ambos nombres de Things en Inglés y Alemán (o Francés) para el mismo job … pero eso es una cuestión diferente.

Vamos ahora a crear un nuevo Thing. ¿Deseas convertir XCHANGE en un Thing como por ejemplo el menú “Pick”? Fácil, el HOTKEY System te ayudará a hacerlo:

ERT HOT_CHP ("X","XCHANGE")

Tú debes tener XCHANGE disponible en el dispositivo por defecto para los programas. Mediante esta sencilla instrucción convertimos un ejecutable en un Thing llamado XCHANGE. Comprueba ahora el menú “Things”, XCHANGE estará ahí.

Y, aún mejor, si ahora tecleas

EXEP "XCHANGE"

¡el programa se iniciará sin ningún acceso al disco duro! Por supuesto, se puede iniciar también usando el HOTKEY System II (pulsando ALT X, pero recuerda que el job HOTKEY se activa tecleando HOT_GO primero).

Cuando tú liberas de la memoria la definición HOTKEY, el Thing también será liberado.

El HOTKEY System II ofrece otras funciones que permite que HOTKEYs sean asignados a Things existentes sin que ellos sean eliminados de la memoria cuando el HOTKEY es eliminado, pero esto lo explicaremos en la siguiente entrega de esta serie. También, los Things que están integrados en QPAC2 son más avanzados que los que tu puedes crear manualmente, pero esto también es material para otro artículo.


Artículo reproducido en “The Dilwyn Jones sinclair QL Pages” con permiso de QL Today Volúmen 4, número 1.
Autor: Jochen Merz.
Traducción y adaptación: afx.

Sé que debería haber escrito este artículo hace algún tiempo, pero yo no estaba seguro de qué escribir y cómo empezar.

Decidí que debería empezar con algún tipo de explicación general acerca de los “Things”, contar lo que podrías hacer con ellos (probablemente, ya los habrás usado durante bastante tiempo sin saberlo) y dar una explicación de cómo usarlos y cómo crearlos. Por supuesto, esto no va a caber en una sola entrega y como no queremos llenar este artículo con un largo listado en ensamblador solamente, yo dividiré el tema en varias partes. Tómalo como un tutorial, y esta es la primera entrega de tres.

Para asegurar de que no se confunde demasiado el término, pondré el término “Things” en mayúsculas, cuando me refiera a los Things de SMSQ.

El término Thing fué usado porque un Thing puede ser virtualmente cualquier cosa. Puede ser un controlador de dispositivo, un área de datos, puede ser un menú, puede ser una extensión del sistema, puede ser un programa …

La primera ventaja de los Thing es que tienen un nombre único. Tu puedes identificar a un Thing por su nombre, y localizarlo en la memoria del sistema. Un Thing puede estar localizado en cualquier sitio en la memoria de tu ordenador, y la única forma de encontrarlo es por su nombre (de forma similar a como nos referimos a un fichero específico en el sistema de archivos por medio de su nombre).

Si un job (tarea) quiere usar un Thing (hay diferentes maneras de usar los Thing, dependiendo de lo que son realmente, pero veremos eso más adelante), en primer lugar, el job tiene que tratar de averiguar si el Thing existe en tu sistema -de otro modo no podría usarlo-. De forma análoga a un archivo, si tratamos de abrir un archivo de disco, debemos buscar previamente si existe o no ese archivo.

Si el Thing existe y se le permite al job usarlo (puede haber limitaciones que dependen del Thing, algunos Thing sólo permite ser usado por un usuario a la vez, otros pueden ser usados por más de un usuario) entonces el job es marcado como un usuario de ese Thing particular, el job “sabe” que el Thing existe y obtiene su dirección de memoria. Es incluso posible que se produzca un timeout cuando se intenta usar un Thing (es posible por ejemplo cuando se intenta abrir un fichero y esa tarea falla), útil para los Thing que pueden ser usados sólo por un usuario al mismo tiempo, por lo que el job puede intentarlo durante un tiempo predefinido o abortar el intento.

La dirección del Thing es lo que obtienes, y eso es todo lo que necesitas porque ésta es la principal idea: una especie de “sistema indexado” para partes del sistema software de tu ordenador, junto con un registro de usuarios. Suena simple ¿no es así? y en realidad lo es.

Un job es un usuario del Thing hasta que lo libera (similar al “cierre”). En la medida en que un job es un usuario de un Thing, su “vida” depende de la presencia del ese Thing. Como SMSQ es, al igual que QDOS, un sistema con auto-limpieza, eso significa que si se remueve algo del sistema, todos los ítems relacionados con él son también de alguna manera cerrados o liberados. Si tu remueves un trabajo en SMSQ/QDOS, entonces todos los canales que son propiedad de este job son automáticamente cerrados por el sistema, toda la memoria propiedad del job es retornada a la lista de memoria libre, todos los jobs de los que éste es propietario son liberados y así de forma recursiva hasta que todos los recursos que son propiedad o usados por este job son liberados.

Los Things van un paso más allá. Cuando un job se convierte en un usuario de un Thing, parece lógico que quiere hacer algo con él y confía en su presencia. Si el Thing es liberado de la memoria, entonces naturalmente todos los jobs que están registrados como usuarios de ese Thing son liberados también por el sistema, de otro modo ¿cómo podría continuar la ejecución de un job si el Thing necesario ya no está disponible? Esto podría conducir a resultados inesperados y seguramente nosotros preferiríamos tener un sistema estable. Pude sonar un poco tosco el remover jobs de esta manera, pero piénsalo ¿qué otra cosa se puede hacer?

DIFERENTES THINGS …

Como ya he mencionado … es posible tener diferentes tipos de Things. Teóricamente es posible que cada trozo o sección de la memoria pudiera ser un “Thing”. Esto probablemente sería “excesivo”, pero sin embargo sería posible. No es necesario que todas las localizaciones de memoria sean reconocibles por su nombre, pero si lo piensas bien, podrías encontrar que es útil el que largas partes de la memoria, que contienen diferentes partes del sistema operativo y controladores de dispositivos sean reconocidos por su nombre. Podrías personalizar tu sistema mientras esté en funcionamiento, agregar controladores, liberar controladores, actualizar controladores.

En el pasado, añadir otro controlador de disco-RAM mientras otro controlador de disco-RAM estaba siendo usado no conducía a un sistema limpio. El antiguo controlador de disco-RAM permanecía en el sistema y tú te encontrabas con dos entradas “RAM” en la lista de dispositivos de QPAC2, la primera no se eliminaba. Todavía podías acceder a él, esto podría ser un poco complicado, pero es posible. ¿Y qué ocurre con los ficheros que estaban abiertos en la primera unidad de disco-RAM? Pues que permanecerán abiertos hasta que tú lo cirraras. Si abres de nuevo el mismo nombre de archivo otra vez se abrirá a un diferente disco-RAM …. ooooop, ambiguo, ¿no?

Si el controlador de disco-RAM fuera un Thing, entonces cuando el nuevo disco-RAM fuera cargado el viejo disco-RAM sería removido del sistema, la totalidad de la memoria reservada para él sería liberada y el job con los canales abiertos a ese disco-RAM serían liberados. ¿Qué otra cosa se puede hacer? No hay medias tintas en este proceso.

Los Things también pueden ser muy útiles en las extensiones del sistema. La extensión “Menu” puede es un ejemplo muy bueno. Si tu reemplazas la extensión “Menu” por una versión más reciente, la antigua extensión se descarga completamente de la RAM y se sustituye por la nueva versión. Pruébalo: inicia QD (un editor de texto que usa la extensión “Menu”), intenta cargar un archivo, pero cuando el cuadro de selección del archivo aparece (éste cuadro de diálogo no forma parte de QD sino es que forma parte de la extensión “Menu” en ese momento) regresa al BASIC y vuelve a cargar la extensión “Menu” una vez más (empleando LRESPR MENU_rext). En primer lugar, la antigua copia de la extensión “Menu” es removida (y por tanto, QD también será removido, -recuerda, todos los procesos usuario de un Thing son liberados cuando se libera el Thing) y posteriormente la nueva extensión “Menu” es instalada en el sistema.

QD (y otros programas) solamente usan Things en el momento en el que realmente lo necesita, esto significa que puedes cargar una nueva extensión Menu sin necesidad de remover los jobs que lo están usando en ese momento. Sería posible (y puede que un poco más rápido) para un job registrarse a sí mismo como usuario de la extensión Menu (obteniendo la dirección de la extensión) y luego seguir siendo usuario de esa extensión y llamarla cada vez que se necesite, esto ahorrará algunas llamadas y también funcionaría (recordemos que la dirección no cambia: si reemplazamos la extensión Menu, lo que llevaría a un cambio de esta dirección, no provocaría ningún daño, porque en ese momento los usuarios de la extensión serían liberados).

QD (editor)

QD, editor de textos de Jochen Merz que hace uso de Things

Thing Menu

Thing Menu, un Thing creado por Jochen Merz que actúa como cuadro de diálogo para buscar ficheros, es muy popular y es usado por muchas aplicaciones

Espero que por ahora no estés muy confundido, una vez más piensa en el sistema de los Things como un sistema de identificación y registro.

No hay ningún límite sobre lo que pueden ser los Things. Parece lógico que si podemos tener extensiones Thing, nosotros podemos tener Things ejecutables también (al igual que con los archivos, puedes observar la analogía en todo momento). Es posible tener muchos canales de entrada al mismo tiempo, así ¿por qué no tener muchos usuarios que utilizan el mismo código de programa el cual sólo existe una vez en memoria?.

Este es el concepto de los Things ejecutables. El código de programa, es el mismo todo el tiempo sin importar si cero, uno o cualquier número del mismo job lo usa, sólo necesita estar en memoria una sola vez. Todos los programas QPAC2 son Things ejecutables, y tú puedes ejecutar tantos como tú quieras mientras dispongas de memoria.

Ahora, seguramente estarás definitivamente de acuerdo que los jobs o usuarios de los Things deben desalojarse si éste se elimina de la memoria, ¿cómo se pude ejecutar un programa si su código necesario se ha ido? Como podrás ver, el concepto no suena demasiado radicla ¿no?

El tercer tipo general de Thing es el Thing de tipo “datos”. Una vez más, es responsabilidad del programador definir la estructura de datos que se almacenan aquí, cómo se organizan y como deben ser usados. No me canso de repetirlo: el sistema de Things es una herramienta para ayudar al job (a la tarea) a encontrar y a registrar un conjunto de información o de datos para luego usarlos.

Creo que eso es suficiente por el momento. En la próxima parte vamos a echar un vistazo a los Things en tu sistema (siempre que hayas cargado QPAC2) y una de las varias formas que existen para crear un Thing tú mismo