pc facile

Correva l’anno 2012. Più precisamente, era il 12 maggio 2012.
Se non erro l’anno precedente, per il suo compleanno, avevo regalato a mia mamma un PC portatile, ripromettendomi di insegnarle a usarlo.

Il tempo vola, i ricordi riaffiorano, la società si modifica con i nuovi paradigmi della nuova morale condivisa, e ciò a cui si attribuisce importanza varia col variare delle responsabilità e degli impegni di una quotidianità da affrontare con sempre più pregiudizi personali e sempre meno energie e tempo disponibile.
Ma ci sono anche cose che non cambiano. Una di queste, a quanto pare, è la mia negazione totale per l’insegnamento.

Ricordo che quella sera avevo cominciato con una digressione su come funzionassero PC e sistema operativo. Anche bene, per la verità; cose abbastanza base, interconnettendole, tipo CPU/FPU/ALU/MMU, ROM, memoria cache e RAM, dischi di memoria, sistema operativo e file system, e periferiche di I/O.
Avevo previsto una sorta di interrogazione finale, che mia mamma aveva sorprendentemente superato dopo qualche spiegazione più pratica.

Ora,mi trovavo di fronte a una scelta “drammatica”: come evitare che mia mamma diventasse una scimmia della tecnologia, di quelle che vedono la strumentazione elettronica come un primitivo vede il fuoco?
A mio parere (ingenuo), avevamo già superato il punto in cui: «Il computer ha deciso [azione_arbitraria_generica]…», ma non eravamo ancora giunti al punto in cui mia mamma potesse considerarsi un homo sapiens anziché una pseudo-scimmia del cazzo.

Lampo di genio: costruiamo insieme un eseguibile. Decido di scaricare il masm32.

Penso a qualcosa di molto semplice: un programma che utilizzi la funzione GetLocalTime per generare un output con una GUI minima che riporti ore, minuti, secondi e millisecondi.
Inizio a codarglielo davanti agli occhi, spiegandole ogni singolo passaggio, ovviamente senza inserire nemmeno un commento nel codice come mia consuetudine (per fortuna oggi esiste ChatGPT che potrebbe aiutarmi capire funzioni più complesse che ho programmato negli anni).

Ora, immaginate una signora che si trova di fronte una persona che scrive sta roba, spiegandole ogni singolo passaggio: i registri da 8, 16 e 32 bit (per la verità, questi ultimi, non utilizzati, ma mi viene da pensare che le avessi parlato anche di rax per correttezza intellettuale), la struttura di SYSTEMTIME (sicuramente collegandola alla gestione del sistema operativo), lo stack…

.386
.model flat, stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
.data
nome_finestra db “Ora esatta”,0
orario db 0,0,58,0,0,58,0,0,44,0,0,0,0
l_time SYSTEMTIME <>
.code
start:
push offset[l_time]
call GetLocalTime
mov ax,l_time.wHour
mov bx,10
mov cx,0
div bl
add al,48
add ah,48
mov byte ptr[orario],al
inc cx
mov byte ptr[orario+cx],ah
add cx,2
mov ax,l_time.wMinute
div bl
add al,48
add ah,48
mov byte ptr[orario+cx],al
inc cx
mov byte ptr[orario+cx],ah
add cx,2
mov ax,l_time.wSecond
div bl
add al,48
add ah,48
mov byte ptr[orario+cx],al
inc cx
mov byte ptr[orario+cx],ah
add cx,4
mov ax,l_time.wMilliseconds
div bl
add ah,48
mov byte ptr[orario+cx],ah
dec cx
mov ah,0
div bl
add al,48
add ah,48
mov byte ptr[orario+cx],ah
dec cx
mov byte ptr[orario+cx],al
push MB_OK
push offset[nome_finestra]
push offset[orario]
push 0
call MessageBox
push 0
call ExitProcess
end start

Come risaputo, il masm32, per semplificare la programmazione, prevede l’utilizzo della funzione “invoke”, ma come potresti considerarti un utente consapevole se non conosci il significato di LIFO? E allora andiamo di push e call, ovviamente con davanti una API reference di Microsoft scritta in inglese.

Manco a dirlo, mia mamma ha usato quel PC tre volte nella vita, e ogni volta è stato un dramma.

La domanda che mi pongo oggi, è quante volte nella vita continui a usare questo approccio, senza manco rendermene conto, nella convinzione di aiutare qualcuno…