Vala (linguagem de programação)

Vala
Vala Logo.svg
ParadigmaMultiparadigma : imperativo , estruturado , orientado a objetos
DesenvolvedorJürg Billeter, Raffaele Sandrini
Apareceu pela primeira vez2006 ; 17 anos atrás ( 2006 )
Versão estável
  • 0.56.7 [1] / 18 de abril de 2023 ; 52 dias atrás ( 18/04/2023 )
Disciplina de digitaçãoEstático , forte , inferido , estrutural
SOPlataforma cruzada, tudo suportado pelo GLib , mas distribuído apenas como código-fonte.
LicençaLGPLv2.1+
Extensões de nome de arquivo.vala, .vapi
Local na rede Internetvala.dev
Influenciado por
C , C++ , C# , D , Java , Boo

Vala é uma linguagem de programação orientada a objetos com um compilador auto-hospedado que gera código C e usa o sistema GObject .

Vala é sintaticamente semelhante ao C# e inclui recursos notáveis, como funções anônimas , sinais , propriedades , genéricos , gerenciamento de memória assistida , manipulação de exceção , inferência de tipo e instruções foreach . [2] Seus desenvolvedores, Jürg Billeter e Raffaele Sandrini, queriam trazer esses recursos para o tempo de execução C simples com pouca sobrecarga e nenhum suporte de tempo de execução especial, visando o sistema de objetos GObject . Em vez de compilar diretamente para código de máquina ou linguagem assembly, ele compila para uma linguagem intermediária de nível inferior . Ele compila fonte a fonte para C, que é então compilado com um compilador C para uma determinada plataforma, como GCC ou Clang . [3]

O uso da funcionalidade de bibliotecas de código nativo requer a gravação de arquivos vapi, definindo as interfaces da biblioteca . Escrever essas definições de interface é bem documentado para bibliotecas C, especialmente quando baseadas em GObject . Bindings já estão disponíveis para um grande número de bibliotecas, inclusive para bibliotecas C que não são baseadas em GObject , como a biblioteca multimídia SDL , OpenGL , etc.

Descrição

Vala é uma linguagem de programação que combina o desempenho de tempo de construção de alto nível de linguagens de script com o desempenho de tempo de execução de linguagens de programação de baixo nível . O objetivo é trazer recursos modernos da linguagem de programação para desenvolvedores GNOME sem impor nenhum requisito adicional de tempo de execução e sem usar uma ABI diferente , em comparação com aplicativos e bibliotecas escritas em C. A sintaxe do Vala é semelhante ao C# , modificada para melhor se adequar ao sistema de tipos GObject . [4]

História

Vala foi concebido por Jürg Billeter e foi implementado por ele e Raffaele Sandrini, que desejavam uma alternativa de nível superior para desenvolver aplicativos GNOME em vez de C. Eles gostaram da sintaxe e semântica de C#, mas não queriam usar Mono , então terminaram um compilador em maio de 2006. Inicialmente, ele foi inicializado usando C e, um ano depois (com o lançamento da versão 0.1.0 em julho de 2007), o compilador Vala tornou-se auto-hospedado . A partir de 2021, o ramo de lançamento estável atual com suporte de longo prazo é 0,48 e a linguagem está em desenvolvimento ativo com o objetivo de lançar uma versão estável 1.0. [5]

Versão Data de lançamento [6]
Versão antiga, não mais mantida: 0.0.1 15/07/2006
Versão antiga, não mais mantida: 0.1.0 2007-07-09
Versão antiga, não mais mantida: 0.10.0 2010-09-18
Versão antiga, não mais mantida: 0.20.0 2013-05-27
Versão antiga, não mais mantida: 0,30,0 18/09/2015
Versão antiga, não mais mantida: 0,40,0 12-05-2018
Versão antiga, não mais mantida: 0,42,0 01/09/2018
Versão antiga, não mais mantida: 0,44,0 2019-05-09
Versão antiga, não mais mantida: 0,46,0 05/09/2019
Versão estável atual: 0.48.18 2021-06-09
Versão estável atual: 0,50,9 2021-06-04
Versão estável atual: 0,52,4 2021-06-04
Lenda:
Versão antiga
Versão mais antiga, ainda mantida
Última versão
Versão de visualização mais recente
lançamento futuro
Para versões antigas, apenas os primeiros lançamentos pontuais são listados

Projeto de linguagem

Características

Vala usa GLib e seus submódulos ( GObject , GModule, GThread, GIO) como a biblioteca central, que está disponível para a maioria dos sistemas operacionais e oferece recursos como encadeamento independente de plataforma , entrada/saída , gerenciamento de arquivos , soquetes de rede , plug-ins , expressões regulares , etc. A sintaxe do Vala atualmente suporta recursos de linguagem moderna como segue:

As interfaces gráficas com o usuário podem ser desenvolvidas com o kit de ferramentas GTK GUI e o construtor Glade GUI .

Gerenciamento de memória

Para gerenciamento de memória, o sistema GType ou GObject fornece contagem de referência . Em C, um programador deve gerenciar manualmente a adição e remoção de referências, mas em Vala, o gerenciamento dessas contagens de referência é automatizado se um programador usar os tipos de referência internos da linguagem em vez de ponteiros simples. O único detalhe que você precisa se preocupar é evitar gerar ciclos de referência , pois nesse caso este sistema de gerenciamento de memória não funcionará corretamente. [7]

Vala também permite gerenciamento manual de memória com ponteiros como opção.

Ligações

Vala destina-se a fornecer acesso em tempo de execução a bibliotecas C existentes, especialmente bibliotecas baseadas em GObject , sem a necessidade de vinculações de tempo de execução. Para usar uma biblioteca com Vala, basta um arquivo API (.vapi) contendo as declarações de classe e método na sintaxe Vala. No entanto, as bibliotecas C++ não são suportadas. Atualmente, os arquivos vapi para grande parte do projeto GNU e da plataforma GNOME estão incluídos em cada versão do Vala, incluindo o GTK . Há também uma biblioteca chamada Gee, escrita em Vala, que fornece interfaces e classes baseadas em GObject para estruturas de dados comumente usadas . [8]

Também deve ser facilmente possível escrever um gerador de ligações para acesso às bibliotecas Vala a partir de aplicativos escritos em outras linguagens, por exemplo, C#, já que o analisador Vala é escrito como uma biblioteca, para que todas as informações em tempo de compilação estejam disponíveis ao gerar uma ligação .

Ferramentas

Editores

As ferramentas para o desenvolvimento do Vala tiveram melhorias significativas nos últimos anos. A seguir está uma lista de alguns IDEs populares e editores de texto com plug-ins que adicionam suporte para programação no Vala:

Inteligência de código

Atualmente, existem dois servidores de idiomas em desenvolvimento ativo que oferecem inteligência de código para Vala da seguinte forma:

  • benwaffle/vala-language-server, projetado para qualquer editor que suporte LSP , incluindo VSCode, vim e GNOME Builder [12]
  • esodan/gvls, atualmente o servidor de idioma padrão para Vala no GNOME Builder e fornece suporte para qualquer editor com suporte para LSP [13]

Construir sistemas

Atualmente, há vários sistemas de construção que suportam o Vala, incluindo Automake , CMake , Meson e outros. [14]

Depuração

A depuração de programas Vala pode ser feita com GDB ou LLDB . Para depuração em IDEs ,

Exemplos

Olá Mundo

Um simples programa " Alô, Mundo! " em Vala:

void main () { print ( "Olá Mundo \n " ); }   
	 

Como pode ser observado, ao contrário de C ou C++, não há arquivos de cabeçalho no Vala. A vinculação às bibliotecas é feita especificando --pkgparâmetros durante a compilação. Além disso, a biblioteca GLib está sempre vinculada e seu namespace pode ser omitido ( printé de fato GLib.print).

Programação Orientada a Objetos

Abaixo está uma versão mais complexa que define uma subclasse HelloWorldherdada da classe base GLib.Object, também conhecida como classe GObject . Ele mostra alguns dos recursos orientados a objetos do Vala:

class HelloWorld : Object { private uint ano = 0 ; public HelloWorld () { } public HelloWorld . with_year ( int ano ) { if ( ano > 0 ) this . ano = ano ; }   
	    
	
	   
	
	
	    
		 
			  
	

	saudação public void () { if ( ano == 0 ) print ( "Olá Mundo \n " ); else /* Strings prefixadas com '@' são modelos de string. */ print ( @"Olá Mundo, $(este.ano) \n " ); } }    
		   
			 
		
			
			  
	


void main ( string [] args ) { var helloworld = new HelloWorld . with_year ( 2021 ); olamundo . saudação (); }    
	     
	 

Como no caso da biblioteca GObject , Vala não suporta herança múltipla , mas uma classe em Vala pode implementar qualquer número de interfaces , que podem conter implementações padrão para seus métodos. Aqui está um exemplo de código para demonstrar uma interface Vala com implementação padrão (às vezes chamada de mixin )

usando GLib ; 

interface Imprimível { public abstract string print ();  
	    

	public virtual string pretty_print () { return "Por favor" + print (); } }     
		    
	


class NormalPrint : Object , Imprimível { string print () { return "não se esqueça de mim" ; } }    
	   
		 
	


class OverridePrint : Object , Imprimível { string print () { return "Cuidado com o intervalo" ; }    
	   
		 
	

	public override string pretty_print () { return "Substituir" ; } }     
		 
	


void main ( string [] args ) { var normal = new NormalPrint (); var substituído = new OverridePrint ();    
	     
	     

	imprimir ( normal . pretty_print ()); imprimir ( substituído . pretty_print ()); }  
	  

Sinais e retornos de chamada

Abaixo segue um exemplo básico para mostrar como definir um sinal em uma classe que não é compacta, que possui um sistema de sinais embutido pela Vala através do GLib. Em seguida, as funções de retorno de chamada são registradas no sinal de uma instância da classe. A instância pode emitir o sinal e cada função de retorno de chamada (também conhecida como manipulador) conectada ao sinal da instância será invocada na ordem em que foram conectadas:

class Foo { sinal público void some_event (); // definição do sinal  
           

    método public void () { some_event (); // emitindo o sinal (callbacks são invocados) } }    
                           
    


void callback_a () { stdout . printf ( "Chamada A \n " ); }   
     


void callback_b () { stdout . printf ( "Retorno de Chamada B \n " ); }   
     


void principal () { var foo = new Foo (); foo . algum_evento . conectar ( callback_a ); // conectando as funções de callback foo . algum_evento . conectar ( callback_b ); foo . método (); }   
         
           
     
     

Rosqueamento

Um novo thread no Vala é uma parte do código, como uma função que é solicitada para ser executada simultaneamente em tempo de execução. A criação e sincronização de novas threads são feitas utilizando a Threadclasse em GLib, que toma a função como parâmetro na hora de criar novas threads, conforme exemplo (bem simplificado) a seguir:

int question (){ // Algumas operações de impressão for ( var i = 0 ; i < 3 ; i ++ ){ print ( "." ); Tópico . usleep ( 800000 ); stdout . nivelar (); } 
    
            
         
         
         
    

    retorno 42 ; } 


void main () { if ( ! Thread . suportado ()) { stderr . printf ( "Não é possível executar sem suporte a threads. \n " ); retorno ; } print ( "A Última Questão da Vida, do Universo e de Tudo" ); // Parâmetro genérico é o tipo de valor de retorno var thread = new Thread < int > ( "question" , question );   
       
         
        
    
     
    
          

    print ( @"$(thread.join()) \n " ); 
}

Interface gráfica do usuário

Abaixo está um exemplo usando GTK para criar uma GUI "Hello, World!" programa (veja também GTK hello world ) em Vala:

usando Gtk ; 

int main ( string [] args ) { Gtk . init ( ref args );    
	  

	var janela = nova janela (); janela . title = "Olá, Mundo!" ; janela . largura_borda = 10 ; janela . window_position = WindowPosition . CENTRO ; janela . set_default_size ( 350 , 70 ); janela . destruir . conectar ( Gtk . main_quit );     
	  
	  
	  
	  
	 

	var label = new Label ( "Olá, Mundo!" );     

	janela . adicionar ( rótulo ); janela . mostrar_todos (); 
	 

	Gtk . principal (); retorna 0 ; } 
	 

A instrução Gtk.main ()cria e inicia um loop principal ouvindo eventos, que são transmitidos por meio de sinais para as funções de retorno de chamada. Como este exemplo usa o pacote GTK--pkg , ele precisa de um parâmetro extra (que invoca pkg-config no backend C ) para compilar:

valac  --pkg  gtk+-3.0  hellogtk.vala

Veja também

  • Genie , uma linguagem de programação para o compilador Vala com uma sintaxe mais próxima do Python .
  • Shotwell , um organizador de imagens escrito em Vala.
  • Geary , um cliente de e-mail escrito em Vala.
  • elementary OS , uma distribuição Linux com um ambiente de desktop programado principalmente em Vala.
  • Budgie , um ambiente de desktop Linux programado principalmente em Vala.

Referências

  1. ^ "Vala - Compilador usando o sistema de tipo GObject". Projeto GNOME . Seção de notícias . Acesso em 2 de maio de 2023 .
  2. ^ "Vala: programação de alto nível com menos gordura" . Ars Technica . 2 de setembro de 2007 . Consultado em 13 de dezembro de 2011 .
  3. ^ "Uma olhada em duas novas linguagens: Vala e Clojure" .
  4. ^ "Vala · GitLab" . GNOME . Recuperado em 16 de março de 2021 .
  5. ^ Michael Lauer (2019). Apresentando a Programação Vala. doi : 10.1007/978-1-4842-5380-9. ISBN 978-1-4842-5379-3. S2CID  207911698 . Recuperado em 16 de março de 2021 .
  6. ^ "Vala lança" . Projeto Vale . Recuperado em 18 de março de 2021 .
  7. ^ "Gerenciamento de memória de Vala explicado" .
  8. ^ "Libgee no Gitlab" .
  9. ^ ab "Codificação em Vala com Visual Studio Code" . Recuperado em 17 de março de 2021 .
  10. ^ "Codificação em Vala com o editor de texto Vim" . Recuperado em 17 de março de 2021 .
  11. ^ "Habilitar realce de sintaxe Vala e suporte ao navegador de código no GNU Emacs" . Recuperado em 17 de março de 2021 .
  12. ^ "benwaffle/vala-language-server no Github" . GitHub . Recuperado em 17 de março de 2021 .
  13. ^ "esodan/gvls no GitLab" . Recuperado em 17 de março de 2021 .
  14. ^ "Ferramentas Vala" . Recuperado em 29 de março de 2021 .

links externos

  • Website oficial
  • Página Wiki do GNOME
  • Documentação da API
  • Repositório Vala no GNOME · GitLab
  • LibGee, uma biblioteca de utilitários para Vala.
  • Exemplo de código Vala para iniciantes
  • Lista de programas Vala
  • Autovala, um programa que automatiza e simplifica a criação de arquivos CMake e Meson para projetos Vala/C
  • A comunidade Vala no GitHub
  • Akira - ferramenta de design nativa do Linux
  • Kangaroo - ferramenta de cliente de banco de dados de plataforma cruzada para bancos de dados populares
Comparação com outras línguas
  • Vala e Java
  • Vala e C#
  • Benchmarks de diferentes idiomas, incluindo Vala