De Engelse pagina is meer recent.

Artikel over het verschijnen van Gambas 2.0

Na drie jaar van ontwikkeling, ben ik verheugd om de eerste stabiele versie van Gambas 2 aan te kondigen.

Inleiding

Het nieuwe logo van Gambas 2
Gambas is een volledige object taal en programmeeromgeving gebouwd op een BASIC interpreter. Ze wordt uitgegeven onder de GNU General Public License.

Zijn architectuur is grotendeels geïnspireerd op Java. Gambas is opgebouwd uit:
  • Een compiler.

  • Een interpreter.

  • Een archiver.

  • Een scripter.

  • Een programmeeromgeving.

  • Vele uitbreidingscomponenten.

De compiler is een snel klein programma geschreven in C:
  • Hij compileert ongeveer 128000 non-void lijnen per seconde op mijn eigen Athlon 2000. Deze snelheid laat toe om snel te ontwikkelen in een codeer-, compileer- en test opeenvolging.

  • Hij doet op het moment zo goed als geen optimalisatie en vertrouwt op de interpreter om dat "at runtime" te doen.

  • Hij beheert en compileert tekstwaarde-vertalingen door gebruik van het GNU gettext gereedschap.

De interpreter is een klein programma, ook in C geschreven, kleiner dan 180 kb:
  • Hij voorziet in alle eigen mogelijkheden van de taal, door onrechtstreeks toegang te verlenen tot bijna alle POSIX glibc voorzieningen.

  • Hij laadt de klassen op aanvraag, en optimaliseert de bytecode de eerste keer dat die gebruikt wordt.

  • Het linken tussen de klassen wordt volledig tijdens de runtime gedaan. Dit wordt zo laat mogelijk uitgevoerd zodat ook grote programma's snel starten.

Tenslotte is de archiver een programma dat een Gambas uitvoerbaar programma maakt van een Gambas projectmap.

Merk op dat een Gambas programma niet meer is dan een niet gecomprimeerd archive van een project. Het kan eender welk type van bestand bevatten, niet alleen gecompileerde bytecode, en het wordt intern door de interpreter aangesproken als een bestandssysteem.

De Gambas Taal

De belangrijkste eigenschappen van de Gambas BASIC taal zijn:
  • Ongeveer 250 sleutelwoorden en ingebouwde functies om met bijna alles om te gaan: arithmetic, teksten, invoer-uitvoer, bestanden, tijd...

  • Volledige foutafhandeling.

  • Volledige procescontrole, met pseudo-terminal beheer.

  • Volledige ondersteuning bij het in het oog houden van invoer-uitvoer file descriptors.

  • Ondersteuning voor Event loop met timers.

  • Ingebouwde UTF-8 tekstondersteuning.

  • Volledige internationalisering en vertalingsvoorzieningen.

  • Mogelijkheid om externe functies uit system shared libraries aan te roepen.

Maar Gambas is ook een echte object-georiënteerde taal, met :
  • Objecten en klassen.

  • Eigenschappen, methodes, constanten en events.

  • Publieke en private symbolen.

  • Polymorphisme, i.e. virtual method dispatching.

  • Enkelvoudige inheritance.

  • Constructors en destructors.

  • Array accessors, enumerators, sorteerbare objecten.

Het overervingsmechanisme in Gambas is volledig dynamisch en laat toe:
  • een meer gespecialiseerde versie te maken van een reeds bestaande klasse.

  • een klasse te re-implementeren en uit te breiden.

  • sommige methodes of eigenschappen van een klasse te overschrijven.

Eender welke klasse kan worden overgeëft, geherimplementeerd worden, of overschreven worden, zelfs de ingebouwde die in C of C++ geschreven zijn.

Tenslotte kan elk event, vanuit eender welk opbject onderschept worden met de ingebouwde Observer klasse.

Een uitbreidbare taal

De Gambas interpreter kern is een terminal programma. Alle andere mogelijkheden worden geleverd door components , groepen van klassen geschreven in C, C++ of in Gambas zelf.

Deze componenten voorzien onder meer:
  • Toegang tot vele databanksystemen: MySQL, PostgreSQL, SQLite, Firebird, ODBC.

  • Programmeren voor de grafische gebruiksomgeving, gebaseerd op de QT toolkit of de GTK+ toolkit.

  • Netwerkprogrammeren, met doorgedreven protocolbeheer: HTTP, FTP, SMTP, DNS.

  • SDL programmering.

  • OpenGL programmering.

  • XML programmering.

  • CGI programmering met sessiebeheer.

All deze mogelijkheden worden voorzien door slechts 351 klassen en 4197 symbolen (op dit moment). Er zijn maar weinig concepten die aangeleerd moeten worden, in vergelijking met andere talen. Bovendien hebben we geprobeerd de namen van de symbolen zo samenhangend mogelijk te maken.

Dit alles draagt ertoe bij dat Gambas relatief gemakkelijk te leren is.

Componenten die geschreven zijn in C/C++ zijn opgeslagen in shared libraries, en componenten geschreven in Gambas zijn gewoon Gambas projecten zoals elk ander project.

Ze worden door de interpreter geladen bij het starten van het programma of op het moment dat ze nodig zijn tijdens het lopen van het programma.

Het ontwikkelen van een component in C/C++ is een beetje als het ontwikkelen van een device driver voor de Linux kern:
  • De broncode van de component zit in de Gambas broncode struktuur.

  • De componenten en de interpreter communiceren door de Application Programming Interface.

  • Ze worden uitgevoerd in de interpreter omgeving, en kunnen dus niet zomaar eender wat doen.

De documentatie over het schrijven van componenten is nog niet klaar, maar alle mogelijke hulp zal gegeven worden via de ontwikkelaars "developer mailing list".

Een script taal

Gambas kreeg onlangs ondersteuning om een script taal te worden. Deze mogelijkheid wordt geboden door de scripter, een klein Gambas programma dat toelaat om eender welke Gambas code in een tekstbestand achter te laten.

Hier is een klein script voorbeeld: 
#!/usr/bin/env gbs2

' This script returns the memory really used by the system, the cache and swap being excluded.
' Dit script geeft het werkelijk gebruikt geheugen, het cache geheugen en de swap niet meegerekend.

FUNCTION GetUsedMemory() AS Integer

  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)] = CInt(aRes[1])
  NEXT

  RETURN cVal!MemTotal - cVal!MemFree - cVal!Buffers - cVal!Cached + cVal!SwapTotal - cVal!SwapFree - cVal!SwapCached

END

PRINT Subst("Used memory: &1 bytes", GetUsedMemory())

Databank, GUI & Desktop onafhankelijkheid

 Gambas componenten zijn niet zomaar bindings. Ze proberen de onderliggende bibliotheek waarop ze gebaseerd zijn van een abstractielaag te voorzien zodat de samenhang en de eenvoud toenemen.

Als gevolg daarvan kan je met Gambas programma's schrijven :
  • Onafhankelijk van de onderliggende databank: iedere databank wordt langs dezelfde API benaderd.

  • Onafhankelijk van de grafische toolkit: de QT component en de GTK+ component hebben dezelfde interface.

Zo bied Gambas bijvoorbeeld een databankbeheer dat:
  • Toelaat om eender welke databank te beheren en aan te passen op voorwaarde dat er een component voor bestaat.

  • bij gebruik vanuit KDE de QT toolkit gebruikt en vanuit Gnome of XFCE de GTK+ toolkit gebruikt

Databank beheer in KDE Databank beheer in XFCE

Bovendien probeerden we ook onafhankelijkheid van de desktop te verstrekken door
  • Het gebruik van iconen passend bij de gebruikte omgeving (KDE, Gnome or XFCE).

  • De gb.desktop component, gebaseerd op shell scripts van het Portland project.

De programmeeromgeving

Gambas levert een volledige IDE, die zelf geprogrammeerd is in Gambas.

Je kan forms maken, controls toevoegen door ze gewoon te tekenen, je code wijzigen en vele andere dingen die overeenkomen met andere snelle ontwikkelomgevingen (RAD-IDE's).

IDE in ontwikkel mode IDE in debugging mode

De Gambas ontwikkelomgeving biedt volgende mogelijkheden:
  • Syntax highlighting van Gambas code, HTML en CSS bestanden.

  • Automatic completion.

  • GUI form editor.

  • Integrated debugger.

  • Icon editor.

  • String translator.

Broncode bewerker Icoon bewerker Vertaling dialog

  • Subversion ondersteuning.

  • Database manager.

  • Online documentatie die onmiddellijk uit de documentation wiki komt.

  • Vele programmeervoorbeelden.

De eerste drie tabs van de project property dialog

Bovendien kan ze installation packages maken voor veel distributies, en ook tar.gz installation packages gebaseerd op de GNU autotools.

De volgende GNU/Linux distributies worden ondersteund:
  • Debian.

  • Fedora.

  • Mandriva.

  • SuSE.

  • Slackware.

  • Ubuntu.

De packages die door de IDE gemaakt worden werken alleen als het doel-systeem op de juiste manier Gambas bijgeleverd heeft gekregen, zoals uitgelegd op How To Package Gambas van de wiki. Helaas is dat momenteel niet altijd het geval ...

Tenslotte, alhoewel de ontwikkelomgeving sterk aan de Gambas taal is gebonden, moet je ze niet gebruiken om Gambas programma's te maken.

Waarschuwing

Omdat niet zou gezegd worden dat dit essay er als een advertentie uitziet :-), moeten we vermelden dat er nog een aantal problemen zijn in Gambas.

De belangrijkste zijn:
  • Gambas is een 32 bit programma en draait niet natively op 64 bit systemen.

  • Sommige mogelijkheden ontbreken nog in de taal: enumeration declaration, en ondersteuning van structures.

  • De GTK+ component is not volledig klaar, en dus is de GUI toolkit onafhankelijkheid niet volledig.

Hopelijk worden die problemen opgelost tegen de volgende versie.

De toekomst

...is niet voorspelbaar, vooral die van Gambas niet.

Dankzij een Perl script met de Positronic::Variables and Quantum::Superposition modules, slaagden we erin te gissen dat de volgende uitgave zal voorzien in:
  • 64 bit ondersteuning.

  • DBus ondersteuning.

  • De integratie van de databankbeheerder in de programmeeromgeving.

  • Een rapport ontwerper in de IDE.

  • QT4 & Cairo ondersteuning.

  • KDE4 ondersteuning.

  • Een uitgebreide gb.desktop component.

  • OpenOffice documenten maken vanuit Gambas.

Gambas is vrije software. Dus, in tegenstelling tot de commerciele software zal wat beloofd wordt niet altijd op tijd afgeleverd worden, en misschien zelfs helemaal nooit. :-)

Download Gambas en andere links

Je kan Gambas afhalen van http://gambas.sourceforge.net/download.html.

Voor meer informatie over Gambas zijn hier een paar links: Je kan problemen en bugs melden op de mailing-list of op de bug tracker op http://gambasrad.org.

We hopen dat je evenveel van Gambas zult genieten als wij! :-)

Benoît Minisini

"When you are doing something, you have against you every people doing the same thing, every people doing the opposite thing, and the very large majority of people doing nothing."
  • Confucius./

(Als je iets doet, heb je iedereen tegen die hetzelfde doet, iedereen die het tegenovergestelde doet, en het grootste deel van de mensen die niets doen.)