Executando verificação de segurança...
25

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):

  1. Normalmente existe apenas uma forma de fazer algo;
  2. 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 😯

  1. Gerenciamento de memória automático
  2. Null safe
  3. Inicialização de objetos
  4. Structs
  5. Generics
  6. Sum types
  7. ...

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 index no navegado

Acessando o endpoint hello
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!)
}

Imgur


4. Coisas massa construídas com V.

  1. Uma distro linux compilada com V(vnix);
  2. Um banco de dados, parecido com o sqlite, é o vsql;
  3. Alternativa ao GitHub/GitLab escrito em V, é o gitly

Algumas coisas que já vem por default na linguagem sem necessidade de instalar.

  1. Teste unitário já contido;
  2. Perfil de execução(pra saber partes mais quentes do código);
  3. 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.);
  4. Formatador de código;
  5. 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!

Carregando publicação patrocinada...
4

Existem várias críticas a V, desde sua concepção. A linguagem até hoje não consegue cumprir vários de seus objetivos.

Uma pessoa escreveu um artigo em seu blog e foi bloqueada no Twitter pelo time da Vlang.

Houve também uma discussão no Github onde o autor deletava comentários e sempre reagia com postura agressiva a qualquer crítica válida. Ele diz que algumas críticas são desinformação mas não as corrige. Isso levantou muitas suspeitas.

Enfim, tenho muitas dúvidas sobre essa linguagem. Vou esperar até sair a stable para ver se entregaram tudo o que foi prometido.

3

É foda, mano.
Eu tento contruir com o projeto faz um tempo.
Já fiz várias coisas para contrubuir para o projeto. Se eu vejo algo que não funciona, eu vou lá e crio um PR. O problema é várias pessoas vão só para criticar (não que críticas tbm não seja bom) e nunca para contribuir. Aí vão lá, criticam não ajudam em nada e esperam que a solução esteja pronta no outro dia. O vlang evoluiu muito; tem muito a evoluir ainda (ainda está em beta). Mas precisa de alguns detalhes para serem ajustados.
O foda é que os caras estão sozinhos para resolver.
Se vc participa do grupo no discord (https://discord.gg/vlang) vai ver que todo mudo lá é muito gente boa. e tá todo mundo dando o sangue para a linguagem evoluir.

1

Eu não tenho problemas com a lang se não tivessem prometido tanto. Eu te prometo um fusca que anda na terra e na água e te entrego um que mal anda na terra, claro que você vai ficar decepcionado e me questionar.

Leia novamente aqui: https://www.tabnews.com.br/kamuridesu/1f8a702a-a48c-4671-abf6-12228feaeebb

As críticas não foram sobre a linguagem em si, mas sim sobre o que foi prometido. A linguagem é boa, mas engaram as pessoas dando a entender que x funcionalidade já havia sido implementada quando não foi.

1

Essa issue acabei de ver, nunca tinha visto, mas os post de blogs e o twiter tava ciente.

E realmente foi muito triste isso, foi uma decisão muito chata de como lidar com isso!

Tem muitos problemas citados que não são problemas, mas também não é solução é uma adaptação...
Acho que o mais fácil de citar é o null.
Ele é um problema! Mas e porque é permitido usar no V, porque ele precisa lidar com a interoperabilidade com C.
Olha que legal isso A história do null

E a última coisa, ainda tem muito problema no V! Tem pouca gente trabalhando no V, dev ser dificil fazer o que V faz em 3 anos com 15 dev(chutando) ativos. Go ta ai já tem 13 anos.

1

TL;DR: A lang promete demais e entrega de menos

Texto completo:

Sim sim. A questão do null é a lang prometer null safety quando o compilador sequer emite um warning.

Outra questão não é nem querendo que em tão pouco tempo a equipe implementasse tudo, mas sim que eles parassem de falar que a lang tem features que ainda não tem. Novamente, a questão do null safety, que está no README do repositório mas ainda não foi implementado.

O gerenciamento de memória, pelo menos da ultima vez que vi, estava horrível também. O sistema "inovador" de gerenciamento de memória dela (que é só inserir varios free ao transpilar para C) aumentava o memory leak.

Já fazem cerca de dois anos desde a ultima vez que tentei usar. Vou repetir alguns testes e ver se algo mudou, mas com pouca fé.

1

Put's, de fato essa quebra de espectativa é ruim mesmo!

Olha sobre essa parte do warning de uso de nil, ou eu ou o post está errado.
Mas olha esse link e faz uns testes https://play.vlang.io/?query=7303deca28
Deixei algumas partes comentadas só para melhorar no teste.

E ele não permite nem compilar(falha com o C), e mesmo assim só é possível utilizar em um bloco unsafe, se o método estiver com um atributo unsafe, ainda assim não é suficiente, porque para cada uso inseguro que a linguagem não recomenda, precisa estar em um bloco unsafe assim como qualquer linguagem, mas cada linguagem possuí sua régua do que é seguro ou não.

E o gerenciamento de memória atual está de fato ruim. Eu esperava que fosse melhor, hoje ficou por padrão o uso de GC, porém ainda está em constantes melhoras(até porque o nativo não pode ter sobrecarga de GC) o gerenciador de memória da linguagem, mas eu to torcendo pra que no final possamos usar tudo o que foi prometido.

(Não sei você, mas eu acho massa demais não precisar estar dando free e vendo onde a memória pode vazar, e com custo zero!(só precisa funcionar 🤣🤣). E eu falo isso porque esses dias tive que estudar um vazamento de memória de um app grande desenvolvido com delphi, não foi uma tarefa trivial. Um free simples depois de um uso é tranquilo, mas tem as passagens de referências de onde começa e onde termina, mas isso você já sabe 😜.)

E vlw demais, esse assunto ta rendendo de uma forma massa! 💪🏻

1
1

Vou sugerir a alteração hoje lá no discord...

Mas a questão do nil, já era possível fazer, só introduziram uma palavra chave para isso.
Eu acho que está tendo uma certa confusão sobre null.

Olha essa delícia aqui https://www.baeldung.com/scala/nil-null-nothing-unit-none. Todos os sabores de null possível, cada lang tem sua abordagem...

Mas eu acho que o mais sensato é o que o C#(acredito que tenha outras que faça o mesmo) vem fazendo em torno do null, usando Nullable<T>.
Lê só https://carlosschults.net/pt/null-problematico. Aqui ele vai falar do início do problema até como contornar esse vício de uso.
Independentemente da linguagem sempre vamos querer tratar a falta de um dado com outra coisa e não com um dado assim... "" ou 0 ou até mesmo Class(instanciada, mas sem valor concreto!). Sempre setimos a necessidade de representar essa ausência de dado.

A maioria do que falo acima, é baseado em muito achimos de uso diário!

1

A moeda sempre tem 2 lados,
Nunca tinha ouvido falar disso, minha analise não é em relação "ao que ocorreu", mas aos comportamentos,
Neste "mundo atual de tecnologia" sempre esperamos o perfeito e melhor (que o anterior), dificilmente damos chance à evolução de algo que iniciou "do zero",
Por outro lado, quem desenvolveu, (às vezes, ) tem "amor" pelo que fez, e reluta em aceitar críticas.
Mas os dois lados, estão certos e errados em parte, o meio termo seria o ideal, mas muitas vezes é dicifil de encontrar.

1
3

Ai eu encontrei Vala, Nim, Zig e claro V.

Uau, não pensei que conheceria outro brasileiro com conhecimento nessas linguagens de baixo nível exóticas kkkkk

Eu já dei uma olhada no Nim e Zig, ja comecei a estudar um pouco de Nim até, mas Vala e V eu tinha visto muito pouco sobre

Vendo o que você falou ela está me parecendo bem legal, e já estou com vontade de hospedar uma instância desse servidor git escrito em V, mas meu amor por Nim não passa não. Quando sua linguagem escrever macros usando AST a gente conversa

Fora isso, já estou inscrito no canal, e curioso em ouvir algum conteúdo dessas linguagens estranhas no nosso PT-BR

1

Pow massa demais, o que mais gosto muito desses "transpiladores", por que reaproveita coisa demais da linguagem de back.

Sobre essa macro AST, me dá um exemplo não entendi muito bem, é macro tipo C(usando dfine)?

E vlw demais por me seguir...

1

Primeiro, quero esclarecer que a mensagem "Quando sua linguagem escrever macros usando AST a gente conversa" foi só uma piada. Lendo de novo está me soando meio passivo-agressivo kkkkk

Então, existem dois tipos de "macros"

Templates

referencia

aqui é bem estilo do define do C, parafraseando os docs

Templates are a simple substitution mechanism that operates on Nim's abstract syntax trees


They integrate well with the rest of the language and share none of C's preprocessor macros flaws

template `!=` (a, b: untyped): untyped =
  # this definition exists in the System module
  not (a == b)

assert(5 != 6) # the compiler rewrites that to: assert(not (5 == 6))

Obs: sobre o `!=`, Nim pode criar operadores assim, mas se removesse os ` e colocasse um nome valido, teria mais cara de função

macros

Esse é o que usa AST. ela é estilo uma função que recebe a AST de um bloco, e retorna uma nova, nem eu entendo mais a fundo como ela funciona, mas é basicamente isso. Recomendo que veja exemplos aqui

E isso permite umas coisas muito legais na linguagem, por exemplo

  • nimsl | uma biblioteca que permite transformar diretamente código Nim em GLSL (linguagem que roda na GPU)
  • wxnim | biblioteca de GUI que uma uma macro para ter uma criação de interfaces mais declarativas
#exemplo wxnim, que é código valido em nim
Panel | Boxsizer(orient = wxHorizontal):
  StaticBox(label = "Basic controls") | StaticBoxSizer(orient = wxVertical):
    Button: "Click me!"
    CheckBox: "Check me!"

Para finalizar, leve tudo isso com um grão de açucar, eu não fiz muito mais que um hello world até então 😅

1

Fica tranquilo bicho, entendi a piada, 'kkkkkkkk
Agora, deixa te contar isso é quase como generics pra mim, levou um tempo para entender o funcionamento, mas depois foi lindo 🥹

Vou estudar o nim, porque gostei da forma de criar um operador, algo que poucas linguages tem!

1

Ela ainda tem como fazer operadores de prefixo, então um #variavel pode retornar o tamanho dela, igual um Length Operator.

Mas o Nim é uma linguagem que eu achei muito dahora, só preciso de um bom motivo para aprender ela, por que hoje em dia parece ser muito mais fácil fazer tudo em js mesmo 😅

2
2

Lendo o site da linguagem, eu vi algumas coisas que podem interferir nisso.

Lá eles fizeram comparações com Go, Rust e Nim. Eles dizem que têm uma filosofia muito diferente dessas linguagens.

O objetivo deles é ser uma linguagem simples, previsível e sustentável. Rust tem uma curva de aprendizado muito acentuada, mas admitem que uma vez que você aprende Rust, você tem uma ferramenta muito poderosa para desenvolver software seguro, rápido e estável.

Também tem isso aqui:

V is not going to change much, if at all.

"V não vai mudar muito, se é que vai mudar"

1

Isso, é mas como foi o python 2 para o 3.
A ideia é não ter um 2 que muda de forma "estranha" para o 3.

Mas atualmente teve algumas várias mudanças...
Propriedades de struct opcionais, algo que tava bem consolidado(sem o opcional de prop).

E sobre a comparação, é inevitavel 'kkkk
Mas como falei Rust realmente a curva de aprendizado é mais acentuada, porém muito poderosa até porque vai ser usada para o kernel do linux.

Ah, uma coisa legal a se falar é... a versão 0.0.1 do V foi construída com Go e depois V se auto compilou(fluxo natural) e hoje V gera V.
Por isso o esquema de thread é idêntico ao de GO usando canais.(acho que a troca de contexto do GO mais rápida)

1

Tenho sim(eu acho que esse o um dos maiores motivos) o lançamento inicial... Tem muita coisas que a comunidade quer por antes do lançamento inicial do 1.0, estamos atualmente na 0.3.2. E tem mais pessoas falando sobre esse atraso de lançamento vê a opnião desse cara -> Erik Engheim(Medium)

Mas uma coisa que esqueci de dizer acima é, vamos fazer um barulho na comunidade, entrem lá no canal do discord, eu to lá também no servidor em português... Tem mais uma galera massa lá. Eles todos são muito amigavéis e ajudam bastante!!
E esse é o momento de dá sugestões de sintaxe, estratégias, e todo tipo de pitaco 😄.

2

Legal. Eu também encontrei V depois de ficar meio frustrado com Rust.
No começo da pandemia, fiquei uns 3 meses trabalhando pouco e remoto, com tempo sobrando, aí comecei a aprender V por hobby. Cheguei até a fazer uns PRs em SumType.
Mas depois acabou a moleza e eu tive que voltar a trabalhar :(
Eles estão fazendo progresso, em várias áreas, incluindo memory safety, mas eles são poucos desenvolvedores, sem nenhuma empresa grande usando a linguagem e bancando parte do desenvolvimento, o que faz com que o progresso seja devagar.
Nunca encontrei uma comunidade tão amigável quanto V. Existem gênios contribuindo ali.
É claro que houve erros no passado, principalmente nas promessas, putz, mas atire aí a primeira pedra quem sempre entrega os projetos no prazo, com todas as funcionalidades prometidas :)
E pelo que pude eu mesmo identificar, existe uma minoria barulhenta, capitaneada por uma pessoa que foi banida da comunidade, que tem por diversão vomitar as críticas de sempre no Reddit e no news do ycombinator contra o V. Eles simplesmente amam odiar.
Queria muito que a linguagem ganhasse momentum, mas infelizmente não vejo isso ...

1

Tenho uma certa resistência a linguagens que traduz para outras langs, o que é um pouco contraditório já que uso TypeScript 😂.

Mais quando preciso de uma linguagem de baixo nível gosto mais de usar langs como o Rust(E sim ele é mais "chatinho" de se acostumar, mais quando se acostuma se torna uma linguagem boa de se usar).

Dessas linguagens que você mencionou só conhecia o Vala que eu até cogitei estudar, parecia ser bem legal, mais essa parte de traduzir para C me desaminou um pouco(Não que isso seja rui).

Parabéns pelo post, é bem legal conhecer essas linguagens("Invisíveis") que acaba passando despercebido no nosso dia a dia.

1

Passo pelo mesmo problema 🤣. Em um segundo tô "nossa, como o ecossistema js cresceu para precisar de transpilação de tipagem, minificação bundle..." E no outro tô "wow, a compatibilidade de uma linguagem que compila para C é incrível, poder distribuir código e compilar usando só o gcc, revolucionário!"

1
1

Não sei, mas apartir do próximo mês vou iniciar o meu canal com uma playlist sobre V e C#. Ai se quiser ver coisas massas para fazer com V, segue lá... @Andreldev no minímo vai ser divertido 😄.

1
1

parece ser uma linguagem incrível realmente e parabéns por trazer esse conteúdo, vou manter ela no radar e acompanhar as novidades 🍷🗿

1

Cara que conteúdo fantástico!!
@Andreldev é a primeira vez que ouço falar de Vlang e você a descreveu de forma tão rica, parabéns e obrigada por compartilhar. Sucesso.

1
1
1