La pagina in inglese è più recente.

Che cos'è Gambas?

The Gambas 3 logo

Introduzione

Il maestro sale sul pulpito,
e proprio mentre stà per
iniziare l'arringa quotidiana,
un usignolo comincia a cantare.
Quando l'uccello finisce il suo canto,
il maestro dice:

"Questo è tutto ciò che dovevo dirvi."

Quindi si congeda.

Gambas è un completo linguaggio orientato agli oggetti e un ambiente di sviluppo basato su un interprete BASIC.

È rilasciato sotto la GNU General Public License.

La sua architettura è ampiamente ispirata a Java. Quindi Gambas è composto da:
  • Un compilatore.

  • Un interprete.

  • Un archiviatore.

  • Un interprete di script.

  • Un ambiente di sviluppo.

  • Molti componenti che ne estendono le funzionalità.

Il compilatore è un piccolo eseguibile veloce scritto in C:
  • Compila circa 500000 linee non vuote in un secondo sul mio Core2 Duo @2,33GHz. Questa velocità consente un rapido processo di sviluppo incrementale di codice/compilazione/test.

  • Sull'istante non esegue quasi nessuna ottimizzazione, basandosi sull'interprete per eseguire questa attività in fase di esecuzione.

  • Gestisce e compila le traduzioni delle stringhe usando gli strumenti GNU gettext.

L'interprete è un piccolo eseguibile anch'esso scritto in C che è di circa 320 Kb su un sistema a 64 bit.
L'interprete è un piccolo eseguibile anch'esso scritto in C che è di circa 508 Kb su un sistema a 64 bit.
  • Fornisce tutte le funzionalità native della lingua, fornendo un accesso indiretto a quasi tutte le funzionalità glibc di POSIX.

  • Carica le classi on demand, ottimizzando il bytecode la prima volta che viene eseguito.

  • Il collegamento tra le classi avviene interamente in fase di runtime. Questo viene fatto il più tardi possibile. Quindi anche eseguibili di grandi dimensioni si avviano rapidamente.

Infine, l'archiviatore è un programma che crea un eseguibile Gambas da una directory del progetto Gambas.

Nota che un eseguibile di Gambas è solo un archivio non compresso di un progetto. Può includere qualsiasi tipo di file, non solo il bytecode compilato, ed è accessibile internamente dall'interprete come un file system.

Il linguaggio Gambas

Le caratteristiche principali del linguaggio BASIC di Gambas sono:
  • Circa 250 parole chiave e funzioni native per gestire quasi tutto: aritmetica, stringhe, errori, input-output, file, tempo...

  • Gestione totale degli errori.

  • Controllo totale dei processi, con gestione di uno pseudo-terminale.

  • Supporto completo per ricevere gli eventi dei descrittori di file di input-output.

  • Supporto del ciclo ripetitivo degli eventi con cronometri.

  • Supporto nativo per le stringhe nel formato UTF-8.

  • Supporto completo per l'internazionalizzazione e la traduzione dei progetti.

  • Possibilità di chiamare funzioni esterne nelle librerie condivise del sistema.

Gambas, tuttavia, è anche un vero linguaggio orientato agli oggetti con:
  • Oggetti e classi.

  • Proprietà, metodi, costanti ed eventi.

  • Simboli pubblici e privati.

  • Polimorfismo, cioè gestione dei metodi virtuali.

  • Ereditarietà singola.

  • Costruttori e distruttori.

  • Gestione di matrici, enumeratori, oggetti ordinabili.

Il meccanismo dell'ereditarietà di Gambas è interamente dinamico e permette all'utente di:
  • Creare una versione più specializzata di una classe già esistente.

  • Reimplementare una classe ed estenderla.

  • Sovrascrivere alcuni metodi o proprietà di una classe.

Ogni classe può essere ereditata, reimplementata o sovrascritta, anche quelle native scritte in C/C++.

Per finire, la classe nativa chiamata Observer consente di intercettare qualsiasi evento generato da un oggetto.

Un linguaggio estensibile

L'interprete principale di Gambas è un programma per il terminale. Tutte le altre funzionalità sono fornite da componenti, che sono gruppi di classi scritti in C/C++ o scritti direttamente in Gambas.

Questi componenti assicurano, tra le altre cose:
  • Accesso a vari sistemi di database: MySQL, PostgreSQL, SQLite, Firebird, ODBC.

  • Programmazione di interfacce grafiche per l'utente (GUI), basate su QT e GTK+.

  • Programmazione per la rete, con gestione avanzata dei protocolli HTTP, FTP, SMTP, DNS.

  • Programmazione SDL.

  • Programmazione OpenGL.

  • Programmazione XML.

  • Programmazione CGI con gestione della sessione.

Tutte le funzionalità di Gambas sono coperte da solo 405 classi e 5065 simboli (al momento attuale). Esistono solo pochi concetti da apprendere rispetto ad altri linguaggi. Inoltre, abbiamo cercato di rendere i nomi di questi simboli il più coerenti possibile.

Tutto ciò aiuta a rendere Gambas relativamente facile da imparare.

I componenti scritti in C/C++ sono memorizzati in librerie condivise e i componenti scritti in Gambas sono solo progetti di Gambas come qualsiasi altro progetto.

Vengono caricati dall'interprete all'avvio del programma o quando necessario durante l'esecuzione del programma.

Lo sviluppo di un componente in C/C++ è un po' come lo sviluppo di un driver di dispositivo per il kernel Linux:
  • Il codice sorgente di un componente si trova dentro l'albero del codice sorgente di Gambas.

  • I componenti e l'interprete comunicano tramite una Application Programming Interface (API).

  • Essi sono eseguiti nell'ambiente dell'interprete e quindi non possono fare tutto quello che vogliono.

La documentazione sulla scrittura dei componenti non è ancora terminata, ma tutto l'aiuto richiesto verrà fornito nella mailing list dello sviluppatore.

Un linguaggio di scripting

Gambas può essere usato come linguaggio di scripting. Questa funzione è fornita dallo scripter, un piccolo eseguibile di Gambas che consente di scaricare qualsiasi codice di Gambas in un file di testo.

Ecco un piccolo esempio di script:

#!/usr/bin/env gbs3
 
' Questo script restituisce la memoria realmente utilizzata dal sistema, la cache e lo swap sono esclusi.
    
Function GetUsedMemory() AS Long
    
  Dim sRes As String
  Dim aRes As String[]
  Dim cVal As New Collection
  Dim sVal As String
    
  Exec ["cat", "/proc/meminfo"] To sRes
    
  For Each sVal In Split(sRes, "\n", "", True)
    aRes = Split(sVal, " ", "", True)
    cVal[Left$(aRes[0], -1)] = CLong(aRes[1])
  Next
    
  Return cVal!MemTotal - cVal!MemFree - cVal!Buffers - cVal!Cached + cVal!SwapTotal - cVal!SwapFree - cVal!SwapCached
    
End
    
Print Subst("Memoria utilizzata: &1 Kb", GetUsedMemory())

Database, GUI e Indipendenza del Desktop

I componenti di Gambas non sono solo bindings. Tentano di astrarre la libreria sottostante su cui si basano, in modo che coerenza e semplicità vincano.

Indipendenza dai Database

Con Gambas puoi scrivere programmi indipendenti dal sistema di database sottostante: qualunque sistema di database è accessibile tramite la stessa API.

Ad esempio, il gestore database integrato nell'IDE utilizza lo stesso codice per gestire database MySQL, PostgreSQL, SQLite o ODBC.

Il Gestore dei Database della IDE

Indipendenza dalla GUI

Con Gambas puoi scrivere programmi indipendenti dal toolkit grafico: il componente QT4 e il componente GTK + hanno la stessa interfaccia.

Ecco un esempio di Gambas eseguito con i toolkit QT4 e GTK +.

Esempio di stampa con Qt4 Esempio di stampa con GTK+

Indipendenza dal Desktop

Abbiamo inoltre cercato di garantire anche l'indipendenza dal desktop:
  • L'uso di temi di icone in base all'attuale ambiente desktop (KDE, Gnome o XFCE).

  • Il componente gb.desktop, è basato sugli script della shell del progetto Portland.

Ecco l'IDE di Gambas usando i temi delle icone di KDE e Gnome.

L'ambiente di sviluppo usando il tema delle icone di KDE L'ambiente di sviluppo usando il tema delle icone di GNOME

Ambiente di Sviluppo Integrato

Gambas fornisce un IDE completo, che è a sua volta scritto in Gambas.

È possibile creare moduli, inserire controlli semplicemente disegnandoli, modificare il codice e fare molte altre cose simili ad altri sistemi di Sviluppo Rapido di Applicazioni.

L'editor del codice sorgente Il debugger

L'ambiente di sviluppo di Gambas offre le seguenti funzionalità:
  • Evidenziazione della sintassi del codice Gambas, file HTML e CSS.

  • Completamento automatico.

  • Editor GUI per le form.

  • Debugger integrato.

  • Editor di icone.

  • Traduttore di stringhe.

L'editor di icone L'interfaccia per le traduzioni

  • Supporto per Subversion.

  • Gestore di database.

  • Documentazione online proveniente dal wiki della documentazione.

  • Molti programmi d'esempio.

Inoltre, può creare pacchetti di installazione per molte distribuzioni e anche pacchetti di installazione tar.gz basati su autotools GNU.

Sono supportate le seguenti distribuzioni GNU/Linux:
  • Archlinux.

  • Debian.

  • Fedora.

  • Mandriva.

  • SuSE.

  • Slackware.

  • Ubuntu.

     

Il Packager dell'IDE

I pacchetti creati dall'IDE funzionano solo se la distribuzione di destinazione impacchetta correttamente Gambas come specificato nella pagina How To Package Gambas del wiki.

Cerchiamo il più possibile di fare pressioni sulle distribuzioni in modo da poter impacchettare correttamente Gambas. Questo non è sempre facile!

Puoi aiutarci inviando segnalazioni di bug alle distribuzioni che non riescono a svolgere questo compito essenziale.

Infine, anche se l'ambiente di sviluppo è fortemente legato al linguaggio Gambas, non è necessario utilizzarlo per creare programmi Gambas. Tutti gli strumenti di Gambas (compilatore, interprete...) possono essere utilizzati dalla riga di comando.

Scarica Gambas e Altri Link

Puoi scaricare Gambas su http://gambas.sourceforge.net dal menu "Download".

Per ulteriori informazioni su Gambas, ecco alcuni link: Puoi segnalare problemi e bug sulla mailing list o sul bugtracker.

Speriamo che apprezzerai Gambas tanto quanto noi! :-)

Benoît Minisini