Saltar a: navegación, buscar

Gambas

Gambas2
Información sobre la plantilla
Parte de la familia Software Libre
Versiones2.19
GéneroEntorno de Programación
Sistemas Operativos compatiblesGNU/Linux
IdiomaEspañol
LicenciaGNU General Public Licence
Sitio web
http://gambas.sourceforge.net/

Gambas. Es un entorno de desarrollo libre basado en un intérprete de BASIC con extensiones de objetos, similar a Visual Basic ™ (pero no igual).

Con Gambas, usted puede diseñar su programa de interfaz gráfica de usuario con QT o GTK +, acceso a MySQL, PostgreSQL, Firebird, ODBC y bases de datos SQLite, las aplicaciones de KDE con DCOP, también puede traducir su programa a cualquier idioma, crear aplicaciones de red fácilmente, hacer aplicaciones 3D OpenGL, hacer aplicaciones web CGI.

Introducción

Gambas es un lenguaje orientado a objetos con gran número de capacidades y un entorno de desarrollo basado en un intérprete de BASIC. Se encuentra publicado bajo licencia GNU General Public Licence.
Su arquitectura está ampliamente inspirada por Java: un ejecutable Gambas es un archivo de clases compiladas y archivos con datos que se ejecuta a través de un interprete creado al efecto.

Gambas se compone de:

  • Un compilador.
  • Un intérprete.
  • Un archivador.
  • Un intérprete de scripts.
  • Un entorno de desarrollo.
  • Muchos componentes que extienden su funcionalidad.

Compilador: es un programa rápido y pequeño escrito en C:

  • Compila cerca de 128000 líneas de código útil por segundo en mi propio Athlon 2000. Tal velocidad permite un proceso rápido de desarrollo en el ciclo código/compilación/pruebas.
  • No realiza prácticamente ninguna optimización en este momento, dejando dicho trabajo al intérprete para su realización durante la ejecución del programa.
  • Gestiona y compila traducciones de cadenas empleando las herramientas de GNU gettext.

  Intérprete: es también un pequeño ejecutable escrito en C, de menos de 180Kb:

  • Proporciona todas las características nativas del lenguaje, dando acceso indirecto prácticamente a todas las herramientas del estándar POSIX contenidas en glibc.
  • Carga clases por demanda, optimizando el bytecode la primera vez que es ejecutado.
  • El enlace entre clases se realiza también en tiempo de ejecución, y lo más tarde posible. Así, incluso ejecutables de gran tamaño se inician rápidamente.

Finalmente, el archivador es un programa que crea un ejecutable Gambas a partir de la carpeta de un proyecto Gambas.
Tenga en cuenta que un ejecutable Gambas no es más que un archivo no comprimido creado a partir de un proyecto. Puede incluir cualquier tipo de archivo, no solamente código bytecode compilado, e internamente el intérprete accede a dicho archivo como si fuera un sistema de archivos.

  Lenguaje Gambas

Características principales

  • Cerca de 250 palabras clave y funciones nativas para gestionar prácticamente cualquier cosa: aritmética, cadenas, errores, entrada-salida, archivos, fechas...
  • Gestión completa de errores.
  • Control total de procesos, con gestión de pseudo-terminal.
  • Soporte completo para recibir eventos de descriptores de archivo de entrada/salida.
  • Soporte de lazo de eventos con temporizadores.
  • Soporte nativo de cadenas en formato UTF-8.
  • Soporte completo de internacionalización y traducciones.
  • Capacidad de hacer llamadas a funciones externas alojadas en librerías de enlace dinámico.

  Gambas orientado a objetos

  • Objetos y clases.
  • Propiedades, métodos, constantes y eventos.
  • Símbolos públicos y privados.
  • Gestión de métodos virtuales.
  • Herencia simple.
  • Constructores y destructores.
  • Gestión de matrices, enumeradores, objetos ordenables.
  • La herencia en Gambas es un mecanismo totalmente dinámico, y permite:
  • Crear versiones más especializadas de cualquier clase existente.
  • Reimplementar clases y extenderlas.
  • Reimplementar algunos métodos o propiedades de una clase.

Cualquier clase puede ser heredada, reimplementada o sobrecargada, incluso aquellas nativas creadas en C/C++.
Por último, una clase nativa denominada Observer permite interceptar cualquier evento generado por un objeto.

 Lenguaje extensible

El intérprete básico de Gambas es un programa de consola. El resto de características son provistas mediante componentes, que son grupos de clases escritas en C/C++, o directamente en Gambas.
Dichos componentes proporcionan, entre otras cosas:

  • Acceso a muchos sistemas de bases de datos: MySQL,PostgreSQL, SQLite, Firebird, ODBC.
  • Programación de interfaces gráficas de usuario basadas en QT o GTK+.
  • Programación de red, con gestión de procolos de aplicación: HTTP, FTP, SMTP, DNS.
  • Programación SDL.
  • Programación OpenGL.
  • Programación XML.
  • Programación CGI con gestión de sesiones.

Observe que todas esas características se cubren con sólo 351 clases y 4197 símbolos (a día de hoy). Es una cantidad muy pequeña de conceptos a aprender cuando se compara con otros lenguajes. Aún más, tratamos de hacer los nombres de los símbolos lo más coherentes posibles. Todo ello hace a Gambas relativamente fácil de aprender.

Los componentes escritos en C/C++ se almacenan en librerías dinámicas, y los componentes escritos en Gambas son simplemente proyectos Gambas como cualquier otro.
El intérprete los carga al inicio, o cuando se necesitan, durante la ejecución del programa.

Desarrollar un componente en C/C++ es similar hasta cierto punto a desarrollar un driver para el kernel Linux

El código fuente de un componente se encuentra dentro del árbol principal del código fuente de Gambas.

  • Los componentes y el intérprete se comunican a través de una API.
  • Se ejecutan dentro del entorno del intérprete, por lo que no pueden hacer todo lo que quieran.

Un lenguaje para crear scripts

Recientemente, Gambas ha sido ampliado con soporte para ejecutar scripts. Esta característica es posible gracias al scripter, un pequeño ejecutable escrito en Gambas que permite ejecutar código Gambas desde cualquier archivo de texto.
He aquí un pequeño ejemplo de script:

#!/usr/bin/env gbs2

' Este script devuelve la memoria realmente utilizada por el sistema, así como el caché y swap en uso.

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("Memoria en uso: &1 bytes", GetUsedMemory())

Independencia en bases de datos, interfaz de usuario y escritorio

Los componentes de Gambas no son solo bindings. Tratan de abstraer la librerías subyacentes en las que están basados, de forma que se gane en coherencia y simplicidad.

  • En consecuencia, con Gambas, puede escribir programas que sean:
  • Independientes del sistema de bases de datos empleado: cada base de datos es accedida a través de la misma API.
  • Independientes del toolkit gráfico: los componentes QT y GTK+ tienen la misma interfaz.

  Gestor de bases de datos 

  • Permite editar y gestionar cualquier base de datos, siempre que exista un componente para ella.
  • Utiliza el toolkit QT cuando se ejecuta en KDE, y el toolkit GTK+ cuando se ejecuta sobre Gnome o XFCE.

  Independencia del escritorio

  • Se usan temas de iconos acordes con el escritorio en ejecución (KDE, Gnome o XFCE).
  • El componente gb.desktop, basado en los scripts de shell del proyecto Portland

  Entorno de desarrollo

Gambas dispone de un IDE rico en gran número de características, que está también escrito en Gambas.
Puede con él crear formularios, insertar controles arrastrándolos con el ratón, editar su código, y hacer todas las tareas habituales en en otros entornos para desarrollo rápido de aplicaciones.

Características
Gambas-diseno.png

Resaltado de texto de código escrito en Gambas, HTML y CSS.

  • Autocompletado automático.
  • Editor de formularios.
  • Depurador integrado.
  • Editor de iconos.
  • Traductor de cadenas.
  • Soporte de Subversion SVN.
  • Gestor de bases de datos.
  • Documentación on-line proveniente del wiki de documentación.
  • Muchos programas de ejemplo.

Más aún, permite crear paquetes de instalación para muchas distribuciones, y paquetes tar.gz de instalación basados en las herramientas GNU autotools.

Soporte de distribuciones GNU/Linux
Gambas-codigo.png

Los paquetes creados por el IDE sólo funcionan si la distribución de destino empaqueta Gambas correctamente, de acuerdo con lo especificado en la página del wiki How To Package Gambas. Por desgracia, no es el caso de todas las distribuciones, en este momento...

Finalmente, incluso aunque el entorno de desarrollo está muy ligado al lenguaje Gambas, puedes usarlo si quieres para otras tareas.

Advertencia

Gambas a pesar de ser un proyecto que es totalmente nuevo para las comunidades posee algunas dificultades que quizás resulten incómodas para los usuarios.
Los principales son:
Gambas es una aplicación de 32 bits, no se ejecuta de forma nativa en sistemas de 64 bits.
Algunas características que aún no existen en el lenguaje: declaración de enumeraciones, soporte de estructuras.
El componente GTK+ aún no está finalizado, por lo cual la independencia de toolkit no es total.
Con suerte, el objetivo es resolver estos problemas en la próxima versión.

El futuro

Gracias a un script de Perl que emplea los módulos Positronic::Variables y Quantum:Superposition, podemos adivinar que la siguiente versión vendrá acompañada de:

  • Soporte de 64 bits.
  • Soporte de DBus.
  • La unión del gestor de bases de datos con el entorno de desarrollo.
  • Un editor de reportes en el IDE.
  • Soporte de QT4 y Cairo.
  • Soporte para KDE4.
  • Un componente gb.desktop mejorado.
  • Generación de documentos OpenOffice.

Descarga de Gambas

Se puede descargar la aplicación de cualquiera de los repositorios actualues de Ubuntu y Debian

Puede descargar Gambas desde http://gambas.sourceforge.net/download.html

Véase también

Referencias

 http://gambas.sourceforge.net/