glide

Comparação

Glide vs Go.
Uma comparação justa.

As duas linguagens oferecem corrotinas M:N, canais e uma toolchain de binário único. A linguagem de programação Glide de Murillo Deolino adota padrões diferentes do Go em quatro pontos: segurança de memória (em tempo de compilação vs GC), generics + traits, erros como valores e a expressividade do sistema de tipos.

gc

Sem coletor de lixo

Go depende de um GC de rastreamento concorrente — conveniente para o desenvolvedor, mas com sobrecarga constante de CPU e picos ocasionais de latência que importam em loops críticos, sistemas de baixa latência e alvos com pouca memória. Glide usa empréstimos delimitados por escopo e arenas: o compilador rastreia a posse em tempo de compilação, a liberação acontece ao sair do bloco, sem rastreamento em tempo de execução. O modelo mental é mais próximo de Rust do que de Go, mas sem necessidade de escrever anotações de tempo de vida.

glide.glide 
fn parse_tree() {
    let arena: *Arena = Arena::new(4096);
    defer arena.free();
    let n1: *Node = arena.create(Node);
    let n2: *Node = arena.create(Node);
}                              // arena liberada de uma só vez
go.go 
func parseTree() {
    n1 := &Node{}
    n2 := &Node{}
    _ = n1; _ = n2
}                              // GC coleta quando quiser
!T

Erros como valores, mas tipados

O modelo de erros do Go é "retorne um valor e um erro, verifique if err != nil em cada linha". O padrão funciona, mas é verboso, e o sistema de tipos não o impõe — você pode ignorar um erro e o compilador fica em silêncio. O !T do Glide é um único valor, o sufixo ? propaga falhas em um único caractere, e o compilador trata um !T não tratado como erro grave. Mesma semântica, um terço do código repetitivo.

glide.glide 
fn read_all(p: string) -> !string {
    let data: string = fs_read(p)?;
    let trimmed: string = data.trim();
    return ok(trimmed);
}
go.go 
func readAll(p string) (string, error) {
    data, err := os.ReadFile(p)
    if err != nil {
        return "", err
    }
    return strings.TrimSpace(string(data)), nil
}
<T>

Generics reais + traits, monomorfinizados

Go adicionou generics na versão 1.18, mas são limitados (sem parâmetros de tipo em nível de método, sem tipos associados, sem especialização), e a implementação usa passagem de dicionário para tipos não compatíveis com shape — sobrecarga em tempo de execução. Os generics do Glide são monomorfinizados em tempo de compilação (uma função C por tipo concreto) com traits, supertraits, métodos padrão, tipos associados e despacho via vtable com *dyn Trait — mais próximo de Rust do que de Go, com total expressividade em nível de tipos.

glide.glide 
trait Render {
    fn render(self: *Self) -> string;
}

impl Render for Box {
    fn render(self: *Box) -> string {
        return "Box";
    }
}

fn show<T: Render>(v: *T) {
    println!(v.render());
}
chan

Concorrência, a forma que você já conhece

É aqui que Glide se inspirou mais no Go: corrotinas M:N via spawn (equivalente ao go do Go), canais tipados via chan<T>, multiplexação de múltiplos canais via select! (equivalente ao select do Go), e recebimentos com detecção de fechamento via while let v = c.recv(). Se você é programador Go, a superfície de concorrência parecerá familiar — apenas a sintaxe é ligeiramente diferente.

glide.glide 
fn producer(c: chan<int>) {
    for i in 0..3 { c.send(i); }
    c.close();
}

fn main() -> int {
    let c: chan<int> = make_chan(2);
    spawn producer(c);
    while let v = c.recv() { println!(v); }
    return 0;
}

Quando escolher cada um

Os dois oferecem ciclos de iteração rápidos e boa concorrência. Escolha com base no que te prejudica em produção.

Escolha Go se…

Você precisa do ecossistema massivo (Kubernetes, Docker, toda ferramenta CNCF). Está montando uma equipe que precisa aprender em dias, não semanas. Pausas do GC são aceitáveis para sua carga de trabalho (~99% dos serviços). Você valoriza estabilidade de ferramentas acima de expressividade da linguagem.

Escolha Glide se…

Você quer concorrência no estilo Go sem pausas de GC ou sobrecarga de runtime. Precisa de generics e traits de verdade, não apenas funções parametrizadas por tipo. Quer a ergonomia do if err != nil sem a verbosidade. Está visando binários menores e menor uso de memória.

Experimente Glide

Linux / macOS

$ curl -fsSL https://glide-lang.org/install.sh | bash

Windows (PowerShell)

> iwr https://glide-lang.org/install.ps1 -UseB | iex