A.N.S.U. - Qb64 per programmare con Basic su Windows, Linux e MacOs.

Ansu

Cittadini disoccupati, aziende ed associazioni possono avvantaggiarsi dal sistema QB64, producendo software nuovo con il semplicissimo linguaggio Basic. Chi negli anni ottanta e novanta aveva programmato dei Commodore 64 o degli Amiga adesso può inventarsi un lavoro, realizzare un videogioco oppure realizzare un programma dedicato alla risoluzione di un problema. Un'arma economica che aiuta l'Italia ad importare meno software, permettendo a nostri cittadini di guadagnare soldi onesti oppure attivare iniziative utili.

QB64 è un compilatore open source gratuito per il linguaggio di programmazione QuickBASIC. QuickBASIC è stato un linguaggio di programmazione sviluppato da Microsoft negli anni '80 e '90, era popolare tra i principianti e gli hobbisti grazie alla sua facilità d'uso e alla sua interfaccia grafica. QB64 è un ambiente di sviluppo e un linguaggio di programmazione basato sul popolare linguaggio di programmazione BASIC.

È progettato per offrire un'esperienza di sviluppo moderna e user-friendly, consentendo ai programmatori di creare software e giochi per piattaforme Windows, Linux e macOS. QB64 è compatibile con QuickBASIC e può compilare programmi QuickBASIC in codice macchina nativo per Windows, Linux e macOS. Ciò significa che i programmi QuickBASIC esistenti possono essere facilmente portati su piattaforme moderne utilizzando QB64.

QB64 offre un ambiente di sviluppo integrato (IDE) che facilita la scrittura, il debug e l'esecuzione di programmi BASIC. È in grado di convertire i programmi scritti in QB64 in codice nativo per le varie piattaforme di destinazione, fornendo prestazioni ottimali per le applicazioni sviluppate. La sintassi del linguaggio BASIC è generalmente considerata semplice e facile da apprendere, rendendo QB64 una scelta ideale per principianti e per chi desidera avvicinarsi alla programmazione.

Il linguaggio di programmazione BASIC supportato da QB64 è simile al classico QBasic e offre una sintassi semplice e intuitiva, rendendolo accessibile anche ai principianti. QB64 è apprezzato per la sua versatilità e facilità d'uso, consentendo ai programmatori di creare una vasta gamma di applicazioni, giochi e strumenti software. QB64 è compatibile con i programmi scritti in QuickBASIC e QBasic, permettendo agli utenti di eseguire e modificare vecchi progetti senza problemi. QB64 include anche uno strumento per convertire i programmi scritti in BASIC in codice JavaScript, permettendo così di eseguire le applicazioni direttamente nel browser.

QB64 è utilizzato da programmatori di varie competenze, dai principianti agli esperti, per sviluppare software personalizzati, giochi, strumenti di produttività e molto altro ancora. È apprezzato anche per la sua comunità attiva di sviluppatori e appassionati che condividono risorse, guide e progetti creati con QB64. A differenza delle versioni precedenti di BASIC, QB64 offre funzionalità grafiche e audio migliorate, consentendo la creazione di giochi e applicazioni più complesse. Esistono numerose risorse online, tra cui guide, tutorial e forum, che possono aiutare gli utenti a imparare e risolvere problemi relativi allo sviluppo con QB64.

QB64 include anche una serie di funzionalità aggiuntive che non erano presenti in QuickBASIC, come:
- Supporto per la programmazione orientata agli oggetti.
- Supporto per la grafica e il suono avanzati.
- Supporto per il networking e il multithreading.
- Un debugger integrato per scoprire gli errori.

Ecco alcuni esempi di cosa che potete fare con QB64:
- Creare giochi 2D e 3D.
- Sviluppare applicazioni desktop.
- Scrivere script e automazioni.
- Creare programmi educativi..
- Realizzare programmi scientifici e matematici.

Nell'esempio qui sopra un breve software scritto con Qb64, volutamente nella prova non ci sono punteggiature dopo i numeri di linea. Qui sotto si vede il comando che avvia il test dei programmi che voi scrivete dentro Qb64.

Dopo l'avvio che vedete qui sopra si apre una nuova finestra, detta di output, che potete vedere in azione qui sopra.

Il sito ufficiale di QB64: https://qb64.com

Il forum ufficiale di QB64 in inglese: https://qb64.boards.net

Una guida online in lingua italiana per QB64: https://lumiroseblog.wordpress.com

Il wiki ufficiale in inglese per QB64: https://qb64.com ed un altro in inglese: https://qb64.dijkens.com

Dove scaricarsi QB64 per Windows, Linux e MacOs: https://github.com

Una gui per realizzare velocemente dei software con QB64: https://qb64.com

Convertitore di QB64 in Javascript: https://qb64.com usabile anche online: https://qbjs.org per inserire i vostri software nei siti web.

Un corso in inglese per usare QB64: https://www.qb64tutorial.com ed un altro di tipo scolastico: https://www.schoolfreeware.com ed una guida in inglese con informazioni utili: https://web.archive.org/web/20180906052438/http://qb64.org/vwatch

Il codice ASCII di QB64: https://qb64.com

Il sito/forum del QB64 Phoenix Edition: https://qb64phoenix.com

Alcuni software di esempio realizzati con QB64: https://qb64.com

Istruzioni su come installare QB64 sui sistemi operativi Windows, Linux e MacOs: https://qb64phoenix.com ed un video su come installare QB64 su Linux Ubuntu: https://www.youtube.com

QB64 è nato nel 2007 come progetto open source per creare un compilatore moderno per il linguaggio di programmazione QuickBASIC, che era un linguaggio di programmazione popolare negli anni '80 e '90, ma il suo sviluppo era stato interrotto da Microsoft nel 1996, era stato sviluppato negli anni '80 come un ambiente di sviluppo per il linguaggio BASIC. Era noto per la sua facilità d'uso e per la sua capacità di compilare codice in eseguibili autonomi. Con l'avvento di sistemi operativi più moderni e linguaggi di programmazione più avanzati, l'uso di QuickBASIC è diminuito. Con il passare del tempo, molti programmatori che avevano utilizzato QuickBASIC desideravano continuare a scrivere in BASIC, ma con funzionalità moderne e compatibilità con i sistemi operativi attuali. Questo ha portato alla necessità di un nuovo ambiente di sviluppo che potesse combinare la semplicità del BASIC con le tecnologie contemporanee. Il progetto QB64 è nato con l'obiettivo di portare il linguaggio di programmazione BASIC, che era popolare nelle vecchie versioni di Microsoft QuickBASIC e QBasic, in un contesto più moderno e accessibile per i programmatori contemporanei. Il primo rilascio pubblico di una versione di QB64 è stato nel 2008 grazie ad un gruppo di programmatori appassionati, guidati da "Galleon", il fondatore del progetto. L'obiettivo era creare un compilatore e un IDE che fossero compatibili con QuickBASIC, ma che includessero anche nuove funzionalità come grafica avanzata, supporto audio e compatibilità multi-piattaforma. Da allora, il progetto è stato costantemente sviluppato e migliorato. Nuove funzionalità vengono aggiunte regolarmente e vengono rilasciati aggiornamenti per correggere bug e migliorare le prestazioni.

Le prime versioni di QB64 sono state sviluppate da Fred Janes, un programmatore e appassionato di BASIC, che ha lavorato per portare il BASIC classico su piattaforme più recenti e con funzionalità più avanzate. Il progetto QB64 è stato avviato da un gruppo di sviluppatori che volevano creare un compilatore QuickBASIC che fosse compatibile con le versioni moderne dei sistemi operativi Windows, Linux e macOS. Volevano anche aggiungere nuove funzionalità al linguaggio, come il supporto per la programmazione orientata agli oggetti e la grafica avanzata. Il progetto ha guadagnato rapidamente una comunità di sviluppatori e utenti, che hanno contribuito al miglioramento del software attraverso feedback, suggerimenti e codice. Questa comunità ha giocato un ruolo fondamentale nello sviluppo continuo di QB64.

QB64 è stato progettato per mantenere la semplicità e la facilità d'uso del BASIC classico, ma con prestazioni migliorate e funzionalità aggiuntive per soddisfare le esigenze dei programmatori moderni. È diventato popolare tra gli appassionati di programmazione BASIC e ha acquisito una reputazione come uno strumento flessibile e potente per lo sviluppo di software, giochi e applicazioni su diverse piattaforme. Nel corso degli anni, QB64 ha ricevuto numerosi aggiornamenti e miglioramenti, inclusi nuovi comandi, funzionalità grafiche avanzate e strumenti per la creazione di giochi. La compatibilità con le versioni precedenti di BASIC è stata mantenuta, consentendo agli utenti di eseguire i loro vecchi programmi senza modifiche significative.

Negli anni successivi, il progetto QB64 è cresciuto e ha continuato a evolversi attraverso il contributo della comunità di sviluppatori e degli utenti. La sua storia riflette l'interesse e la passione per il linguaggio di programmazione BASIC e la volontà di preservare e modernizzare questa tradizione nel contesto attuale della programmazione informatica.

Per utilizzare QB64 seguite questi passaggi descritti qui sotto.
Visitate il sito web di QB64 https://qb64.com e scaricate la versione del compilatore per il vostro sistema operativo. Una volta scaricato, installate QB64 seguendo le istruzioni: https://qb64phoenix.com

Avviate QB64 e fate clic sul menù "File" e poi su "New", verrà creata una nuova finestra di codice. Se la vostra finestra di lavoro è troppo piccola andate nella barra dei comandi, scendete nel menù "Options" e scegliete il comando "Display", impostate dimensioni differenti (per esempio "Window width" a: 136 e poi "Window height" a: 46) e confermate sotto premendo il comando "Ok". Nella finestra ora pronta iniziate a scrivere il codice del vostro programma, nel Basic tipico di QB64.

Una volta scritto il codice, nella barra degli strumenti entrate nel menù "Run" e cliccate sul comando "Start", QB64 compilerà il programma in codice macchina nativo, permettendo di provarlo, se non ci sono errori andate nel menù "File" ed usando il comando "Save" realizzate un file che conserverà il vostro lavoro. Ecco un semplice esempio di programma QQ64 che mostra la scritta "Ciao mondo!" sullo schermo:
100: PRINT "Ciao mondo!"

Avviandolo con "Run" vedrete la scritta "Ciao mondo!" stampato nella finestra della console che si aprirà. Suggerimenti per migliorare il vostro codice:
- Usate nomi di variabili descrittivi.
- Commentate il vostro codice per renderlo più facile da capire, dopo il comando ' potete mettere dei commenti scritti per individuare i vostri lavori.
- Utilizzate l'indentazione per rendere il tuo codice più leggibile.
- Controllate attentamente il vostro codice per eventuali errori.

Ecco un semplice esempio di codice che disegna un cerchio sullo schermo:
100: SCREEN 12 ' Imposta la modalità grafica
105: CIRCLE (320, 240), 100 ' Disegna un cerchio con centro (320, 240) e raggio 100
115: SLEEP ' Aspetta che l'utente prema un tasto

Dopo aver scritto il codice di prova dentro QB64, potete prima provarlo e poi magari dopo compilarlo per creare un eseguibile. Nella barra dei comandi andare sul menù "Run" per attivare il comando "Start" (oppure premete F5) per eseguire il software. Se non ci sono errori nel codice, vedrte il risultato nella finestra di attivazione. Se volete salvare questa prova andate nella barra dei comandi, e quindi entrate nel menù "File" per attivare il comando "Save". Se invece ci sono errori nel codice, QB64 fornirà messaggi di errore sotto che indicano dove si è verificato il problema. Potete correggere gli errori direttamente nell'editor.

Quando siete pronti a distribuire la vostra applicazione potete compilare il vostro progetto in un file eseguibile (.exe su Windows) andando nella barra degli strumenti, scendete nel menù "Run" ed attivate il comando "Make Executable Only", il vostro lavoro vi apparirà nella finestra di lavoro di QB64 che avete impostato. Questo file .exe si riesce ad utilizzare nei computer che utilizzano il sistema operativo Linux, a patto di averci installato dentro sia QB64, sia l'emulatore Q4wine .

In QB64 potete modificare le dimensioni della finestra di esecuzione del vostro programma utilizzando il comando SCREEN. Per aumentare le dimensioni della finestra durante l'esecuzione avviate il comando SCREEN con un valore appropriato, che rappresenta la modalità grafica desiderata.

Ecco un esempio di come farlo (dopo il comando ' si possono inserire dei testi di annotazioni):
100: ' Impostare la modalità grafica a 1024x768 (o qualsiasi altra dimensione)
105: SCREEN 12 ' Potete usare SCREEN 0 per tornare alla modalità testo
110: ' Codice del programma qui sotto
115: PRINT "Ciao, mondo!"
120: SLEEP ' Aspetta che l'utente prema un tasto

Il numero dopo SCREEN rappresenta una modalità grafica predefinita, potete trovare l'elenco delle modalità disponibili nella documentazione di QB64. Se desiderate una finestra di dimensioni specifiche potete anche utilizzare il comando WINDOW per definire le dimensioni della finestra di output. Ad esempio:
100: ' Imposta una finestra di dimensioni specifiche
105: WINDOW (0, 0)-(800, 600) ' Definisci la dimensione della finestra
110: ' Codice del tuo programma qui
115: PRINT "Ciao, mondo!"
120: SLEEP

Ricordate che le dimensioni specifiche della finestra potrebbero non corrispondere esattamente alla risoluzione del vostro display, quindi potreste dover sperimentare con i valori per ottenere l'aspetto desiderato. Per conoscere gli effetti dei vari comandi SCREEN premere qui .

Nel video qui sopra ed in quello qui sotto si vede la programmazione su QB64, sono ottimi esempi per capire meglio come lavorare su questo sistema.

Nella programmazione di QB64, l'utilizzo dei numeri di linea è essenziale per la strutturazione e l'organizzazione del codice, ma non dimentichiamo che QB64 supporta anche l'altra forma di programmazione di Basic che NON richiede questi numeri. Ogni riga di codice deve iniziare con un numero di linea seguito da due punti (:), una convenzione conosciuta come "numerazione delle righe". Questo approccio consente di identificare in modo univoco ciascuna istruzione nel programma, facilitando la gestione e la comprensione del codice. Ad esempio, una riga di codice in QB64 dovrebbe essere formattata come segue:
100: PRINT "Hello, World!"

Nell'esempio sopra riportato, il numero di linea (100) seguito dai due punti (:), indica l'inizio di un'istruzione nel programma. Questa pratica promuove una struttura logica e sequenziale, aiutando i programmatori a seguire un flusso di lavoro ordinato durante lo sviluppo del software. L'utilizzo corretto dei numeri di linea e dei puntini associati contribuisce a migliorare la leggibilità, la manutenibilità e l'efficienza del codice in QB64. Assicuratevi di seguire questa convenzione standard nell'organizzazione del vostro programma per una programmazione chiara e professionale. I numeri di linea e i puntini sono due elementi essenziali della programmazione in QB64. I numeri di linea vengono utilizzati per organizzare il codice e per saltare a righe specifiche durante il debug. I puntini vengono utilizzati per indicare l'inizio di una riga di codice eseguibile.

Un altro esempio pratico di utilizzo dei numeri di linea e dei puntini è il seguente:
10. PRINT "Ciao, mondo!"
20. INPUT "Inserisci un numero: "; num
30. PRINT "Hai inserito: "; num
In questo esempio:
- 10. rappresenta il primo numero di linea, indicando che si tratta della prima istruzione del programma.
- I puntini separano in modo inequivocabile il numero dall'istruzione PRINT, rendendo chiaro che si tratta di un comando da eseguire.

I puntini forniscono una chiara distinzione tra il numero di linea e il codice, facilitando la lettura e l'interpretazione del programma. Questo aiuta a mantenere il codice ordinato e facilmente comprensibile. L'uso dei puntini è parte integrante della sintassi di QB64. Ogni riga di codice deve presentare il formato numero di linea.punto codice. L'assenza di puntini potrebbe portare a errori di compilazione, poiché il compilatore non riconoscerebbe correttamente la riga. È imprescindibile rispettare la sintassi stabilita dal linguaggio. Ogni istruzione deve seguire rigorosamente il formato stabilito, garantendo così che il codice venga interpretato correttamente dal sistema.

Numeri di linea.
- Ogni riga di codice, ad eccezione delle righe di commento e delle righe vuote, deve iniziare con un numero di riga.
- I numeri di riga devono essere univoci e devono essere seguiti da due punti (:).
- È consigliabile utilizzare numeri di riga incrementali, come 10, 20, 30, ecc.
- I numeri di riga possono essere utilizzati per saltare a righe specifiche durante il debug. Ad esempio, se si desidera andare alla riga 100, è possibile premere F5 per andare alla prima riga del programma, quindi premere F8 99 volte per andare alla riga 100.

Puntini.
- Ogni riga di codice eseguibile deve iniziare con due punti (:).
- I puntini vengono utilizzati per separare il numero di riga dal codice stesso.
- I puntini dicono a QB64 che la riga di codice deve essere eseguita quando il programma viene eseguito.

Seguendo queste istruzioni, è possibile utilizzare i numeri di linea e i puntini per migliorare l'organizzazione, la leggibilità e la manutenibilità del codice QB64.

Per ottenere numeri interi casuali in QB64 potete utilizzare la funzione RND (Random) insieme alla funzione INT (Integer). La formula per generare un numero intero casuale compreso tra due valori specifici min e max è la seguente:

100: numerocasuale = INT(RND * (max - min + 1)) + min

Nella formula sopra:
- RND restituisce un numero casuale compreso tra 0 (incluso) e 1 (escluso).
- INT arrotonda il risultato verso il basso all'intero più vicino.
- Il termine (max - min + 1) specifica il range di numeri interi casuali desiderati.
- min rappresenta il valore minimo dell'intervallo.
- max rappresenta il valore massimo dell'intervallo.

Ad esempio, se desiderate generare un numero casuale compreso tra 1 e 10, potete utilizzare la seguente istruzione in QB64:
100: randomNumber = INT(RND * (10 - 1 + 1)) + 1

Questa istruzione assegnerà a randomNumber un valore intero casuale compreso tra 1 e 10. Potete personalizzare gli estremi dell'intervallo (min e max) in base alle vostre esigenze specifiche.

In QB64 il comando DIM è utilizzato per dichiarare variabili e array, consentendo di riservare spazio in memoria per i dati che utilizzerai nel tuo programma. Il comando DIM in QB64 viene utilizzato per dichiarare e dimensionare variabili, array e altre strutture dati prima della loro utilizzazione nel programma BASIC. Ecco come si utilizza il comando DIM in QB64 per definire variabili:

Per dichiarare e dimensionare una variabile singola:
100: DIM nomeVariabile

Per dichiarare e dimensionare un array unidimensionale:
100: DIM nomeArray(dimensione)

Per dichiarare e dimensionare una matrice bidimensionale:
100: DIM nomeMatrice(righe, colonne)

Esempi di utilizzo del comando DIM in QB64:
100: DIM x As Integer ' Dichiarazione di una variabile intera denominata "x"
105: DIM a(10) As Float ' Dichiarazione di un array float denominato "a" con 11 elementi (da 0 a 10)
115: DIM b(5, 5) As String ' Dichiarazione di una matrice di stringhe denominata "b" con 6 righe e 6 colonne

Utilizzando il comando DIM, è possibile definire e allocare memoria per variabili, array e strutture dati necessarie all'interno del programma QB64. Assicurati di dichiarare le variabili in modo appropriato prima di utilizzarle per garantire un funzionamento corretto del tuo codice. Ecco qui sotto come utilizzare DIM in vari scenari.

Potete dichiarare variabili singole specificando il tipo di dati. Ad esempio:
100: DIM nome AS STRING
105: DIM eta AS INTEGER
In questo caso, nome è una variabile di tipo stringa ed eta è una variabile di tipo intero.

Per dichiarare un array si possono specificare le dimensioni tra parentesi. Ad esempio:
100: DIM punteggi(10) AS INTEGER
Questo crea un array chiamato punteggi che può contenere 11 valori interi (da 0 a 10).

QB64 supporta anche array multidimensionali. Potete dichiararli in questo modo:
100: DIM matrice(3, 3) AS SINGLE
Questo crea un array bidimensionale chiamato matrice con 4 righe e 4 colonne (da 0 a 3).

Se avete bisogno di cambiare la dimensione di un array già dichiarato potete utilizzare REDIM. Ad esempio:
100: REDIM punteggi(20)
Questo ridimensiona l'array punteggi per contenere 21 elementi. Se usate REDIM PRESERVE potete mantenere i dati esistenti nell'array:
100: REDIM PRESERVE punteggi(20)

Dopo aver dichiarato le variabili o gli array con DIM potete utilizzarli nel vostro programma. Ecco un esempio completo:

100: DIM nome AS STRING
105: DIM eta AS INTEGER
115: DIM punteggi(10) AS INTEGER

125: ' Input dell'utente
130: PRINT "Inserisci il tuo nome: ";
135: INPUT nome
140: PRINT "Inserisci la tua età: ";
145: INPUT eta

150: ' Popolamento dell'array con punteggi
155: FOR i = 0 TO 10
160: PRINT "Inserisci punteggio " + STR$(i) + ": ";
165: INPUT punteggi(i)
170: NEXT i

175: ' Stampa dei risultati
180: PRINT "Nome: "; nome
185: PRINT "Età: "; eta
190: FOR i = 0 TO 10
195: PRINT "Punteggio "; i; ": "; punteggi(i)
205: NEXT i

In questo esempio, abbiamo dichiarato variabili per il nome e l'età dell'utente, oltre a un array per memorizzare i punteggi. Abbiamo quindi utilizzato queste variabili nel programma per raccogliere input dall'utente e stampare i risultati. Utilizzando DIM in questo modo potete gestire efficacemente le variabili e gli array nel vostro programma per QB64.

In QB64 potete ottenere l'input da parte dell'utente per la scelta di un tasto utilizzando la funzione INPUT o la funzione INKEY$. Ecco qui sotto degli esempi su come avere la scelta di un tasto e gestire le selezioni in base al tasto premuto.

Utilizzo della funzione INPUT per ottenere l'input dall'utente (senza usare i numeri di linea):
INPUT "Premi un tasto (f per esempio): "; a$
IF a$ = "f" THEN
PRINT "Hai premuto il tasto 'f'"
ELSE
PRINT "Hai premuto un tasto diverso da 'f'"
END IF

In questo esempio qui sopra la funzione INPUT viene utilizzata per acquisire la scelta dall'utente e assegnarlo alla variabile a$. Successivamente, viene eseguita una verifica condizionale utilizzando l'istruzione IF...THEN per gestire le scelte in base al tasto premuto.

Utilizzo della funzione INKEY$ per ottenere l'input dall'utente senza necessità di premere "Invio" (senza i numeri di linea):
a$ = INKEY$
IF a$ = "f" THEN
PRINT "Hai premuto il tasto 'f'"
ELSE
PRINT "Hai premuto un tasto diverso da 'f'"
END IF

In questo esempio qui sopra la funzione INKEY$ viene utilizzata per ottenere l'input dall'utente senza attendere che venga premuto "Invio", consentendo una gestione più reattiva degli input da parte dell'utente. Utilizzando la funzione INPUT o la funzione INKEY$ potete acquisire l'input dell'utente per la scelta di un tasto e gestire le azioni da intraprendere in base al tasto premuto.

Ecco un esempio qui sotto su come utilizzare INKEY$ per gestire le scelte dell'utente in modo simile a quanto faresti nel BASIC del Commodore 64, volutamente non ci sono i numeri di linea perchè QB64 può funzionare senza di esse, se il software viene progettato nel modo giusto:
DIM scelta AS STRING

PRINT "Premi un tasto (f, g, h) per scegliere un'opzione."

DO
scelta = INKEY$ ' Ottiene il tasto premuto
IF scelta <> "" THEN ' Controlla se è stato premuto un tasto
IF scelta = "f" THEN
PRINT "Hai scelto l'opzione F."
ELSEIF scelta = "g" THEN
PRINT "Hai scelto l'opzione G."
ELSEIF scelta = "h" THEN
PRINT "Hai scelto l'opzione H."
ELSE
PRINT "Scelta non valida. Premi f, g o h."
END IF
END IF
SLEEP 1 ' Aspetta un secondo prima di controllare di nuovo
LOOP UNTIL scelta <> "" ' Continua finché non viene premuto un tasto

- Variabile scelta: viene dichiarata una variabile per memorizzare il tasto premuto dall'utente.
- Ciclo DO...LOOP: questo ciclo continua a eseguire il suo corpo fino a quando non viene premuto un tasto.
- INKEY$: questa funzione restituisce una stringa contenente il carattere del tasto premuto. Se nessun tasto è stato premuto, restituisce una stringa vuota.
- Controllo delle scelte: utilizziamo una serie di IF...ELSEIF per verificare quale tasto è stato premuto e stampare un messaggio corrispondente.
- SLEEP 1: introduce una pausa di un secondo tra i controlli per evitare che il ciclo giri troppo velocemente.

Potete anche utilizzare SLEEP con un valore più basso se desiderate che il programma risponda più rapidamente agli input dell'utente. Potete anche modificare le opzioni disponibili cambiando i caratteri nel controllo IF.

Articolo del Dottor Bishop e del Webmaster dell'Ansu.

QB64, nato originariamente come QB32, è un compilatore BASIC per Microsoft Windows, Linux e macOS, progettato per essere retrocompatibile con il QBASIC e il QuickBASIC. Esso traduce essenzialmente i programmi dal QB64 al C++ e poi li compila. Il QB64 implementa molte istruzioni del QBasic e può compilare quasi tutti i programmi QBasic, compresi i popolari Gorillas e Nibbles; inoltre, permette l'emulazione di parecchie funzionalità DOS. Il QB64 è stato progettato per presentare al programmatore un IDE del tutto simile a quello del QBasic originale. La particolarità di QB64 è che, in più, include i tipi di dati a 64 bit, prevede una migliore resa del sonoro e ha un migliore supporto per la grafica. È software libero, ed è autocompilante.

Storia.
Il QB64 è stato compilato per la prima volta in QuickBASIC 4.5. Dopo uno periodo di sviluppo piuttosto lungo, Galleon, lo sviluppatore, non soddisfatto delle limitazioni di memoria imposte dal QuickBasic, decise di compilarlo con il Basic PDS 7.1 della Microsoft, che risolse questi problemi per un po' di tempo. Dalla versione 0.63, QB64 fu in grado di auto-compilarsi, cosicché le limitazioni della memoria convenzionale non furono più un problema.

Sintassi.
La sintassi del QB64 è stata scelta per essere completamente retrocompatibile con il QuickBasic (ma anche precedenti versioni di Basic, anche se tale non è lo scopo principale del progetto). I numeri di linea possono essere specificati, ma non sono obbligatori. Le istruzioni possono finire con un invio oppure con i ":" due punti. Esempio di programma "Ciao, mondo":
10 PRINT "Ciao, mondo!"

Novità rispetto al QuickBasic.
Le nuove istruzioni messe a disposizione dal QB64 iniziano tutte con un carattere di sottolineatura (trattino basso o underscore), in modo da evitare eventuali conflitti con vecchi programmi che possono usare tali istruzioni come funzioni personalizzate definite dall'utente (infatti nel QuickBasic originale non è previsto che il nome di una parola chiave, di una variabile o di una funzione contenga un trattino basso). QB64 implementa molte nuove funzioni rispetto al QuickBasic. Per esempio, possono essere usati nuovi tipi di variabili, come _BIT, _BYTE, _INTEGER64 e _FLOAT, anche di tipo unsigned (senza segno). I nuovi tipi di variabili hanno un suffisso, proprio come è tipico dei tipi di dati del QBasic. QB64 include anche una libreria audio, che permette di riprodurre i più comuni tipi di formati audio, come WAV, MP3, Ogg Vorbis. Il supporto per la grafica è maggiore: sono disponibili modalità schermo con risoluzione maggiore di 640x480 pixel, e con profondità di colore fino a 32-bit (RGB più il canale alfa). Le librerie che usa QB64 permettono di caricare agevolmente immagini in formato BMP, JPEG, GIF, ecc... Dal momento che QB64 conserva la filosofia del BASIC, e cioè di essere un linguaggio semplice, non è necessario che il programmatore specifichi le librerie che devono essere utilizzate, in quanto il compilatore le include automaticamente tutte (in futuro questo aspetto verrà migliorato, e il compilatore deciderà di includere solamente quelle strettamente necessarie). Il programmatore ha comunque la possibilità di includere una libreria personale usando il metacomando $INCLUDE, come nel QuickBasic originale (anche se tale funzionalità non era prevista nelle prime versioni e negli interpreti).

Librerie.
QB64 usa le librerie OpenGL. È risultato essere il più sviluppato fra tutti i dialetti della famiglia BASIC dal punto di vista sia grafico che sonoro, grazie anche alla capacità di supportare tutte le librerie di Windows e del linguaggio C. Da segnalare l'utility vWATCH che consente di eseguire passo-passo un programma fatto con QB64 e verificare istante per istante le variabili, in modo da agevolare il debug.