Sommario | Come funziona | Approfondimenti | Download | Esempi | Links

Nidl è un piccolo esperimento nato dalla passione per Linux e per la programmazione, unite a un paio di considerazioni linguistiche. Nidl si propone di rendere agevole per chiunque realizzare piccole applicazioni per l'ambiente grafico di Linux. 

Una delle peculiarità di Linux è l'apertura e la flessibilità del sistema, che colpisce ma al tempo stesso spaventa il nuovo utente: nei primi approcci con questo sistema operativo da un lato si ha la sensazione di poter configurare e modificare qualsiasi cosa, dall'altro ci si sente sperduti e intimoriti al pensiero della mole di conoscenze tecniche che ciò richiede. Ciò lascia ampio spazio alla creatività e all'intelligenza dell'utente, ma implica un "uso della testa" che non tutti sono disposti a mettere in campo nell'uso quotidiano della macchina. Proprio da questo sono nati tanti luoghi comuni su Linux, spesso bollato come sistema operativo per "smanettoni" o "camici bianchi", riservato a una stretta cerchia di appassionati e di difficilissimo uso, installazione e manutenzione. 

Per la sua stessa genesi, filosofia e struttura, Linux è un fenomeno in continua evoluzione, del quale è difficile dare una definizione che non risulti riduttiva e banalizzante. 
Chi ha provato le distribuzioni meno recenti ricorderà che l'interfaccia grafica era un mero accessorio con un aspetto esteriore molto lontano dallo "stile Microsoft", e assolutamente estranea al sistema. Viceversa oggi sembra verificarsi una "migrazione" sotto l'interfaccia grafica della maggior parte delle applicazioni e addirittura della gestione del sistema; alcune distribuzioni propongono come default
l'avvio del sistema sotto X Window, e iniziano a essere disponibili tools di configurazione in veste grafica che dovrebbero rendere la gestione più user friendly di quanto fosse in passato. 
Questa tendenza, legata al lodevolissimo tentativo di rendere Linux più diffuso su larga scala, offre alcuni spunti di riflessione che meritano di essere valutati. 

Da un lato bisogna prendere atto della proliferazione di nuovi utenti Linux, che non conoscono la praticità e la velocità dell'interfaccia a carattere e tutte le meraviglie che si possono realizzare uscendo dai confini di X. Dall'altro lato, senza nulla togliere all'ottimo lavoro che si sta svolgendo da più parti intorno alla veste grafica di Linux, qualcuno inizia a osservare una certa tendenza emulativa: a parte un paio di vecchi WM che sembravano piccole scimmiottature dell'interfaccia di Windows95, si nota oggi una sempre maggiore somiglianza delle finestre e dei relativi elementi decorativi allo "stile Microsoft" e, per contro, una sempre minore flessibilità dei tools di configurazione che, per rendere il
compito sempre più facile al newbie, finiscono di fatto per limitarne le scelte. 

Non entro qui nel merito del discorso, che trova ampio spazio in altre e più competenti sedi. Osservo solo che molti auspicano che una maggiore diffusione di Linux (un giusto obiettivo cui tanti stanno oggi faticosamente lavorando) non si traduca in una perdita di quelle caratteristiche originarie e originali che tanto ci hanno fatto apprezzare questo ottimo strumento. 

E' ovvio che per accogliere tanti nuovi utenti abituati allo "stile Microsoft" la cosa migliore e più naturale sia fornire loro un sistema somigliante a Windows, sul quale abbiano a disposizione le stesse applicazioni che usavano prima. Ed è altrettanto ovvio che pochi sarebbero disposti a imparare il funzionamento di parte del sistema prima di riuscire anche solo a stampare una semplice lettera. Ma c'è
sempre una via di mezzo per raggiungere un più ottimale rapporto costi/benefici. 

Nidl nasce proprio dal tentativo di stimolare la diffusione italiana di Linux, dimostrando non solo che l'uso del sistema può essere semplice, ma che può addirittura essere semplicissimo e alla portata dell'utente medio sviluppare piccole applicazioni che girino sotto l'ambiente grafico, senza dover per questo studiare oscuri trattati sulla programmazione e relativi linguaggi. 

Per realizzare questo scopo Nidl usa esclusivamente la lingua italiana sia nell'interfaccia sia nel set di comandi che compongono il suo linguaggio. 
  
  

                       _________________________________________________________
 

Nidl e linguaggi di programmazione 

Come si possono avvicinare gli utenti alla programmazione? 

Ho sempre pensato che in realtà programmare è una cosa semplice, creativa e alla portata di tutti. Mi rendo conto che questa affermazione può suonare pazzesca per chi si trovi per la prima volta davanti a un listato C o assembler. Ma se ci si pensa bene la difficoltà non è tanto nella programmazione in se stessa quanto nel metodo che dobbiamo usare per istruire la macchina, troppo "stupida" per capire istruzioni nel nostro sofisticatissimo linguaggio naturale. 

In altre parole, per quella meraviglia della natura che è il nostro cervello, è un gioco da bambini istruire una macchina senza alcuna capacità di ragionamento a compiere una serie di operazioni; ma il problema è farle capire quello che vogliamo da lei. Del resto la considerazione è di banale esperienza: più il nostro interlocutore è "stupido", più siamo costretti a spiegargli le cose in modo (per noi) ridondante ed elementare. 

Per usare una vecchia metafora, noi siamo la mente e il programma è il braccio. Noi l'intelligenza e i creatori del suo mondo e delle regole che lo governano, lui un semplice esecutore che si muove all'interno di questo mondo, senza avere il benché minimo arbitrio. Tutte le azioni che la macchina eseguirà sono racchiuse nello schema da noi previsto e costruito. Tanto più lo schema è corretto, tanto meno vi sarà possibilità che la macchina compia un'azione imprevista. 

La cosa può essere divertente e molto creativa, anche perché, se si immagina uno schema infinitamente complesso, diventa impossibile prevedere tutte le azioni che potrebbe compiere l'esecutore. Ecco che ci troveremmo davanti ad azioni inaspettate e impreviste, ma del tutto logiche dal punto di vista della macchina perché implicite nel ragionamento partorito dal nostro cervello, che rimane il mondo in cui
l'esecutore si muove. Naturalmente più lo schema è complesso più è difficile mantenere la logica e la coerenza tra le sue parti evitando le ambiguità e le possibili contraddizioni. 

Una volta trovato un modo semplice per istruire la macchina, realizzare applicazioni non troppo complesse è, per il nostro cervello, decisamente banale. Il maggior ostacolo è il linguaggio, o per meglio dire la nostra abitudine al linguaggio; non è un caso che i ragazzini abbiano più facilità degli adulti a interagire con le macchine e a imparare a programmare, e che i bambini abbiano maggiore facilità degli
adulti ad apprendere le lingue. Chi ha qualche conoscenza degli studi sull'intelligenza artificiale sa quanto questo aspetto sia cruciale. 

Partendo da queste considerazioni ho pensato di creare una scorciatoia che aiutasse ad aggirare questo primo e fondamentale ostacolo: se istruire la macchina è così semplice, perché dobbiamo usare un linguaggio tanto complicato? 
Il motivo in realtà c'è, come abbiamo detto: il nostro linguaggio è troppo sofisticato, quindi lo dobbiamo "tradurre". La logica degli attuali processori è elementare (0-1), quindi dobbiamo creare tutti i passaggi intermedi per arrivare a comunicare le nostre intenzioni in termini di 0-1. Naturalmente tanto più ci avviciniamo al nostro linguaggio, tanto più saranno necessari passaggi e traduzioni.
E più il linguaggio di programmazione è simile al linguaggio naturale, meno sarà efficiente e veloce nell'istruire la macchina. 
Questo è l'assioma entro il quale dobbiamo muoverci e operare. Ma all'interno diquesto assioma iniziamo ad avere ampio spazio di manovra. 

Agli inizi della cosiddetta "era informatica" l'assioma era rigido e si presentava come un'assoluta necessità. I processori erano lenti e dotati di poca memoria (intesa in questo caso come un'area temporanea da usare per le operazioni di traduzione). Il primo PC era una scatola con dentro il processore e fuori una serie di interruttori che servivano a impartirgli le istruzioni; per immettere un
programma bisognava spellarsi le dita a forza di agire sugli interruttori, e ogni volta che si commetteva un errore o che si era terminata l'esecuzione bisognava ricominciare da capo.

Oggi le cose sono diverse. La crescita esponenziale della potenza di calcolo e della memoria disponibili in qualunque PC ci mette in grado di usare anche linguaggi meno veloci ed efficienti ma a noi più vicini e comprensibili. Peraltro la scelta resta aperta, perché abbiamo a disposizione molti strumenti tra cui scegliere quello di volta in volta più adatto al nostro scopo: useremo un linguaggio molto vicino alla
macchina per applicazioni che richiedono grande velocità e potenza (si pensi allo scheduler di Linux, una delle poche parti in assembler dell'intero sistema operativo), mentre potremo ricorrere a semplicissimi linguaggi script per applicazioni che non richiedono grande velocità di calcolo e che si possono permettere anche un piccolo spreco di memoria e di risorse. 

Posto dunque che la programmazione non presenta in linea di principio grandi difficoltà e che oggi, a differenza che in passato, possiamo ricorrere a linguaggi più vicini al nostro, si può concepire l'idea di semplificare ancora il compito all'utente finale usando un ulteriore passaggio intermedio. 
E' un po' il principio adottato dai vari linguaggi visual lanciati dalla Microsoft.
Creiamo cioè un programma che si ponga tra utente e linguaggio di programmazione facilitando ulteriormente il suo compito. Insomma un'ulteriore traduzione, o meglio un'interfaccia, che si ponga a un diverso stadio: non tra linguaggio e macchina ma tra utente e linguaggio. 

Ed ecco come nasce Nidl. Nidl si pone esattamente in questa prospettiva, mettendo a disposizione dell'utente sia un'interfaccia semplice e intuitiva per creare gli oggetti e inserire i comandi, sia un sottolinguaggio basato su un set di oggetti e comandi tutti in italiano, con una sintassi scarna e che consente una certapossibilità di errore. 
A differenza di un classico "visual", quindi, Nidl oltre a offrire la facilitazione dell'interfaccia grafica interviene sul linguaggio: anziché presupporre che l'utente ne abbia una conoscenza completa, gli si fornisce un set di istruzioni il più vicine possibili alla sua lingua madre, nella fattispecie l'italiano; sarà Nidl stesso a occuparsi poi di tradurle nel codice che verrà passato alla macchina. 

Ciò è stato possibile soprattutto grazie alla scelta del tcl/tk, un linguaggio script disponibile sotto l'ambiente grafico di Linux che già di per sé appare molto semplice, flessibile e vicino a una lingua naturale. Il lavoro di traduzione che deve operare Nidl è quindi facilitato e permette un buon margine di avvicinamento all'utente finale. 
  

                       _________________________________________________________
 

Come funziona 

1. Il linguaggio 

Per cercare di realizzare, tramite Nidl, l'obiettivo di un maggiore avvicinamento al linguaggio naturale sono partito da alcune considerazioni sui linguaggi di programmazione. Cos'è che rende così oscuro un listato a un non addetto ai lavori, anche presupponendo la conoscenza del set di comandi che compongono il linguaggio? 

1. un eccessivo simbolismo 
2. una sintassi spesso del tutto oscura 
3. una base linguistica non italiana 
4. un rigore esasperato 

Ho quindi provato a intervenire su questi elementi creando un set di comandi completamente in italiano, eliminando il più possibile il simbolismo e riducendo la sintassi allo stremo. Ho cercato inoltre di introdurre un minimo di tolleranza all'errore. 

Ad esempio per scrivere con Nidl il classico "programmino di base", che consiste nel far apparire una piccola finestra col messaggio Ciao Mondo, basteranno le seguenti due righe: 

assegna a stringa1 "Ciao Mondo" 
finestra messaggio 

Tutto qua! 
Ma avremmo anche potuto scrivere: 

assegna a stringa1 "Ciao Mondo" 
Ollala susanna 
finestra messaggio 

Funziona lo stesso! Infatti anche se scriviamo una riga con parole estranee al set di comandi, Nidl le ignora e non genera alcun errore. 

Con gli oggetti funziona ancora meglio. Qui è necessaria una piccola premessa: per capire come funziona Nidl bisogna tenere a mente la semplice distinzione tra oggetti e procedure; gli oggetti sono l'aspetto grafico della nostra applicazione con cui interagisce l'utente (ad esempio bottoni, caselle di immissione testo, listbox ecc.), le procedure sono i comandi che il programma esegue quando si avvia o quando l'utente compie una certa azione, come premere un bottone o cliccare su un menu. 
Ad esempio per creare un'etichetta che abbia uno sfondo verde, una larghezza di 20, un aspetto rientrato e un testo Ciao, basta scrivere: 

Nome: etic1 Tipo: Etichetta 
allinea basso sfondo verde bordo 2 aspetto rientrato 
larghezza 20 testo "Ciao" 

Semplice e chiaro. Oltretutto l'oggetto lo crea Nidl in maniera assistita e al massimo l'utente lo arricchisce con gli attributi che preferisce tra quelli riconosciuti. Inoltre, dato che gli oggetti funzionano tramite parole chiave e che vengono ignorate quelle non riconosciute, avremmo potuto tranquillamente scrivere: 

Nome: etic1 Tipo: Etichetta 
allinea basso Porca miSEria 
VOGLIO UN bordo 2 ed un aspetto rientrato con una larghezza 20 
e un bello sfondo verde 
Ah... e schiaffamici dentro il testo "Ciao" !!!! 

Anche in questo caso, funziona lo stesso! 

Oddio, non è tutto oro quello che luccica. Ad esempio se immettessimo una parola casuale tra aspetto e rientrato (cioè tra l'attributo e l'opzione) avremmo in ogni caso un errore; inoltre questo giochetto non funziona con i comandi all'interno delle procedure ma solo con gli oggetti. Comunque anche con i comandi, come abbiamo visto, si può inserire una riga di testo assolutamente casuale tra una linea e
l'altra e la cosa viene del tutto ignorata se non coincide con un comando specifico.

                                      __________

2. L'interfaccia grafica 

A parte la semplificazione del linguaggio, l'aiuto più grosso all'utente è nell'interfaccia grafica. 

Anzitutto abbiamo un bottone per eseguire il codice in ogni momento, come in ogni visual che si rispetti. 
Inoltre abbiamo una finestra di aiuto sempre attiva sulla destra dell'applicazione, che comprende una lista di tutti gli oggetti e di tutti gli attributi e comandi riconosciuti da Nidl. Ogni oggetto, comando e attributo è corredato da un esempio che può essere inserito nel listato in modo che l'utente possa facilmente e immediatamente applicarlo. Inoltre abbiamo un sistema che assiste l'utente
nell'inserimento degli oggetti e dei comandi. 

Insomma se vogliamo inserire nella nostra applicazione una finestra di testo, basta premere il bottone per l'inserimento degli oggetti e Nidl si occupa di inserire il codice nel listato. Potremo poi, in base alla lista e agli esempi disponibili, assegnare all'oggetto gli attributi che più ci aggradano, ad esempio sfondo nero, font courier ecc. 

Per quanto riguarda i comandi il lavoro è ancora più semplificato. Nidl non impone all'utente di conoscere il set di comandi che compongono il linguaggio: basta premere il relativo bottone per l'inserimento e sarà presentata una lista di tutti i comandi disponibili divisi in categorie. Una volta selezionato il comando che ci serve avremo a disposizione un aiuto con la descrizione dettagliata, un esempio e i parametri richiesti. Sarà quindi Nidl a inserire per noi il comando nel listato. Ciò
naturalmente non impedisce che, una volta imparati i comandi, possiamo inserirli da soli. 

Tanto per avere un'idea dei risultati, ho fatto fare un paio di test ad alcuni amici: anche persone che non sapevano nulla di programmazione sono riuscite a realizzare con Nidl piccole applicazioni. 

                                      __________

3. Esempi di applicazioni 

Nella directory degli esempi sono contenute alcune piccole applicazioni scritte con Nidl: un semplice editor, una calcolatrice, un mailreader e un newsreader. 

Nidl contiene infatti anche i comandi per la gestione del socket e permette dunque di creare applicazioni che funzionino in rete. 

Inoltre gli esempi dimostrano come funzionano i protocolli Smtp, Pop3 e Nntp e come si può realizzare un piccolo client che dialoghi con i relativi server per le operazioni di invio e ricezione di posta e messaggi. 

                                      __________

4. L'applicazione finale 

Una volta concluso il proprio lavoro, un'apposita voce del menu file permette di generare l'applicazione finale. 
Nidl produce codice finale in tcl/tk, quindi l'applicazione generata sarà tradotta in questo linguaggio e potrà girare oltre che su Linux su tutte le piattaforme Unix che lo prevedono. Inoltre in rete sono facilmente reperibili programmi che permettono di compilare le applicazioni tcl/tk come eseguibili stand-alone che possano girare anche su piattaforme su cui non è disponibile il relativo package.