Hive
type Tick {
Hit
Seen { count: Int }
}
// Uma mensagem por vez, então a contagem não precisa de lock.
proc counter(count: mut Int, tick: Tick): Tick {
count += 1
return Tick.Seen(count)
}
proc handle(req: hive.net.HttpRequest): hive.net.HttpResponse {
plain := [["Content-Type", "text/plain"]]
Address<Tick> service = at(#Hits)
// Perguntar a um serviço dá um Result: ele pode estar fora.
if service(Tick.Hit()) is Result.Ok(Tick.Seen(n)) {
return hive.net.HttpResponse(200, plain, "visita {n}\n")
}
return hive.net.HttpResponse(503, plain, "tente de novo\n")
}
proc main(): void {
if spawn(counter, 0, #Hits) is Result.Error(err) {
panic err
}
hive.net.httpServe(8080, handle)
}Por que escolher o Hive
O Hive serve para o seu próximo projeto?
Combina bem com
APIs web e serviços de backend
HTTP, SQL e JSON estão na biblioteca padrão.Sistemas espalhados por várias máquinas
A distribuição faz parte da linguagem, não é um framework acoplado.Software que precisa rodar em todo lugar
Um só código para o desktop, o servidor, o navegador e o celular.Ferramentas de linha de comando e internas
Um arquivo para distribuir, e nenhum runtime para instalar.Times que não querem surpresas em produção
O que seria uma falha às 3 da manhã vira um erro de compilação.Pense duas vezes se
Você precisa de estabilidade de longo prazo hoje
O Hive é jovem — ainda não chegou à 1.0 — e ainda muda de uma versão para outra.Você depende de integração profunda com o editor
Ainda não há language server. Os erros vêm como arquivo:linha, que qualquer editor sabe abrir.Você precisa controlar a memória manualmente
O Hive tem coleta de lixo, como o Go para o qual ele compila.O que falharia não compila
Referências nulas, exceções não tratadas e índices fora do intervalo estão entre as causas mais comuns de falhas em produção, e no Hive nenhuma delas pode acontecer. Tudo que pode falhar devolve um Result, e o compilador obriga você a verificá-lo antes de tocar no valor dentro dele. Um índice que ele não consegue provar seguro é um erro de compilação, e o erro diz como corrigir. Até uma divisão por zero é um valor, não uma falha.
Os erros que apareceriam em produção aparecem enquanto você ainda está escrevendo o código.
type User {
name: Str
email: Str
}
func find(users: User[], name: Str): Result<User, Str> {
for each user in users {
if user.name == name {
return Result.Ok(user)
}
}
return Result.Error("ninguém se chama {name}")
}
proc main(): void {
users := [User("ada", "[email protected]")]
if find(users, "ada") is Result.Ok(user) {
echo user.email // [email protected]
}
if find(users, "alan") is Result.Error(why) {
echo why // ninguém se chama alan
}
// echo find(users, "ada").email — recusado: não é um User
}Um código, todas as plataformas
O mesmo código Hive roda no Windows, no Linux e no macOS, no navegador via WebAssembly, em um contêiner e no Android. Escolher a plataforma é uma flag na build, não uma reescrita do programa — nenhuma toolchain separada, e nenhum compilador C para instalar. No desktop e no servidor, uma build é um único executável nativo, sem runtime para entregar junto.
As interfaces vão junto. Uma view do hive.ui é desenhada como uma janela de desktop, servida como uma página web, ou empacotada como um app Android — a mesma view, sem mudar nada.
Comece como um processo, cresça para muitas máquinas
A concorrência no Hive é construída em torno de serviços: um pedaço de estado que trata uma mensagem por vez, então não há locks para errar. Chamar um serviço em outra máquina é a mesma linha de código que chamar um no mesmo processo, sobre conexões que já vêm criptografadas e autenticadas.
Um sistema pode começar como um único executável e ser espalhado por várias máquinas depois, sem ser reescrito em torno de uma fila de mensagens ou de um framework de RPC.
type Note {
Say { text: Str }
Heard { count: Int }
}
// Trata uma mensagem por vez: sem lock, onde quer que rode.
proc inbox(count: mut Int, note: Note): Note {
count += 1
return Note.Heard(count)
}
proc main(): void {
if hive.syslink.listen("10.0.0.1:9100") is Result.Error(e) {
panic e
}
if spawn(inbox, 0, #Inbox) is Result.Error(e) {
panic e
}
Address<Note> here = at(#Inbox) // nesta máquina
Address<Note> there = at("10.0.0.2:9100", #Inbox) // em outra
// A mesma chamada nos dois casos. A segunda atravessa a
// rede, criptografada e autenticada.
echo here(Note.Say("oi"))
echo there(Note.Say("oi"))
}Menos para instalar, menos para auditar
A biblioteca padrão cobre o que a maioria dos serviços precisa, então um projeto começa sem dependências e tende a continuar com poucas. Os padrões dela são os seguros: valores de SQL sempre vão como parâmetros, segredos não vão parar num log por acidente, e as máquinas só conversam entre si sobre TLS.
Quando você precisa de um pacote, ele é importado direto do repositório git dele e fixado em um commit — não há nenhum registro no meio. E um arquivo Go pode ser importado diretamente, trazendo junto todo o ecossistema Go.
Uma ferramenta, da primeira linha à produção
O comando hive checa, roda, testa e constrói, e a única outra coisa de que ele precisa é o Go. Testes fazem parte da linguagem e toda execução reporta a cobertura, então não há framework de testes para escolher.
O hive analyze aponta o código que vai sair caro antes mesmo dele rodar, e todo erro que o compilador reporta diz qual é o problema e como corrigir.
Este site é um programa Hive
Toda página aqui é servida por um servidor HTTP escrito em Hive e montada com a própria biblioteca de UI do Hive — sem framework web, e sem JavaScript além do único script que roda os exemplos do tour no seu navegador. O site inteiro é um único executável, publicado em um contêiner.
85 slides curtos, e você conhece a linguagem
Cada exemplo é um programa completo, que você pode copiar e rodar. Comece do início, ou vá direto ao que precisa pelo sumário.Primeiros passos
Controle de fluxo e funções
Vetores, limites e tabelas
Tipos, padrões e valores
Módulos, testes e leis
Threads e serviços
A biblioteca padrão
Janelas, canvases e cenas
Ferramentas
- Primeiros passos
- Controle de fluxo e funções
- Vetores, limites e tabelas
- Tipos, padrões e valores
- Módulos, testes e leis
- Threads e serviços
- A biblioteca padrão
- Janelas, canvases e cenas
- Ferramentas