Vala (programming language)

Vala

Paradigm(s)	Multi-paradigm: imperative, structured, object-oriented
Appeared in	2006
Developer	Jürg Billeter, Raffaele Sandrini
Stable release	0.20.1 (8 April 2013 (2013-04-08))
Typing discipline	static, strong
Influenced by	C, C++, C#, D, Java, Python
OS	cross-platform all supported by GLib, but distributed as source code only.
License	LGPL 2.1+
Usual filename extensions	.vala, .vapi
live.gnome.org/Vala

Vala is an object-oriented programming language with a self-hosting compiler that generates C code and uses the GObject system. Vala is syntactically similar to C# and includes useful language features like anonymous functions, signals, properties, generics, assisted memory management, exception handling, type inference, and foreach statements. Its developers Jürg Billeter and Raffaele Sandrini aim to bring these features to the plain C runtime with little overhead and no special runtime support by targeting the GObject object system. Rather than being compiled directly to assembly or to another intermediate language, Vala is source-to-source compiled to C which is then compiled with a platform's standard C compiler, such as gcc.

For memory management, the GObject system provides reference counting. In C, a programmer must manually manage adding and removing references, but in Vala, managing such reference counts is automated if a programmer uses the language's built-in reference types rather than plain pointers.

Using functionality from native code libraries requires writing vapi files, defining the library interfacing. Writing these interface definitions is well-documented for C libraries, especially when based on GObject. However, C++ libraries are currently not supported. Vapi files are provided for a large portion of the GNOME platform, including GTK+.

Vala was conceived by Jürg Billeter and was implemented by him and Raffaele Sandrini, finishing a self-hosting compiler in May 2006.

Code example

A simple "Hello, World!" program (see also GTK+ hello world)

int main () {
    print ("Hello World\n");
 
    return 0;
}

A more complex version, showing some of Vala's object-oriented features:

class Sample : Object {
    void greeting () {
        stdout.printf ("Hello World\n");
    }
 
    static void main (string[] args) {
        var sample = new Sample ();
        sample.greeting ();
    }
}

An example using GTK+ to create a GUI "Hello, World!" program:

using Gtk;
 
int main (string[] args) {
    Gtk.init (ref args);
 
    var window = new Window ();
    window.title = "Hello, World!";
    window.border_width = 10;
    window.window_position = WindowPosition.CENTER;
    window.set_default_size(350, 70);
    window.destroy.connect (Gtk.main_quit);
 
    var label = new Label ("Hello, World!");
 
    window.add (label);
    window.show_all ();
 
    Gtk.main ();
    return 0;
}

The last example needs an extra parameter to compile on GNOME3 platforms:

valac --pkg gtk+-3.0 hellogtk.vala

This is the converted C code:

/* hellogtk.c generated by valac 0.20.1, the Vala compiler
 * generated from hellogtk.vala, do not modify */
 
 
#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
 
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
 
 
gint _vala_main (gchar** args, int args_length1);
static void _gtk_main_quit_gtk_widget_destroy (GtkWidget* _sender, gpointer self);
 
 
static void _gtk_main_quit_gtk_widget_destroy (GtkWidget* _sender, gpointer self) {
        gtk_main_quit ();
}
 
 
gint _vala_main (gchar** args, int args_length1) {
        gint result = 0;
        GtkWindow* _tmp0_;
        GtkWindow* window;
        GtkLabel* _tmp1_;
        GtkLabel* label;
        gtk_init (&args_length1, &args);
        _tmp0_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL);
        g_object_ref_sink (_tmp0_);
        window = _tmp0_;
        gtk_window_set_title (window, "Hello, World!");
        gtk_container_set_border_width ((GtkContainer*) window, (guint) 10);
        g_object_set (window, "window-position", GTK_WIN_POS_CENTER, NULL);
        gtk_window_set_default_size (window, 350, 70);
        g_signal_connect ((GtkWidget*) window, "destroy", (GCallback) _gtk_main_quit_gtk_widget_destroy, NULL);
        _tmp1_ = (GtkLabel*) gtk_label_new ("Hello, World!");
        g_object_ref_sink (_tmp1_);
        label = _tmp1_;
        gtk_container_add ((GtkContainer*) window, (GtkWidget*) label);
        gtk_widget_show_all ((GtkWidget*) window);
        gtk_main ();
        result = 0;
        _g_object_unref0 (label);
        _g_object_unref0 (window);
        return result;
}
 
 
int main (int argc, char ** argv) {
        g_type_init ();
        return _vala_main (argv, argc);
}

IDE support

There are various projects in various states of stability in order to provide IDE support for Vala:

• Geany
• Val(a)IDE
• MonoDevelop
• Vala Toys for gedit
• Valencia
• Anjuta
• NetBeans
• TextMate
• RedCar
• Sublime Text (syntax plugin)

See also

• Genie, a programming language for the Vala compiler with a syntax closer to Python
• MonoDevelop, a programming IDE that runs on Linux, Windows and Mac OS X with support for Vala
• Geary, an email client written in Vala
• Shotwell, an image organiser written in Vala
• Ease, a presentation program written in Vala
• Val(a)IDE, an IDE for Vala, written in Vala

External links

• Official website , on GNOME Live!
• ValaToWindows, Vala compiled binaries for Windows.
• LibGee, a collection library for vala.
• Val(a)IDE, an IDE for Vala
• Valencia, a Vala plugin for Gedit
• Vala Toys for Gedit, a plugin for Gedit that adds support of autocompletion and more, to program with Vala.
• API Documentation
• Vala sample code for beginners.
• List of Vala programs

Comparison with other languages

• Vala and Java
• Vala and C#
• Benchmark of Vala versus C# and C
• More Vala benchmarks