Este documento presenta una guía sobre el lenguaje de programación Vala. Explica que Vala es un lenguaje diseñado para desarrolladores de GLib que ofrece características de alto nivel de una forma simple y compilable de forma eficiente. También introduce algunos conceptos básicos de Vala como variables, tipos de datos y cómo compilar e imprimir un programa simple "Hola Mundo".

1. Guía de Vala
Versión 0.1
Autor
Varun Madiath
Agosto 8, 2010
Traductor
Juan Matías Olmos
Agosto, 2011

2. Licencia del documento original
Copyright ©2010 Varun Madiath
Permission is granted to copy, distribute, and/or modify this document under the
terms of the GNU Free Documentation License, Version 1.1 or any later version
published by the Free Software Foundation; with Invariant Sections being
“Preface”, with no Front-Cover Texts, and with no Back-Cover Texts.
Licencia de la traducción
Esta obra está bajo una licencia Creative Commons Atribución 2.5 Argentina
Usted es libre de:
Compartir – copiar, distribuir, ejecutar y comunicar públicamente la obra
hacer obras derivadas
hacer un uso comercial de esta obra
Bajo las condiciones siguientes:
Atribución – Debe reconocer los créditos de la obra de manera
especificada por el autor o el licenciante (pero no de una manera que
sugiera que tiene su apoyo o que apoyaron el uso que hace de su obra).
[…]
Aviso – Al reutilizar o distribuir la obra, tiene que dejar en claro los
términos de la licencia de esta obra. La mejor forma de hacerlo es enlazar
a la siguiente página (donde puede acceder a la versión completa de la
licencia):
http://creativecommons.org/licenses/by/2.5/ar/

3. Contenido
Capítulo 1............................................................................................... 4
Introducción..............................................................................................................4
Capítulo 2............................................................................................... 6
Lo básico de Vala......................................................................................................6
Compilar el código...............................................................................................6
Comprender el código..........................................................................................7
Programando con Variables.................................................................................8
Un recorrido por la gramática básica de Vala....................................................11
Espacios en blanco.............................................................................................12
Comentarios.......................................................................................................12
Identificadores...................................................................................................12
Palabras clave....................................................................................................13
Literales.............................................................................................................13
Separadores.......................................................................................................14

4. Capítulo 1
Introducción
C es un lenguaje de programación de bajo nivel que puede ser ejecutado en una
variedad de plataformas. Un lenguaje de bajo nivel es el que expone al programador
al hardware donde se ejecutará el código. C viene con las librerías C estándar, las que
en teoría permite a los programadores escribir código que puede ser compilado en
diferentes sistemas operativos, y diferentes arquitecturas de procesador, para crear
un archivo ejecutable que pueda ejecutarse en el sistema. Sin embargo, en la
práctica, la librería estándar de C no es realmente portable a los diferentes sistemas
operativos, y para solucionar esto se desarrolló la librería GLib.
GLib es una librería escrita en C diseñada para ser multiplataforma, y se usa como
alternativa a la librería estándar. Además de proveer funcionalidades como imprimir
texto en la pantalla y lectura de archivos, también provee un tipo de sistema que
permite la implementación de clases, interfaces y objetos en C.
Vala es un lenguaje de programación diseñado para los desarrolladores GLib. El uso
de Vala provee un montón de características presentes en otros lenguajes de
programación de alto nivel pero de una forma que es simple y fácil de entender. Esto
lo hace sin incorporar ninguna máquina virtual de ningún tipo, y por ello el código
escrito puede ser compilado muy eficientemente.
Este lenguaje funciona convirtiendo el código Vala en código fuente C y archivos
cabecera. Vala usa el sistema de tipos GObject de GLib para obtener las
características de orientación a objetos. La sintaxis de Vala es similar a C# o Java, pero
modificada para trabajar con el sistema de tipos GObject.
Algunas de las características que soporta Vala son:
• Interfaces
• Propiedades
• Señales
• Bucle foreach
• Expresiones Lambda

5. • Inferencia de tipo para variables locales
• Genéricos
• Tipo Non-null (no nulos)
• Gestor de memoria asistido
• Control de excepciones
Vala no incluye ninguna característica que no se puede realizar usando C con GLib,
sin embargo hace el uso de estas mismas características de forma más simple. Una
de las criticas más comunes de GLib es que resulta muy verboso y tiene un código
desprolijo. Usando Vala, los programadores pueden evitarse escribir todo ese código
verboso que requiere GLib.
Este lenguaje está diseñado para permitir el uso de librerías C fácilmente, en especial
las librerías basadas en GObject. Todo lo que se necesita para usar una librería escrita
en C es un archivo describiendo la API, estos archivos suelen usar extensión .vapi.
Ésta es una diferencia con respecto a otros lenguajes que usan librerías en C, los
cuales requieren un código especial, llamado binding, que une la funcionalidad del
lenguaje con la librería en C. El problema con eso es que si una librería cambia, el
binding tendría que ser reescrito antes de seguir siendo usado con la librería, dando
como resultado que el binding esté un poco detrás de la implementación oficial.
Los programas escritos en C también pueden usar librerías de Vala sin ningún
esfuerzo extra. El compilador de vala genera automáticamente los archivos cabecera
requeridos, lo cual necesitan los programas en C para usar la librería. También es
posible escribir bindings para Vala desde otros lenguajes como Python y Mono.
Se encuentra más información sobre Vala en:
http://live.gnome.org/Vala/

6. Capítulo 2
Lo básico de Vala
Comencemos a escribir programas usando Vala. El siguiente es un programa simple
que muestra en pantalla las palabras Hola Mundo. Ingresa este código en tu editor de
texto favorito y guárdalo en un archivo llamado holamundo.vala. Vala es un lenguaje
que distingue mayúsculas de minúsculas, así que asegúrate de ingresar el código
correctamente.
/*
* holamundo.vala
*
* Este es un programa en Vala simple.
* Se muestra en pantalla las palabras Hola Mundo
*/
void main(string[] args) {
// La siguiente linea muestra en pantalla las palabras “Hola Mundo”.
stdout.printf(“Hola Mundon”);
}
Compilar el código
Para compilar este programa, abre una terminal, ingresa al directorio donde
guardaste tu archivo y escribe valac seguido del código fuente, como se muestra aquí.
$ valac holamundo.vala
Si no hubieron errores parecerá que no ocurrió nada. Sin embargo el compilador
habrá creado un nuevo archivo ejecutable llamado holamundo. Puedes ejecutar este
programa escribiendo su nombre precedido por ./ como se muestra abajo.
$ ./holamundo
Verás la siguiente salida.
Hola Mundo

7. Comprender el código
A pesar de su longitud, el programa «hola mundo» introduce varias de las
características y conceptos usados en Vala. El programa inicia con las siguientes
líneas:
/*
* holamundo.vala
*
* Este es un programa en Vala simple.
* Se muestra en pantalla las palabras Hola Mundo
*/
Esto es un comentario, un texto encontrado en el código fuente pero que el
compilador ignora. Generalmente, un comentario se usa para describir la operación
del programa, la razón detrás de algún código o una explicación del funcionamiento
de una sección del mismo.
Este lenguaje usa dos tipos de comentarios. El comentario visto arriba se llama
comentario multilínea. Se llama de esa forma porque ocupa varias líneas del código
fuente. Este tipo de comentario inicia con los caracteres /* y finaliza con */, con todo
lo que haya entre estos caracteres componen el comentario.
void main(string[] args) {
Esta línea define el método main(), el mismo contiene el código que se ejecuta
cuando inicia el programa. Se entiende como un punto de partida para la ejecución
del programa. Todas las aplicaciones en Vala (así como C, C++ y C# entre otros)
inician ejecutando este método.
Cuando un programa es ejecutado por el sistema operativo, el mismo corre el código
del método principal, y cuando el programa a terminado, puede devolver o no un
número al sistema operativo. Este número puede ser usado para informar al sistema
operativo si el programa termino sin problemas o si hubo alguno durante la
ejecución. La palabra clave void de esta línea simplemente le dice al compilador que
main() no retornará ningún valor. Todos los métodos pueden retornar un valor, como
se verá más adelante.

8. Vala es un lenguaje que distingue mayúsculas de minúsculas, por lo que void no
puede ser escrito como VOID o Void. El método main() debe ser escrito exactamente
como es, cualquier cambio en la capitalización producirá un archivo que no se
ejecutará. Esto es porque el compilador no vería un método llamado main(), y por
ello el compilador asumirá que el código será usado en otro programa.
El último carácter de esta línea es la llave {. Esto señala el inicio del cuerpo de main().
Todo el código que comprenda un método estará entre una llave abierta y una llave
cerrada.
Otro punto: main() simplemente es un punto de partida del programa. Un programa
complejo tendrá docenas de clases, solo una de las cuales tendrá que ser el método
principal main() para que las cosas puedan arrancar.
// La siguiente linea muestra en pantalla las palabras “Hola Mundo”.
Esta línea es un comentario de línea simple, el otro tipo de comentario soportado en
Vala. Un comentario de una sola línea comienza con los caracteres // y termina al
final de la línea. Generalmente se usan para agregar explicaciones cortas en una línea
de código en particular, mientras que los comentarios de múltiples líneas son usados
para explicaciones más largas.
stdout.printf(“Hola Mundon”);
Esta línea muestra en pantalla la cadena de caracteres “Hola Mundo”, seguida del
carácter de salto de línea, que mueve la salida a la línea siguiente. El método printf()
mostrado aquí es parte de GLib, una librería de la que Vala depende ampliamente.
Este método mostrará en pantalla todo el texto que está entre paréntesis. La
secuencia de caracteres especial n representa el salto de línea.
Observa que la sentencia printf() termina con un punto y coma. Todas las sentencias
en Vala terminan de esta forma. En este programa, la única sentencia es printf(), las
otras líneas son comentarios, declaración de métodos, o líneas con solo caracteres
como { o } llamados también descriptores de alcance.
Programando con Variables

9. Aunque el programa escrito arriba instruye a la computadora, no es muy útil ya que
todo el programa es estático. El programa produciría la misma salida cada ejecución,
y no hacía ningún cálculo. El concepto de variable es fundamental para hacer
programas dinámicos. Una variable es solo el nombre de una cierta dirección de
memoria, puede pensarse como una caja donde guardas datos. El dato dentro de una
variable puede ser modificado durante la ejecución del programa, lo que le permite
volverse dinámico.
El siguiente programa introduce algunos tipos básicos de variables que están
disponibles en Vala.
/*
* ejemplo_variable.vala
*
* Este programa muestra como usar variables, introduce algunos tipos de
* ellas que están disponibles en Vala.
*/
void main(string[] args) {
// Declaracion de variables
bool verdadero = false;
unichar letra = ‘v’;
int num = 10;
double punto_decimal = 15.33;
string nombre = “Alejandro Magno”;
// Imprimiendo los valores de las variables
stdout.printf(verdadero.to_string() + “n”);
stdout.printf(letra.to_estring() + “n”);
stdout.printf(num.to_string() + “n”);
stdout.printf(punto_decimal.to_string() + “n”);
stdout.printf(nombre + “n”);
//Modificando una variable
num = num * 2;
// Imprimiendo la variable modificada
stdout.printf(num.to_string() + “n”);
}
Puedes compilar y ejecutar el programa escribiendo.
$ valac ejemplo_variable.vala
$ ./ejemplo_variable

10. La salida se verá como la siguiente.
false
v
10
15.33
Alejandro Magno
20
Vamos a disecar este código para comprender como se generó esta salida.
bool verdadero = false;
unichar letra = ‘v’;
int num = 10;
double punto_decimal = 15.33;
string nombre = “Alejandro Magno”;
Estas líneas crean variables y les asigna valores. Se crearon diferentes tipos de
variables aquí. La variable bool representa un booleano, una variable que puede
tener uno de dos posibles valores, true o false (serían verdadero o falso en español).
La variable unichar representa un carácter de texto, por lo que casi cualquier carácter
puede ser guardado en esta variable (si, esto incluye caracteres de escrituras
Japonesas e Índicas). El carácter es encerrado con comillas simples para indicar que
es un carácter y no un comando para la computadora. La variable int representa un
entero (un número que no tiene punto decimal). La variable double representa un
número de punto flotante (una variable que puede o no tener punto decimal) y
finalmente una variable string que representa una serie (o cadena) de caracteres. Una
cadena es encerrada con comillas dobles para indicar que el texto es una cadena.
Las variables de asignan con el operador =, con el nombre y tipo del operador del
lado izquierdo y el valor del lado derecho. La forma general de una declaración de
variable puede ser escrita como (el texto encerrado por corchetes es opcional).
type name [= value]
stdout.printf(verdadero.to_string() + “n”);
stdout.printf(letra.to_estring() + “n”);
stdout.printf(num.to_string() + “n”);
stdout.printf(punto_decimal.to_string() + “n”);
stdout.printf(nombre + “n”);

11. Estas líneas imprimen los valores de las variables en la pantalla. La impresión en la
pantalla se hace usando el mismo método printf() que fue usado en el primer
ejemplo. Notarás que en este caso, a la mayoría de las variables se le añade
.to_string(). Esto se debe a que el método printf() debe dar una cadena para imprimir
en pantalla. Por la misma razón, la variable string no lleva .to_string().
num = num * 2;
Esta línea modifica el valor de num asignándole un valor nuevo. El valor nuevo es
dado por la expresión num * 2. Es importante no ver esto como una expresión
algebraica, que no tendría sentido, sino como una asignación. Hay otro operador
para igualdad, como veremos luego. Aquí, el valor de num es multiplicado por dos, y
el resultado es almacenado en num.
stdout.printf(num.to_string() + “n”);
Esta línea imprime el valor de num, como puedes ver en la salida, el valor a cambiado
desde de la asignación de arriba.
Un recorrido por la gramática básica de Vala
Ahora hemos escrito dos programas pequeños en Vala, pero antes de seguir sería
bueno mirar los elementos que componen el programa. Los diferentes elementos
que componen un programa en Vala son:
• Espacios en blanco
• Comentarios
• Identificadores
• Palabras Clave
• Literales
• Operadores
• Separadores

12. Espacios en blanco
Vala es un lenguaje de formato libre. Eso significa que el código no necesita ser
formateado de alguna manera en particular. Los programas que hemos escrito hasta
aquí podrían ser condensados en una simple línea (con la excepción del comentario
de línea simple). El único requisito es que cada símbolo esté separado por al menos
un carácter de espacio, salvo que ya esté separado por algún separador u operador.
Los separadores y operadores se verán más adelante también.
Comentarios
Ya hemos introducido los dos tipos de comentarios que soporta Vala, el comentario
de una línea y el de múltiples líneas.
Es importante observar que la secuencia de caracteres */ no puede aparecer en tu
comentario, ya que el compilador entenderá que se trata del final del comentario.
Esto implica que un comentario en línea no puede ser colocado dentro de otro. En
cuanto comiences a escribir programas más largos y complicados, desearás comentar
secciones del código para tratar de seguir los rastros de posibles errores. En tales
casos utiliza comentarios de líneas múltiples, esto no se recomienda si ya tienes
comentarios de múltiples líneas en esa sección de código. Se recomienda usar un
editor para anteponer // en cada línea de ese bloque para evitar cualquier problema.
La mayoría de los editores traen una característica para realizar esto.
Identificadores
Los identificadores se usan para nombrar variables y métodos. En los programas que
hemos escrito hasta ahora siempre escribimos el métodos main(), en este caso, el
identificador es main. Todos los nombres de las variables del segundo ejemplo son
identificadores. Otros identificadores menos obvios son stdout y printf, separados
por un separador (el punto). Los identificadores de Vala solo pueden contener los
caracteres A-Z, a-z, 0-9 o el guión bajo, además el primer carácter no puede ser un
número.

13. Palabras clave
Vala tiene un conjunto de palabras que no pueden ser usadas como identificadores.
Estas palabras son reservadas para expresar información sobre el programa al
compilador.
La lista de palabras reservadas se muestra en la siguiente tabla:
if else switch case default do while
for foreach in break continue return try
catch finally throw lock class interface struct
enum delegate errordomain const weak unowned dynamic
abstract virtual override signal extern static async
inline new public prívate protected internal out
ref throws requires ensures namespace using as
is in owned delete sizeof typeof this
base null true false get set construct
default value construct void var yield global
Literales
Los literales son construcciones que representan valores en el programa. Un ejemplo
de una constante sería el valor true, para un booleano, o Varun para una cadena.
Aquí tenemos algunos ejemplos más:
• 1824
• 1858.58
• true
• false
• null
• “Alejandro Magno”
Los primeros literales representan un entero y un valor de punto flotante, el tercero y
cuarto son constantes booleanas, el quinto es una constante nula y el último
representa una cadena. Un literal puede ser sustituido por una variable en cualquier
lugar donde una variable de ese tipo sea permitida. Si lees la lista completa de las

14. palabras reservadas, verás que los literales true, false y null también son palabras
reservadas.
Separadores
Símbolo Nombre Objetivo
() Paréntesis Se usan para contener la lista de parámetros en la
definición de un método y su invocación. También se
usan para definir la prioridad en expresiones que los
contenga. Finalmente, se usan para contener tipos de
dato realizando lo que se llama casting de tipo estático.
{} Llaves Usadas para contener los valores de los arreglos
inicializados automáticamente. También se usan para
definir un bloque de código, para clases, métodos y
alcances locales.
[] Corchetes Uso para declarar tipo de arreglos. También se usan para
referenciar valores en arreglos.
; Punto y coma Termina una sentencia.
, Coma Separa identificadores consecutivos en una declaración
de variables. También se usa para juntar las expresiones
dentro de una sentencia for.
. Punto Usado para separar los nombres de paquetes y los
nombres de subpaquetes y clases. También usado para
separar una variable o método de variable de referencia.
Fuente de la traducción:
The Vala Guide, Varun Madiath, Version 0.1, August 8, 2010.