Rust, Go, mas e Vlang?
V uma linguagem rápida e segura.
Tem uns meses que estou devendo a mim mesmo fazer minha primeira publicação, de conteúdo e bons exemplos no tabnews sobre V.
Como eu vou "escrever" muito daqui pra frente, caso você seja como eu e gosta de ver exatamente do que se trata, olha a seção 2. e a 3. com os exemplos...
Tudo começou em 2019 quando conheci a linguagem, mas acabei não dando muita atenção, mas havia duas coisas que gostei nela(hoje tem mais):
- Normalmente existe apenas uma forma de fazer algo;
- O código é traduzido para C e compilado;
Bom, vamos por parte. Como assim "uma forma de fazer algo"?
Bem essa é a primeira filosofia da linguagem. Tendo poucas formas de fazer algo, as chances de erros são menores, as respostas em comunidades irão convergir(diminuindo o espaço pra dúvida) e de bônus temos mais previsibilidade do código final.
Acima coloquei minhas palavras, mas abaixo está o texto real (vlang)
You can learn the entire language by going through the documentation over a weekend, and in most cases there's only one way to do something.
This results in simple, readable, and maintainable code.
E sobre a parte da tradução, em alguns texto encontramos algo dizendo que o V é front da linguagem C(que seria o back) e tem se tornado cada vez mais como um front, porém um front altamente inteligente, hoje suportando cuspir código em Js, nativo, Go e por último, mas jamais será menos importante, C.
E sim, se ouviu C isso quer dizer que é multiplataforma e tem compilação cruzada também.
E o que me fez não ter dado a devida atenção?
Em 2019 foi quando a linguagem nasceu e eu não sabia disso, achava que ela estava "pronta" cheia de coisas faltando.
1. 2022 Eu reencontrei V estudando sobre Rust
Bem nesse momento estava precisando construir um app simples console, que a linguagem fosse intuitiva, o executável fosse pequeno e sem dependências. Muito a se pedir né!? Pois é...
Fiz com Go e Rust, consegui melhores resultados em Rust e ainda fiz um compress com UPX e ficou ainda melhor!
Mas achei que não tava muito preparado para Rust. Rust é ótimo mas precisa de alto comprometimento inicial(e não vejo nada de errado nisso, mas eu precisava de algo simples!)
Daí você tira que não existe linguagem melhor que outra, só existe a que atende melhor em um determinado momento, visto que minha main linguagem é C#, e eu teria feito tudo muito rápido em C#, mas existia dependências e com AOT eu teria um executável de 150MB
Então nesse momento não dava pra mim ficar com rust também.
Ai eu encontrei Vala, Nim, Zig e claro V.
Todas fazem o mesmo que V(não sei se vala também, mas acho que sim). Traduz o código para C e então compila, porém exceto vala e v, não fui muito com a cara das outras(nada contra, são boas propostas de linguagens, zig tem até um showcase que é o bun uma alternativa mais rápida de Nodejs e Deno).
Vala pra mim foi legal pois me lembrava C#, mas ela possuía algumas pequenas dependências.
Então foi V que ganhou meu coração.
2. Quando vi o que o V tinha a oferecer para o mundo 😯
- Gerenciamento de memória automático
- Null safe
- Inicialização de objetos
- Structs
- Generics
- Sum types
- ...
Quando eu vi V além de se traduzir para C, ela traduzia C para V, e com isso foi possível traduzir o código do Doom para V e então compila-lo novamente e fazer alterações, etc... 🥹 Fiquei passada(como diria minha esposa)
Bem vejam vocês mesmos Repo -> repo V-Doom/Vídeo V-Doom.
Ah, e é claro não precisei de nada disso listado acima pra construir meu app simples, porém foi rápido, simples e se não me engano o executável ficou com tamanho de 80kb e com zero dependências.
3. Chega ver uns exemplos...
Vou tentar fazer um "de para" para a maioria das coias.
E sim, começar com Hello world ainda tem seu charme
// Console.log(...);
println('Hello world')
> v run .
Hello world
Teste você mesmo: https://play.vlang.io/p/ba3bf54f32
Vamos criar uma função
fn main(){
println(say_my_name__say_my_name())
}
fn say_my_name__say_my_name() string {
//Say My Name - Destiny's Child 🤣🤣
return 'André'
}
> v run .
André
Ta, mas que tal acessar uma função de uma "instância de ""classe""".
Teste você mesmo: https://play.vlang.io/p/508dd0f1df
struct Pessoa {
nome string
idade int
}
// Sintaxe parecida com go e rust
// Mas um... "de para"(js) seria algo assim:
// class Pessoa {
// constructor(nome, idade) {
// this.nome = nome;
// this.idade = idade;
// }
// to_string() { return `nome: ${this.nome}\nidade: ${this.idade}`; }
// }
fn (p Pessoa) to_string() string {
return "nome: ${p.nome}\nidade: ${p.idade}"
}
fn main(){
// Aqui seria o mesmo que -> const p = new Pessoa(...);
p := Pessoa{
nome:"André"
idade: 25
}
println(p.to_string())
}
> v run .
nome: André
idade: 25
E que tal criarmos uma api?
Para testar esse, localmente pois precisa abrir porta.
import vweb //lib builtin(não precisa instalar nada)
struct App {
vweb.Context // É Como se eu estivesse "herdando" Context em App.
}
fn main() {
app := App{} // Criando uma nova "instância".
vweb.run(app, 8090)
}
fn (mut app App) index() vweb.Result {
return app.html("<!DOCTYPE html>
<head>
<meta charset=\"UTF-8\">
</head>
<body>
<h1>Tabnews ❤️</h1>
</body>
</html>"
)
}
['/hello/:name']
fn (mut app App) hello(name string) vweb.Result {
return app.json({
'message': 'hello ${name}'
})
}
> v run .
[Vweb] Running app on http://localhost:8090/
acessando o index no navegado
Acessando o endpoint hello
E como poderiamos fazer pra instalar novos módulos?
Atualmente temos essa página vpm pra visualizar os repos dos módulos.
Mas para instalar e começar um projeto novo você faz assim...
(pra instalar segue o readme readme).
mkdir testeV
cd testeV
v init
Change the description of your project in
v.mod
Complete!
v install ui
Installing module "ui" from "https://github.com/vlang/ui" to "C:\Users\AndreLuiz.vmodules\ui" ...
module main
import ui
struct App {
mut:
window &ui.Window // Estou criando um referência do tipo Window do módulo ui.
first_name string
last_name string
}
fn main() {
mut app := &App{ //Criando uma referência do tipo App.
window: 0
}
app.window = ui.window(
title: 'V UI Demo'
children: [
ui.row(
margin: ui.Margin{10, 10, 10, 10}
children: [
ui.column(
width: 200
spacing: 13
children: [
ui.textbox(
max_len: 20
width: 200
placeholder: 'First name'
text: &app.first_name
),
ui.textbox(
max_len: 50
width: 200
placeholder: 'Last name'
text: &app.last_name
),
]
),
]
),
]
)
ui.run(app.window) // Start o form independente do OS(tem muito o que melhorar ainda!)
}
4. Coisas massa construídas com V.
- Uma distro linux compilada com V(vnix);
- Um banco de dados, parecido com o sqlite, é o vsql;
- Alternativa ao GitHub/GitLab escrito em V, é o gitly
Algumas coisas que já vem por default na linguagem sem necessidade de instalar.
- Teste unitário já contido;
- Perfil de execução(pra saber partes mais quentes do código);
- Hotreload(existem dois modos, um ele compila tudo de novo e o outro só compila a modificação pontual, mas está instável no windows.);
- Formatador de código;
- Reporte de erros integrado, já abre na tela de issues do github.com/vlang/v/issues e já com a maior parte do erro escrito;
Para mais coisas interessantes... https://github.com/vlang/awesome-v.
5. Considerações finais.
Bem pessoal, tem muito ainda pra dizer, mas eu pretendo falar sobre no formato de vídeo lá no meu canal. Por enquanto ta um livro em branco lá, mas se tiverem interesse de se inscrever, agradeço por contribuirem com essa troca! 😄
Bem, se nada disso que disse acima te fez ir lá agora baixar e testar, ao menos aprendeu um monte de linguagens com essa finalidade de ser o front da linguagem C.
Olha outra lista aqui -> https://github.com/dbohdan/compilers-targeting-c 😜
E agradeço demais por esse espaço do tabnews, isso é bom até no sentido de ser um espaço pra que eu possa descarregar algo que ta aqui na minha cabeça e eu gostaria de passar pra frente, porque acho massa e poderia agregar pra alguém. Obrigado demais a todos os envolvidos no tabnews!
Fonte: https://vlang.io/