Gambas

Gambas; linguaggio di programmazione
Autore	Benoît Minisini
Data di origine	1999
Ultima versione	3.19.4 (13 agosto 2024)
Utilizzo	generico
Paradigmi	Programmazione orientata agli oggetti
Tipizzazione	Forte, statica
Influenzato da	Visual Basic, Java
Implementazione di riferimento
Sistema operativo	Linux
Licenza	GPL
Sito web	gambas.sourceforge.net/

Gambas è un linguaggio di programmazione orientato agli oggetti disponibile per piattaforme GNU/Linux ed altri sistemi Unix o assimilati la cui sintassi è basata sul linguaggio BASIC. Gambas indica al contempo sia il linguaggio sia l'IDE, anch'esso scritto in Gambas. L'interprete di Gambas è scritto in C/C++.

Storia

Gambas è nato nel 1999 per mano di un programmatore francese di nome Benoît Minisini che voleva realizzare un nuovo linguaggio di programmazione per Linux, facile da apprendere e semplice da utilizzare come il Visual Basic di Microsoft, di cui però non è un clone, come rimarca con decisione il suo autore^[1]. Anche se molto spesso si tende ad usare la similitudine con il Visual Basic per spiegare ai profani a cosa più assomiglia Gambas, i punti di contatto sono limitati al linguaggio di base, il BASIC, ma la sintassi dei comandi e la struttura dei programmi è diversa tant'è che un programma dell'uno non può girare sull'altro.

Gambas è free software ed è distribuito sotto licenza GPL.

Funzionalità

Con Gambas è possibile:

realizzare applicazioni stand-alone con interfaccia grafica (GUI) basate su GTK+ o Qt;
accedere ai database MySQL, PostgreSQL, Firebird, ODBC ed SQLite;
pilotare le applicazioni KDE con DCOP;
realizzare applicazioni 3D con OpenGL;
creare applicazioni web basate su CGI;
è possibile tradurre i propri progetti per renderli internazionali.

Il suo ambiente di sviluppo (IDE) è un complesso programma scritto in Gambas stesso che permette all'utente di creare le interfacce dei propri programmi semplicemente inserendo i widget sulle finestre delle applicazioni. L'IDE integra un editor di codice con funzioni di autocompletamento per la stesura dei programmi in modo rapido e semplice.

Il linguaggio Gambas

Gambas è un linguaggio di programmazione orientato agli oggetti strutturato ed imperativo, fortemente e staticamente tipizzato. Ciò significa che il controllo sui tipi dei dati delle variabili è eseguito in fase di compilazione e che il tipo di dati che una variabile conterrà non può essere modificato in fase di esecuzione.

Gambas è composto da circa 250 parole chiave e funzioni predefinite per gestire operazioni aritmetiche, manipolare stringhe, input ed output, file, date ed orari, ecc. Offre un gestore completo degli errori, un pieno controllo del processo con gestione tramite pseudo-terminale, pieno supporto all'internazionalizzazione delle applicazioni, possibilità di richiamare funzioni esterne.

Gambas è anche un linguaggio pienamente orientato agli oggetti. Gestisce infatti:

classi ed oggetti;
proprietà, metodi, costanti ed eventi;
simboli pubblici e privati;
polimorfismo;
ereditarietà;
costruttori e distruttori;
enumeratori ed oggetti ordinabili.

Il meccanismo dell'ereditarietà di Gambas è interamente dinamico e permette di:

creare una versione più specializzata di una classe già esistente;
reimplementare una classe ed estenderla;
effettuare l'overloading di metodi o proprietà di una classe.

Qualunque classe può essere ereditata e reimplementata o ne può essere gestito l'overload, anche le classi native scritte in C/C++.

Infine, una classe nativa denominata Observer permette di intercettare qualunque evento sollevato da un oggetto.

Limitazioni

Il componente GTK+ non implementa tutte le caratteristiche di quello che gestisce le Qt (su cui è basato l'IDE di Gambas) per cui l'indipendenza grafica dei progetti dal desktop utilizzato non è ancora completa al 100%.

Linguaggio pseudo compilato

Gambas non è un linguaggio compilato come il C, dove l'eseguibile viene creato durante la compilazione del sorgente, ma non è neanche un linguaggio interpretato come il vecchio BASIC, dove ogni istruzione viene analizzata ed eseguita via via che il flusso dell'elaborazione attraversa il listato del codice. Gambas può creare dei cosiddetti "eseguibili", che altro non sono che archivi non compressi contenenti l'applicazione scritta in Gambas convertita in bytecode, uno pseudo codice a metà fra il linguaggio macchina puro ed il codice originale scritto in Gambas, che l'interprete Gambas può eseguire più velocemente rispetto ad una interpretazione del codice comando per comando. Questo modo di operare è comune ad altri linguaggi, ad esempio Python o Java: anch'essi traducono il codice sorgente in bytecode la prima volta che viene eseguito il programma, in modo da avere la versione "più veloce" pronta per le successive esecuzioni.

Versioni

Lo sviluppo di Gambas è iniziato nel 1999 ma la prima versione del linguaggio ad essere pubblicata, la 0.20, ha visto la luce solo il 28 febbraio 2002. Gambas è stato sviluppato inizialmente con il supporto per le sole librerie Qt di Trolltech. A questa versione sono seguiti 3 anni di intenso sviluppo durante i quali Gambas si è arricchito di comandi, funzioni e componenti fino ad arrivare al 1º gennaio 2005, quando è stata distribuita la versione 1.0. L'ultimo aggiornamento del ramo 1.0 è datato 16 luglio 2007, con l'uscita della versione 1.0.18. Gambas 1 non è più supportato.

Il 9 gennaio 2005 è iniziato lo sviluppo di Gambas 2, la nuova versione del linguaggio. Fra le molte novità è stato aggiunto il supporto alle librerie GTK+ e sono stati aumentati di numero i componenti ed i widget grafici. Lo sviluppo è durato 3 anni ed il 2 gennaio 2008 è stata pubblicata la versione 2.0. L'ultima versione stabile del ramo 2.0 è la 2.24.0, pubblicata il 9 aprile 2012. Gambas 2 non è più supportato.

Gambas 3 ha visto la luce il 31 dicembre 2011. L'IDE è stata ridisegnata e basata sulle librerie QT4 e diversi componenti sono stati rivisti. A partire dalla versione 3.8.0 del 1º agosto 2015 è stato aggiunto il supporto alle librerie QT5.^[2]

Esempi di codice

Ecco il classico Hello world in Gambas:

 PUBLIC SUB Main()
   PRINT "Hello world!"
 END

L'esempio qui sopra stampa il messaggio "Hello World!" su terminale.

Questo è lo stesso esempio ma sfruttando l'interfaccia grafica:

 PUBLIC SUB Form_Open()
  Message.Info("Hello World!")
 END

L'istruzione Message.Info fa apparire una finestra di dialogo che visualizza il messaggio: Va inserita all'interno dell'evento Open() del form principale del programma.

Gambas supporta i cicli, la cui sintassi di un ciclo FOR..NEXT è la seguente:

 PUBLIC SUB Main()
   DIM variabile AS Integer
     FOR variabile = 0 TO 10
       PRINT "Numero " & Str$(variabile)
     NEXT
 END

Il programma stampa su terminale il valore della variabile variabile. Qui si nota anche la tipizzazione forte di Gambas: variabile ed il suo tipo di dati devono essere definiti prima del suo utilizzo.

Architettura

Gambas si compone di diversi elementi:

come prima cosa abbiamo il progetto, una cartella contenente le classi, i moduli ed i form che costituiscono l'applicazione;
un compilatore, denominato gbc, che converte il progetto in bytecode;
un archiviatore, denominato gba, che archivia il progetto in bytecode in un file eseguibile;
un interprete, denominato gbx, che esegue il progetto compilato.

Il compilatore

Il compilatore è un eseguibile scritto in C. È capace di compilare circa 128.000 linee di codice in un secondo su un AMD Athlon 2000+. Questa velocità permette un processo di sviluppo molto rapido perché si riduce il tempo di test rispetto a linguaggi prettamente compilati come il C. Il compilatore è capace di gestire e compilare le stringhe di traduzione per l'internazionalizzazione dei progetti grazie a strumenti quali Gettext. Il compilatore crea un file composto da bytecode, uno speciale codice a metà fra Gambas ed il codice macchina puro, più veloce da eseguire rispetto al linguaggio di partenza.

L'interprete

L'interprete è un piccolo eseguibile (meno di 190 KB) scritto anch'esso in C. Esso carica le classi quando richiesto, ottimizzando il bytecode la prima volta che viene eseguito. Il link fra le classi viene eseguito interamente durante l'esecuzione del codice solo nel momento del reale utilizzo: in questo modo anche grandi eseguibili si avviano molto rapidamente.

L'archiviatore

L'archiviatore è un programma che crea gli eseguibili Gambas partendo dalla cartella del progetto. Da notare che un eseguibile Gambas non è altro che un archivio non compresso che può contenente qualunque tipo di file, non solo il bytecode compilato. Internamente l'interprete accede all'archivio come se fosse un filesystem.

Origini del nome

La scelta del nome è curiosa. Il creatore di Gambas notò che diversi progetti software avevano nomi di animali (es.: Bonobo), ed i linguaggi di programmazione non sfuggivano a questa regola (es.: Camel). Egli voleva però anche un nome che ricordasse ciò che il suo linguaggio era, vale a dire un derivato del BASIC. Fu scelto perciò GAMBAS, che è l'acronimo ricorsivo di Gambas Almost Means BASIC (Gambas più o meno significa BASIC) ma che è anche il nome di un animale, dato che la parola in spagnolo significa gambero^[3].