Outro salto que dei no mundo de programação com IA foi o Claude Sonnet 4.5 via web. O chat me devolvia códigos que funcionavam com quase nenhum erro mas também não era prático de se usar, já que tinha que ficar baixando os arquivos em cada diretório sem me perder. Aqui já estava colocando projetos no ar.

O próximo passo aconteceu quando a OpenAI liberou o Codex para usuários com plano gratuito recentemente. Experimentei e fiquei espantado com a praticidade e qualidade do código gerado. Eu simplesmente abria o Codex no diretório do projeto, pedia para analisar e me ajudar com uma nova funcionalidade. Ele fazia, corrigia eventuais erros de compilação que ele criava e eu tinha algo funcional com uma ou duas iterações no máximo.

Contudo, não existe almoço grátis. Me deram uma amostra, me fizeram sentir o gosto do banquete para logo depois me negar a entrada. Continuei o ritmo de desenvolvimento tentando de todas as formas contornar os limites, só para me frustrar ainda mais. Era como uma droga, quanto mais usava, mais precisava daquilo. Continuar sem era enfadonho.

Comecei a brincar com o Groq e sua API gratuita para inferência com modelos como GPT-OSS 120B, 20B e Llama 70B-versatile. Para conversação e tradução eram ótimos modelos. Integrei eles em alguns projetos, mas não para programação. Não era viável com a qualidade dos modelos e tamanho do contexto que o Groq disponibilizava. Isso me deu a experiência de mexer programaticamente com APIs e LLMs.

Na mesma época houve o vazamento do código do Claude Code, o CLI do Claude para agentes de codificação. Li a análise do Akita sobre o código. Dei uma olhada nos ports que estavam fazendo para Python e Rust. Não havia muito código funcional. Larguei mão e segui a vida, mas aquilo me deixou com uma pulga atrás da orelha. “Não existe só o Codex. Também existem CLIs open source”.

Naquele ponto eu já tinha ouvido falar bastante do OpenCode. Decidi instalar e ver o que era aquilo. Se não tivesse nenhum plano ou uso gratuito, paciência, me contentaria em ver o código, já que era aberto.

Logo de cara me impressionei com a interface, bem melhor do que Codex e Gemini CLI. Havia algumas opções de providers como OpenAI, Anthropic, Zen e pra minha surpresa até mesmo Groq. O Zen, que é o padrão do OpenCode tinha alguns modelos disponíveis para uso sem que eu tivesse que caçar algum provider e chaves de API. Escolhi um modelo qualquer, já que não conhecia nenhum naquela lista: MiniMax M2.5

O Projeto de Teste

Não tinha coragem de usar aquilo em nenhum projeto rolando por preguiça mesmo. Queria subir o nível aos poucos para ver onde seria o limite, tanto de tokens quanto de qualidade de código. Escolhi algo que já fiz algumas vezes sozinho em mais de uma linguagem diferente: Um bot de xadrez.

Comecei pedindo que ele fizesse uma interface que processasse comandos no protocolo padrão chamado UCI(Universal Chess Interface). Ele fez sem dificuldades, e fez além. Implementou uma versão rudimentar de engine que lidava com regras de tabuleiro e peças, basicamente um jogo completo de xadrez via texto. Não cheguei a testar se aquilo realmente funcionava. Pedi para ele importar uma biblioteca que lidasse com essa lógica interna do jogo. Meu objetivo era fazer um bot que conseguisse jogar procurando o melhor lance. Não queria passar o resto da vida analisando casos raros onde as regras de jogo que ele implementou falhavam. Além disso, precisava de funções que gerassem listas com os lances possíveis na posição com a maior eficiência possível.

Em seguida pedi explicitamente por um bot que respondesse aos comandos UCI (a biblioteca cuidava disso) e respondesse com um movimento aleatório entre os movimentos possíveis na posição. Ele fez sem problemas.

Testes

Outro motivo pra eu ter escolhido essa tarefa foi o método de testar. Não é trivial saber quando houve uma melhora olhando apenas para o código. No passado, quando eu era mais ingênuo, eu compilava o bot e jogava contra ele. Funcionava bem no começo, quando o bot deixava de levar mate em um ou entregar peças valiosas eu sabia que havia melhorado. Mas pra todo o resto era muito subjetivo e difícil de mensurar.

Com o tempo descobri que existem outras bibliotecas que fazem torneios automatizados entre arquivos executáveis. Basta que o bot responda e se comunique em UCI para que possa ser testado. Pedi uma desse tipo e pedi que ele usasse a primeira que listou. Qualquer uma servia. Ele clonou o repositório de uma escrita em C e compilou sem qualquer problema. Pedi que ele explicasse o funcionamento. Eram comandos gigantes com dezenas de flags para se preocupar. Pedi um script que usasse a biblioteca com os caminhos dos executáveis. Por enquanto só tinha a versão 1 aleatória.

A biblioteca roda os binários e realiza um número predeterminado de jogos, cada versão jogando a mesma posição de brancas e de pretas. Peguei uma base de dados com jogos do Lichess. A base continha dados de partidas completas, mas a biblioteca exigia arquivos com aberturas. Pedi para o modelo pegar as partidas após os cinco primeiros lances. Não era perfeito, poderiam ter desigualdades e posições com vantagem para um dos lados, mas isso era razoavelmente mitigado já que havia a alternância das cores. Pegar posições de partidas reais é uma boa abordagem pois se começar as partidas a partir da posição inicial do Xadrez (eu já cometi esse erro) todas as partidas são praticamente iguais. A versão aleatória não seria afetada, mas as futuras sim.

Após o fim do torneio a biblioteca me devolve informações importantes como número de vitórias, derrotas e empates do modelo mais recente, junto com estimativas de ELO e LOS(Likelyhood of Superiority) que me ajudam a saber o quão melhor o bot ficou e se o resultado é estatisticamente confiável. Após uma mudança ou melhoria no bot o mínimo que tenho que fazer é rodar esse teste e saber interpretar os resultados para saber se não houve regressão.

Versão 2

Com uma forma objetiva de avaliar o progresso, podia finalmente começar fazer o código para o bot. Não vou me aprofundar nas técnicas que implemento no bot para encontrar bons lances, basta entender que ele faz uma busca em profundidade com uma função de avaliação.

Em outras palavras, ele faz o lance em um tabuleiro imaginário, executa a função que diz quanta vantagem ele tem, repete para todos os lances possíveis, depois faz o mesmo para todas as respostas do oponente, depois todas as respostas dele. Sempre indo uma camada mais profunda na busca.

Pedi ao modelo que implementasse uma iteração gradual e que mantivesse o melhor lance da camada anterior, assim o bot sempre teria uma resposta para dar quando o tempo que ele tinha para pensar acabasse. A versão 2 estava pronta. Caso queira pesquisar as técnicas utilizadas até aqui são MiniMax(não confundir com o nome da LLM, é só uma coincidência) e Iterative Deepening.

Como esperado, a versão 2 ganhou de lavada, mas ainda com algumas derrotas. Isso é interessante. Um modelo com uma função de avaliação que entende quanto material cada jogador tem consegue perder cerca de 16% das vezes para um bot que joga qualquer coisa. Isso pode acontecer pois esse método de busca é muito demorado. A segunda versão mal conseguia enxergar 2 ou 3 lances no futuro.

"stats": {
	"v0.2.0 vs v0.1.0": {
		"wins": 1658,
		"losses": 28,
		"draws": 314,
		"penta_WW": 684,
		"penta_WD": 267,
		"penta_WL": 23,
		"penta_DD": 21,
		"penta_LD": 5,
		"penta_LL": 0
	}
}

Observação: No torneio os bots têm 1 segundo para pensar em cada lance.

Versão 3 (Alpha-Beta Pruning)

A melhoria aqui é deixar a busca mais inteligente, cortando ramificações inteiras que sabemos que são ruins sem ter que vasculhar e avaliar. Assim sobrando mais tempo para vasculhar o que realmente importa.

Lembrando que no fim das contas o que estava fazendo era analisando o modelo e o OpenCode. Até aqui não tinha escrito, mexido ou sequer lido uma linha de código. Pedi para o modelo fazer tudo e ele fez tudo de primeira. Minha única preocupação era dizer quais melhorias fazer e ir com calma. Eu poderia desde o início pedir para ele fazer o bot mais forte quanto possível, mas queria ter controle sobre o processo e avaliar quão significativa cada passo seria no desempenho do programa.

O resultado foi de 18% derrotas da terceira versão contra a segunda.

"stats": {
	"v0.3.0 vs v0.2.0": {
		"wins": 264,
		"losses": 64,
		"draws": 22,
		"penta_WW": 102,
		"penta_WD": 12,
		"penta_WL": 48,
		"penta_DD": 2,
		"penta_LD": 6,
		"penta_LL": 5
	}
}

Observação: A primeira versão do bot não precisava pensar, então a execução do torneio era muito mais rápida que a segunda e a terceira que usam todo o tempo disponível. Para esse segundo torneio precisei diminuir o número total de partidas.

Versão 4 (Transposition Table)

A ideia dessa alteração é evitar cálculos desnecessários. No xadrez existe o que chamamos de transposições. São posições iguais que são alcançadas por meio de movimentos diferentes. Como o bot vasculha todos os movimentos possíveis, ele encontra várias posições iguais. Sempre que calculamos a avaliação de uma posição, guardamos ela em memória, e antes de calcular outras posições, verificamos se a posição já foi analisada antes.

Até aqui o modelo estava lidando muito bem com o trabalho de codificação e eu estava bastante impressionado. O resultado foi uma taxa de vitória entre 50-60%. Realizei o teste com um número de partidas suficiente para que a significância estatística fosse real, mas o resultado foi menor que o esperado.

Não estava fazendo nenhum versionamento de código. Isso me causou problemas no futuro. (Acabei apagando o registro do torneio)

Princípio do Fim

Existe algo chamado Efeito Horizonte em bots de xadrez. Acontece pois o cálculo e avaliação da posição acontece até um número limitado de lances futuros. Esse limite entre o que entra no cálculo e o que não entra pode ser no meio de uma troca. Por exemplo, no limite pode estar um movimento que uma Dama captura um Peão, o que é claramente um lance que ganha material. E é só isso que o bot enxerga. A avaliação parou antes de ver aquela Dama sendo recapturada por outra peça, o que configura uma perda de material (uma Dama vale bem mais que um Peão).

Algo semelhante acontece para xeques. O bot pode achar que está se defendendo de um xeque, quando na verdade está caminhando para um xeque-mate no lance seguinte. Isso acontece frequentemente em uma análise pouco profunda.

Para resolver isso podemos fazer uma busca especial somente em lances decisivos. Ou seja, não paramos a busca antes de capturas ou xeques, mas continuamos até que a posição estabilize e fique mais calma. Só então rodamos a função de avaliação.

Como sempre, pedi que o modelo executasse a alteração. Ele fez sem dificuldades e rodou o torneio, como já tinha se acostumado a fazer a essa altura.

Resultado: 50% de vitórias, nenhuma melhora real.

Os últimos dois torneios não tinham melhorado a força do bot substancialmente. Resolvi que era hora de criar o repositório antes de continuar. Eu estava guardando os executáveis de cada versão, mas não o código. A qualquer momento eu podia ter uma regressão e teria que confiar no modelo para retornar o código a como era antes.

Porém, fazendo uso de toda a inteligência que acumulei por 20 longos anos, antes de criar o repositório e salvar o progresso - e continuar o processo de melhoria sem preocupações - pedi para o modelo refatorar o código do núcleo do programa. O que poderia dar de errado, não é mesmo? XD

Resultado: 0% de vitórias, quebrou totalmente, de forma silenciosa.

Em teoria o bot deveria estar mais otimizado, sem realizar cálculos desnecessários. Na prática, eu não fazia ideia de como o código funcionava aquela altura. Pra piorar, não tinha uma forma clara de voltar atrás.

Depois de várias iterações investigando e debugando o código, o modelo ainda não faz ideia de qual foi o problema ou qualquer proposta para desfazer a alteração que introduziu o problema.

É nesses momentos que você deve parar, respirar fundo e refletir. Existem algumas lições aqui a serem aprendidas:

1. Nenhum projeto é tão pequeno que não mereça um repositório local. Ainda não tenho o costume de trabalhar com Git, uso somente para projetos que sei que vou manter. Pensei que não seria necessário para um teste rápido.

2. Não se atreva a fazer uma grande mudança antes de marcos importantes. A escolha do momento não poderia ter sido pior.

3. Modelos de linguagem são convictos e nada confiáveis. Tudo indica que as alterações que a IA me apresentou como pequenas melhorias causaram um erro silencioso, na lógica do programa, que causou uma mudança total no comportamento.

4. Não aceite alterações que não entende. Eu não busquei entender as alterações propostas pelo modelo. Confiei cegamente na análise dele devido aos resultado anteriores realmente satisfatórios.

Ele continuou por mais um tempo em loop de correção e testes, mas sem sucesso. No meio disso tudo ele acabou apagando os torneios recentes e escrevendo por cima com outras versões do bot já totalmente quebrado.

De certa forma alcancei um dos objetivos primários, atingir o limite do modelo. Agora eu sei até onde o modelo MiniMax M2.5 no ambiente do OpenCode consegue ir sem monitoramento pesado e expertise do usuário.

A ferramenta é realmente útil, mas sem meu esforço ativo na tarefa não vai longe. Com certeza modelos melhores como GPT 5.4, Claude Opus 4.6 ou Sonnet 4.6 chegariam um pouco mais longe, mas apesar de tudo isso ainda fiquei impressionado com o desempenho desse modelo. Não sei dizer quanto do mérito se deve ao OpenCode.

Os próximos passos são evidentes: Testar em projetos um pouco maiores e com outros modelos.

Sobre o bot, a solução seria uns bons dias lendo e testando o código linha a linha, mas o progresso que eu tinha até agora era tão pouco que seria mais prático simplesmente começar do zero.

Para começar vou explicar o processo para a rede neural mais clássica de todas. É como o Hello Word2 dessa área. A ideia não é ser estritamente técnico, mas dar uma noção para quem acha que é algo quase etéreo.

Qualquer tecnologia suficientemente avançada é indistinguível de magia. (Arthur C. Clarke)

O Problema

O problema XOR é simples: dadas duas entradas binárias, a saída é 1 se elas forem diferentes, e 0 se forem iguais.

A | B | A XOR B
--|---|--------
0 | 0 |    0
0 | 1 |    1
1 | 0 |    1
1 | 1 |    0

Nenhuma linha reta separa os casos onde a saída é 0 dos casos onde é 1. XOR não é linearmente separável, o que o torna o exemplo clássico para justificar redes com mais de uma camada. Diferente de um AND, por exemplo, onde é fácil da rede criar uma relação de proporcionalidade com os dados:

A | B | A AND B
--|---|--------
0 | 0 |    0
0 | 1 |    0
1 | 0 |    0
1 | 1 |    1

O Modelo

A rede que vamos treinar tem essa estrutura:

• Camada de entrada: 2 neurônios (os valores de A e B)

• Camada oculta: 2 neurônios

• Camada de saída: 1 neurônio

Em cada neurônio o que existe é uma série de multiplicações e uma soma. Cada conexão entre neurônios tem um peso, e cada neurônio tem um viés. A operação é:

saída = ativação( entrada₁×peso₁ + entrada₂×peso₂ + viés )

A função de ativação é o que introduz não-linearidade na rede — sem ela, empilhar camadas não ajudaria em nada, porque a rede seria só uma função linear proporcional a entrada. Usamos a sigmoide, que comprime qualquer valor real para o intervalo (0, 1):

sigmoid(x) = 1 / (1 + e^(-x))

O código abaixo implementa tudo isso do zero, sem nenhuma dependência externa. Todos os cálculos são feitos à mão:

import random
import math

# ── Funções base ──────────────────────────────────────────────

def sigmoid(x):
    return 1.0 / (1.0 + math.exp(-x))

def forward(inputs, weights_hidden, bias_hidden, weights_out, bias_out):
    # Camada oculta: 2 neurônios
    h0 = sigmoid(inputs[0]*weights_hidden[0][0] + inputs[1]*weights_hidden[0][1] + bias_hidden[0])
    h1 = sigmoid(inputs[0]*weights_hidden[1][0] + inputs[1]*weights_hidden[1][1] + bias_hidden[1])

    # Camada de saída: 1 neurônio
    out = sigmoid(h0*weights_out[0] + h1*weights_out[1] + bias_out)
    return out

def loss(weights_hidden, bias_hidden, weights_out, bias_out):
    # Dados XOR
    data = [([0,0], 0), ([0,1], 1), ([1,0], 1), ([1,1], 0)]
    total = 0.0
    for inputs, target in data:
        pred = forward(inputs, weights_hidden, bias_hidden, weights_out, bias_out)
        total += (pred - target) ** 2  # erro quadrático
    return total / len(data)

# ── Inicialização aleatória ───────────────────────────────────

random.seed(42)
weights_hidden = [[random.uniform(-1, 1) for _ in range(2)] for _ in range(2)]
bias_hidden    = [random.uniform(-1, 1) for _ in range(2)]
weights_out    = [random.uniform(-1, 1) for _ in range(2)]
bias_out       =  random.uniform(-1, 1)

# ── Treinamento por passo aleatório ──────────────────────────

best_loss = loss(weights_hidden, bias_hidden, weights_out, bias_out)

for step in range(100_000):
    # Escolhe um peso aleatório para perturbar
    layer = random.choice(['hidden', 'out', 'bias_h', 'bias_o'])

    if layer == 'hidden':
        i, j = random.randint(0,1), random.randint(0,1)
        old = weights_hidden[i][j]
        weights_hidden[i][j] += random.uniform(-0.1, 0.1)
        new_loss = loss(weights_hidden, bias_hidden, weights_out, bias_out)
        if new_loss < best_loss:
            best_loss = new_loss
        else:
            weights_hidden[i][j] = old  # reverte

    elif layer == 'out':
        i = random.randint(0,1)
        old = weights_out[i]
        weights_out[i] += random.uniform(-0.1, 0.1)
        new_loss = loss(weights_hidden, bias_hidden, weights_out, bias_out)
        if new_loss < best_loss:
            best_loss = new_loss
        else:
            weights_out[i] = old

    elif layer == 'bias_h':
        i = random.randint(0,1)
        old = bias_hidden[i]
        bias_hidden[i] += random.uniform(-0.1, 0.1)
        new_loss = loss(weights_hidden, bias_hidden, weights_out, bias_out)
        if new_loss < best_loss:
            best_loss = new_loss
        else:
            bias_hidden[i] = old

    else:
        old = bias_out
        bias_out += random.uniform(-0.1, 0.1)
        new_loss = loss(weights_hidden, bias_hidden, weights_out, bias_out)
        if new_loss < best_loss:
            best_loss = new_loss
        else:
            bias_out = old

# ── Inferência ───────────────────────────────────────────────

print(f"Erro final: {best_loss:.4f}\n")
for inputs, target in [([0,0], 0), ([0,1], 1), ([1,0], 1), ([1,1], 0)]:
    pred = forward(inputs, weights_hidden, bias_hidden, weights_out, bias_out)
    print(f"{inputs} → {pred:.3f}  (esperado: {target})")

Treinamento é o loop de 100 mil passos. Em cada iteração, o algoritmo escolhe um peso qualquer da rede e o altera um pouco. Depois calcula o erro total sobre todos os quatro exemplos XOR. Se o erro caiu, mantém a mudança. Se piorou, reverte. Simples assim — nenhuma matemática sofisticada, só tentativa e erro.

Inferência é o que acontece depois do treino, quando a rede já está pronta — entenda rede como um conjunto de pesos e vieses, nesse caso 6 pesos e 3 vieses. Você passa uma entrada pelo forward e lê a saída. Nenhum peso muda. A rede agora é uma função fixa que aprendeu a imitar o padrão.

A função de erro (ou loss) mede o quão longe as previsões estão das respostas certas. Aqui usamos o erro quadrático médio: para cada exemplo, eleva ao quadrado a diferença entre o que a rede previu e o que era esperado, e tira a média. Quanto menor, melhor.

O resultado após o treino se parece com isso:

Erro final: 0.0023

[0, 0] → 0.047  (esperado: 0)
[0, 1] → 0.956  (esperado: 1)
[1, 0] → 0.957  (esperado: 1)
[1, 1] → 0.051  (esperado: 0)

A rede não memorizou uma tabela. Ela encontrou pesos que, quando combinados pelas operações matemáticas de cada neurônio, produzem os valores certos. Isso é o que existe dentro de qualquer rede neural, independente do tamanho.

Observação: técnicas como o gradiente descendente — que ao invés de alterar os pesos às cegas calculam a direção exata em que cada peso deve se mover para reduzir o erro — dão um salto enorme na velocidade e eficiência do treinamento. Mas o objetivo é o mesmo: encontrar os pesos certos. O método muda, a essência não.

O resultado desse processo, quando o erro fica abaixo de um certo limite aceitável, é uma rede capaz de prever o padrão nos dados de treino.

Coisas como número de neurônios são diretamente proporcionais ao número de padrões que podem ser potencialmente aprendidos (existe um fator exponencial aqui).

Modelos de Linguagem

Uma LLM(Large Language Model) é um modelo de rede neural grande feito para aprender padrões de linguagem. Ele tem uma estrutura em camadas com neurônios que fazem as mesmas operações que acabei de descrever. São multiplicações e somas. O que muda? Os dados de treinamento.

LLMs são treinadas com quantidades colossais de textos escritos por humanos. Até que ponto uma máquina é inteligente por imitar padrões criados por uma inteligência real?

Qual a diferença entre imitar esse padrão e reproduzir um debate ou discurso altamente inteligente em texto ou vídeo? Estou falando de reprodutor mesmo, no sentido de arquivos de vídeo ou .txt.

Claramente existe uma diferença aqui. A adaptabilidade. LLMs já se mostraram úteis para resolver novos problemas pela aplicação de técnicas já conhecidas. Encaixando um padrão no outro ela consegue gerar uma resposta e manter uma conversa totalmente nova a cada vez.

Treinamento

O treinamento é apenas ajuste de parâmetros — pesos e vieses, que serão multiplicados e somados — então existe um processo ordenado. Saímos de parâmetros aleatórios para uma sequência bem específica que processa entradas em saídas desejadas.

Overfitting é um problema bem conhecido que descreve quando o treinamento passou do ponto. É quando o treinamento dura demais fazendo o modelo ficar tão preso aos dados do treinamento ao ponto de ser inútil para outros dados que ele nunca viu.

Overfitting vs Generalização é um balanço bem subjetivo que depende do uso que farão do modelo. Prender-se aos dados te dá respostas objetivamente mais confiáveis, mas cada vez mais inúteis para problemas novos. Do outro lado da moeda, treino de menos faz um modelo flexível de mais, que não internalizou padrões e não fala coisa com coisa.

Comparar o modelo do exemplo com LLMs é como comparar o conceito de formas básicas do desenho com o teto da Capela Sistina. É comparar um bebê aprendendo a andar e um ginasta olímpico. Ainda assim, existe semelhança na essência da atividade. A diferença não é qualitativa, a ação não mudou. É quantitativa, a potência mudou.

Sei que o exemplo que dei é simples, mas quero tentar extrapolar para redes maiores, da ordem de centenas de bilhões de pesos, tipo os modelos comerciais como ChatGPT e Claude. O input é o contexto da conversa, são todos os tokens/palavras ditos até agora, seja por você ou por ele mesmo. O output é o próximo token.

A inferência é calcular tokens, um seguido do outro até chegar ao fim da resposta. No cálculo do segundo token, o input é o primeiro. No cálculo do terceiro, o input são os dois primeiros tokens. Assim por diante.

Qual é o processo de treinamento? É feito com textos de livros, artigos, blogs, tutoriais e tudo mais que está disponível na internet, tomando os devidos cuidados com copyright e propriedade intelectual. Esses textos são dados para a IA da mesma forma que expliquei antes. Depois de um chunk de treinamento ser feito a função loss calcula o erro de todas as inferências e é feito um cálculo de quais pesos mudar para diminuir o erro médio em todas as amostras do chunk.

Com o tempo, a rede consegue reproduzir o texto com razoável fidelidade, talvez usando sinônimos, ou simplesmente a ideia geral. É um ajuste fino onde ir em uma direção afeta a resposta em outros milhões de textos, mas no final temos um modelo que no pior dos casos pesa algo em torno de 50-200 GB sendo capaz de citar trechos inteiros de diversas obras, englobando o conhecimento de dezenas de terabytes de dados. Uma forma de pensar em LLMs é como um compressor do conhecimento humano, como ZIP faz com arquivos de computador.

Observação: Por mais que a informação esteja ali em algum lugar no modelo, o que geralmente acontece é uma busca na internet pois é mais seguro. Os modelos atuais não rodam de forma crua, mas num ambiente que foram treinados para usar. Esse ambiente permite que eles requisitem informação da internet, de arquivos dentro do próprio chat, ou arquivos da sua máquina em caso de interfaces de linha de comando(CLI).

Nenhum desses conceitos que expliquei é novo. Redes Neurais são ideias tão velhas quanto a própria computação e estatística, que só foram aplicadas algumas décadas depois da Segunda Guerra — que é vista como a era de ouro da computação para a maioria das pessoas — com o Perceptron3 de Frank Rosenblatt.

Acontece que entre a formulação dos conceitos e a implementação existe um gap temporal. LLMs não se chamam assim à toa. Com poucos parâmetros elas não tem estrutura suficiente para armazenar padrões complexos. Com muitos parâmetros elas não conseguem rodar rápido o suficiente para serem úteis e isso ainda vale para os dias de hoje.

Nos últimos anos houve uma verdadeira guerra armamentista entre empresas de tecnologia por infraestrutura e chips capazes de rodar modelos de linguagem, mas mesmo todo esse poder de processamento não seria suficiente para sustentar a quantidade de inferência atual servindo milhares de usuários simultâneos, esqueça milhões.

O paper Attention is All You Need da Google propôs, em 2017, a arquitetura que usava Transformers para transformar o comportamento recursivo dos modelos antigos em um comportamento paralelizável.

A partir de então, novos modelos cada vez maiores foram treinados. Eles só podiam ter quantidades absurdas de parâmetros graças a nova arquitetura e a expertise de treinar modelos com mais parâmetros e com melhor material de treinamento. Em 2026 parece que chegamos ao estado da arte em modelos de linguagem. OpenAI, Anthropic e Google desistiram de aumentar os modelos e estão focando em aspectos laterais aos modelos. Agents, tool calling, harness e coisas do tipo estão sendo desenvolvidas e são o maior diferencial entre os produtos delas.

Comercialmente não compensa aumentar o tamanho do modelo, dividir o poder computacional em menos modelos fazendo inferência para menos clientes para ter um pouco mais de inteligência.

Atualmente as LLMs estão próximas do que Fábio Akita chama de Inverno das IAs. Modelos pararam de crescer, bateram num teto do que é viável comercialmente. O processo de inferência e treinamento é muito caro. Mesmo as maiores empresas do ramo com esses modelos topo de linha operam no vermelho, se mantendo graças a dinheiro de investidores. A única esperança para elas é acumular o maior número possível de usuários agora e quando eles estiverem totalmente dependentes do serviço de inferência, ajustar o preço para cobrir — dessa vez de verdade — os custos de toda essa brincadeira.

Outras saídas possíveis para toda essa bagunça seriam:

1. uma nova arquitetura ainda mais barata

2. uma revolução na produção de energia global e de chips capaz de derrubar os custos de inferência de LLMs

Outra coisa interessante que aconteceu recentemente foi a distribuição de um modelo de linguagem de grande porte da Meta como open source. Até onde sei não existia nenhum outro modelo tão bom disponível para o público. Depois disso o modelo(Llama) foi customizado e retreinado em várias versões para diferentes propósitos e especialidades pela comunidade open source.

Pessoalmente estou bastante animado e ansioso para saber onde tudo isso vai dar. Mais recentemente, do ano passado para cá, as empresas estão investindo na área de desenvolvimento com agentes de programação, janelas de contexto maiores e capacidade de planejar e executar tarefas em paralelo.

Usando as palavras do próprio Akita:

Os agentes foram evoluindo nessa direção. Esses modelos pararam de fazer a guerra dos parâmetros e melhoraram o treinamento — foi saindo 5.0, 5.1, 5.2, e agora estamos no 5.4. A OpenAI foi iterando em cima do mesmo modelo cinco, sem refazer do zero para um modelo seis, fazendo ajustes e alinhamentos em cima dele. (Trecho do Flow Podcast 1:09:25-1:09:47)

Agora, no ano passado, finalmente a gente chegou, depois eu vou explicar mais sobre isso, mas parece que a gente chegou num ponto onde acabou as possibilidades, eles finalmente tiveram que: “vamos parar de ficar aumentando, ver o que a gente tem e realmente usar o que a gente tem.” (Trecho do Flow Podcast 2:32-2:49)

É isso. Acabou.

Um dos primeiros textos que escrevi foi sobre arquitetura e limites. Existe um limite para o quão um algoritmo pode ser otimizado, a partir dali o algoritmo deve ser trocado. Porém, não existe um limite para o quão devagar um algoritmo pode ser.

Nesse texto eu tento imaginar um computador hipotético e mostrar que mesmo ele não seria suficiente para calcular todo e qualquer algoritmo:

Alerta de Spoilers!

O começo da história mostra a infância de Arthur descobrindo mais sobre seus novos poderes nesse mundo enquanto convive com sua nova família e aprende o que é ter uma, já que ele era um órfão em sua vida passada.

Desde cedo ele percebe como o mundo é perigoso e como ele precisa de poder para proteger aqueles que ele ama. Existem inúmeros perigos, desde bandidos na estrada, tráfico humano e nobres com poder para saírem impunes de suas injustiças. E Arthur quer força para manter tudo isso longe dos seus pais, irmã e amigos.

Após uma experiência de quase morte ao defender sua família durante uma viagem, Arthur encontra Silvia, um ser estranhamente carinhoso e compreensível que destoa de sua aparência sombria e opressiva, que o ajuda a voltar para casa durante alguns meses. Silvia é gravemente feria por alguém de sua raça e deixa uma mensagem para Arthur, pedindo que ele não repita os erros da sua vida anterior ao procurar vingá-la. Que chegará o dia em que ele fará a diferença, mas que aproveite sua vida, sua infância e sua família até lá.

O protagonista segue esse pedido a risca, se tornando aventureiro e depois entrando na escola de magia, mas coisas estranhas continuam acontecendo: uma besta Rank S onde não devia, alunos com runas estranhas marcadas na pele, a descoberta de um novo continente e, por fim, uma general assassinada.

Os tempos de paz estavam chegando ao fim. Arthur continuou crescendo em força para lidar com as ameaças do mundo, mas não em maturidade para lidar com as dificuldades, que sempre serão maiores do que nós. Em sua vida passada afastou todas as pessoas que se importavam com ele, eliminando todas as suas fraquezas e se tornou invencível, mas perdeu o sentido de lutar. Agora, teria que lidar com a culpa de talvez ter acelerado uma guerra que só viria em um futuro distante.

Aluno da mais prestigiada academia de magia, amigo de príncipes e princesas dos reinos humanos e élficos, único mago quadra elemental. Arthur parte em um arco de treinamento e volta após o início da guerra.

Ele podia ser um dos combatentes mais fortes do continente, ser nomeado como general ou qualquer outra coisa, mas não tinha a capacidade para defender sua família da forma que desejava. Pensou que bastava ser forte o suficiente e todos os problemas poderiam ser contornados. Seus pais e irmã entram na guerra como soldados. Seu pai morre em uma batalha particularmente difícil. Sua namorada, Tessia, entra em crise em outra batalha. O reino élfico é invadido.

Sem tempo para chorar a morte do seu pai, Arthur é confrontado com uma das batalhas mais marcantes da guerra para mim: A batalha de Bloodfrost.

Nesse ponto a guerra já foi perdida para Arthur que perdeu parte da sua família. Isso o faz refletir sobre a proposta que ele tinha recebido do inimigo, Agrona, alguns dias antes: Deixar a guerra e ter sua família poupada.

Durante a batalha o castelo cai por conta da traição do rei elfo para salvar sua filha, Tessia. Assim como Arthur, Alduin teve sua grande perda na guerra: seu reino. Sua família era a única coisa que lhe restava e ela se encontrava com uma doença incurável.

Arthur sente algo esquisito na batalha, que só tinha escravos e nenhum soldado ou mago de verdade. Volta pro castelo e descobre a traição. Descobre também a força real dos generais inimigos, e que nunca tiveram nenhuma chance de vitória. Ele foge com os únicos sobreviventes no castelo para algum lugar qualquer perto de uma montanha e chora a derrota.

Seu pai tinha morrido alguns dias antes. Sua mãe e irmã estavam no castelo. Ele não sabia se tinham sido carbonizadas pelas mesmas chamas que mataram Silvia ou se tinham escapado e estavam fugindo assim como ele. A única coisa que restava para ele era sua companheira dragão que criou desde filhote, Silvie, e talvez Tessia.

Nessa situação ele faz algo inesperado movido pelo desespero. Contata Agrona aceitando o contrato sem nem mesmo saber se ainda tem uma família para proteger, entregando de bandeja um continente que já tinha sido conquistado de qualquer maneira.

Esse é o fundo do poço para o personagem. No futuro ele ainda ficaria mais ferido, mais fraco, com mais cicatrizes, mais cansado, mas nunca com tantas perdas como nesse momento.

TBATE é uma obra que acompanhei os lançamentos semanalmente alguns anos atrás com uma mente totalmente diferente da que tenho hoje. Lembro que na época o mais importante para mim, o que realmente ocupava minha mente, eram assuntos que hoje percebo serem menores.

A evolução de força do personagem era um deles. Ansiava pelo momento onde o protagonista dominaria sua vontade bestial e varreria o chão com a cara de seus inimigos. Isso veio, mas junto de momentos que os humanizavam.

Havia também bastante discussão entre torcidas organizadas sobre possíveis interesses amorosos do protagonista, sendo que era claro que ele terminaria com Tessia, sem a menor sombra de dúvida.

E ao mesmo tempo se desenvolvia no fundo de tudo isso um dilema que eu só daria importância depois. Algo que Arthur repetiu em suas duas vidas, mas que não percebi na época por simplesmente pular todos os flashbacks da vida passada dele. Afinal, eles eram inúteis para o desenrolar dos eventos, as batalhas e táticas de guerra no primeiro plano, mas fundamentais para entender a visão de mundo do personagem. Também é curioso como ele começa a ter pesadelos com a vida passada somente depois do início da guerra.

Arthur tem, desde o princípio, um desejo natural de afastar todo o mal daqueles que ele ama. E quando ele perde a primeira pessoa com quem se importou na vida passada, a diretora do seu orfanato, desvirtua toda sua vida em busca de vingança.

Aqui o dilema surge, ele ainda tem pessoas para proteger: seus amigos Nico e Cecilia. Mas ele decide se afastar de ambos, deixando de os proteger, porque os caminhos que ele trilharia seriam muito perigosos dali em diante. Porém, seus amigos não o abandonam e decidem trilhar esse caminho junto com ele, o que os leva para vidas terríveis e mortes prematuras.

De forma semelhante, nessa nova vida ele perde Silvia, mas decide fazer diferente, mostrando amadurecimento. Essa maturidade seria posta a prova quando ele perde outro amigo Elijah e quando perde seu pai, sua família, seu país. Durante toda essa nova vida ele sente o peso de tudo que ele precisa proteger e tenta carregar aquilo sozinho, acumulando fracassos no processo.

A obra me pegou pelas lutas e sistema de combate, mas me segurou pelo desenvolvimento dos personagens, ou a falta dele em muitos casos, o que é bem humano na verdade.

Arthur é cabeça dura e se apoia no seu tempo somado de duas vidas para fantasiar sua teimosia como experiência. Tessia faz de tudo para se sentir menos inútil como princesa, participando nas linhas de frente da guerra. O ódio irracional que Nico e Cecilia alimentam por Arthur. A manipulação de Agrona sobre o psicológico de personagens nos dois continentes. Algumas poucas disputas políticas bem localizadas. Esses são só alguns exemplos.

Outro grande arco para mim acontece quando ele tem que se infiltrar no continente inimigo, interagindo tanto com camponeses quanto militares e líderes. O foco do personagem é conseguir voltar para casa o mais rápido possível, mas você nota capítulo a capítulo o pensamento dele mudando e ele lutando contra isso.

Não digo que a história é a melhor de todos os tempos, mas com certeza é uma das quais eu mais engajei e, por isso, tive tempo para notar o que vai além do óbvio.

OBS: Não vejam o anime, é horrível. Além de que tudo que eu descrevi demoraria anos de adaptação para chegar, se é que chegará.

Eu consumi muitas histórias na minha adolescência e com o último texto sobre Attack on Titan percebi que foi um entretenimento, mas que pode ser aproveitado retroativamente também. Sempre posso revisitar aquelas memórias e analisar outros pontos de vista. Foi o que tentei fazer em ambos os textos.

Sou obrigado a dizer que esse texto contém spoiler de toda a obra, apesar de que seria interessante ver a percepção de alguém que não conhece e não assistiu.

A parte mais legal da história para mim sempre foi o mistério sobre a origem das muralhas, dos titãs e dos humanos que viravam titãs. Porém, quando descobrimos os segredos guardados no porão da casa do Eren o foco muda completamente para um lado mais político da coisa.

Ou é o que gostaria de dizer. A verdade é que Shingeki não mudou tanto quanto as pessoas tanto reclamam, muito menos o protagonista. Sempre houve uma semente desde o início, como uma premissa oculta que o argumento ainda não levou às últimas consequências.

No porão, e mais pra frente com a expedição de reconhecimento em Marley e a história do Zeke, descobrimos que o povo das muralhas não eram que restou da humanidade, que eram súditos de Ymir presos em um ciclo de vingança iniciado há 2000 anos.

O Reino de Eldia era um reino qualquer até que recebeu o poder do Titã Fundador e usou esse poder para oprimir todos os outros povos, se tornando uma superpotência titã. O aspecto sobrenatural e grotesco desse poder criou um trauma e ressentimento similar, ou até pior, ao de paises vencidos em guerras.

Esse período de guerra e carnificina unilateral continuou até que o Rei Fritz decide se isolar na ilha e construir as muralhas, ele está sendo movido por um enorme sentimento de culpa por algo que seus ancestrais cometeram.

Alguns eldianos ficam no continente e um outro país ascende como nova potência Titã usando esses remanescentes, mostrando que não existe vácuo de poder.

Pelo próximo século se forma um equilíbrio falso de poder. Marley tem quase todos os Titãs primordiais enquanto os descendentes do Rei Fritz têm milhares de colossais podendo, se assim quisessem, destruir o mundo inteiro, e nenhum toma nenhuma ação contra o outro.

Marley denomina a ilha como Paraíso e passa a exilar criminosos e rebeldes na ilha depois de transformá-los em Titãs. O objetivo era cercar a muralha de Titãs para que os súditos de ymir, mais conhecidos como “Demônios da Ilha”, não pudessem ter dias tranquilos nem desenvolvimento tecnológico.

Portanto existe uma tensão entre Eldia, agora Paradis, e o resto do mundo, representado por Marley. Acompanhamos a história do ponto de vista do povo dentro das muralhas em uma vida comparável a da era medieval que não sabem o que são os Titãs, mas os têm como uma ameaça silenciosa, porém constante.

O sonho de Marley seria acabar com o risco de um ataque massivo de Eldia tomando o poder do rei atual, enquanto o sonho de Eldia, representado agora pela Divisão de Reconhecimento com Eren e Históia, é de acabar com os Titãs e, posteriormente, com qualquer outra ameaça.

O Rei Fritz, com seu pensamento e visão de mundo indiscutivelmente únicos condenou as futuras gerações do seu povo a ficarem indefesos ao apagar toda a memória dos seus súditos e qualquer registro, além de passar a própria ideologia para seus descendentes quando herdam o poder de fazer algo para mudar essa situação. No fundo ele deixou o futuro de todos nas mãos dos próprios inimigos em nome de uma dita reparação histórica.

Claramente nosso protagonista shounnen com sonho de liberdade não lidaria bem com isso. Por causa do pensamento entreguista do rei, Eren vai para o extremo oposto:

Se a gente matar os inimigos do outro lado do mar, será que finalmente nós seremos livres? (Fim da 3ª temporada)

Se queremos a solução mais pacífica para esse conflito, isto é, aquela com menos mortes não importando de que lado, nem a solução do rei, que não é uma solução de fato, nem a do Eren são válidas. Sobra então o plano do Zeke e o da Divisão de Reconhecimento.

Zeke, apesar de nascido em Marley e de um ramo diferente da família real de Eldia, tem no fundo um pensamento parecido com o do Rei Fritz porém com uma nuance. A solução do rei não é uma solução no sentido de delegar a outrem o direito de julgar Eldia por seus crimes passados fadando-os a um inevitável extermínio no futuro. Já Zeke também quer o extermínio de Eldia, um extermínio pacífico, mas ainda extermínio. Isso mostra que ele enxerga culpa no próprio povo, mas principalmente um cansaço por tanta luta e ódio que só quer que acabe, não importando o ganhador.

Já o plano da Divisão de Reconhecimento era integrar Paradis no jogo político e de poder internacional, mostrar um gostinho do poder de Eldia e negociar uma paz tão duradoura quanto possível. Nesse cenário veríamos um mundo de poder bélico e tecnológico crescente movido pelo medo da força da ilha. O poder de ambos os lados cresceria até que o poder Titã fosse irrelevante numa guerra generalizada, isso revela algo interessante: Por mais que os fundadores dessa nova era política da ilha tivessem as melhores intenções de manter a paz e a cooperação entre os povos, todo o incentivo para as futuras gerações era de atacar e erradicar seus vizinhos para não ver seu poder e sua vantagem derretendo diante dos seus olhos.

Zeke defende eutanásia extermínio silencioso. Eren defende extermínio violento. Paradis defende uma falsa paz, mas quem disse que existe uma paz verdadeira?

O problema não é de transformação de texto em pensamento ou raciocínio, é anterior. Não há capacidade de raciocínio estruturado, complexo ou sequer consistente sendo ensinado nas escolas. E isso pertence ao campo da matemática, mais especificamente ao campo do Raciocínio Lógico Matemático.

Nada na matemática é arbitrário, mas é construído a partir de uma base de premissas por meio de raciocínios estruturados que chamamos de provas matemáticas. No entanto, a matéria é apresentada aos alunos desprovida de sua parte mais importante, sua construção, restando somente as conclusões jogadas aos coitados com o mínimo de contexto possível enganando-os a acreditar que as aplicações das fórmulas aprendidas é a única coisa que há para ser aproveitada, sendo que não é a única, nem mesmo a mais importante.

A geometria plana de Euclides se junta ao plano cartesiano de Descartes, figuras e números se unem numa das ferramentas mais interessantes da matemática: Funções.

A teoria dos conjuntos ensina sobre elementos, grupos, interseções e uniões que permitem entender quantificadores: universal e existencial, muito confundidos e usados em falácias lógicas e generalizações.

O raciocínio lógico propriamente dito, a base para as provas matemáticas, define conectivos para linkar proposições na lógica proposicional que permite elevar o raciocínio para algo realmente estruturado e consistentemente transmissível entre diferentes pessoas.

Ela também escancara as bases aristotélicas de silogismos usados em argumentos. Existem premissas e um argumento que leva a uma conclusão. Estudamos os argumentos logicamente válidos e entendemos que se a conclusão se segue das premissas por um argumento válido, a validade e veracidade dela estão diretamente ligados a veracidade das premissas.

Somente estas ideias que pincelei superficialmente já derrubariam inúmeras falácias comumente espalhadas no debate público e dariam bases sólidas para o aprendizado de outras tantas matérias para os estudantes caso internalizadas desde o começo.

Problemas do sistema educacional brasileiro como aprovação compulsória afetam todas as disciplinas, mas com muito mais peso prejudicam o aprendizado das exatas, entre elas a matemática.

Passar de ano sem ter aprendido sobre Revolução Francesa de forma apropriada não gera nenhuma dificuldade aparente em aprender sobre o Período Napoleônico, mas não aprender funções e trigonometria te impedem de aprender Cálculo e coisas como derivadas que dependem fortemente de interpretar funções e gráficos.

Ao invés de admitir que existe um erro na forma como matemática é ensinada na escola porque ninguém consegue aprender o segundo por uma deficiência no primeiro, jogam o estudo de Cálculo silenciosamente para fora do currículo da educação básica e se enganam fingindo que os alunos terminam o ensino médio sabendo sobre funções. Este é só um exemplo de algo que acontece com diversos outros exemplos como Análise Combinatória e Geometria no geral.

Isso fica claro quando olhamos para o Exame Nacional do Ensino Médio(ENEM) que deveria, na teoria, avaliar o domínio do aluno sobre conteúdos aprendidos no ENSINO MÉDIO. Quando, na prática, mais da metade da prova se trata sobre conteúdo do ensino fundamental. Deixando bem claro o quanto a prova se adaptou aos alunos e não o contrário.

Professor Toshio Nakamura em entrevista ao Correio Braziliense sobre o ENEM de 2021:

A prova é de ensino fundamental. Grande parte das questões envolvia porcentagem, estatística e interpretação de gráficos/tabelas — conteúdo que um aluno aplicado do 9º ano resolveria. Assuntos clássicos do ensino médio (probabilidade, análise combinatória, matrizes, geometria analítica, polinômios) tiveram zero ou uma questão. Trigonometria apareceu só uma vez; logaritmos e exponenciais, nenhum.

Ele chamou a prova de “Enef” (mais fundamental que médio) e criticou a falta de profundidade para avaliar candidatos a cursos como engenharia. Dificuldade: baixa em conteúdo, mas exigia leitura e cálculos simples. E esse padrão se mantém em todo o histórico recente de provas. Muita contextualização, pouca avaliação do que realmente importa.

A ideia de que exatas, diferente de matérias de humanas, são como prédios com andares que precisam ser construídos na ordem certa é uma boa maneira de ver isso. Os andares 4 e 5 estarão flutuando sem compreensão básica enquanto não voltar para construir o terceiro.

Professores de Cálculo e Física do currículo comum das engenharias costumeiramente dizem que os alunos não têm dificuldade específica nos conceitos de limites, derivadas e integrais, mas uma dificuldade anterior que vem da escola.

Notem o que fiz até aqui:

Dificuldade de interpretação é dificuldade de raciocínio, que por sua vez é matemática deficiente criada por um ensino público direcionado por um incentivo (passar no ENEM e cursar ensino superior).

Isso é uma sequência encadeada de implicações.

A implica B que implica C. Se A é falso, C é falso. Não há costume de estruturar o raciocínio. Essa estrutura foi formalizada na matemática. E sem ela nos perdemos no mérito da discussão sem entender o que estamos falando ou lendo.

Ninguém devia sequer abrir a boca para argumentar algo sem antes entender os pressupostos das partes. Qualquer argumento pode ser válido a partir de premissas quaisquer. É preciso saber a diferença entre argumento e premissa, geralmente entendido como valores no sentido de serem parte da visão de mundo de alguém, incluído por tabela em qualquer argumento.

A solução não é ensinar mais matemática, isso seria ingênuo. É mudar a estrutura, o como matemática é ensinada. Uma mudança tanto no foco, de fórmulas para construção, como de ritmo.

Uma modularização do ensino onde todos os conteúdos pudessem ser acessados a qualquer momento seria uma ideia para resolver o problema do prédio. Ao invés de parar no segundo andar, ter dificuldade com o resto, repetir de ano para finalmente aprender o terceiro, quarto e quinto, o aluno, de alguma forma, pudesse preencher a lacuna de forma paralela ao ano letivo. Claro que isso leva a repensar várias características do sistema atual como reprovação, ano letivo, turmas fixas e etc.

Essas são somente algumas ideias. Muitas outras coisas poderiam ser feitas, correções pontuais e alterações do paradigma de ensino atual para otimizar os recursos atuais.

Esse texto é a construção de um argumento maior que procura mostrar que resultados melhores podem ser atingidos, não por otimização com aprimoramento que vem de um aumento de complexidade do sistema que impedem melhorias futuras, mas por remodelagem que mude a rota de forma a permitir saltos de eficiência que a complexidade anterior não permitia.

Falo um pouco sobre complexidade e ganho de eficiência por organização no texto a seguir:

Você pode achar interessante estes textos sobre aprendizado e o papel da LLM na expansão de generalistas:

A maior dificuldade que percebo em estudantes de inglês é a fala. Eu absolutamente nunca precisei falar em inglês então nunca me interessei por desenvolver essa habilidade. Por outro lado, sempre quis ler massivamente em inglês centenas de capítulos de dezenas de histórias e livros.

No caminho para atingir um nível alto de leitura, para ler sem demora e com fluidez eu percebi, não por falta de avisos de pessoas como Mairo Vergara e Matt, que minha habilidade de me expressar evoluía sempre na mesma proporção, mas um passo atrás da minha leitura.

Não me peça para pronunciar nada em inglês com pessoas presentes num raio de 100 metros, mas eu não hesitaria em explicar raciocínio longos e complexos ou nerdar sobre animes e mangás para um falante nativo num chat via texto, por exemplo.

A maioria das pessoas que diz ser capaz de entender conteúdo escrito ou falado, mas não de falar também não escreve. Só por isso já é bem óbvio que o problema da pessoa não é pronúncia, é vocabulário.

Enquanto coisas como gramática, gírias e phrasal verbs recebem atenção desproporcional, acredito que a coisa mais importante e que traz a maior parte dos resultados é ter um vocabulário extenso. É como diz a Regra de Pareto, 80% da sua capacidade de se expressar vem dos 20% dos esforços vem de aprender novas palavras e seus significados. Depois você pode buscar os 20% restantes que envolvem gramática, velocidade, naturalidade, mas inverter essa lógica e priorizar isso nas primeiras etapas do aprendizado é matar completamente o progresso que você poderia ter.

É de onde vem o conceito de Comprehensible Input. A melhor forma de aumentar seu vocabulário é por imersão por causa do contexto, mas você não sabe inglês então não pega o contexto. Por isso é necessário um certo uso de conteúdos feitos para estudantes no início. Porém recomendo fortemente que você deixe a piscina o mais rápido possível e se jogue no mar dos textos reais, feitos por nativos para nativos.

Querendo potencializar ainda mais a velocidade com que novas palavras são aprendidas em contexto foram criados métodos usando o Anki1 para revisar aquelas palavras no contexto em que foram estudadas.

Juntamente com isso surge o conceito de frases I+1 para reduzir o peso da revisão e internalizar aquelas palavras. Estudamos palavras novas e guardamos somente as frases com uma única palavra nova.

Aqui existem dois truques:

1. Ao usar frases inteiras para revisão, você aprende gramática de forma passiva.

2. Você internaliza os padrões da língua. Coisas como quando uma palavra é usada, e com que outras palavras ela é usada.

No começo é um sofrimento achar fases I+1, o que geralmente acontece é decifrar um texto de forma lenta e em várias etapas, pesquisando em dicionários e buscando frases mais simples que usam as palavras do texto base. Com o tempo, depois de meses de pratica deliberada com pesquisas e revisões diárias, você passa a achar frases I+1 nos próprios textos que você está estudando.

Você aprende os padrões e palavras mais usados, os mais comuns de maneira geral e no nicho do conteúdo que você gosta. Isso cria um ciclo retroalimentado de aprendizado. Você aprende e se torna mais capaz de acompanhar textos do seu interesse. Com mais compreensão você começa a entender via contexto, além de estar por si só revisando estruturas gramaticais e palavras que você estudou antes sem o Anki.

A maior dúvida para quem começa a usar o método é saber quais textos estudar. Escolha os textos do seu interesse a menos que seja algo muito técnico e específico como treinamento de redes neurais convolucionais. Geralmente a melhor escolha é ficção, entretenimento, no máximo notícias.

Chamamos de minerar sentenças o passo a passo de ler o texto até encontrar palavras desconhecidas, pesquisar seu significado, entender a frase original ou procurar outra frase que use a palavra, formatar e copiar no Anki. Essas palavras desconhecidas não necessariamente precisam ser totalmente novas, mas devem estar ali com um significado novo que te impede de explicar a sentença com propriedade e facilidade.

As consultas no dicionário e a leitura de um texto cheio de palavras desconhecidas e contexto nebuloso são um trabalho cognitivo que não tem escapatória. É necessário passar por isso para, junto com as revisões, assimilar a língua. Por outro lado, a etapa de passar esse material para o Anki é puramente mecânico e perfeitamente evitável.

Pensando nos sufocos que passei para aprender inglês e que continuo passando para ler textos mais complexos e técnicos decidi criar um site que me ajudasse no processo de estudar um texto e simplesmente pular a barreira Texto->Anki, que agora são sincronizados sem a necessidade de ficar copiando e colando de lá pra cá por mais de 20 minutos.

Eu estou me esforçando para tornar a experiência o mais fluida possível pra poder focar só no aprendizado. Foram semanas interessantes aprendendo sobre codificação e experiência de usuário, questionando os meus métodos de aprendizado e se devia compartilhar isso aqui.

Gostaria muito que você usasse e me desse feedback sobre a usabilidade e se seria útil para aprender novos idiomas. Pode deixar seu comentário ou mandar mensagens diretamente para mim, agradeceria muito.

O projeto ainda está em desenvolvimento e adoraria sugestões, contribuições e ideias. Qualquer coisa que melhore o aprendizado tá valendo!

Link do projeto

Quando duas pessoas fazem uma troca voluntária, tendemos a enxergar isso como algo bom. E de fato, segundo qualquer visão de mundo liberal, conservadora ou anarco capitalista não devia ter nada de errado nisso. Isso se deve a noção de que a troca se dá entre itens de valor equivalente ou próximo.

Apesar de não ser exatamente o que ocorre. A verdade é que uma “Troca Equivalente” pelo princípio do mínimo esforço não aconteceria. Se a satisfação por ter o outro bem ao invés do atual fosse exatamente igual, não haveria sentido empenhar esforço na execução da troca.

Antes da troca existe uma valoração de satisfação atrelada a cada parte da troca com seus bens. Fazer a troca deve aumentar o nível de satisfação de forma a justificar o seu custo. Depois da troca o nível geral de satisfação geral é maior que antes da troca. Riqueza foi gerada apesar de os bens não mudaram em quantidade ou qualidade. A única coisa que mudou foi na mão de quem eles estão.

Conservação da Matéria

O princípio da conservação da matéria é absoluto. Não é possível criar recursos, apenas explorar os recursos da natureza e agregar nosso trabalho em cima. É disso que trata o estudo da Economia: lidar com recursos escassos.

Porém, isso não se aplica para tudo na nossa vida. Existem coisas que podem ser criadas e compartilhadas infinitamente.

Conhecimento

Conhecimento, informação e técnica/tecnologia são bens imateriais que requerem um esforço ordenado e direcionado para passarem a existir, mas depois de surgirem podem ser espalhados e compartilhados de forma ilimitada. Uma ideia não deixa de existir por escassez, ela morre da memória coletiva quando deixa de ser útil.

Assimetria de informação dá ao criador de uma técnica vantagem competitiva em uma área que o incentiva a dispender tempo e recursos em atividades que não são imediatamente produtivas. Isso se chama investimento, que também pode se dar na fabricação de bens intermediários (bens que não são para consumo imediato) para além de invenções somente.

De certo modo, patentes são uma tentativa centralizada de proteger esse incentivo à criação de conhecimento na forma de propriedade intelectual. Na prática não existe propriedade sobre bens não escassos.

Neurociência

O cérebro humano é uma rede de neurônios interconectada. Existe hardware (neurônios) e o software (conexões). Os mesmos neurônios podem representar diversos pensamentos e memórias tudo a depender da forma como estão conectados. O aprendizado é o processo de reordenar as conexões deles para a execução de uma nova tarefa, aumentando a utilidade do circuito.

O número de conexões possíveis aumenta em uma proporção exponencial se comparada com o número de neurônios. Se você lembra de qualquer coisa de Análise Combinatória das aulas de matemática básica, sabe do que estou falando.

Portanto, o maior trabalho realizado pelo cérebro - a máquina mais complexa que o ser humano utiliza no seu dia a dia - não é de fabricar novos neurônios dia e noite. O maior trabalho do cérebro é de reorganizar as conexões para aumentar a gama de habilidades disponíveis: motoras e cognitivas. Isso ocorre durante o sono, como eu explico aqui.

Materialismo

Tanto o comunismo quanto o capitalismo se prenderam ao material, aos recursos que obedecem as leis da física, e esqueceram completamente do imaterial: ideias, inovação. Todos as correntes econômicas que buscam dar uma forma para a sociedade trata inovação como um mero detalhe sendo que foi a inovação em tecnologia que permitiu o mundo que vivemos hoje sequer existir.

Discussões sobre produtividade e desenvolvimento nacional só se preocupam com quanto recurso tiramos da terra e como agregamos valor aos produtos antes de exportar. É uma melhora, mas não existe um efeito bola de neve enquanto um problema anterior não for resolvido.

Aumentar a produção tem um limite, assim como aumentar neurônios no cérebro. Um ser humano não precisa de trilhões de neurônios, isso seria só um desperdício de energia, uma máquina ineficiente.

Se o objetivo é aumentar a satisfação geral isso envolve aumentar a produção, mas também envolve resolver outros problemas nascidos da entropia, do caos, da dissolução da ordem pública.

Ordem e Progresso

É comum um sistema acumular emendas, correções e “aprimoramentos” que aumentam a sua complexidade. Essas alterações muitas vezes geram retornos cada vez menores ao ponto que revolucionar o sistema, mesmo com todos os custos da incerteza, se torna a melhor opção.

Uma das coisas mais naturais para um dev é abandonar projetos pessoais que cresceram da forma errada e começar de novo já sabendo o caminho que deve ser tomado. Muda-se a arquitetura, às vezes as tecnologias usadas, e chegamos num resultado melhor e com espaço para crescimento que não existia na versão anterior. Isso não acontece por genialidade do desenvolvedor, mas por incompetência na primeira tentativa, revelada pela prática no mundo real. A correção é feita por honestidade de saber que os fundamentos no qual o sistema foi pensado eram falhos.

É conhecimento comum que não é possível aumentar um prédio ad eternum, mas é preciso desde a base saber o tamanho final do prédio. Se já há um prédio ali, para construir um maior é preciso demolir e construir uma base específica para o novo prédio.

É preciso, portanto, de uma ordem no projeto para que os recursos sejam aplicados de forma racional. Ordem essa que degrada e precisa ser restaurada, às vezes por um processo desagradável.

Lei e ordem é exatamente esse conceito materializado em expressão idiomática frequentemente associado a autoritarismo e coisas ruins quando na verdade é o que tem o maior potencial de trazer enormes resultados. Pois reduz a complexidade, desata nós e abre espaço para melhoria real.

Enquanto há briga por todos os lados discutindo sobre estado sim ou estado não, estado forte ou estado fraco, o estado existe e é ineficiente, de propósito. É dito que busca o desenvolvimento nacional na Constituição de 1988, quando na verdade é só uma instituição de caridade com dinheiro alheio.

O nosso progresso não virá de criar cidadãos com consciência social ou coisas do tipo, mas de criar cidadãos capazes de usar os recursos naturais e humanos do país para algo mais útil que decidir quem senta no trono. Virá de criar um sistema educacional que realmente eduque de verdade. Virá de criar um ambiente onde as pessoas não sintam medo de serem violentadas, assaltadas, fraudadas, mortas. Virá de criar um mercado onde você não tenha medo do desemprego, pois sempre há mais e mais empresas crescendo e sendo criadas disputando por funcionários. E nada disso se dará com reformas envergonhadas, com medo de mudar o que está posto, mas de fazer uso forte da mão do estado para o bem, não só para o mal como acontece hoje. O autoritarismo que todos temem já está posto, embalado em gentileza e palavras bonitas, mas está posto.

Lei e Ordem são necessários para que o poder estatal tenha algum sentido em existir. Não há motivo para deixar na mão dos indivíduos o desenvolvimento do país se há um estado com poderes absolutos sobre a sociedade. Ordem não é um pressuposto para a existência do Estado. É sua única justificativa.

Na verdade, todos esses termos que acabei de falar são apenas números com algumas dezenas de dígitos na base decimal ou 256 dígitos na base binária. Os bitcoins não está em um endereço (hash da Chave Pública) ou Chave Pública, muito menos numa Chave Privada. Todos os bitcoins estão na blockchain.

Blockchain

Essencialmente, a blockchain é um registro contábil. Nela estão registradas todas as transações feitas com bitcoin deste 2009. Fazer uma transação na camada principal do Bitcoin é pedir para todos os full nodes1 do mundo inteiro guardem aquela informação por toda a eternidade. Imagine uma planilha com 1 bilhão de linhas, cada nova transação feita é uma nova linha nessa planilha onde todos os usuários da rede tem uma cópia em um formato resistente à mudanças: a blockchain.

O resultado real de uma transação ser incluída na blockchain é a criação de um novo output(UTXO) no nome de um endereço. O que isso significa? Significa que você criou esse output com uma condição de gasto. A condição normalmente é “Quem quer que tenha a Chave Privada da Chave Pública que criou esse endereço pode gastar esse output” e isso é feito com o que chamamos de scriptPubKey em uma linguagem de pilha usada pelo Bitcoin chamada simplesmente de Script.

Script

Script é uma linguagem baseada em pilha, isso significa que as informações e dados que um script dessa linguagem recebe só podem entrar ou sair pelo topo dessa estrutura. Isso limita a linguagem e a torna mais previsível.

Locking script (scriptPubKey)

É o script que fica na saída (output) de uma transação. Ele define as condições que precisam ser satisfeitas para que aquele Bitcoin possa ser gasto no futuro. Funciona como um cadeado.

Exemplo clássico (P2PKH — Pay to Public Key Hash):

OP_DUP OP_HASH160 <hash da chave pública> OP_EQUALVERIFY OP_CHECKSIG

Traduzindo: “Para gastar isso, prove que você tem a chave pública correspondente a esse hash e assine com a chave privada.”

Unlocking script (scriptSig)

Enquanto o output da transação é “travado” pelo scriptPubKey, ao virar o input de uma nova transação é preciso destravar, ou seja, atender as condições definidas pelo scriptPubKey. No exemplo P2PKH, é simples assim:

<assinatura> <chave pública>

Observação: Tanto scriptPubKey quanto scriptSig são incluídos na transação que vai para a blockchain. Eis a importância de ser simples, compacto e de comportamento previsível.

Como a pilha funciona na validação

Quando um nó valida a transação, ele concatena os dois scripts e os executa em sequência sobre uma pilha vazia:

[scriptSig]  +  [scriptPubKey]

Passo a passo para P2PKH:

1. <assinatura> → empilha a assinatura

2. <chave pública> → empilha a chave pública

3. OP_DUP → duplica o topo da pilha (copia a chave pública)

4. OP_HASH160 → aplica HASH160 no topo (hash da chave pública)

5. <hash esperado> → empilha o hash do scriptPubKey

6. OP_EQUALVERIFY → compara os dois hashes; falha se diferentes

7. OP_CHECKSIG → verifica a assinatura com a chave pública; empilha TRUE

Se ao final restar TRUE no topo da pilha, a transação é válida e os bitcoins podem ser gastos. O passo 6 verifica se a Chave Pública que você deu é a mesma do endereço original. Agora só resta a assinatura e a Chave Pública — dona do endereço, portanto, dos fundos — na pilha. É hora de verificar se a assinatura realmente foi feita pela Chave Privada correspondente. Nesse artigo eu explico a matemática que permite a validação de assinaturas.

OUTPUT (criado por quem pagou)    INPUT (quem gasta depois)
┌─────────────────────┐           ┌─────────────────────┐
│   scriptPubKey     │    ←──    │     scriptSig        │
│   (cadeado)        │           │     (chave)          │
└─────────────────────┘           └─────────────────────┘

Carteiras Bitcoin

Agora que passamos pela introdução, você deve estar se perguntando “O que tudo isso tem a ver com carteiras Bitcoin?”. Se você prestou atenção na explicação, entendeu que existem dois processos entre uma Chave Privada e gastar os bitcoins: A Criptografia de Curva Elíptica(ECC) que gera a Chave Pública e o SHA-256 que gera o endereço.

Apesar do nome, é uma boa prática expor sua Chave Pública uma única vez, somente na hora de gastar os bitcoins controlados por aquela chave e depois nunca mais usá-la novamente. A lógica por trás disso é que você recebe bitcoins num endereço e ninguém sabe qual a Chave Pública daquele endereço. Uma vez que você gasta aqueles bitcoins (revelando sua PubKey) e continua recebendo naquele endereço, alguém pode tentar via força bruta adivinhar sua PrivKey. Esse tipo de ataque é impossível com a tecnologia atual, mas o Bitcoin opera na lógica de longo prazo. Expor algo significa expor eternamente para um atacante imaginário que nunca esquece, nunca descansa e nunca se revela. Caso você não volte a usar aquele endereço e par de chaves, você ficou exposto apenas entre o tempo de propagar sua transação na internet até a inclusão dela na blockchain.

Porém isso cria outro problema. Como gerenciar todas as suas chaves se você só pode usar cada par uma única vez? Esse é o trabalho das carteiras Bitcoin.

Dos primórdios até Seed Phrases

Quando o Bitcoin foi criado pelo Satoshi, havia somente o programa Bitcoin Core criado pelo mesmo. Era o único programa que sabia usar o protocolo do Bitcoin, diferente de hoje, onde Bitcoin deixou de ser um programa e se tornou uma linguagem que uma infinidade de softwares usam para se comunicar e transferir valor real 24/7.

Sendo assim, o Bitcoin Core precisava ser completo, fazer tudo ao mesmo tempo:

• Validar e propagar transações

• Minerar

• Gerenciar chaves/ser uma carteira

Para receber pagamentos, uma nova Chave Privada era criada — entenda escolher entre as quase infinitas que existem — a Chave Pública era derivada e só. Nem mesmo endereços existiam naquela época. Cada chave tinha que ser armazenada. Perder ela significaria perder os fundos.

Todas as chaves eram guardadas em um arquivo para que você fizesse backup. Todos os seus fundos estavam em um cofre impenetrável, mas as chaves estavam em um efêmero arquivo .txt ou .dat.

Exemplo de wallet.dat:

Chave 1:

  Privada: 5Kb8kLf9zgWQnogidDA76MzPL6TsZZY36hWXMssSzNydYXYB9KF

  Pública:  1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa

  Label: “”

Chave 2:

  Privada: 5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf

  Pública:  1XPTuPXXuW727z92mJvEAsXj75xT3bN4x

  Label: “Duas pizzas”

Chave 3:

  Privada: 5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM2Z6ptgqe

  Pública:  1dice8EMZmqKvrGE4Qc9bUFf9PX3xaYDp

  Label: “”

Chave 4:

  Privada: 5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss

  Pública:  1AJbsFZ64EpEfS5UAjAfcUG8pH8Jn3rn1F

  Label: “Troco tx 2f3a...”

Carteiras Hierárquicas Determinísticas (HD Wallets)

A ideia do BIP 32 era criar uma forma de derivar todas as chaves a partir de uma Chave Mestra. É determinístico porque você sempre vai derivar as mesmas chaves na mesma ordem.

É hierárquico pois segue uma estrutura de derivações que suporta alterações. Quer criar outra conta com uma cadeia inteira de novos endereços? Você consegue. Quer criar endereços para SegWit, Taproot ou modelos antigos? Você consegue. Chaves para outras moedas? Também é possível.

A estrutura de derivação é a seguinte:

MasterKey/Purpose’/CoinType’/Account’/Change/AddressIndex

• A Chave Mestra é fixa e nunca muda. A partir dela você desbloqueia toda a árvore de derivações.

• O propósito é o tipo de endereço a ser criado, pode ser Legacy, SegWit, Taproot etc.

• Tipo de moeda pode ser BTC, ETH e por aí vai.

• Conta é uma questão de organização, para o usuário separar como bem entender.

• Troco serve para separar pagamentos de retornos, pode ser 0 ou 1, booleano.

• O index é um número de 0 até 4 bilhões. Cada um representa um conjunto diferente formado por chaves pública e privada + endereço.

A sequência de derivação m/84’/0’/0’/0/5 sempre vai gerar o mesmo par de chaves, não importa qual software eu use nem o momento, nem se algum novo BIP foi adotado.

Considerando que você pode ter 4 bilhões de contas diferentes, são muitos endereços para uma Chave Mestra de míseros 256 bits (o mesmo tamanho de uma PrivKey).

Seed Phrases

Em seguida veio o BIP 39 que convertia essa Chave Mestra em uma sequência de palavras fáceis de memorizar. Sem muito segredo aqui. Criaram uma lista de 2048 palavras padronizadas em várias línguas, onde cada palavra representa 11 bits de informação.

O processo funciona assim: uma sequência aleatória de 128 a 256 bits é gerada (dependendo se você quer 12, 18 ou 24 palavras). Um checksum é adicionado ao final para detectar erros de digitação. Essa sequência é então dividida em pedaços de 11 bits, e cada pedaço corresponde a uma palavra da lista.

Por exemplo, uma seed de 12 palavras representa 128 bits de entropia + 4 bits de checksum = 132 bits totais, divididos em 12 grupos de 11 bits. Já uma seed de 24 palavras oferece 256 bits de entropia + 8 bits de checksum. Essas palavras, através de uma função criptográfica chamada PBKDF2, geram a Chave Mestra Estendida de 512 bits que desbloqueia toda a árvore HD.

Com seed phrases você pode guardar todos os seus endereços anotando ou memorizando uma informação, uma única vez.

Chaves Estendidas (Extended keys)

A Chave Mestra Estendida, também conhecida como Chave Privada Estendida(xprv), é dividida em dois blocos de 256 bits. O primeiro é a Chave Privada Mestra(m) enquanto o segundo é a Master Chain Code. Esse último é necessário para derivar as chaves filhas na árvore.

Você pode usar m para derivar a Chave Pública, juntar com a Master Chain Code para obter a Chave Pública Estendida(famosa xpub) para derivar as PubKeys filhas e os endereços.

Derivação normal vs hardened

Com a derivação normal é possível derivar as PubKeys e endereços filhos somente com a Chave Pública Estendida. Com a derivação hardened, é necessário também a Chave Privada Estendida para derivar qualquer coisa dos filhos

Com a derivação normal, caso a PrivKey de um dos filhos seja descoberta é possível, usando a Chave Pública Estendida do pai, descobrir as chaves de todos os irmãos, comprometendo uma camada inteira da árvore. Ao exigir a xprv, a derivação hardened impede que outras camadas acima sejam comprometidas também.

Essa proteção extra foi propositalmente deixada de lado para as últimas camadas da árvore de derivação para permitir carteiras watch-only e servidores que podem gerar endereços novos para pagamentos online sem comprometer a xprv de nenhuma camada ao mesmo tempo que têm acesso a xpub.

Geralmente a notação usada pelos softwares de carteiras para a árvore de derivação usa um apóstrofo para representar as camadas protegidas pela derivação hardened:

MasterKey/Purpose’/CoinType’/Account’/Change/AddressIndex

Digamos que a xpub da sua conta esteja em um servidor em um website gerando novos endereços diariamente para pagamentos online. Imagine que algum bug no software ou uma invasão ocorra no sistema de forma que um atacante tenha acesso as chaves privadas dos AddressIndex. Ele conseguiria então descobrir a xprv da camada superior por meio de um cálculo matemático simples. Ele poderia continuar subindo camadas enquanto tivesse a xpub da camada superior. Como a camada de contas é de forma padronizada protegida por derivação hardened, o risco de ter suas outras contas ou seed descobertas é eliminado completamente.

Ativar derivação hardened para todas as camadas é possível, mas ao custo das vantagens que falei antes. O comportamento padrão de softwares de carteiras Bitcoin modernas é de usar derivação normal para índices de 0 até 2³¹-1(2.147.483.647) e derivação hardened para 2³¹ até 2³²-1 (2.147.483.648 a 4.294.967.295) totalizando os 4 bilhões de índices que falei antes.

Conclusão

Saímos de chaves avulsas, independentes e aleatórias para carteiras com uma estrutura bem definida e geração de chaves repetível. Esse foi um dos maiores saltos em quesito experiência de usuário(UX) desde a criação do Bitcoin. Permitiu gerenciar todos os fundos de uma pessoa sob um único dado e o transformou em uma sequência de palavras memorizável.

Mas há algo mais profundo acontecendo aqui. Toda essa complexidade, Scripts, pilhas, derivações hierárquicas, checksums, existe para resolver um problema que o sistema financeiro tradicional nunca precisou resolver: como dar a uma pessoa soberania real sobre o próprio dinheiro, sem depender de ninguém para guardar, autorizar ou validar nada.

Em uma rede descentralizada onde ninguém é soberano, ninguém pode validar sua identidade ou posse. Isso tem que ser feito através da matemática da Criptografia de Curva Elíptica com suas Chaves Públicas e Privadas. O que é bem complicado quando você precisa gerenciar múltiplos endereços. Por isso as carteiras precisaram evoluir para lidar com o peso desse gerenciamento e foi exatamente isso que o BIP 32 e o BIP 39 fizeram.

Quem tem a seed, tem os fundos, sem intermediários, sem permissão, sem horário de funcionamento. O preço dessa soberania é a responsabilidade. Doze palavras escritas num papel são, ao mesmo tempo, a coisa mais simples e mais poderosa que existe no sistema. Não existe suporte para recuperar o acesso caso você as perca. Não existe seguro. Não existe recurso.

”Not your keys, not your coins.” Simples assim.

Se você roda um full node de Bitcoin e ao mesmo tempo mora numa caverna, no dia 24 de Agosto de 2017 você viu algo sem precedentes acontecendo na blockchain: transações sem endereço definido. Semelhantes àquelas feitas para scripts e smart contracts, mas um tipo específico que podia ser realizado por literalmente qualquer pessoa.

Sim, você leu corretamente: Qualquer um poderia gastar aqueles bitcoins. Mas claro que a história não é tão simples assim.

SegWit

O que acontece é que à época estava sendo lançado uma alteração no Bitcoin: o SegWit.

SegWit, uma abreviação para Segregated Witness, é um conjunto de BIPs que reorganiza a estrutura dos blocos, separando as assinaturas (witness) das transações base. Isso permite que os dados de assinatura “contem menos” para o limite de 1 MB, aumentando a capacidade efetiva dos blocos.

Outra vantagem crucial foi resolver a maleabilidade de transações — permitindo que o ID da transação (txid) não pudesse mais ser alterado. Isso abriu caminho para protocolos de segunda camada como a Lightning Network. Pretendo escrever sobre isso no futuro.

Soft Fork vs Hard Fork

Por se tratar de uma mudança nas regras de consenso, isso necessariamente gera um fork, uma divisão na rede entre nós que adotam a mudança e nós que não adotam.

Hard Forks são divisões brutas da rede, onde cada lado aceita e trabalha em cima de uma blockchain diferente.

Soft Forks são divisões onde as regras de um dos lados se torna mais restritiva, mas ainda dentro do que os dois lados aceitam. Assim, a blockchain não se divide.

Retrocompatibilidade

O resultado disso é uma atualização retrocompatível. Todos os blocos aceitos pelos novos nós, são aceitos pelos antigos. Mas nem todos os blocos aceitos pelos nós antigos são aceitos pelos novos.

Regras antigas: “X é válido se condições A, B e C”

Soft fork: “X é válido se condições A, B, C e também D”

Como nós antigos continuam podendo usar a rede, Soft Forks são preferíveis.

Para ser um soft fork (compatível com versões anteriores), o SegWit precisava que:

• Nós antigos aceitassem blocos com transações SegWit

• Nós novos aplicassem regras extras de validação

• Não causasse fork da blockchain

Detalhando o SegWit

Enquanto novos nós olham no novo campo witness:

witness: <assinatura> <pubKey>

Nós antigos continuam olhando nos campos antigos:

scriptPubKey: OP_0 <hash qualquer de 20 ou 32 bytes>
scriptSig: [vazio]

Onde

- scriptPubKey: define CONDIÇÕES para gastar

- scriptSig: fornece DADOS para satisfazer as condições

Ao receberem esses valores ao invés de um script de verdade, qualquer um pode satisfazer as condições para gastar os fundos daquela transação.

Exemplo comum de valores válidos:

scriptSig: <assinatura> <pubKey>
scriptPubKey: OP_DUP OP_HASH160 <hash160(pubKey)> OP_EQUALVERIFY OP_CHECKSIG

Em outras palavras, para resumir:

SegWit não usa o campo designado para dizer quem tem controle sobre o output(UTXO) criado naquela transação, então nós que não entendem SegWit pensam que aquele output pode ser gasto por qualquer um.

Nós que entendem SegWit fazem a verificação do campo witness e rejeitam transações que não atendam as condições específicas do SegWit(diferente do scriptPubKey).

Vantagem real do SegWit

Pelo que eu disse até aqui parece que o SegWit meramente move as assinaturas das transações para outro lugar no bloco. Que vantagem real ele traz? E qual a relação disso com o título do texto?

Antes as assinaturas estavam unidas de forma inseparável às transações, e por isso entravam no limite máximo de 1 MB que os blocos têm. Com SegWit, a parte principal do bloco fica preenchida de forma contígua somente por dados das transações, enquanto os witness ficam segregados em uma parte separada.

┌─────────────────────────────────────┐
│ Block Header (80 bytes)             │
├─────────────────────────────────────┤
│ Transaction Count                   │
├─────────────────────────────────────┤
│ TRANSAÇÕES (parte principal)        │ ← Contíguas, SEM witness
│   TX1: version, inputs, outputs...  │
│   TX2: version, inputs, outputs...  │
│   TX3: version, inputs, outputs...  │
│   ...                               │
├─────────────────────────────────────┤
│ WITNESS DATA (separado)             │ ← Todos os witness juntos
│   Witness para TX1                  │
│   Witness para TX2                  │
│   Witness para TX3                  │
│   ...                               │
└─────────────────────────────────────┘

Em essência, witness contém as assinaturas e condições de gasto — o mesmo conteúdo que antes ficava embutido na transação, mas agora em local separado.

Aqui está o pulo do gato: o SegWit redefiniu o que conta como “tamanho do bloco”.

Antes, a regra era simples: “bloco não pode ter mais de 1 MB de dados, ponto final”. Isso limitava quantas transações cabiam, já que cerca de 60% de cada transação era ocupado pela assinatura.

O SegWit mudou a regra para: “bloco não pode exceder um certo peso, onde dados da transação base pesam 4x mais que dados witness”. Isso significa que assinaturas agora “contam menos” para o limite — é como se você pudesse colocar mais coisas numa mala porque roupas agora “pesam menos” que antes, mesmo ocupando o mesmo espaço físico.

O resultado? Blocos podem ter ~1.8-2.2 MB de dados reais (transações + assinaturas), mas para fins da regra de consenso ainda “cabem” dentro do limite.

Para nós antigos, nada mudou — eles só veem a parte base (~1 MB) e pensam “tudo normal, dentro do limite”. Nós novos veem o bloco completo (1.8-2.2 MB) mas aplicam as novas regras de peso que tornam isso válido.

Em resumo: SegWit não economizou espaço de armazenamento — ele trapaceou no sistema de medição para permitir blocos maiores sem fazer hard fork.

Por que isso não quebra nada?

Nós antigos continuam vendo apenas a parte base das transações (sem witness), que fica abaixo de 1 MB — respeitando o limite antigo. Eles literalmente não enxergam os dados witness que foram adicionados. Ou seja, o limite de tamanho do bloco continua sendo respeitado retroativamente.

Por outro lado, witness é um campo importante que nós novos se importam. O que garante que as regras SegWit estão sendo respeitadas se nós antigos não fazem ideia sobre essas regras e não as usam para fazer sua validação?

Quem faz essa verificação são os mineradores que são nós novos por uma maioria quase unânime.

Adoção do SegWit (Mineradores)

Como já expliquei em um texto anterior o Bitcoin é um protocolo de consenso onde mudanças podem ser feitas desde que seja o consenso da rede. O BIP 9 definia um critério claro para organizar essa mudança repentina gerando o menor caos possível.

O BIP 9 dizia que os mineradores poderiam adicionar uma informação extra nos seus blocos de forma padronizada para sinalizar apoio. Caso num período de 2016 blocos seguidos 1916 blocos sinalizassem apoio, em mais 2016 blocos todos deveriam começar a usar as novas regras. Ou seja, se no período de duas semanas pelo menos 95% dos mineradores apoiassem as novas regras, em mais duas semanas eles poderiam usá-las.

De Novembro de 2016 até Maio de 2017 a sinalização dos mineradores apoiando SegWit ficou girando em torno de 30% sem sinal de aumentar. Muita coisa aconteceu nesse período entre Maio e Agosto de 2017 que tornam o SegWit a maior mudança no Bitcoin e a mais turbulenta.

Em 24 Maio 2017, o BIP 148 (UASF - User Activated Soft Fork) definiu que os nós que o adotassem iriam rejeitar blocos de mineradores que não sinalizassem apoio ao SegWit a partir de 1 de Agosto de 2017. Isso causaria um Hard Fork!!

Em 14 de Junho, o BIP 91 teve seu código finalizado. Ele servia como um passo intermediário na busca do consenso, definia regras mais brandas para ativação do SegWit: Somente 80% de sinalização num período de 336 blocos (2-3 dias).

Em 19 de Julho os 80% de sinalização do BIP 91 são atingidos evitando o fork do UASF, que aconteceria em menos de duas semanas.

Entre 23 e 24 de Agosto a rede atinge 100% de sinalização para SegWit.

Toda essa luta era necessária por um motivo. Em um Soft Fork os nós antigos perdem a capacidade de validar plenamente as transações seguindo o padrão SegWit pelos motivos já discutidos. Mas com a grande maioria dos mineradores fazendo essa validação, esse problema é mitigado. Sem falar que os nós antigos que não adotaram SegWit na main-net são uma raça em extinção.

Vale mencionar que em 1 de Agosto de 2017, antes mesmo do SegWit ativar, uma facção contrária à mudança executou um hard fork criando o Bitcoin Cash (BCH) — uma blockchain separada que rejeitou o SegWit e aumentou o tamanho dos blocos para 8 MB.

Conclusão

Então se você é um nó desatualizado e usa uma versão anterior ao Bitcoin Core 0.13.1, lançado em 15 de outubro de 2016, você começou a ver bitcoins grátis sendo distribuídos pela rede e transações tentando usar esses bitcoins sendo recusadas por não ter um certo campo witness que você não faz ideia de pra que serve. Isso se deve aos mineradores que em sua totalidade aderiram ao SegWit e fazem a correta validação de todas as transações segundo as novas regras.

Nós antigos ainda podem usar a rede, fazer transações e receber pagamentos normalmente, apesar de usar um modelo de transação antigo que deixou de ser competitivo com os novos modelos, que pagam menos taxas pela sua otimização.

Respondendo ao título: Eles têm dono, mas nós antigos não sabem disso. Eles são UTXOs que foram criados por transações usando SegWit.

Foi uma boa oportunidade para explorar como o SegWit mudou a forma como o Bitcoin funciona. E ainda deu pra falar sobre a história do Bitcoin e dar uma ideia de como funciona BIPs e alterações das regras de consenso.

As discussões sobre SegWit se iniciaram em 2015 e se concretizaram totalmente em 2017, mas a adoção pelas pessoas não foi tão imediata como pode ver pela tabela a seguir mostrando a quantidade de transações feitas com SegWit e o número de nós reconhecendo e propagando transações SegWit.

Data          | % TXs SegWit | % Nodes
--------------|--------------|----------
Ago 2017      | ~10%         | ~60%
Set 2017      | ~12%         | ~65%
Dez 2017      | ~14%         | ~70%
Mar 2018      | ~30%         | ~75%
Dez 2018      | ~40%         | ~80%
2019          | ~50%         | ~85%
2020          | ~60%         | ~90%
2021          | ~70%         | ~92%
2024          | ~85%         | ~95%

Mudanças no protocolo são possíveis, mas muito difíceis de serem feitas. Elas exigem a aceitação de quase toda a rede. Bitcoin pode mudar, mas resiste a isso. Acho isso perfeito pois gera a previsibilidade que ele vai continuar com as características que desejamos e amamos enquanto pode se adaptar contra possíveis inimigos como computação quântica ou qualquer outra coisa quem ainda nem imaginamos.

Se gostou desse texto, leia outros na mesma pegada:

A diferença entre os humanos do século 21 depois de Cristo e os do século 21 antes de Cristo não é biológica. A diferença mora no conhecimento acumulado pela raça humana.

Enquanto a tradição oral tinha um limite de tamanho e um tempo de vida útil antes de se perder na memória de uma comunidade pequena, a escrita permitiu que o conhecimento transcendesse o espaço, podendo ser levado a outros povos, e transcendesse o tempo, podendo resistir e ser preservado para as próximas gerações com muito mais eficácia.

Conhecimento acumulado

Tecnologia atualmente é vista como dispositivos digitais como computadores, sensores e maquinário, mas a definição é algo bem mais abrangente:

técnica ou conjunto de técnicas de um domínio particular.

A invenção da escrita foi revolucionária e permitiu, inclusive, a construção de sociedades maiores e mais complexas graças ao registro de leis.

Posteriormente, com a criação da imprensa e o índice cada vez maior de alfabetização, a produção e consumo de textos aumentou exponencialmente nos últimos séculos.

Rapidamente esse corpo de conhecimento acumulado e descentralizado cresceu a um ponto onde seria impossível uma única pessoa conseguir ler e aprender todo o conhecimento e tecnologia produzido. Tentativas como a enciclopédia foram feitas, mas logo descontinuadas pela natureza impossível da tarefa: catalogar e condensar o conhecimento sobre tudo.

Foi quando nasceram os especialistas. O sentido de existirem especialistas se contrapõe ao generalista, muito mal visto nos dias de hoje.

O pato nada, o pato anda, o pato voa. O pato não faz nada direito.

A conotação cada vez mais pejorativa do termo generalista mostra uma intuição verdadeira sobre a natureza do conhecimento. É impossível que uma pessoa saiba tudo sobre tudo. Por isso é necessário um especialista, alguém que escolhe propositalmente não perder tempo e focar em uma única área. Sendo assim capaz de chegar mais longe, fazer descobertas e desenvolver novas técnicas.

Houveram sim muitos casos na história de generalistas famosos por conseguirem resultados admiráveis desafiando todo o bom senso: os famosos polímatas. Leonardo Da Vinci e outros tantos se destacaram na história por fazerem avanços em várias áreas do conhecimento comparáveis aos avanços de especialistas habilidosos. Isso se deve, claro, à uma genialidade fora de série, mas também à tendência da época de separar menos os assuntos do que atualmente.

Coisas como a criação das universidades, revolução industrial, urbanização e globalização deram um novo salto que somado ao acúmulo natural do tempo fizeram esse corpo de conhecimento humano crescer ao ponto onde não era mais possível uma pessoa saber tudo sobre uma área sequer. Assim, especialistas tinham uma literatura muito vasta e precisavam se contentar em estudar e desenvolver uma sub-área dentro da sua área de estudo.

Lembro do meu professor de história no ensino médio explicando a lógica do ensino superior (ele estava terminando seu doutorado na época).

Imagine um grande círculo. Este é todo o conhecimento da humanidade. Veja esse círculo menor contido no maior. Essa é a história. Ela estuda os acontecimentos passados e os conecta em relações de causa e efeito. Eu me graduei em história e me especializei na história do Brasil (e desenhou mais um círculo menor dentro do segundo). Agora eu estou fazendo um doutorado, não sobre a história de Sobral (minha cidade), mas sobre como a história da cidade foi manipulada pelos políticos locais nos registros oficiais. Percebem como vai afunilando? (e desenhou um ponto no círculo mais interno)

Ele falava com orgulho como naquele ponto específico desenhado no quadro não havia ninguém mais competente do que ele. Um domínio simples, mas poderoso.

Outra boa analogia é a de círculos concêntricos. O desenvolvimento humano, o aprimoramento da tecnologia, é a adição de uma camada externa, com área maior. Imagine que você deve estudar as camadas internas, subir até a camada externa para só então começar a construir a nova camada, seria desnecessário e ineficiente. Na prática, o que fazemos durante a vida inteira no ensino básico é estudar com inteligência o mínimo possível das camadas interiores. Somente o suficiente para podermos seguir em frente, às vezes com grande quantidade de abstrações.

Assine agora

Camadas de abstração

Vamos pegar como exemplo um computador pessoal nos dias de hoje. Ele tem várias camadas de abstração que chamamos de Modelo OSI. São 7 camadas no total que são desenvolvidas em paralelo.

A Camada 1 - Física: trata de sinais. Voltagem, luz, rádio, ruído, conectores, bits crus passando. É o mundo dos elétrons e fótons. O mundo real.

A Camada 3 - Rede: decide por onde os dados vão passar para chegar ao destino, mesmo atravessando várias redes diferentes. Roteadores operam aqui.

A Camada 4 - Transporte: cuida da confiabilidade. Ordem dos pacotes, retransmissão, controle de congestionamento, portas. TCP e UDP vivem aqui.

A Camada 6 - Apresentação: Aqui os dados ganham significado. Codificação, compressão, criptografia. UTF-8, JSON, TLS conceitualmente passam por aqui.

A Camada 7 - Aplicação: é a que você usa através de coisas como HTTP, FTP, SMTP, DNS, navegador, e-mail, APIs.

Eu, como programador, não preciso saber como o computador se comunica com outros pela rede nem como a rede em si funciona. Me basta saber que o computador se comunica e que essa conexão pode ser através de requests pontuais ou comunicação contínua com troca perpétua de informações.

Já os engenheiros que trabalham com a parte física não precisam saber como sites são feitos ou como games são programados para aprimorar a tecnologia de fibra óptica e eletromagnética que o computador usa para trocar informação com a rede.

E você não precisa saber de nada disso para usar um computador ou um celular para consumir conteúdo na camada de Aplicação.

Camadas de Abstração te permitem seguir em frente com zero conhecimento sobre como prédio que você subiu foi construído e com a impressão de que ele não vai cair de uma hora pra outra. Abstração é importante para que um aspirante a inovação consiga aprender o suficiente para criar nova tecnologia em cima do que já existe dentro do seu tempo de vida.

Gênios

Pessoas geniais são aquelas com criatividade para aplicar o pouco conhecimento que elas tem no grande esquema das coisas para aplicar uma ideia inovadora, para criar uma técnica útil. Gênios são pessoas com habilidades incríveis de aprendizado que conseguem navegar por essas Camadas de Abstração e aprender o suficiente sobre elas para otimizar processos e unir técnicas aparentemente não relacionadas.

Enquanto criatividade não pode ser controlada, o número de coisas a serem aprendidas cresce a cada dia.

A próxima camada

A questão então se torna: como manter essa corrida? Como garantir que novos gênios continuem surgindo quando o volume de conhecimento necessário para chegar à “borda” do círculo só aumenta?

Temos basicamente duas opções. A primeira é continuar estreitando os domínios de expertise - transformar especialistas em hiper-especialistas, dividindo o conhecimento em pedaços cada vez menores até que alguém consiga dominar o suficiente para contribuir. Mas isso tem um limite prático: coordenar milhares de especialistas trabalhando em fragmentos microscópicos do conhecimento é lento, caro e ineficiente.

A segunda opção é criar uma nova camada de abstração. Assim como a escrita abstraiu a necessidade de estar fisicamente presente para transmitir conhecimento, precisamos de algo que abstraia o processo de consumir todo o conhecimento acumulado.

E se pudéssemos comprimir não apenas textos individuais, mas a essência de milhões deles? E se, em vez de passar anos lendo e conectando ideias dispersas em bibliotecas infinitas, você pudesse conversar com o conhecimento acumulado da humanidade e chegar direto ao que precisa para sua inovação específica?

LLMs

A tradição oral permitia que conhecimento morresse. A escrita permite o crescimento teoricamente ilimitado do conhecimento, mas à custa de não ser completamente acessível para uma pessoa. E se os modelos de linguagem como ChatGPT, Grok, Gemini e Claude fossem a próxima tecnologia capaz de levar a produção de tecnologia a outro patamar?

Large Language Models(LLMs) são modelos treinados para repetir padrões dos textos usados no seu treinamento de forma probabilística. De forma prática LLMs podem ser pensados como arquivos ZIP, uma compressão de conteúdo e conhecimento de centenas ou milhares de gigabytes de informação condensada em poucos gigas. Mesmo na minha máquina modesta sem placa de vídeo, consigo rodar modelos de 3 ou 7 bilhões de parâmetros pesando entre 1 e 4 gigabytes capazes de conversar em múltiplas línguas, fazer raciocínios simples e até mesmo citar textos de cor, sem acesso a internet.

Isso mesmo, a humanidade chegou a um ponto onde conseguiu ajustar parâmetros de um programa para reproduzir textos já escritos de uma forma comprimida para ocupar menos espaço ao custo de um comportamento não determinístico, mas probabilístico. Se você ler esse paper da Meta você vai entender o quão conceitualmente profundo é substituir espaço de armazenamento por tempo e energia gasta no treinamento de forma a conseguir respostas tão precisas, quase como se os textos estivessem realmente ali, guardados.

E mais importante do que ocupar menos espaço, isso permitiu a esse programa ligar essas ideias ao ser guiado por uma pessoa que sabe onde quer chegar.

Alguém com o mínimo conhecimento sobre uma área consegue usar da IA para pular etapas e construir coisas acima do próprio nível. IA não pode fazer isso sozinha, mas é uma ferramenta com potencial enorme para acelerar o processo de aprender o que a humanidade já construiu e impulsionar alguém direto para o endgame.

Conclusão

Como alguém da TI, eu, mais do que você, estou cansado de gente falando merda sobre IA, mas não posso deixar de falar sobre isso pois é revolucionário, não ironicamente.

Vejo muita gente usando IAs das formas mais estúpidas possíveis. Isso me lembra da imagem de índios pegando espadas pela primeira vez, não pelo cabo, mas pela lâmina. Maravilhados pelo brilho do metal, esquecemos da utilidade e do potencial do uso direcionado do equipamento.

Pelo menos eu acho essa uma discussão melhor do que entrar em debates sem fim sobre “Será que a IA vai criar consciência?” ou “Será que a IA vai ficar mais inteligente do que humanos?” e filosofia sem fim tentando definir o que é e o que não é inteligência.

Fato é, que desde o princípio tive a noção clara de que IA vai automatizar o conhecimento atual e deixar os humanos de verdade livres para criar coisas novas.

Um especialista gasta 80% do seu tempo aprendendo o que já foi descoberto, -dominando sua área - e só 20% inovando/tentando criar coisas novas. A IA pode permitir que isso vire um 30/70, por exemplo. Em vez de passar anos subindo cada camada, você pode usar a IA como um atalho - pular direto para a borda externa onde o novo conhecimento é criado.

Isso inverte a lógica atual: ao invés de “IA vai roubar empregos/criatividade”, a IA pode libertar humanos do trabalho repetitivo de processar conhecimento antigo para focar no que realmente importa - inovação genuína.

Na vida adulta, quase não são criados novos neurônios além da taxa de reposição. Neurônios morrem, novos são criados para repor. Diferente da infância, onde nosso cérebro aumenta constantemente, tanto em volume quanto em densidade pelo aumento no número deles.

A maior mudança fisiológica que ocorre na massa cinzenta é a organização do número constante de neurônios. Neurônios tem uma cabeça que recebe estímulos de outros neurônios e uma cauda que manda esses mesmos estímulos para outros. Eles podem se conectar com vários neurônios, tanto pela cabeça quanto pela cauda. Isso cria uma gama de combinações de como eles podem se conectar entre si que aumenta de forma exponencial. Em um cérebro com dezenas de bilhões deles, as possibilidades de conexões é praticamente infinita.

De forma bem simplificada, memórias são um estado do cérebro onde circuitos específicos estão ativados. Uma certa vivência que você viveu ativou um desses circuitos que já existia, mas que nunca tinha sido usado, ou usado raramente . Vivências parecidas ou pensamentos podem reativar aquele caminho, te fazendo experienciar aquela situação novamente na sua cabeça. Conforme esses circuitos são usados para repassar aquela experiência na sua mente, as conexões daqueles neurônios se fortalecem, tornando menos provável que eles se separem pela plasticidade do cérebro, que faz os neurônios mudarem suas conexões e até mesmo sua posição. Essas conexões fortalecidas facilitam que o cérebro atinja aquele estado com pouca exploração. Como se mesmo o menor dos estímulos levasse àquele estado.

Pensamentos funcionam da mesma forma. Linhas de raciocínio são como se você navegasse nesses caminhos buscando aquele que te leva de A até B dentro desse espaço estranho. Uma vez que você acha o caminho correto, fica mais fácil repeti-lo. Aqui ainda estamos no princípio do intelecto humano e nas suas capacidades mais basilares: Lembrar e fazer ligações lógicas. Existem inúmeras operações mais complexas e com mais passos como aritmética.

Operações aritméticas como somar dois números de um algarismo envolve ligar o conceito daqueles dois números com um terceiro. Chamamos isso de “decorar a tabuada”. Para números maiores, com mais algarismos, usamos um circuito específico que envolve manter números em memória de trabalho e executar um algoritmo para cada dígito, um de cada vez. Aos poucos vamos guardando esses resultados na memória e agilizando o processo, mas já estou me desviando demais.

Quando aprendemos conceitos e operações novas não temos circuitos neuronais para executá-los de uma vez. Precisamos fazer uso de circuitos genéricos e ineficientes. Ao dormirmos, nosso cérebro reproduz certas ativações que ocorreram durante o dia de forma acelerada. Ele analisa a topologia e formato dos caminhos ativados e fortalece as conexões entre neurônios que ativaram de forma conjunta. O resultado final é um caminho eficiente com menos bifurcações, menos energia necessária para ativar, mais curto e com conexões mais fortes.

Eu nunca dirigi, mas os relatos que ouvi dizem que no começo você precisa de foco intenso em todos os detalhes dos arredores e uma vez que você domina o ato de dirigir isso é substituído por uma direção intuitiva que não consome tanto foco e energia. Isso é a neuroplasticidade agindo como deveria: um comportamento complexo e que exige atenção sustentada dizendo quais ações devem ser tomadas sendo substituído por um circuito que pula do começo direto para o fim.

Assim como você não precisa passar por uma longa linha de raciocínio para frear ao ver um pedestre na sua frente, você não precisa lembrar do cheiro que sentiu enquanto seu professor te ensinava a fazer multiplicações e potências. O circuito “estímulo -> resultado” é reforçado. As bifurcações indesejadas que não afetam o resultado são podadas. Os passos intermediários são substituídos pelo caminho mais eficiente.

Até aqui eu falei de circuitos e caminhos, mas diferente das redes neurais que estamos acostumados - feitas pelo homem - a topologia do cérebro não é linear, mas extremamente intrincada. Não falamos que a ativação de um neurônio ou conjunto de neurônios A se propaga e ativa um outro conjunto de neurônios B. O mais correto é dizer que um estado A do cérebro como um grande conjunto, obtido por estímulos externos e internos, leva para um novo estado B. B é o novo estado que leva para um terceiro estado C. Isso torna B um estímulo interno que leva para o próximo. Isso precisa ser dito para que você entenda que o cérebro não é uma máquina complexa com entrada e saída bem definidas , mas um loop, um circuito fechado que se retroalimenta.

Para programadores, ele é um while True usando variáveis globais que, às vezes, são alteradas por programas externos.

Voltando para a simplificação. Um circuito leva a ativação de A até B por inúmeros caminhos, devido as quase infinitas conexões que existem no cérebro. Durante o sono o cérebro reproduz esse processo e percebe a relação causal entre A e B: A ativa e logo em seguida B ativa. O cérebro, então, fortalece as conexões desses caminhos de forma a favorecer o caminho mais curto, de preferência um que não dê a volta ao mundo, disparando inúmeras memórias e distrações. O custo de ativar o circuito A->B diminui. O comportamento passa a precisar de menos atenção, o resultado se torna previsível, como uma reação impulsiva ou instintiva. Claro que depende da complexidade do comportamento, mas a tendência é essa.

Simplificar o circuito responsável por uma ação ou pensamento não é importante somente para economizar carga mental. Fazer essa simplificação é preparar a fundação na qual você poderá construir algo em cima.

É como fazer um algoritmo complexo com laços de repetição, recursão e várias outras técnicas para resolver o problema imediato para logo em seguida empacar em continuar, desenvolver, adicionar novas funcionalidades. Primeiro você precisa desatar o nó que você fez, entender a estrutura para só então refatorar, mudar o código fonte. Agora sim, o resto flui com naturalidade, depois de uma noite de sono, saindo da analogia.

Já me peguei muitas vezes tentando manter longas linhas de raciocínio em mente e tentando seguir em frente. Era impossível. Antes eu teria que sintetizar aquilo em algo mais linear e simples, mesmo as custas de perder alguns nuances para só então seguir, por vezes, em outro dia.

Embora eu não me considere versado nessa área, isso também se aplica para a criatividade. A tão recorrente experiência de um escritor de ter ideias nos mais variados momentos, ao ponto discutirem técnicas para anotá-las o mais rápido possível antes que esqueçam, não é nada mais que o estímulo do ambiente os levando por novos caminhos criados anteriormente pela plasticidade do cérebro. Não quero diminuir a complexidade desse mundo ao material então, pondo em outras palavras, diria que o cérebro dá uma mãozinha no processo de conectar os pontos.

Quando você inicia o processo de explorar um raciocínio, você está enviesado, preso a um único caminho no cérebro. A neuroplasticidade te ajuda, depois de um tempo, a explorar outros caminhos que pareciam não existir antes: ideias, processos, experimentos, técnicas, abordagens e etc.

Isso me ajudou a entender que existem barreiras temporais no aprendizado. Não conseguir agora não quer dizer que eu não consiga depois de um descanso, de um intervalo ou de uma mudança de ares. “Nove grávidas não fazem um bebê em um mês” e você não devia tentar aprender tudo de uma vez.

Método Feynman

Um dos melhores métodos de aprendizado é o de ensinar a alguém algo que você está aprendendo. A tentativa de ensinar te força a passar de forma explícita por todos os passos do raciocínio e avaliar de uma nova perspectiva. Também te faz entender quais tópicos devem vir antes de forma a construir o conhecimento, como andares de um prédio.

No começo você tem uma intuição comprimida, algo que pula do início para o fim, do problema para a resposta. Esse tipo de circuito funciona bem para uso imediato, mas é rígido. Ao tentar ensinar, essa intuição precisa ser esticada. Os passos intermediários voltam a existir e o raciocínio se torna explícito.

Antes, o circuito resolvia um problema. Depois, ele passa a suportar variações: generalizações, analogias, exceções, combinações com outros conceitos. O que era um atalho vira uma estrutura.

Uma analogia topologicamente imprecisa do que realmente acontece com os neurônios de fato, mas vai te fazer entender bem é: Ao tentar explicar um conteúdo novo, você está tornando uma corda lisa em uma corrente com elos furados. Desses furos você pode encaixar novos elos de outras correntes. Dessa forma você pode construir em cima, abrir caminho para novos raciocínios e aprender derivações do assunto original. Mas primeiro é preciso desfiar a corda por completo.

Por sinal, meus textos sou eu aplicando o método Feynman na prática. Eu recomento fortemente que você escreva sobre assuntos do seu interesse e coisas que você quer aprender. Nem precisa publicar, mas garanto que traz clareza produzir uma peça coesa do início ao fim sobre um assunto.

Repetição Espaçada

Já a repetição espaçada leva a neuroplasticidade ao extremo te forçando a revisitar aquele assunto diversas vezes em dias diferentes. Na maioria das vezes o método é apresentado baseado na curva de esquecimento, que não deixa de ser verdade, mas entender o porquê da curva descer cada vez mais devagar é crucial para mostrar o poder da técnica.

No dia 1 você aprende a informação. Durante o sono seu cérebro se reorganiza internamente alterando as conexões dos neurônios responsáveis por fazer as operações e ações relacionadas àquela informação e os necessários para puxar a informação. No dia 2, se você revisar, vai estar reativando a memória, a fortalecendo. E também vai estar reutilizando esses mesmos circuitos aplicando-os em novas coisas que você aprender depois.

Uma boa metáfora para representar o aprendizado com repetição espaçada é o de uma construção onde você faz uma fundação que você vai fortalecendo, a alargando enquanto constrói em cima. Você continua alargando a base e o andar de cima enquanto constrói o topo. No fim você tem uma pirâmide que não tomba, não importa o que aconteça.

Os efeitos são compostos, quanto mais conhecimento interligado você aprende usando esse método, mais vantagens você colhe desse método. É por isso que ele é muito usado para o aprendizado de idiomas. Eu já escrevi sobre como aprendi inglês durante a pandemia usando repetição espaçada.

Conclusão

Queria te fazer entender neuroplasticidade como algo diferente de um termo vago, como o limite que o cérebro precisa para transformar intuições frágeis em estruturas estáveis.

Talvez você já tenha vivenciado a lei dos retornos decrescentes, não no sentido econômico formal, mas na experiência prática de estudar por horas e perceber que cada unidade adicional de esforço produz cada vez menos avanço real. Isso não acontece apenas por cansaço ou falta de foco, mas porque o cérebro tem uma capacidade limitada de reorganização em um mesmo intervalo de tempo.

Nem sei até que ponto explicação neurológica ajudou, mas se pelo menos a utilidade dos métodos tiver ficado clara estarei satisfeito.

Esse assunto em específico foi bem difícil e agradeceria se deixasse um comentário falando da sua experiência com Feynman e Repetição Espaçada.

Essa ligação PrivKey -> PubKey -> Assinatura é feita pela Criptografia de Curva Elíptica(ECC). Ao aplicar uma função determinística — que resulta sempre o mesmo para a mesma saída — na Chave Privada, obtemos a Chave Pública. Nesse texto eu vou explicar que função é essa e por que ela é irreversível na prática. Ou seja, é humanamente impossível descobrir a Chave Privada de uma Chave Pública específica.

Private Keys

Chaves Privadas são um número natural entre 1 e aproximadamente 10⁷⁷. Nada mais, nada menos. Chute um número dentro desse intervalo e você tem uma Chave Privada, simples assim. Quando um software de carteira de Bitcoin cria novas chaves, ele está usando funções específicas para gerar as chaves de forma determinística a partir de uma seed que foi escolhida aleatoriamente.

Public Keys

A partir de uma Chave Privada, é possível derivar uma Chave Pública. Uma é consequência matemática da outra. O resultado de uma conta. Só isso. E essa conta é feita no espaço vetorial da curva elíptica.

Enquanto a PrivKey é um número, a PubKey é um ponto da curva em um plano cartesiano. Logo, ela tem coordenadas (x,y). A Chave Pública é um ponto obtido ao multiplicar a Chave Privada por um ponto inicial da curva arbitrariamente escolhido conhecido como G.

Lembrando que operações com vetores são diferentes de operações com números. Essa multiplicação que me refiro é uma repetição de somas (G+G+...+G) de G uma certa quantidade de vezes. A soma na curva elíptica é definida de forma diferente1, de forma que sabendo o ponto final e o ponto inicial G, você não tenha como saber quantas vezes o cálculo foi repetido.

Não existe um algoritmo que descubra esse número de somas(que é a PrivKey) de forma eficiente. Só o que você pode fazer é chutar valores e multiplicar por G e verificar se resultou na Chave Pública que está buscando(ou pelo menos uma que tenha fundos). Você teria que testar números entre 0 e 115792089237316195423570985008687907852837564279074904382605163141518161494337. Boa sorte.

Assine agora

Mesmo considerando que você não quer descobrir a PrivKey de uma PubKey específica, mas qualquer PubKey que tenha saldo(aproximadamente 38 milhões de endereços com um satoshi ou mais), ainda seria uma chance de 1 em 10⁷⁰. Seria como procurar um átomo específico em todo o universo.

Em suma, fica algo como PubKey = PrivKey x Ponto G(padronizado e público). A Criptografia de Curva Elíptica é o que permite que você possa expor sua Chave Pública sem medo na internet para, por exemplo, pesquisar o saldo dos seus endereços sem ter medo de alguém descobrir sua Chave Privada. Mais importante que isso, no entanto, é que a Chave Pública é necessária para a prova de conhecimento da Chave Privada, necessária para a assinatura de uma transação.

Assinaturas

Assinar uma transação significa provar que você conhece a Chave Privada da qual a Chave Pública é derivada e cujo endereço tenha depósitos de bitcoin. Isso sem revelar sua Chave Privada, claro.

Na matemática existe um conceito chamado Prova de Conhecimento-Zero, onde você prova que sabe um segredo para outrem sem jamais dar possibilidade de o segredo ser descoberto. Assinaturas de transação formalmente não são Prova de Conhecimento-Zero pois a passagem de Chave Pública → Chave Privada pode ser feita com processamento suficiente, mas na prática funciona como se fosse.

Em termos técnicos, uma assinatura é um conjunto de um ponto na curva e um número (R, s) tal que satisfaçam a seguinte igualdade:

onde “e” é o hash da transação. Pontos na curva são representados em letras maiúsculas. O ponto R é G multiplicado por um número aleatório k. “s” é criado pelo dono da Chave Privada da seguinte forma:

Se eu multiplicar os dois lados por G fica:

Note que “kG” é a definição de R e “PrivKey x G” é a definição de Chave Pública. O assinante monta a equação 2, o verificador monta a equação 1. A equação 3 é o elo que une as duas. A igualdade só é verdadeira do lado do verificador se a PrivKey usada para criar “s” for a mesma que dá vida a PubKey com os fundos(implícito em “e”).

Conclusão

A Criptografia de Curva Elíptica(ECC) é o que garante a posse soberana das suas chaves. E da próxima vez que você disser “Not your keys, not your coins” vai lembrar disso. A Chave Privada é o que determina o controle sobre seus bitcoins, por isso precisa de uma segurança absoluta. Essa segurança é feita pela ECC.

Para quebrar a ECC, não basta ter mais poder computacional que o resto da rede — como acontece em ataques ao consenso da blockchain2. Seria necessário operar em escalas físicas absurdas ou descobrir um algoritmo capaz de inverter a multiplicação na curva, o que seria mais difícil ainda. E mesmo se um algoritmo do tipo fosse criado, os fundos de carteiras modernas não estariam perdidos automaticamente por um único detalhe: A Chave Pública não precisa ser exposta para receber pagamentos, apenas para fazê-los. Pretendo me aprofundar em carteiras em um texto futuro.

No white paper do Bitcoin, Satoshi avalia as probabilidades de um atacante modificar a blockchain para tentar desfazer seus próprios pagamentos, ficando com o dinheiro e o produto comprado. Ele conclui que, desde que o atacante tenha menos poder computacional que o resto da rede combinada, é seguro dizer que transações incluídas há certa quantidade de blocos são estatisticamente impossíveis de reverter. A seguir vou analisar as ferramentas que ele usou para concluir isso.

Sobre o ataque

Antes disso, é importante definir por que especificamente esse tipo e ataque é considerado. Por que não alterar a blockchain para desviar os bitcoins das transações alheias para si?

Uma das regras primordiais do Bitcoin é que outputs(UTXO) estão ligados a endereços. Endereços ligados à Chaves Públicas que estão ligadas à Chaves Privadas por Criptografia de Curva Elíptica e SHA-256. Muita matemática para dizer, em resumo, que bitcoins tem dono e só ele pode assinar uma transação. Mesmo que um minerador — um atacante montando um bloco falso — crie uma transação de qualquer endereço para um endereço dele e inclua no bloco, ele não será capaz de criar uma assinatura válida para a transação e o bloco inteiro será rejeitado por todos os nós da rede.

Vimos que ele não pode criar transações partindo de endereços que ele não controla. Só resta remover transações existentes em um bloco válido o substituindo por um bloco sem elas. Isso ainda é ineficaz com transações alheias. Uma vez assinada, uma transação pode ser adicionada a qualquer momento em um bloco. Se a transação já se espalhou pela rede, fazer uma corrente de blocos alternativa sem ela é adiar o inevitável. Assim, só resta como alternativa substituir um pagamento feito pelo próprio atacante para alguém por um pagamento para outro endereço próprio. Isso torna a primeira inválida se a corrente alternativa for adotada como definitiva.

Passeio aleatório

Em um passeio aleatório, a tendência quando o experimento é repetido uma quantidade massiva de vezes é que não saia do mesmo lugar. Imagine um bêbado andando em uma estrada sempre para frente, mas tropeçando para os lados. Ora ele dá um passo para a esquerda ora para a direita. Passeios aleatórios seguem a distribuição binomial que é bem conhecida no campo da estatística.

Supondo que o dito bêbado tem a mesma chance de dar um passo para a esquerda ou para a direita. Pegamos a probabilidade de um evento (nesse caso dar um passo a esquerda) acontecer e chamamos de p. A probabilidade desse evento acontecer k vezes em n tentativas é dada por:

Para n = 1 e k = 1, P(1,1,p) = p, como definimos. Isso significa: A chance do próximo passo lateral ser para a esquerda é p

Aplicando para o Bitcoin, o evento pode ser um atacante descobrir o hash de um bloco, estendendo uma cadeia de blocos modificada. Isso funciona porque a descoberta do hash que torna um bloco válido é um evento probabilístico onde a probabilidade é proporcional ao seu poder computacional. q seria a porcentagem do poder da rede que o atacante possui. Podemos igualar k e n, resultando na seguinte fórmula:

Lê-se: A probabilidade P de um atacante minerar k blocos seguidos é a porcentagem q do Hashrate elevado a k.

Como q é um número entre 0 e 1. P(k,q) fica bem pequeno conforme o número de blocos aumenta. Mas isso não importa pois um atacante não precisa minerar k blocos seguidos. Ele só precisa que a cadeia adulterada eventualmente fique maior que a cadeia formada pelos mineradores honestos, não importa quanto tempo demore.

Vamos montar isso passo a passo. Imagine a distância entre a cadeia de blocos honesta e a cadeia do atacante como um número. Se elas tem o mesmo tamanho, essa distância é zero. Se nós honestos estenderem a cadeia a distância aumenta e vira 1, caso contrário -1.

O atacante precisa esperar uma quantidade z de blocos honestos serem minerados antes de começar.

q_z = chance de uma distância z>0 virar 0, ou seja, atacante alcançar nós honestos

Independente do histórico passado, as chances do próximo evento é estático. p é a chance da cadeia honesta ser estendida.

onde q(z+1) é uma situação mais difícil pro atacante - ele terá uma desvantagem de z+1 blocos - e q(z-1) é uma situação mais fácil para o atacante - ele terá uma desvantagem de z-1 blocos.

Perceba que q_z é um lugar inicial com uma bifurcação que leva para dois caminhos distintos. p e q são a probabilidade de seguir por cada caminho.

Podemos transformar o problema em um problema quadráfico da seguinte maneira:

Resolvendo a equação temos que r = 1 ou

Então

exatamente como Satoshi concluiu.

Falando de forma gráfica, q_z é a chance do gráfico descer até o eixo x. A chance dele cair até zero algum dia, no futuro.

No tempo entre o pagamento e o recebimento do produto a rede irá criar z blocos enquanto o atacante vai criar sua própria versão em paralelo. Para calcular quantos blocos o atacante minerou nesse tempo precisamos de outra distribuição.

A distribuição de Poisson serve para calcular a probabilidade de um evento raro acontecer k vezes em um intervalo fixo. É necessário que os eventos sejam independentes. É necessário também conhecer a taxa média de ocorrência do evento. Chamamos essa taxa de λ que é dada por:

A probabilidade é dada por:

Agora sabemos a chance do atacante ter minerado $k$ blocos, que vai de 0 até infinito, com probabilidade decrescente. E a distância agora fica como z-k. Caso k seja maior que z o atacante já ganhou a corrida e o ataque foi um sucesso. Essa probabilidade é dada por:

Basta somar a probabilidade de k ser maior que z com a probabilidade seguinte. A próxima probabilidade que nos interessa é a de k ser menor que z e, mesmo assim, o atacante ultrapassar z. Isso pode ser encontrado simplesmente multiplicando q_z por P(K < z). Somando tudo fica:

Essa é exatamente a última fórmula do white paper, mas com substituindo P(K<z) e q_z por seus respectivos valores. Note que q_z aqui não é a chance de ultrapassar uma distância z mas sim uma distância z-k.

O que vimos nesse texto foi que a corrida entre nós honestos e atacante se comporta como uma variável aleatória binomial, mas isso é insuficiente para calcular a probabilidade do ataque ser bem sucedido. É preciso apelar para a distribuição de poisson. Ptotal encontrado é a probabilidade do ataque ser bem sucedido. Seu complemento é a chance de ser mal sucedido, e é simplesmente:

Leia-se: A probabilidade do ataque falhar é a chance do atacante minerar menos blocos durante a espera vezes a chance dele não alcançar uma distância de z-k blocos. Talvez o ocultamento das fórmulas concretas e específicas ajude a entender o raciocínio macro.

Podemos, assim como no white paper, fazer as contas com computador. Podemos fixar um Ptotal pequeno o suficiente e calcular qual z satisfaz essa probabilidade em função de q.

Assine agora

Nem eu esperava que a disciplina se encaixasse tão bem com esse aspecto. Tanto os resultados teóricos quanto os cálculos computadorizados indicam que o risco de ataque é bem baixo enquanto q é menor que 0.5. Apesar de z explodir para valores muito próximos a q=0.5 pela esquerda, isso não ficou bem representado pela natureza discreta dos cálculos.

Comecei pensando em escrever sobre bitcoin, mas o que predominou foi a matemática. Aprendi poucas coisas, confirmei muito do que já sabia e o mais importante: pude aplicar um conhecimento e ferramentas da engenharia em um problema real.

A maior dificulade do Bitcoin não era dar valor à um token digital. Não era criar carteiras, multisig ou qualquer besteira parecida. A maior dificuldade do Bitcoin foi resolver o gasto duplo, parece algo simples, mas exige algo que vem por padrão em qualquer sistema centralizado: Consenso.

Essa é a essência do Bitcoin: Consenso.

Como Satoshi resolveu o gasto duplo? Consenso.

Como o Bitcoin garante que os blocos não são adulterados pelos mineradores? Consenso.

Como o Bitcoin resistirá à computação quantica? Consenso.

Como a sua adoção só aumenta há 16 anos? Consenso.

Como ele pode criar adições e melhorias num sistema que parece tão intrincado e complexo? Consenso.

Consenso é uma caracteristica obrigatória para um sistema descentralizado. O oposto de uma pessoa mandando é todos mandando. Todos são soberanos, logo ninguém é soberano.

Eu posso alterar a blockchain e criar uma versão onde todos os bitcoins foram minerados para endereços meus, mas ninguém aceitaria essa nova versão a menos que eu fizesse o trabalho de minerar cada bloco, mesmo que de forma anacrônica.

O SHA-256 é responsável pelos hashes dos blocos. Existem versões do Bitcoin que usam outras, mais modernas, mais seguras, mais resistentes prontas para serem adotadas, mas elas não serão até que seja necessário.

O dinheiro estatal é um acordo onde concordamos em valorizar papel. O Bitcoin é um acordo onde valorizamos as regras, um protocolo de comunicação.

O Bitcoin tem regras que todos concordam, mesmo que tacitamente. Entre elas o número de bitcoins que existem e vão existir. E como isso é consenso de toda a rede, é a realidade, é difícil de mudar, é previsível.

Enquanto o governo valoriza mais índices diversos — como dívida externa e sonegação de imposto, por exemplo — do que o valor da moeda, os indivíduos se preocupam principalmente com seu poder de compra. E qualquer coisa que o preserve será igualmente valorizado.

Regra n°0: Criar um bloco deve custar energia ao minerador. Isso é o que chamamos de Prova de Trabalho(PoW). É feito descobrindo uma assinatura(hash) que torne o bloco válido. Se o bloco for inválido — não seguir todas as regras em consenso na rede — será ignorado e o minerador terá desperdiçado tempo, que significa dinheiro, e energia elétrica.

Em uma instituição centralizada como bancos, você não precisa saber como a tecnologia funciona. Só precisa saber das politicas da autoridade, como ela age.

O Bitcoin não tem uma autoridade que age, mas um sistema de regras que foram acordadas e que você tacitamente concorda quando usa a rede como ela está arranjada hoje. E por isso é necessário se ater ao funcionamento da tecnologia, mesmo que de forma superficial. Senão a tecnologia, pelo menos as regras e em que situações elas podem mudar. Sim, elas podem mudar.

E é disso que quero falar: das regras do Bitcoin e do consenso.

Transações

Regra n°1: As transações devem ser válidas.

Óbvio. Mas o que significa uma transação ser válida? Significa que um bitcoin existente será gasto com a assinatura do dono.

Verificar existência de um bitcoin e a assinatura do dono são coisas triviais que qualquer participante da rede faz quando recebe um bloco. Algo não bateu? Rejeita. Tudo certo? Adiciona à sua cópia local da blockchain.

Vamos ver como exatamente essa verificação é feita. Um detalhe meramente técnico: não existem bitcoins a serem gastos, mas outputs não gastos(UTXO) que são consumidos virando o input de uma transação.

Uma UTXO que já virou input de uma transação registrada na blockchain não pode ser usado, resolvendo o gasto duplo. E é muito fácil procurar a transação onde esse output foi criado. Assim, é fácil rastrear qualquer UTXO atual até sua criação.

Se todos os blocos que contêm essas transações fazem parte da blockchain, então aquele bitcoin “existe”.

Assinar uma transação é provar que você sabe um segredo sem jamais colocá-lo em risco.

O segredo é a Chave Privada, isso nunca deve estar na internet. Por meio de uma Schnorr Signature você pode verificar se uma assinatura veio do possuidor da Chave Privada sem nunca conhecê-la.

A “mágica” funciona por causa da Criptografia de Curva Elíptica(ECC). Um ponto da curva pode ser obtido fazendo uma operação simples com o ponto inicial. Repita esse processo um número bem específico de vezes. Esse número é sua Chave Privada e o ponto na curva obtido é a Chave Pública. É quase impossível saber que número levou até esse ponto.

Schnorr Signatures não foram usadas desde o começo. Antes o Protocolo Bitcoin usava ECDSA. Esse é um exemplo de regras mudando. A regra que dizia como fazer assinaturas. Nesse caso foi uma alteração para otimização da matemática, uma mera tecnicalidade das mais pequenas. O Bitcoin já passou por dezenas de alterações parecidas e existem centenas de propostas de melhoria (BIP’s) que não foram adotadas.

Existem regras que são alteradas com o consenso total da rede. Outro exemplo é o SegWit, que basicamente era uma técnica nova para segregar as assinaturas no final do bloco, ao invés de intercaladas com as transações em si. Estou falando de forma bem superficial, claro. Quase toda mudança tem seus prós e contras.

Porém, existem casos onde as mudanças nas regras não mudam o consenso da rede. É o que chamamos de fork, quando a rede se divide. Bitcoin Cash é um exemplo. Os blocos do Bitcoin tem tamanho limitado em bytes, e como só um bloco é gerado a cada dez minutos o número de transações em determinado tempo é limitado. Houve bastante discussão sobre aumentar o tamanho dos blocos, já que o tempo entre blocos não podia ser diminuído por motivos que falarei adiante. Resultado: uma parte da rede alterou a regra para blocos maiores, outra parte não. Na prática havia dois protocolos quase idênticos sendo executados e usados por pessoas diferentes. Tratamos Bitcoin Cash como uma moeda diferente porque ainda existe uma outra versão mais usada, o Bitcoin padrão, mas caso uma alteração no consenso de toda a rede acontecesse não seria um fork, mas uma transformação do próprio padrão.

Blockchain

Regra n°2: Os blocos devem demorar 10 minutos para serem minerados.

Se a quantidade ou a eficiência dos mineradores aumentar, a regra diz que as pessoas devem exigir um hash mais difícil de se obter nos próximos blocos. Essa regra pode parecer arbitrária, mas é consequência de um sistema descentralizado e da próxima regra.

Regra n°3: A blockchain oficial é a mais longa. Ou seja, aquela com mais provas de trabalho(PoW).

Em tese, qualquer pessoa pode adicionar blocos válidos à blockchain, por isso podem acontecer situações estranhas onde pessoas têm blockchains diferentes com o mesmo número de blocos em locais diferentes. Quando um nó da rede recebe dois blocos diferentes estendendo a sua corrente atual isso cria uma bifurcação que não pode ser resolvida. Podem ser que as duas correntes formadas sejam legítimas ou uma delas seja uma tentativa de substituir a cadeia legitima.

Se o nó receber um bloco que estenda uma das correntes, essa tem mais trabalho acumulado e por isso é mais confiável. Pode acontecer de duas correntes serem estendidas paralelamente. Parte da rede vai receber uma dessas correntes, parte receberá a outra, e a maioria vai receber ambas. Todos os nós mineradores vão tentar estender a maior cadeia de blocos, e no caso de empate vão escolher a que receberam primeiro. Eventualmente uma cadeia vai se estender mais e colapsar a bifurcação.

Isso é um evento inevitável em uma rede descentralizada. É um caso onde o consenso não é sobre as regras, mas sobre qual a versão verdadeira do registro público global de transações(Blockchain).

Pra que isso seja resolvido da forma mais suave possível, devemos dar tempo pra que a extensão da blockchain alcance a maioria dos nós. Por isso o tempo entre nós deve ser algo entre 10 minutos. Caso o tempo entre blocos fosse menor, bifurcações longas de dezenas de blocos se formaria, gerando incerteza sobre quais transações estão realmente escritas em pedra. É melhor esperar dois blocos de 10 minutos para que o consenso sobre qual cadeia escolher se forme do que vinte blocos de 5 minutos.

Mas como venho dizendo nesse texto inteiro, nenhuma regra está escrita em pedra. Pode haver um momento no futuro onde tudo está ainda mais conectado do que nos dias de hoje. Talvez internet por satélite como a StarLink ou alguma outra coisa inesperada. Caso isso aconteça, a rede poderá atingir o consenso de forma mais rápida justificando reduzir o tempo entre blocos.

Apesar de tudo, existem regras que provavelmente nunca serão mudadas, como o número máximo de 21 milhões de bitcoins. Enquanto outras muito provavelmente vão mudar, como a função hash SHA-256.

O Bitcoin nasceu com uma filosofia bem clara, definida pelo seu criador. Mas ele não é um sistema fechado, um programa. É um protocolo que está se desenvolvendo e evoluindo. Um protocolo sem forma final e definitiva.

Assine agora

Existem atividades que você perde a noção do tempo e faz aquilo por horas seguidas sem olhar para o relógio ou sequer beber água (Beba água). Ao mesmo tempo, existem outras atividades que você adia para depois, e continua adiando até o fim do dia, e acaba nem fazendo.

Nas raras ocasiões onde você executa a tarefa, faz com um olho na tarefa e outro no relógio. Diversas pausas para “tomar um ar”. Pausa pra banheiro. Pausa pra se hidratar. É uma tarefa penosa que, geralmente, é a mais importante.

Longe de mim dizer que descobri a cura para a procrastinação, mas quero compartilhar algo que venho experimentando comigo mesmo, não porque quero te convencer a adotar, mas para pensar um pouco sobre o assunto em voz alta.

A teoria

A grande ideia que tive foi criar um banco de horas para todas as minhas atividades e taxas de conversão. É isso.

Ao invés de criar obrigações e recompensas como sempre ouvi falar, e que nunca funcionou pra mim, eu queria criar um incentivo para fazer mais que o mínimo.

Vou estudar uma hora a mais hoje que estou empolgado para poder jogar mais amanhã.

A prática

A prática foi totalmente diferente do que pensei quando arquitetei um programa que gerenciasse esse tal Banco de Horas.

Achei que teria saldo positivo em atividades obrigatórias para “gastar” em lazer. Mas o que realmente ocorreu me chocou um pouco.

Nas primeiras duas semanas fiquei com saldo negativo na minhas atividades de lazer, ou seja, as gastava sem sequer ter as “comprado” com horas de trabalho.

Entrei numa espécie de corrida dos ratos onde não conseguia quitar as dívidas que assumi comigo mesmo. Incrível...

Dificuldade de manter o foco

Por mais que tenha separado entre trabalho e lazer nas outras seções, a separação funciona diferente na minha cabeça.

A separação é entre atividades que me obrigo a fazer através de horas de foco e atividades que, por mais que eu enrole para fazer, consigo focar por longas horas. Nessas últimas estão coisas como: Escrever, programar e estudar coisas da faculdade.

Recentemente entrei numa fase onde paguei a primeira dívida. Finalmente comecei a fazer o que preciso fazer na medida certa. No fim, o objetivo de tudo isso é me ajudar não só a cumprir minhas obrigações, mas cumpri-las na proporção correta. Uma espécie de gestão do tempo gamificada.

Em detalhes

Programei em uma tarde uma aplicação web local pra fazer esse gerenciamento pra mim. Eu podia criar atividades que precisava fazer e regras do tipo “A cada 3 horas estudando eu posso escrever por 1 hora”. Como disse antes, isso não é pra ser uma recompensa, mas para manter um controle na proporção.

Se eu escrever mais que uma hora quer dizer que saí da minha programação e meu “saldo” de escrita fica negativo até que eu “pague” estudando.

No começo gastei bastante tempo corrigindo erros do programa e negativei totalmente o saldo dessa atividade, mas isso não vem ao caso.

A solução

Queria chegar aqui com uma história bonita sobre como consertei meus problemas mudando uma coisa simples na minha rotina, mas a verdade é que isso está longe de ser perfeito.

Apesar de tudo, acompanhar com o que eu estava gastando o meu tempo me deu o gatilho que faltava pra fazer o que precisava ser feito.

O mais básico de tudo é uma lista homogênea de dados que chamamos vetores. A propriedade mais importante dos vetores é que eles são espaços seguidos de memória que guardam valores com o mesmo tamanho.

A melhor analogia que consigo pensar é a de uma sala de aula com mapeamento dos assentos. Na minha escola nossas posições na sala eram fixas. Se eu queria achar meu amigo eu não precisava vasculhar a sala inteira com o olhar, eu poderia olhar diretamente para a cadeira dele.

Vetores funcionam da mesma forma. Se eu sei a posição, eu acho a informação quase instantaneamente.

Mas novas informações são adicionadas o tempo todo em posições vazias. Informações velhas são apagadas e dão lugar a novas informações. Por isso nem sempre você sabe a posição de uma informação dentro de um vetor. Você vai precisar olhar em cada posição e verificar se a informação naquela posição é a que você deseja.

Isso é bem ineficiente, visto que eu vou precisar repetir isso para todas as posições do vetor, que pode ser bem grande.

Vetor ordenado

Ao invés de olhar todas as posições até achar, eu posso ordenar o vetor de forma crescente. Assim eu não preciso olhar todas as posições, só do começo até o primeiro elemento que for maior que o desejado. Se mesmo assim não encontrar, tenho certeza que ele não está na parte restante que não procurei.

Por outro lado, se o que estiver procurando for maior que todos os elementos do vetor, ainda vai ter bastante trabalho que poderia ser evitado com outra técnica.

Busca binária

Consiste em olhar o elemento no meio do vetor. Se o vetor está ordenado e o elemento central é maior que a informação procurada, posso descartar — em 100% dos casos — metade do vetor. Procurando na outra metade, utilizo a mesma técnica e descarto metade da metade.

Isso significa que mesmo que o vetor cresça e fique duas vezes maior, o meu trabalho para procurar qualquer elemento vai aumentar uma mísera comparação.

Já chegamos no estado da arte. Não existe nada melhor que não envolta colocar restrições e condições. A busca binária, de forma geral, funciona para qualquer tipo de vetor. A única condição é que o vetor esteja ordenado.

O problema

Parece uma pequena condição, uma letrinha miúda de um contrato, mas o problema é maior do que parece. Num raciocínio direto, sem truques, ordenar os elementos de um vetor significa pegar um elemento qualquer e colocar todos os menores à esquerda, maiores à direita. E você vai precisar repetir isso para cada elemento.

Se o vetor tinha N elementos, isso significa mudar quase N elementos de posição, N vezes. São necessários cerca de N² operações para ordenar um vetor, aparentemente.

Porém, existem técnicas para fazer isso ligeiramente melhor.

Ordenação de vetores

Existem inúmeros algoritmos para ordenar vetores, uns melhores, uns piores.

Em geral queremos saber como o algoritmo se comporta na maioria dos casos. Existem algoritmos que demoram sempre o mesmo tempo para executar em vetores do mesmo tamanho. Existem outros que executam mais rápido caso o vetor esteja mais bagunçado, ou menos.

O ideal é aquele que seja mais rápido quando o vetor é totalmente caótico. Não preciso de um algoritmo rápido para ordenar um vetor já ordenado.

Por isso precisamos analisar o comportamento dos algoritmos no pior e no melhor caso. E analisar de qual deles o caso médio está mais próximo.

Bubble Sort

Um dos algoritmos mais simples de ordenação de um vetor.

Algoritmo:

1. Verifique se o elemento atual é maior que o próximo

2. Caso seja, troque os dois de posição

3. Repita até o último elemento

4. Faça isso N vezes

E o vetor está ordenado. Eu vasculhei o vetor do inicio ao fim N vezes. O vetor tem N elementos. Logo NxN = N².

Em outras palavras, o que o algoritmo Bubble Sort faz é levar o maior elemento para o lugar certo, o final. Depois ele pega o segundo maior e leva até a penúltima posição e assim por diante.

O algoritmo realiza duas ações repetidamente. Verificar qual é maior entre dois elementos e trocá-los de posição. Ambos tem um custo de processamento, pequeno, mas diferente de zero.

A verificação é feita sempre. A troca não. Se queremos o melhor caso, o vetor em que o algoritmo trabalha menos, é aquele que não precisa fazer nenhuma troca. Ou seja, o melhor caso é o vetor ordenado de forma crescente.

E o pior caso? É aquele com mais trocas. Se o algoritmo move os maiores elementos para o final, mais trocas significam que o maior está no começo. Então o pior caso é um vetor ordenado de forma decrescente.

Porém, de toda forma ainda precisa fazer N² checagens, então o número de operações ainda está nessa ordem de grandeza.

- Se o vetor estiver bagunçado, vou precisar fazer N² operações

- Se o vetor estiver ordenado de forma decrescente, N²

- Se for de forma crescente (já tá da forma que queremos!), ainda assim N²

Se você se lembrar das parábolas da matemática básica, vai lembrar que ela cresce mais rápido que uma linha reta. Ainda podemos melhorar esse algoritmo.

Bubble Sort Melhorado

Já entendemos que fazemos mais verificações do que trocas. Só precisamos descobrir como fazer menos verificações. Para isso você só precisa saber que a cada vez que o programa vasculha o vetor, alguma troca é feita. Se nenhuma troca tiver sido feita, significa que o vetor já está ordenado.

Resumindo: Quando as trocas pararem de acontecer, paramos de verificar e encerramos o algoritmo, pois atingimos o objetivo.

Após essa melhoria:

- Um vetor bagunçado leva algo entre N e N² operações

- Um vetor decrescente leva N² operações

- Um vetor crescente (já ordenado) leva N operações

É uma melhoria, mas não significativa. Note que no por caso ainda demora N² operações para ordenar o vetor e casos próximos do melhor caso (vetor quase ordenado) são raros.

Se eu só precisar ordenar vetores decrescentes, esse é tão ruim quanto o original, por exemplo.

Mas isso não é nem sobre o que eu quero falar. E finalmente chegamos no tema central desse post.

Complexidade de Algoritmo

Complexidade é esse comportamento do algoritmo que buscamos analisar no tópico anterior.

Como ele se comporta no melhor caso, no pior, e principalmente no caso médio.

O caso médio — ou seja, mais provável — é um vetor completamente bagunçado e caótico. E nesse caso, a complexidade do algoritmo é maior que N e menor que N².

A ideia é que analisando o caso médio e você possa decidir qual o melhor algoritmo. E para isso você precisa analisar o funcionamento interno do algoritmo. Ou foi o que me disseram em sala de aula.

E aqui nasce a ideia desse artigo:

Será possível descobrir melhor e pior caso de um algoritmo sem saber como ele funciona?

E se eu usar o próprio algoritmo para descobrir seu comportamento na prática?

E se eu tirar a média de todas as permutações possíveis de um vetor?

Desafios

Perguntei ao meu professor se seria possível executar o algoritmo de ordenação para todos os vetores possíveis e ver aquele que deu mais trabalho ao computador, aquele que demorou mais tempo para ordenar.

Ele disse que eram muitas possibilidades de vetores e que esse trabalho seria inviável de realizar de forma prática e seguiu a aula, mas essa dúvida me seguiu até em casa e cá estamos.

De fato, o custo de testar todas as possibilidades de um vetor é proibitiva. O que eu quero fazer é ordenar todas as permutações possíveis de um vetor.

Se eu tenho o vetor com os elementos 1 e 2. Ou seja, [1, 2] que é a forma mais usual de representar vetores. Então ele tem duas permutações. [1, 2] e [2, 1].

Um vetor com 3 elementos teria 6 permutações. 4 elementos, 24 permutações. O número de permutações que precisamos testar é exatamente N!(fatorial de N) isso é bem pior do que N². Muito, MUITO PIOR.

5! = 120

6! = 720

7! = 5040

8! = 40 mil

E por ai vai. Cresce, e cresce cada vez mais rápido. Problemas onde o custo em cálculos e tempo aumenta exponencialmente são uma pedra no sapato mesmo para supercomputadores, como expliquei nesse artigo.

Ao mesmo tempo, vetores pequenos (N < 100) são bem rápidos de se ordenar e o tempo necessário é bem pequeno. Pequeno o suficiente para ter muito ruído.

O processador é uma máquina bem rápida, mas ele só consegue fazer uma coisa por vez. Imagine que você tivesse que parar de andar para piscar, para respirar, para pensar. Isso faria você demorar mais para completar seu trajeto. Isso também se aplica para o processador.

Nos dias de hoje os processadores tem de 2 a 16 núcleos. Esses núcleos, para todos os efeitos, são como um processador próprio capaz de executar programas. Mas o número de programas que rodam num desktop moderno está na casa das centenas.

Você mesmo já deve ter aberto mais de 20 programas (ou abas do navegador) ao mesmo tempo alguma vez1. Para dar a impressão de que tudo isso está rodando ao mesmo tempo os processadores aplicam uma técnica chamada concorrência.

Paralelismo faz dois núcleos executarem dois programas diferentes ao mesmo tempo. Concorrência é quando um núcleo executa dois programas diferentes “ao mesmo tempo”.

O que ele faz é intercalar qual programa ele está executando à uma frequência altíssima ao custo de demorar mais. Demorará o tempo de execução de cada programa isoladamente mais um atraso de trocar entre eles constantemente, para ser preciso. Se o aumento do tempo não é perceptivo, é porque era uma tarefa muito rápida de completar.

E o processador está sempre parando de executar seus programas para executar pequenas tarefas da forma mais imperceptível possível. Estamos falando de milésimos de milésimos de milésimos de segundos. Mas que fazem diferença para o que estamos tentando medir: a ordenação de vetores pequenos.

Vetores pequenos sofrem de ruído do processador2. Vetores grandes fazem o teste em todas as permutações muito demorado. Qual a solução?

O melhor a se fazer não é medir o tempo, mas o número de operações que o algoritmo executa para ordenar os vetores. Assim eliminamos o ruído e podemos testar ordenar vetores pequenos. Porém, isso cria outro problema.

Se eu quero manter o algoritmo como uma caixa preta e testá-lo sem saber como funciona, não posso usar esse método.

Pois contar o número de passos envolve:

• Ler o código do algoritmo de ordenação

• Entender quais passos são relevantes em questão lógica e de custo

• Adicionar um contador que aumenta junto com esses passos (alterar o código)

Seria a melhor forma de entender, se não fosse pela restrição que quero explorar.

Então só resta um único caminho para mim: Medir o tempo tentando eliminar o ruído, mas isso tem um custo.

A técnica a ser usada aqui é uma média simples. O programa, em teoria, executaria sempre no mesmo tempo em um processador completamente livre e ocioso, mas o que temos é o tempo de execução mais um ruído variável. A média será o tempo de execução do algoritmo mais um ruído pequeno.

Mais do que chegar ao tempo absoluto de execução para o algoritmo de ordenação, queremos a diferença em proporção entre o tempo de execução em duas permutações diferentes. E para isso a média é suficiente.

Você deve saber muito bem que não existe almoço grátis. A média significa refazer o teste múltiplas vezes, o que significa demorar múltiplas vezes.

Cada vez mais, a cada desafio superado, vejo que meu professor tinha razão desde o início. E vejo que minha “preguiça” teve um valor. Esse experimento me fez pensar nos desafios envolvidos e soluções engenhosas ou gambiarrentas.

Normalização

Uma última coisa a se fazer é normalizar os resultados. Normalizar significa mudar a escala dos dados para facilitar a leitura e interpretação. Na prática significa dividir todos os tempos pelo menor dos tempos.

Assim o “tempo” do melhor resultado, que no caso do Bubble Sort é o vetor já ordenado, será 1. Os outros resultados serão múltiplos desse tempo.

Isso é melhor pois me é mais útil saber que determinado vetor leva 1,5 vezes o tempo de ordenar o vetor mais fácil do que saber que esse vetor leva 684 nanossegundos enquanto o vetor mais fácil leva 456 nanossegundos.

Conclusão

Nesse experimento consolidei meus conhecimentos sobre vetores, busca e ordenação. Aprendi sobre paralelismo e concorrência. Pratiquei escrita de código para rodar os algoritmos citados. Resolvi problemas que apareciam no caminho. Pensei em executar testes mais robustos usando mais tempo. Tudo isso e mais um pouco.

No fim não cheguei a uma conclusão ou resultados dignos de nota. Se tivesse que fazer alguma observação, diria que na prática os resultados pareceram mais aleatórios do que o desejável, mas com certos padrões.

O texto ficou mais longo do que eu gostaria, mas gostei do resultado final. Se você leu até aqui deve ter interesse pelo tema. Você é da área de TI ou um curioso de internet? Me manda uma mensagem aqui nos comentários.

Sinceramente só queria expor meu raciocínio e publicar o quanto antes, apesar de ter faltado falar de algumas coisas.

Acontece que perdi muito tempo montando os testes e rodando eles. E no fim não nem pude mostrar nada sobre eles.

Eu diria que aprendi inglês no início da pandemia no Brasil. Fazia o ensino fundamental em uma escola municipal qualquer e praticamente fiquei sem aulas no ano de 2020.

Esse foi um período da minha vida que guardo com muito carinho, pois foi um momento onde aprendi sobre meus próprios gostos: animes e mangás no geral, e dei meus primeiros passos na programação.

Embora no caso da programação já houvesse conteúdo o suficiente em português para me satisfazer, não era o caso com mangás. Fui pulando de obra em obra. Assistia o anime inteiro, partia para o mangá, que geralmente é a obra original a ser adaptada. Lia as traduções feitas por fãs na internet e cheguei a entrar em algumas delas para acompanhar os lançamentos.

Não me incomodava esperar uma semana ou um mês inteiro até que um novo capítulo fosse postado porque eu tinha um mundo inteiro de histórias para ler. Eram dias e semanas que passavam voando enquanto eu mergulhava em tantos universos.

Eu lia desde obras populares como Yakusoku no Neverland, , One Punch Man, Solo Leveling (antes de virar modinha), até histórias mais desconhecidas como Rooftop Sword Master, Tales of Demons and Gods e outras histórias de gosto questionável que não valem a pena citar. Foi por conta dessas últimas que decidi ajudar uma scan na tradução de uma história que estava esperando.

Depois de passar por um rigoroso teste(contém ironia) para testar minha capacidade de usar o google tradutor — não existia ChatGPT naquela época — entrei pro time e comecei a traduzir o próximo capítulo como se não houvesse amanhã.

Foi o momento de maior foco da minha vida. Lembro de ter aberto o cronômetro, o material para traduzir, uma call no discord com um sênior do grupo e ficar mergulhado naquilo pelas próximas 6 ou 8 horas seguidas. Lembro que o inglês não tinha sido um problema no meu teste. Não lembro dos textos em si, mas lembro que o feedback que recebi foi sobre erros de concordância no meu texto final. Espero que você releve isso, eu tinha 14 anos e estava alguns meses sem pisar sequer numa aula online.

Nem que eu demorasse alguns bons minutos de pesquisa, eu sempre conseguia descobrir o significado das falas e narrações do texto original. Isso serviu para deixar de lado a fluidez da leitura para pensar em mim como um decifrador de um texto estrangeiro.

Passar 8 horas preso em um texto menor que esse que você está lendo agora não me desmotivou ou decepcionou. Saí daquela call orgulhoso de todas as vezes que empaquei e dei um jeito de seguir adiante. Eu não estava preocupado em aprender inglês, eu não estava preocupado em impressionar ninguém. Eu não queria nem mesmo saber como a história continuava mais a esse ponto. Eu queria provar pra mim mesmo que eu conseguia decifrar aquele texto estranho.

Saindo um pouco do tema principal:

Quando foi a última vez que você fez uma atividade somente pelo prazer de fazer?

Já li em algum lugar recentemente que não é ideal aprender outro idioma a partir de tradução como principal método de estudo. Isso deve vir daquela neura das pessoas de se preocuparem em estar ou não traduzindo o que escutam para a lingua nativa antes de entender. Imagino que isso faz algum sentido, mas traduzir mentalmente nunca foi uma preocupação minha, mesmo depois dessa fase ou talvez por causa dela.

Eu só queria terminar aquele texto o mais rápido possível e partir para o próximo. Continuei lendo cada vez mais histórias. Nesse ponto já acessava o saudoso Mangá Livre todos os dias procurando novos títulos e novos capítulos para ler e maratonava histórias mais longas (não, eu não li One Piece).

Até aqui eu lia somente em português e traduzia com alguma dificuldade mangás e capítulos de light novels1, mas eu queria dar um passo além.

Não queria passar horas lutando com o Google Tradutor para entender cada capítulo. Não queria esperar traduções que estavam meses — às vezes anos — atrasada para ler as minhas histórias favoritas. E pra isso eu precisava aprender inglês. Não precisava ser fluente ou perfeito — apenas o suficiente para aproveitar a leitura.

Até cogitei aprender japonês ao invés de inglês, mas desisti pelos seguintes motivos:

1. Como todo ocidental, e principalmente brasileiros, japonês parecia extremamente difícil de se aprender para mim2.

2. Eu tinha uma mentalidade imediatista e queria aprender algo o mais rápido possível.

3. Não há no Japão a cultura da pirataria como no Brasil — e no resto do mundo, de forma geral — então era bem difícil achar mangás direto em japonês na internet.

Resumindo: Mesmo para ler quadrinhos japoneses, aprender inglês me ajudaria mais que japonês. Isso deve valer para várias outras áreas também.

Pesquisando como eu poderia aprender inglês da melhor forma possível, encontrei no YouTube BR o canal do Mairo Vergara, onde ele ensinava inglês, mas mais importante de tudo, era a sua playlist ensinando “O Método Vergara para Aprender Inglês”.

Era a primeira autoridade que conheci no assunto de aprender idiomas e o que ele dizia fazia bastante sentido3.

Nós, humanos, temos a capacidade natural de aprender a nossa língua materna. Claro que temos uma facilidade natural na infância para aprender qualquer coisa, mas existe uma habilidade inata para comunicação que nos acompanha até a vida adulta.

Se te jogassem na Rússia por um ano, você voltaria de lá falando russo razoavelmente bem. Não é uma questão de talento, facilidade ou qualquer outra coisa, é o ambiente e o método. Principalmente o método.

O método é o mais importante na hora de aprender um idioma novo. Você pode se perder em livros e mais livros explicando o porque dos adjetivos de cor virem depois dos adjetivos de tamanho.

Isso não te prepara para entender que o verbo Ser/Estar vem antes do sujeito em perguntas. Isso não te prepara para conjugar uma infinidade de verbos irregulares. Que se chamam assim por um motivo: Porque a língua não foi criada em laboratório, mas é fruto de um processo vivo. É um protocolo de comunicação acordado de forma tácita por uma comunidade e que não precisa ser consistente ou lógico o tempo todo.

O segredo é usar da maior habilidade da raça humana: Reconhecimento de padrões.

Sabe quando você olha para uma tomada com três furos e vê um rosto? Ou quando percebe que quase sempre que aquele time de futebol perde, um primo seu tava assistindo junto com você e coisas do tipo?

Tudo isso faz parte do reconhecimento de padrões, que também se aplica para idiomas.

M3SM0 QU3 3U 3SCR3V4 3SS4 FR4S3 TR0C4ND0 4S L3TR4S P0R NÚM3ROS, V0C3 41ND4 É C4P4Z D3 L3R C0M UM4 V3L0C1D4D3 R4Z0ÁV3L.

Porque você não está decodificando e decifrando em tempo real. Você está confiando e delegando o processamento do que está escrito para um circuito cerebral de reconhecimento de padrões visuais. Da mesma forma existe um circuito para padrões sonoros e para padrões linguísticos.

Quando alguém diz do seu lado “Ado ado ado, cada um no seu quadrado.”, algo que você provavelmente já ouviu várias vezes. Você provavelmente já estava desde o segundo “ado” completando eles e esperando o resto da frase ou alguma variação. Esse é um caso de padrão sonoro e linguístico.

Aprender uma língua significa aprender todos os padrões comuns em todas as situações que você vai precisar dela. E isso só acontece de uma maneira: costume.

Você precisa se acostumar com a língua, respirar a língua. E por fim, ser a língua, usar a língua.

Agora falando em termos menos neurológicos e filosóficos. Você só aprende o significado de uma palavra ou expressão vendo ela sendo usada em vários contextos em vários momentos diferentes. Você só aprende uma estrutura gramatical depois de ver ela sendo usada centenas de vezes. E antes que você seja capaz de reproduzir isso com naturalidade, você vai precisar passar por isso várias outras vezes.

E você só vai conseguir fazer isso depois de milhares de horas de imersão no idioma. E é claro que você não se joga no mar no dia 1.

O método

O método se trata, em linhas gerais, de ficar no limiar do desconhecido.

Um texto em que você sabe a maioria das palavras, mas não tudo. Um áudio que você entende quase por inteiro, mas não todo. Existem várias lacunas, espaços de barulho, termos e expressões desconhecidas.

A partir desse material você aumenta seu vocabulário usando o Anki, ou outro programa de repetição espaçada, para revisar as novas palavras que você aprendeu.

Você encontra uma frase que entende por inteiro, com exceção de uma palavra ou termo. Pesquisa em dicionários até entender a frase. Guarda ela no Anki e repete o processo.

A ideia é fazer isso com materiais feitos por nativos para nativos. Não queremos aprender padrões que só aparecem em livros didáticos e não no filme que você quer ser capaz de assistir, que só aparecem em discussões acadêmicas mas não em conversas que você quer ter no dia a dia.

Não foi o Mairo que inventou isso.

Ele pegou de outros poliglotas e pessoas que estudaram o processo de aprendizado de idiomas, como Stephen Krashen, Steve Kaufmann, Khatzumoto do All Japanese All The Time(AJATT)4 tudo que funcionava para ele e criou um algoritmo que pudesse executar todo dia sem pensar, como um operário em uma fábrica. Assim ele não teria que se preocupar em estar na direção errada, não teria que se preocupar se está fazendo o suficiente. Ele só precisava seguir o método. E com a confiança de ver os resultados bem na sua frente, seguir motivado para continuar executando o algoritmo, dia após dia de forma incansável, por longos períodos.

O segredo é esse. Volume + frequência.

Em passos, o algoritmo seria:

1. Achar 10 palavras desconhecidas, não importa onde

2. Achar frases que você entenda que usem essas palavras

3. Jogar no Anki

4. Revisar o Anki todos os dias

5. Volta no dia seguinte

De resto é imergir, usar o inglês no dia a dia. Ouvir vídeos sobre assuntos que te interessam. Escutar os áudios dos textos que você já estudou. Qualquer coisa.

Aprender palavras dentro de frases te faz assimilar inconscientemente os padrões de gramática da língua, padrões de pensamento e de escolha de palavras dos nativos.

Repita esse processo de forma constante por um ano. Revise centenas de frases diariamente. Adicione algumas milhares dessas no seu baralho do Anki e eu duvido que você não vai conseguir usar o idioma para aquilo que você queria no começo.

A bola de neve

Isso não é exclusivo de método algum, mas uma constatação da realidade: Quando você chega em determinado nível onde é capaz de aproveitar de conteúdos 100% em inglês, mesmo não entendendo tudo, seu aprendizado decola.

Quando você finalmente consegue acompanhar conteúdos em inglês sem estudar previamente e consome eles — não para estudar e aprender, mas simplesmente para se entreter — você aumenta naturalmente seu tempo de exposição aos padrões da língua. Internaliza esses padrões em uma velocidade ainda maior que no começo e, mais importante de tudo, se diverte no processo.

Eu me diverti aprendendo inglês, antes mesmo de poder usá-lo. Pois era o que me permitia ler conteúdos que estava desesperado para consumir. Pois era o que me dava um assunto em comum com amigos online. Pois era o que me facilitava outras coisas na minha vida, como navegar na internet em geral.

Nesse post eu queria contar uma história minha sobre como, não só aprendi inglês, mas descobri a importância de aprender a aprender. Pode ter ficado pessoal demais, ou se nexo demais para dar uma lição, mas foi meu relato.

Quero saber seu relato.

Você sabe inglês? Se sim, como você acha melhor de aprender um novo idioma? Como foi a sua jornada nessa área?

Se você chegou aqui, talvez se interesse por aprendizado de idiomas ou gostou desse relato pessoal.

O pânico em torno da IA nos últimos 3-4 anos se deve, claro, ao grande salto tecnológico, onde um modelo teórico recebeu uma atualização de performance que o permitiu ser executado de forma prática e em tempo real. Porém, esse pânico se deve, também, a uma incompreensão sobre como computadores e tecnologia em geral evoluem.

Tudo isso faz parte de uma argumentação maior que ainda não terminei, mas o objetivo agora é de expor da maneira mais didática possível como um computador funciona e construir um experimento mental que ajude a entender os limites da computação da forma como entendemos hoje.

Um computador é uma calculadora por definição. Tudo que ele é capaz de fazer é executar comandos que envolvem a alteração de números em sua memória, que chamamos de bits, por serem a menor unidade de informação que podemos manipular.

Desde o ENIAC até o meu computador ao lado da minha mesa houve vários avanços físicos, químicos e técnicos na forma como computadores são construídos, mas a sua arquitetura geral continua mais ou menos da mesma forma. O que ocorreu foram melhorias de performance para ser mais rápido e eficiente, ou seja, usar menos energia e menos tempo para fazer o mesmo processamento.

Você provavelmente já ouviu falar do quão pequenos são os transistores dos processadores de hoje em dia e de como estamos próximos do limite físico de quantos deles podemos colocar no mesmo espaço. Apesar disso, ainda há muito espaço para melhora, mas essa melhora de eficiência não levará a grandes saltos como o visto pelo campo das IAs.

Para dizer a verdade, os computadores modernos ainda estão longe dos limites impostos pelas leis da física. Os limites atuais se devem puramente a limites nas técnicas humanas para a construção deles.

Vamos imaginar um computador teórico que use toda sua massa para fazer computações. Meu objetivo é te mostrar que mesmo o melhor computador que nunca será fabricado na prática não resolveria todos os problemas da humanidade, longe disso. Sem uma revolução na arquitetura atual, mais processamento e mais velocidade são pouco impactantes.

O Limite de Bremermann diz que um sistema computacional fechado, ou seja, uma caixa preta que não depende de mais nada além de si mesmo para computar, não pode ultrapassar a quantidade de energia que ele tem armazenado em sua massa dividido pela quantidade mínima de energia necessária para realizar uma única computação. A energia do sistema é dada por E = mc² (grande Einstein).

Fazendo todas as contas chegamos ao número máximo de 1.3563925 × 10⁵⁰ operações por segundo por quilograma. Da mesma ordem de grandeza do número de átomos da Terra — muito maior que o número de grãos de areia ou estrelas visíveis. Grande o suficiente para ter dificuldade em encontrar um exemplo temporal que humanos entendam.

Isso significa que esse sistema hipotético poderia contar os milissegundos que se passaram desde o Big Bang antes que você pudesse decidir assinar, ou não, minha newsletter.

Subscribe now

Agora que temos o computador mais rápido permitido pelas leis da física na arquitetura atual podemos ver o quão rápido ele é em coisas mais complicadas do que contar.

Força Bruta

No exemplo anterior a tarefa era somar 1 num número na memória do computador, mas para as atividades que usamos computadores são necessárias operações mais complexas.1

Numa pesquisa rápida vi que uma inferência do GPT-4 requer 560 trilhões de operações com ponto flutuante (números fracionários). O nosso computador hipotético conseguiria computar mensagens das mais longas instantaneamente. Pode levar um tempo diferente de 0 (na ordem de 10⁻³⁵ segundos), mas menor que a precisão de qualquer relógio que a humanidade tenha inventado até agora.

Partindo para tarefas mais difíceis temos criptografia. Fácil de usar, difícil de quebrar com força bruta. Absolutamente todos os algoritmos de criptografia têm sua confiança baseada nessa dificuldade. Algoritmos como:

• AES-128

• ECC-256

• RSA-2048 (demoraria um pouco)

Seriam quebrados em frações de segundos. Porque, na prática, um segundo é suficiente para esgotar o espaço efetivo de busca desses algoritmos. Já algoritmos como:

• AES-256

• SHA-256

• bcrypt (dependendo da quantidade de caracteres)

Estão seguros. Levando 10²⁷ segundos para quebrar o SHA-256, por exemplo2. Para quebrar essas criptografias nosso computador precisaria crescer até escalas continentais se quiséssemos terminar no tempo de vida humano.

É nesse momento que começamos a sentir os limites da força bruta e da velocidade do melhor computador possível no nosso universo. Nem mesmo ele é o bastante para lidar com certos problemas.

Chegamos nos problemas não determinísticos de tempo polinomial (NP), que incluem classes de problemas cuja melhor solução conhecida cresce de forma exponencial. Aqui entram coisas como o Caixeiro Viajante.

Mas nem só de hardware vive a humanidade, não é mesmo?

Agora que vimos os limites da força bruta e da velocidade da computação, vamos aos limites da arquitetura. No fim das contas, tecnologia é técnica. Além das técnicas de construção de computadores, a humanidade também desenvolveu técnicas para acelerar a computação em certas situações para transformar problemas exponenciais em problemas resolvíveis em tempo constante, e isso é a chave para entendermos que o futuro da tecnologia está em uma revolução na arquitetura atual dos computadores.

Busca Binária

O exemplo mais fresco em minha memória é a busca em bases de dados. Técnicas como busca binária cortam o tempo de encontrar uma informação na memória, causando uma economia proporcional à quantidade de informações.

A maior utilidade da computação no dia a dia é o armazenamento e processamento desses dados para fins comerciais. Espero que entenda que atividades como atualizar, consultar e cadastrar novos dados requerem manipular a memória do computador. E como o volume de dados só cresce, precisamos fazer isso o mais rápido possível.

Exemplo: Tenho uma lista com as informações de todos os meus clientes ordenada pelo valor da renda que me trazem mensalmente. Consigo rapidamente, por meio de uma busca binária, achar um cliente específico entre milhões buscando por esse número que chamamos de chave de busca. Eu consulto o meio da minha lista e vejo que o número no meio é maior que a minha chave, então procuro somente na primeira metade da lista. Repito o processo para a lista menor que obtive.

Traduzindo: Em uma lista com N elementos podemos encontrar um elemento desejado sem ter que comparar com cada elemento individualmente mas com log N elementos, ao custo de manter a lista ordenada de forma crescente (custo típico O(N log N)).

Caso tenha alguma familiaridade com logaritmos, você sabe que quanto maior a lista, maior será a economia. Porém existe um limite econômico para quanta memória temos para armazenamento. E a memória de trabalho (a famosa RAM) é ainda mais escassa. Raramente é possível em bases de dados grandes colocar toda a lista na RAM para usar a busca binária.

Então chegamos em Árvores B para achar com velocidade os dados que precisamos em equipamentos mais lentos como HDs e SSDs. O gargalo aqui não é a comparação, mas o número de acessos ao armazenamento persistente.

Vale notar que, nesse caso, estamos usando uma técnica para burlar limites impostos pela própria arquitetura dos computadores, não limites teóricos. Ou seja, com RAM infinita busca binária sempre seria melhor, mas como ela é menor que o armazenamento persistente, precisamos de outras técnicas para expandir nossos limites práticos.

Conclusão

Eu poderia continuar esse texto falando sobre como criptografias funcionam e porque elas são resistentes à força bruta, mas não é algo que eu tenha domínio ou possa escrever sobre com uma tarde de pesquisa.

Eu poderia continuar esse texto explicando o limite físico e teórico de armazenamento em um espaço com massa finita, e aplicar ao computador hipotético para mostrar que para uma quantidade de dados próxima da que a humanidade lida hoje em dia, mesmo o nosso computador perfeito teria que lidar com o deslocamento dos dados na memória interna e mostrar os gargalos insuperáveis, independentes da arquitetura.

Porém esse texto tem que sair antes que eu perca meu interesse nesse assunto. E pesquisar tudo isso e manter o texto coeso demoraria algumas semanas.

Para alguns esse texto pode ter ficado técnico demais. Para outros pode ter ficado vago demais. No mais espero que isso possa abrir espaço para discussão sobre o que compete à computação e que ela é só mais uma tecnologia, não a cura para todos os nossos problemas.

Da mesma forma que sociedades da antiguidade usavam as religiões como forma de explicar o que elas não entendiam, nós usamos a ciência.

Se a definição de ciência começou como um tipo de conhecimento que constrói teorias que podem ser falseadas e provadas falsas. Hoje ela adotou contornos mais amplos.

“ciência (no sentido ampliado) é a prática que nos fornece as afirmações mais confiáveis (i.e., epistemicamente justificadas) que podem ser feitas, em um determinado momento, sobre um objeto de estudos abarcado por uma comunidade de disciplinas de conhecimento (i.e., sobre a natureza, nós mesmos como seres humanos, nossas sociedades, nossas construções físicas, e nossas construções mentais)” (Hansson, 2013)

Os termos “ciência” e “científico” ganharam conotações positivas independentemente do contexto de forma parecida com o termo “democracia” até o ponto onde movimentos se apropriarem do termo “científico” para propagarem ideias duvidosas.

Hoje, há inúmeros debates e discussões sobre o que é, de fato, ciência, e o que é pseudociência.

Não fiz uma menção ao termo “democracia” à toa. Um sinônimo de “científico” muito utilizado para afirmar que alguma informação é confiável é “é o consenso acadêmico” ou “é o consenso na comunidade científica”, uma espécie de apelo a maioria. Como se a concordância de grande parte de um grupo fosse mais importante que o rigor técnico, estatístico e lógico com o qual a pesquisa foi feita.

Note a sutileza: não estou atacando a ciência, mas as pessoas que se iludem e usam a ciência de forma torpe e em objetos de estudo que não lhe dizem respeito.

Subscribe now

Esse texto nasce de uma indignação pessoal minha causada pela dificuldade em expor opiniões sobre verdade, bem e beleza objetivas por minha parte na vida privada assim como por personalidades na internet.

Da mesma forma que sociedades antigas, e mesmo as recentes, que usavam a religião para justificar suas próprias crenças sobre o que devia ser feito, a maioria das pessoas, se não todas, usam a ciência como uma mera ferramenta para justificar as próprias crenças, não como uma forma de chegar a verdade. Verdade essa que foi relativizada e taxada como forma de oprimir povos e culturas.

Quando negamos a existência de uma verdade absoluta, não nos libertamos das crenças — apenas as trocamos. Passamos a venerar as que criamos nós mesmos: o progresso, a técnica, o consenso. Mas toda crença humana, desprovida de transcendência, tende a se curvar diante do poder e não diante da verdade.

A verdadeira religião, ao contrário, não nasce do medo ou da conveniência, mas do reconhecimento de que há um Deus grandioso demais para caber em nossos conceitos falhos de bem e de verdade. Ele não se molda às nossas ideias — nós é que somos chamados a nos ajustar a Ele.

A ciência, quando praticada com humildade, pode ser uma expressão dessa busca: uma tentativa de compreender o mundo que esse mesmo Deus criou. Mas quando a transformamos em instrumento de justificação moral ou política, ela deixa de revelar a realidade e passa a escondê-la sob a ilusão do controle humano.

Talvez o desafio do nosso tempo seja justamente esse: redescobrir a coragem de buscar a verdade, mesmo quando ela não se encaixa nas crenças que nos confortam.

Subscribe now

Imagino que na maioria dos casos seja dito da boca pra fora, visto que isso é um nonsense total, com a intenção de mostrar o mínimo de proatividade e que você não vai fugir de desafios técnicos. Afinal, isso é o mínimo que se espera de um desenvolvedor de software.

Então o que acontece é a tentativa de aplicar a problemas reais, ferramentas do interesse da pessoa. Uma espécie de amor pela técnica mais que pela melhor resposta para aquela situação.

Não é à toa que tudo que um programador mais deseja é escrever código.

Ou será que não?

Desde a popularização de modelos de linguagem capazes de gerar código junto com o aumento massivo de pessoas entrando na área — pessoas essas com o perfil errado e nenhum interesse real nos problemas e vivência na área, interessados somente na promessa de dinheiro fácil — uma nova geração nasceu, uma geração que não gosta de escrever código e delega o processo de criar uma solução, fazer engenharia em essência.

E eu sou um deles.

Corriqueiramente o que me acontece é:

1. Tenho uma ideia de projeto.

2. Faço um protótipo com rápido com IA.

3. Dou um passo para trás e analiso as decisões da IA para resolver o problema.

4. Concluo que analisar o resultado e tocar o projeto com minhas próprias pernas demoraria mais que o meu entusiasmo.

5. Continuo com a IA.

Não existe mais um preciosismo pela técnica, pela tecnologia, pelo conhecimento aprofundado. Sei que existem razões econômicas que justificam essa visão mais prática de construção de código:

• Feito é melhor que perfeito

• Código melhor não necessariamente dá mais dinheiro

• Prazos

• Hype por tecnologias novas

Mas nada disso tira da minha cabeça essa reflexão.

Entrei na área e comecei a estudar em 2020 pensando que minha motivação era minha curiosidade para saber como um computador funcionava, como a internet funcionava.

Hoje vejo que programação sempre foi uma ferramenta útil para as coisas que eu realmente gostava, explorar ideias, matar minha curiosidade, fazer simulações.

É louco. No passado pensava que o mais legal era o processo de codificar. Hoje, sempre que eu puder testar algo que me veio a mente sem ver nenhuma linha de código, eu farei.

Eu tentei analisar o crescente aumento no uso de IA por outro ângulo. Acha que viajei de mais ou só estou passando pano para mim mesmo?