O logo do Hive: uma abelha sobre um favo de mel

Hive

Uma linguagem compilada sem exceções durante a execução e com leis que o compilador prova, feita para sistemas distribuídos, que roda em qualquer lugar e é pequena o bastante para se aprender em um dia.No Hive, os erros que outras linguagens deixam para a produção viram erros de compilação: não existe null, nada é lançado, e todo índice é verificado. Você também escreve leis sobre o seu código, os seus tipos e as suas tabelas, e o compilador as prova para todo valor possível. HTTP, SQL, JSON, criptografia, UI e serviços entre máquinas já vêm com a linguagem, e o mesmo código roda no Windows, Linux, macOS, navegador e Android.
Um serviço web completo, com estado compartilhado
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

Sem falhas em produçãoSem null, sem exceções, sem índice fora do intervalo: o que falharia em outra linguagem não compila.
Roda em qualquer lugarO mesmo código no Windows, Linux, macOS, navegador, contêiner e Android.
Um processo ou muitas máquinasChamar um serviço pela rede é exatamente igual a chamar um local.
Segura por padrãoConexões criptografadas entre máquinas, SQL à prova de injeção, e segredos que nunca chegam a um log.
Baterias inclusasHTTP, SQL, JSON, criptografia e uma biblioteca de UI vêm com a linguagem.
Produtiva em um diaUma linguagem pequena. Este tour cobre toda ela, um recurso por vez.

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.

Uma busca que pode voltar vazia
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.

O mesmo app.hive, em seis lugares
Windowshive build app.hive --target windows/amd64
Linuxhive build app.hive --target linux/arm64
macOShive build app.hive --target darwin/arm64
Navegadorhive build app.hive --target js/wasm
Contêinerhive container app.hive
Androidhive export app.hive --target android/arm64

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.

O mesmo serviço, aqui e em outra máquina
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.

Na biblioteca padrão
hive.netHTTP, WebSockets e TCP
hive.sqlSQLite e PostgreSQL
hive.jsonJSON, no formato dos seus tipos
hive.cryptoHashes, criptografia e JWTs
hive.syslinkServiços entre máquinas
hive.uiInterfaces de desktop, web e Android
hive.ui.sceneCenas 3D e som
hive.fileArquivos e pastas
hive.termO terminal e outros programas
hive.timeDatas, horas e fusos horários
hive.envConfiguração pelo ambiente
hive.mapDicionários

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.

O comando hive
hive checkEncontra todo erro, não constrói nada
hive runCompila e roda em um passo
hive testRoda os testes, com cobertura
hive analyzeAponta código caro antes de rodar
hive buildUm executável nativo, ou WebAssembly

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