Ecossistema e design

Os dez princípios, medidos

Cada princípio com a frase do documento, o que ela significa aqui, o veredito e uma prova que roda — duas delas chamam o analisador e uma abre um interpretador.

A referência fecha com dez princípios de design. Uma lista de princípios é o texto mais fácil de escrever num projeto e o mais fácil de não cumprir: ninguém a executa, e por isso ela nunca reprova.

Aqui cada princípio carrega cinco coisas, e a terceira é a que muda o gênero do texto:

Campo	O que é
`no_documento`	a frase como a referência a escreve
`aqui`	o que ela significa nesta implementação
`veredito`	`cumprido`, `parcial` ou `nao-se-aplica` — e a lista é fechada
`prova`	uma medida que roda, e o número que ela deu
`custo`	o que foi entregue em troca

bash

dataforge principios             # os dez, medidos
dataforge principios --tensoes   # so onde dois se contradizem
dataforge principios --json      # como dado

O veredito não é dez de dez, de propósito#

Cinco cumpridos, quatro parciais, um que não se aplica. Um relatório que aprovasse os dez seria a prova de que ninguém o leu.

dataforge

adopt Arcane.Principios as Prin

v := Prin.veredito()
assert v["total"] is 10
assert v["cumprido"] bigger 0
assert v["parcial"] bigger 0

// A prova RODA: ela nao repete o texto, ela mede
p := Prin.conferir("compile-time-first")[0]
assert p["veredito"] is "parcial"
assert "4 de 4" in p["medido"]
out p["medido"]

As provas que rodam de verdade#

Três das dez não consultam tabela nenhuma: elas executam o analisador ou o interpretador, porque "verificação antes de rodar" e "custo zero quando desligado" não são frases — são coisas que se demonstram ou não se demonstram.

Princípio	O que a prova faz	O que ela mediu
`compile-time-first`	roda o `check` sobre quatro trechos com defeito conhecido — índice fora do alcance, chave ausente, laço que nunca roda, igualdade impossível	4 de 4 acusados antes de rodar
`custo-zero`	cria um blueprint sem contrato, invariante nem modificador e olha o que ele carrega	3 de 3 sentinelas em `None`, 2 de 2 atalhos de acesso ligados
`seguranca-por-padrao`	roda o `check` sobre um `thread` que escreve num nome de fora e olha a severidade	sai como `warning` — e não como `error`
`interoperabilidade`	adota um módulo do Python de verdade	a ponte resolve
`runtime-modular`	abre um interpretador sem nenhum `adopt`	0 módulos carregados, 0 dependências externas

O que "custo zero" quer dizer aqui — e por que o veredito é `nao-se-aplica`#

O documento diz: abstrações de alto nível devem compilar para código equivalente a implementações manuais. Não havendo compilação para código nativo, a frase não tem como valer, e forçá-la a valer seria redefini-la em silêncio.

Então o veredito é nao-se-aplica — e há outra leitura que vale, é cobrada e foi medida: uma abstração custa zero para quem não a usa.

Leitura	Como é cobrada
contrato, sobrecarga, `exclusive`	`DFAction.extras` é `None`
invariante na linhagem, metaclasse com gancho	`DFBlueprint.vigias` é `None`
congelado, travado, `lazy`, `readonly` em construção	`DFInstance._estado` é `None`
propriedade, descritor, `__getattribute__`	`leitura_simples` e `escrita_simples` continuam ligados

Os dez, em resumo#

#	Princípio	Veredito	O limite
1	segurança por padrão	`parcial`	o analisador é otimista: a escrita concorrente é aviso, não erro
2	custo zero	`nao-se-aplica`	não há compilação nativa; vale a leitura "custa zero quando desligado"
3	controle explícito de recursos	`cumprido`	controla-se o protocolo e o coletor, não a alocação
4	compile-time first	`parcial`	quando não consegue provar, cala — e os silêncios estão listados
5	interoperabilidade	`cumprido`	depende de tratar objeto estranho por protocolo, em todo o caminho
6	portabilidade	`parcial`	é herdada do CPython: é o que dá ARM de graça e o que põe o teto
7	performance observável	`cumprido`	medir e ler erram de formas opostas, e por isso existem as duas
8	extensibilidade	`cumprido`	palavra nova entra como contextual, ao custo de complexidade no parser
9	runtime modular	`cumprido`	zero dependência: criptografia e formato de arquivo escritos aqui
10	escalabilidade técnica	`parcial`	kernel, bare-metal e microcontrolador estão fora, e são nomeados

Cada linha da tabela aponta um arquivo. É o que a próxima página usa: onde dois princípios se contradizem, e qual venceu.