Guia Prático: Blockchain e Contratos Inteligentes II

Na primeira parte deste guia prático exploramos os fundamentos da blockchain. A segunda parte tem um foco claro e objetivo: mostrar na prática a estrutura dos contratos inteligentes e como você pode implementá-los em sua própria blockchain.

Mão escrevendo 'Ethereum" em um quadro 'white board'.
Imagem: pexels.com

Se no primeiro volume vimos a estrutura básica do bloco e da blockchain, aqui começamos a plantar os mecanismos que darão vida às aplicações descentralizadas (dApps). Seja para transferências automatizadas, registros imutáveis ou lógica condicional entre partes, os contratos inteligentes são a chave para desbloquear o verdadeiro potencial da Web3.


🚀 Integrando Contratos Inteligentes à Sua Blockchain

Contratos inteligentes permitem acordos automatizados e autoexecutáveis sem a necessidade de uma autoridade central. Você pode implementá-los diretamente na sua blockchain para viabilizar funcionalidades como transferência de ativos, validação de transações ou execução de aplicativos descentralizados (dApps).

🌐 Visão Geral dos Contratos Inteligentes

Contratos inteligentes são programas que rodam na blockchain. Eles podem ser escritos em linguagens como Solidity (comumente usada no Ethereum) ou Vyper, e têm como objetivo automatizar acordos ou transações entre partes.

Em sua blockchain baseada em Go, você essencialmente precisará de:

  • Uma forma de armazenar contratos inteligentes na blockchain.
  • Um mecanismo para executar o código do contrato inteligente quando certas condições forem atendidas.

Vamos simular isso de forma simples para começar, utilizando as capacidades nativas do Go. Isso não será tão complexo quanto o Ethereum, mas ilustrará os conceitos. Se você quiser avançar para contratos inteligentes compatíveis com o Ethereum, precisará de Solidity e de um cliente Ethereum como Geth ou Parity.

Abordagem Básica para Integrar Contratos Inteligentes

1️⃣ Representar Contratos Inteligentes

Em Go, você pode representar um contrato inteligente criando uma estrutura (struct) para o código do contrato e seu estado. Vamos começar definindo um contrato inteligente simples que pode atualizar seu estado quando chamado.

type SmartContract struct {
	ID    int
	Code  string  // Este pode ser o código do contrato (por exemplo, código Solidity ou pseudo-código)
	State string  // Armazena o estado do contrato (por exemplo, "ativo", "concluído", etc.)
}

2️⃣ Adicionar Contratos Inteligentes aos Blocos

Você pode modificar a estrutura do bloco para incluir um contrato inteligente em cada bloco.

type Block struct {
	Index         int
	Timestamp     string
	Data          string // Dados da transação ou do contrato inteligente
	PrevHash      string
	Hash          string
	SmartContract *SmartContract // Adiciona um ponteiro para o contrato inteligente (se houver)
}

Ao adicionar um novo bloco, você pode verificar se o bloco deve conter um contrato inteligente e configurá-lo.

func (bc *Blockchain) addBlockWithContract(data string, contract *SmartContract) {
	prevBlock := bc.Chain[len(bc.Chain)-1]
	newBlock := Block{
		Index:         prevBlock.Index + 1,
		Timestamp:     time.Now().String(),
		Data:          data,
		PrevHash:      prevBlock.Hash,
		Hash:          calculateHash(prevBlock.Index+1, prevBlock.Hash, data),
		SmartContract: contract,
	}
	bc.Chain = append(bc.Chain, newBlock)
}

3️⃣ Simular a Execução do Contrato

Uma maneira básica de simular a execução de um contrato é chamando uma função no SmartContract quando certas condições forem atendidas.

Vamos supor que você tenha um contrato que permite alguém “ativá-lo” e definir seu estado como “concluído”:

func (sc *SmartContract) execute() {
	// Para este exemplo simples, vamos dizer que executar significa mudar o estado
	if sc.State == "ativo" {
		sc.State = "concluído"
		fmt.Println("Contrato executado com sucesso!")
	} else {
		fmt.Println("Contrato já está concluído!")
	}
}

Então, na sua blockchain, você poderia ter uma função que verifica se há contratos que precisam ser executados quando um novo bloco é adicionado:

func (bc *Blockchain) executeContracts() {
	for _, block := range bc.Chain {
		if block.SmartContract != nil && block.SmartContract.State == "ativo" {
			block.SmartContract.execute()
		}
	}
}

4️⃣ Acionar Contratos Inteligentes

Agora você pode executar a lógica do contrato inteligente ao adicionar blocos à sua blockchain:

func main() {
	blockchain := Blockchain{}
	blockchain.Chain = append(blockchain.Chain, createGenesisBlock())

	// Cria um novo contrato inteligente
	contract := &SmartContract{
		ID:    1,
		Code:  "transferir(100 tokens)",
		State: "ativo", // Inicialmente ativo, pode ser executado
	}

	// Adiciona o contrato a um novo bloco
	blockchain.addBlockWithContract("Dados da Transação", contract)

	// Executa quaisquer contratos ativos
	blockchain.executeContracts()

	// Imprime a blockchain para verificar o estado do contrato
	for _, block := range blockchain.Chain {
		fmt.Printf("Bloco %d: %s - Estado do Contrato: %s\n", block.Index, block.Timestamp, block.SmartContract.State)
	}
}

5️⃣ Expandir os Contratos Inteligentes

Para tornar este sistema mais semelhante ao que você veria com contratos inteligentes baseados no Ethereum, você poderia:

  • Adicionar uma linguagem (como Solidity) para escrever contratos mais complexos.
  • Usar uma máquina virtual para executar a lógica do contrato (semelhante à EVM do Ethereum).
  • Adicionar mecanismos de gás para limitar quanto de recursos cada execução de contrato consome.
  • Implementar um algoritmo de consenso para execução descentralizada (Proof of Work, Proof of Stake, etc.).

Considerações do Mundo Real

Para integrar completamente contratos inteligentes em uma blockchain:

  • Armazenamento de dados: Armazene o código e os estados do contrato de forma descentralizada (por exemplo, IPFS ou em seus blocos).
  • Ambiente de execução: Você precisará implementar um sistema para interpretar e executar o código do contrato de forma segura. Isso poderia ser semelhante à Máquina Virtual Ethereum (EVM), mas poderia ser muito mais simples na sua blockchain baseada em Go.
  • Segurança: Contratos inteligentes podem ser vulneráveis a ataques como reentrância ou bugs de estouro. Lidar com isso de forma segura é crucial (por exemplo, testando contratos minuciosamente).

Conectar a um Contrato Inteligente baseado em Ethereum (Avançado)

Se você está procurando conectar sua blockchain Go ao Ethereum ou a uma blockchain semelhante ao Ethereum para executar contratos inteligentes Solidity, aqui está a abordagem geral:

  1. Instalar o Web3 para Go: Esta é uma biblioteca Go que permite interagir com contratos inteligentes do Ethereum. go get github.com/ethereum/go-ethereum
  2. Conectar-se ao Ethereum: Você precisará configurar um nó Ethereum (por exemplo, usando Infura ou executando seu próprio nó) e usar o Web3 em Go para implantar e interagir com contratos inteligentes.

Aqui está um exemplo:

package main

import (
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID")
    if err != nil {
        log.Fatalf("Falha ao conectar ao cliente Ethereum: %v", err)
    }

    address := common.HexToAddress("0xYourContractAddress")

    fmt.Println("Conectado ao Ethereum!")
    fmt.Println("Endereço do Contrato:", address.Hex())
}

Nesta segunda parte, exploramos na prática como os contratos inteligentes funcionam dentro de uma blockchain. Em breve vamos aprofundar ainda mais: analisando padrões de contratos inteligentes, interações entre múltiplos contratos e desafios reais como segurança, escalabilidade e integração com redes como Ethereum.

O futuro é descentralizado — e ele começa com nossas linhas de código.

Guia Prático: Blockchain e Contratos Inteligentes I

Há muito tempo tenho vontade de criar um tutorial. No entanto, sempre tive um certo pudor, além do receio de ser (percebido como) apenas mais um.

Imagem decorativa do texto, mostrando objetos de escritório em torno da palavra 'blockchain'
Imagem: pexels.com

Sempre estabeleci como condição para um tutorial que o assunto tratado fosse realmente relevante e original. Agora, finalmente, surge a oportunidade de desenvolver um tutorial original sobre esse sistema importante, ainda pouco compreendido, mas cada vez mais presente na realidade do mundo moderno.

A mídia fala constantemente sobre blockchain e seus derivados — como as criptomoedas e os contratos inteligentes mas, para muitos, incluindo colegas de profissão, esses conceitos ainda são envoltos em uma névoa de imprecisão, quando não de total confusão. Este guia tem como objetivo destacar o aspecto concreto dessas tecnologias, trazendo à tona sua implementação real por meio de código, e mostrando, na prática, como interagir com elas dentro do ambiente computacional.

Neste tutorial uso a linguagem Go, tanto pela simplicidade como por seu uso crescente nos projetos voltados à Blockchain. Qualquer LLM poderá refatorar o código facilmente para qualquer outra linguagem, como Python.


O que é uma Blockchain?

O termo “blockchain” vem da junção das palavras em inglês block (bloco) e chain (cadeia), e descreve exatamente o que ela é: uma cadeia de blocos ligados entre si, onde cada bloco contém um conjunto de dados, um carimbo de data/hora (timestamp), e um hash que o conecta ao bloco anterior. Essa estrutura torna os dados praticamente imutáveis, sendo largamente usada para garantir transparência e segurança em ambientes descentralizados.

Um Pouco de História

A ideia de encadear blocos usando hashes não surgiu com o Bitcoin. Já em 1991, Stuart Haber e W. Scott Stornetta propuseram um sistema computacional para armazenar documentos com carimbos de tempo de forma segura — sem possibilidade de adulteração. Esse trabalho é considerado uma das raízes da blockchain moderna. Foi somente em 2008 que Satoshi Nakamoto uniu essa ideia com o conceito de dinheiro digital, criando o Bitcoin e, com ele, a blockchain como a conhecemos hoje.


Conceitos-chave para Entender

🧩 Bloco

Cada bloco é como uma página em um livro-razão digital. Ele possui:

  • Carimbo de data/hora (T1, T2, T3…): Indica quando o bloco foi criado.
  • Hash do bloco anterior (PreHash): Uma “impressão digital” do bloco anterior, que o conecta à cadeia.
  • Hash atual (Root Hash): Calculado com base no conteúdo do bloco e serve para garantir sua integridade.
  • Dados: Pode conter qualquer informação — transações financeiras, contratos, documentos, etc.
Figura 1 - Diagrama ilustrativo da blockchain.
Fig 1 – Ilustração da estrutura de um bloco.

Como se vê, o hash do bloco anterior se liga ao hash atual, conectando a cadeia. Se qualquer informação em um bloco for alterada, seu hash muda. Isso quebra a cadeia, tornando evidente que houve uma tentativa de adulteração.

🔐 Hashing

Hashing é o processo de aplicar uma função criptográfica sobre um dado para obter uma sequência de caracteres (o hash). Um dos algoritmos mais usados é o SHA-256, criado pela NSA e adotado amplamente desde os anos 2000. Ele transforma qualquer entrada (como um texto ou número) em uma sequência hexadecimal de 64 caracteres. Pequenas mudanças no dado original geram hashes completamente diferentes — um princípio chamado efeito avalanche.

⛏️ Prova de Trabalho (Proof of Work)

A Prova de Trabalho surgiu para resolver o problema da confiança em redes descentralizadas, como no Bitcoin. Ela exige que os participantes gastem poder computacional para adicionar novos blocos, tornando ataques muito caros e, portanto, inviáveis. A ideia foi inspirada em sistemas anti-spam dos anos 90 (como o Hashcash de Adam Back), onde uma tarefa computacional dificultava o envio de emails em massa.


🛠️ Construindo uma Blockchain Simples em Go

Agora que (provavelmente) entendemos os conceitos, vamos ver como isso se traduz em código.


Etapa 1: Definir a Estrutura do Bloco

package main

import (
    "crypto/sha256"
    "fmt"
    "time"
)

type Block struct {
    Index     int
    Timestamp string
    Data      string
    PrevHash  string
    Hash      string
}

🧱 Aqui definimos os principais componentes do bloco. Veja que a estrutura lógica do bloco define todos os ítens (atributos) do bloco, como ilustrado na Fig 1. Ele é uma estrutura básica, mas com tudo o que precisamos para construir a cadeia.


Etapa 2: Criar o Bloco Gênesis

func createGenesisBlock() Block {
    return Block{
        Index:     0,
        Timestamp: time.Now().String(),
        Data:      "Genesis Block",
        PrevHash:  "",
        Hash:      calculateHash(0, "", "Genesis Block"),
    }
}

📜 O bloco gênesis é o primeiro bloco da blockchain. Ele é especial porque não possui um antecessor. No Bitcoin, ele foi minerado por Satoshi Nakamoto em 3 de janeiro de 2009. Uma curiosidade: sua mensagem de dados incluía o título de uma manchete de jornal daquele dia, uma crítica à crise bancária da época.


Etapa 3: Função de Hash

func calculateHash(index int, prevHash, data string) string {
    record := fmt.Sprintf("%d%s%s", index, prevHash, data)
    hash := sha256.New()
    hash.Write([]byte(record))
    return fmt.Sprintf("%x", hash.Sum(nil))
}

🔍 Essa função garante a integridade do bloco, produzindo um hash único com base nas suas informações. Isso é o que torna a blockchain resistente a modificações: se qualquer dado mudar, o hash será diferente.


Etapa 4: Criar a Blockchain

type Blockchain struct {
    Chain []Block
}

func (bc *Blockchain) addBlock(data string) {
    prevBlock := bc.Chain[len(bc.Chain)-1]
    newBlock := Block{
        Index:     prevBlock.Index + 1,
        Timestamp: time.Now().String(),
        Data:      data,
        PrevHash:  prevBlock.Hash,
        Hash:      calculateHash(prevBlock.Index+1, prevBlock.Hash, data),
    }
    bc.Chain = append(bc.Chain, newBlock)
}

🔗 Aqui a cadeia começa a tomar forma. Cada novo bloco contém o hash do anterior, criando a estrutura de “cadeia”.


Etapa 5: Iniciar e Usar a Blockchain

func main() {
    blockchain := Blockchain{}
    blockchain.Chain = append(blockchain.Chain, createGenesisBlock())

    blockchain.addBlock("Primeiro bloco depois do genesis")
    blockchain.addBlock("Segundo bloco depois do genesis")

    for _, block := range blockchain.Chain {
        fmt.Printf("Index: %d, Timestamp: %s, Data: %s, PrevHash: %s, Hash: %s\n",
            block.Index, block.Timestamp, block.Data, block.PrevHash, block.Hash)
    }
}

📤 A execução do código imprime cada bloco da cadeia, demonstrando como a estrutura vai se formando e se conectando.


Etapa 6: Saída Esperada

Index: 0, Timestamp: ..., Data: Genesis Block, PrevHash: , Hash: 6b3d...
Index: 1, Timestamp: ..., Data: Primeiro bloco depois do genesis, PrevHash: 6b3d..., Hash: 2c6e...
Index: 2, Timestamp: ..., Data: Segundo bloco depois do genesis, PrevHash: 2c6e..., Hash: 9c4a...

📊 Você verá blocos encadeados, com cada PrevHash correspondendo ao Hash do bloco anterior.


🧠 O que mais?

A blockchain construída acima é funcional, mas ainda simples. Você pode expandir com:


Validação da Blockchain

func (bc *Blockchain) isValid() bool {
    for i := 1; i < len(bc.Chain); i++ {
        prevBlock := bc.Chain[i-1]
        block := bc.Chain[i]
        if block.PrevHash != prevBlock.Hash || block.Hash != calculateHash(block.Index, block.PrevHash, block.Data) {
            return false
        }
    }
    return true
}

🔎 Esta função verifica se a cadeia é válida. É um conceito essencial para detectar fraudes ou inconsistências em sistemas descentralizados.


🔨 Prova de Trabalho (Opcional)

Você pode implementar um campo nonce no bloco e ajustar o algoritmo de hash para que o resultado comece com, por exemplo, “0000”. Isso simula a mineração usada no Bitcoin, onde é preciso tentar milhões de combinações até encontrar um hash com a “dificuldade” exigida.


🌐 Descentralização

Até agora, nossa blockchain é local e centralizada. Em um projeto mais complexo, você pode usar:

  • Go-Ethereum: Implementação oficial do Ethereum em Go.
  • Gorilla Websocket: Para comunicação P2P entre nós (nodes).
  • Go-Swagger: Para criar APIs REST que expõem a blockchain.

🎓 Conclusão da primeira parte

Construir uma blockchain do zero é uma excelente forma de aprender estruturas de dados, criptografia, segurança da informação e sistemas distribuídos. Começando com algo simples, você pode continuar a adicionar camadas de complexidade: provas de consenso, contratos inteligentes, persistência em disco, interfaces gráficas e muito mais.

Se você chegou até aqui você está mais perto de entender não só como a blockchain funciona, mas por que ela é revolucionária. Na segunda parte deste pequeno guia, vou mostrar a lógica estrutural de um contrato inteligente e como adicioná-lo à Blockchain.

Estou desenvolvendo um tutorial completo (e executável!) sobre o tema, que abrigarei em meu Github. Você pode acompanhar — e contribuir.

Post #200: A Era da Hipnocracia

[EDITADO – VER NOTA] Em uma era onde a informação flui livremente — e instantaneamente, é fácil assumir que a batalha pela verdade é a luta definidora do nosso tempo. Frequentemente ouvimos falar em “fake news”, “pós-verdade” e a erosão da realidade objetiva, como se o principal desafio enfrentado pela sociedade fosse simplesmente a distorção dos fatos.

Imagem de um casal com um fundo evocando hipnose.
Imagem: pexels.com

Porém, em seu provocativo livro Hipnocracia, Jianwei Xun apresenta uma perspectiva mais sutil e alarmante sobre como o poder opera hoje. Em vez de se concentrar na supressão da verdade, Xun argumenta que vivemos agora sob um sistema onde o controle é alcançado ao nos sobrecarregar com narrativas, a ponto de perdermos a capacidade de distinguir qualquer uma delas como “a verdade”.


NOTA

Este filósofo de Hong Kong não existe, como revela Sabina Minardi, editora-chefe da revista italiana L’Espresso. A teoria é fruto da imaginação do ensaísta e editor Andrea Colamedici, que assina como tradutor, mas que, na verdade, é coautor do livro, auxiliado por duas plataformas de inteligência artificial, sem qualquer menção a esse fato [conforme exigido pela legislação da UE sobre IA]. Ele justifica a obra como um “experimento filosófico e uma performance artística”.

Eu desconhecia essa infeliz estória. Decidi remover o conteúdo da matéria publicada em 5 de Abril que se referia a conteúdo explícito na obra atribuído ao suposto filósofo de Hong Kong, cuja existência foi comprovada como falsa.

O Caminho para Marte: Um Alerta Contra o Controle Autoritário

A ambição dos ultra-ricos e poderosos de expandir sua influência não é nenhuma novidade. A história está repleta de indivíduos ou grupos que, movidos por um desejo de dominância, tentaram controlar vastas faixas de território, muitas vezes com consequências devastadoras para o resto da humanidade. Mas, à medida que nos aproximamos de uma nova era na exploração espacial, devemos nos perguntar: se um indivíduo poderoso ou uma elite rica pode chegar ao topo da estrutura de poder mais significativa da Terra — falo sobre os EUA, o que o impediria de estender seu alcance além do nosso planeta para Marte, sobre o qual, deve-se dizer, o grupo político-econômico que governa os EUA já acumula ‘know-how’ e ativos consideráveis?

Mulher astronauta ergue bandeira de uma nação fictícia em Marte.
Imagem: pexels.com

Um corolário da Lei da Gravitação Universal é que qualquer entidade situada em um poço gravitacional mais raso, um planeta menos massivo, terá uma vantagem logística e maior flexibilidade comparada ao seu análogo na Terra, seja no comércio, na estratégia militar ou na governança. A menor gravidade de um planeta como Marte significa que escapar de sua superfície ou mover recursos para fora do planeta exigiria muito menos energia em comparação com a Terra. Isso dá a qualquer um no controle de tal planeta uma vantagem significativa, não apenas em termos de extração de recursos, mas também em termos de mobilidade estratégica. Seja lançando foguetes, transportando mercadorias ou exercendo influência em todo o sistema solar, a flexibilidade de operar em um campo gravitacional mais fraco proporcionaria vantagens operacionais substanciais.

À medida que avançamos em direção à possibilidade de colonizar Marte, alguém pode se perguntar com alarme: O que impede as mesmas forças que dominam a Terra de reivindicar Marte, quando sabemos que o principal incentivador e empreendedor da colonização comercial marciana tem hoje um poder que um civil não-eleito jamais teve em toda a história? O próprio conceito de exploração espacial por corporações e indivíduos poderosos abre a porta para um futuro em que alguns poucos selecionados não apenas poderiam controlar a Terra, mas também dominar um planeta adicional por inteiro, exercendo poder irrestrito em dois mundos.

A estrutura de poder da Terra em 2025

Devemos começar considerando a situação atual na Terra. Estamos a assistir a ascensão de uma elite global: indivíduos ultra-ricos que controlam vastos recursos financeiros, corporações multinacionais e os sistemas políticos que governam as nações. Esses indivíduos já estão moldando o futuro da humanidade por meio do controle de recursos, da economia e, cada vez mais, do acesso ao espaço.

Em muitos aspectos, esses jogadores poderosos são como os senhores feudais de antigamente, só que seus domínios se expandiram além das fronteiras e para os reinos da influência global e até mesmo interplanetária. Se um indivíduo ou pequeno grupo pode chegar ao topo da estrutura de poder na Terra, seja por meio de riqueza, influência política ou maestria tecnológica , o que os impediria de reivindicar domínio sobre Marte também?

A vantagem gravitacional

O fato é que um poço gravitacional mais raso de Marte fornece uma oportunidade de dominação de maneiras que o poço mais profundo da Terra não oferece. Marte, como sabemos, é menor que a Terra, o que resulta em uma atração gravitacional significativamente mais fraca. Isso significa que é mais fácil lançar cargas úteis de Marte, seja um container comercial ou um pesado míssil cinético. Se um indivíduo ou corporação pudesse obter controle sobre os recursos em Marte, talvez por meio de operações de mineração ou estabelecimento de assentamentos, eles poderiam usar essa base como um ponto de apoio estratégico para estender seu poder de volta à Terra.

Por que o controle sobre um poço gravitacional mais raso é uma vantagem tão significativa? A resposta está na física básica da viagem espacial. Escapar da gravidade da Terra requer enormes quantidades de energia, vastos recursos e infraestrutura. Mas em Marte, a gravidade mais baixa significa que seriam necessários muito menos energia e recursos para estabelecer uma instalação de lançamento ou deixar a superfície do planeta.

Gráfico comparando as profundidades dos "poços gravitacionais" da Terra e da Lua.

Aqui uma representação bidimensional do conceito da esfera de Hill, aqui mostrando o “poço gravitacional” da Terra (potencial gravitacional da Terra, linha azul), o mesmo para a Lua (linha vermelha) e seu potencial combinado (linha preta grossa). O ponto P é o ponto livre de força, onde as forças gravitacionais da Terra e da Lua se cancelam. Os tamanhos da Terra e da Lua estão na proporção, mas as distâncias e energias não estão em escala.
Image By MikeRun – Own work, using Media and, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=73987051

Se alguém garantisse uma fortaleza em Marte, seja protegendo seus recursos ou controlando a infraestrutura necessária para manter a vida humana lá, estaria em uma posição invejável. Seria capaz de lançar missões com muito menos gasto de energia e usar Marte como uma plataforma de lançamento para futuros empreendimentos interplanetários. E não vamos esquecer que quem controla a tecnologia, os recursos e a logística para chegar e sair de Marte tem uma vantagem estratégica. Eles poderiam facilmente alavancar esse acesso ao espaço para propósitos econômicos, políticos e militares.

Um Novo Tipo de Colonialismo

Não são apenas as vantagens técnicas que devem levantar alarmes, mas as potenciais consequências políticas. Se um indivíduo poderoso, ou um consórcio de elites ricas, obtiver controle sobre Marte, eles poderiam efetivamente estabelecer uma nova forma de colonialismo, um império colonial que se estende muito além dos confins da Terra. Em vez de explorar populações nativas do planeta natal eles explorariam agora uma nova fronteira: o próprio espaço. Marte se tornaria um playground para aqueles com o poder de moldar seu futuro, enquanto o resto da humanidade é deixado para se defender na Terra exaurida.

Isso pode levar a um futuro alarmante, onde os ‘players’ mais ricos e poderosos da Terra, tendo garantido seu domínio sobre outro planeta, podem ditar termos para o resto do mundo. Com Marte como sua base, eles podem manipular mercados, controlar cadeias de suprimentos ou até mesmo criar novas indústrias inteiras em torno de recursos que foram extraídos de lá.

Além disso, as implicações políticas de tal poder podem ser surpreendentes. Não se trata apenas de riqueza, mas de autoridade. Uma pessoa que controla Marte provavelmente teria os meios para controlar a própria economia e estruturas de poder que lhe permitiram estabelecer sua supremacia em primeiro lugar, em um formidável ciclo de retroalimentação. Quer eles visem influência sobre governos globais, tecnologia ou mercados, o controle de um planeta inteiro é uma vantagem inimaginável.

O que está em jogo para a Terra e a Humanidade?

O que está em jogo não é apenas a possibilidade de colonização espacial, mas a natureza da própria liberdade humana. Se a riqueza e o poder nas mãos de alguns indivíduos ou corporações se estendessem a um novo mundo — como parece que vai acontecer no grande Mars grab que se avizinha, não há como dizer o que isso poderia significar para o futuro da governança global. Poderíamos ver uma situação em que ideias como ‘capitalismo’, ‘democracia’ e ‘autodeterminação’ se tornassem sem sentido, à medida que o poder se estendesse da Terra a Marte e além.

Devemos nos perguntar: estamos dispostos a deixar que alguns poucos decidam o destino de dois mundos? O que acontecerá com os ideais de igualdade, liberdade e humanidade compartilhada quando apenas os indivíduos mais ricos puderem reivindicar não apenas a Terra, mas um outro planeta inteiro? Veremos uma nova era de oligarquia interplanetária?


PS: Tudo isso também se aplica à Lua. Mas a competição já estabelecida entre várias nações impede que um pequeno grupo civil e/ou minoritário estabeleça a sua supremacia — quero acreditar.

Algoritmo Versus Comportamento Emergente

Vivemos a falar sobre algoritmos e sobre a influência que exercem sobre a sociedade. Mas algoritmos têm pouco a ver com a assim-chamada ‘revolução da IA’ e participam apenas da fase de input dos dados que serão processados pelas camadas ocultas das redes neurais subjacentes. O resultado dessa computação emerge naturalmente dos dados de uma forma fascinante.

Não é possível determinar por algoritmo o comportamento dos neurônios nas camadas mais profundas (‘hidden layers’) de uma rede neural – Concepção artística. Imagem: pexels.com

Neste post exploro sucintamente o que diferencia esses modelos de IA do software tradicional.

O Software Tradicional: algoritmos e Controle Total

O software tradicional, como as aplicações que usamos para navegar na web ou para organizar nossas tarefas diárias, é criado a partir de uma programação clara e controlada pelos desenvolvedores. Nesse tipo de software, os desenvolvedores são responsáveis por decidir como ele deve funcionar. Eles estruturam a arquitetura do software, definem as entradas e saídas, criam os fluxos de dados e, essencialmente, escrevem as regras que governam o funcionamento do programa. A lógica do código é escrita manualmente, com pouca ou nenhuma intervenção de dados externos.

Por exemplo, quando um desenvolvedor cria um sistema de gerenciamento de tarefas, ele pode definir exatamente como os dados devem ser exibidos na interface do usuário, como as informações serão organizadas em um banco de dados e quais ações o usuário pode executar. O comportamento do software é, portanto, determinado por uma série de decisões conscientes tomadas pelos desenvolvedores, com base em sua experiência e nas necessidades do usuário.

O Software de Aprendizado de Máquina: Os Dados “Programam” o Comportamento

Por outro lado, quando falamos de software de aprendizado de máquina, como os LLMs, o cenário muda drasticamente. Esses modelos não são programados da mesma forma que o software tradicional. Eles são, de certa forma, “treinados” em grandes volumes de dados, e seu comportamento é amplamente determinado pelas características e padrões presentes nesses dados.

A diferença principal está no fato de que, enquanto no software tradicional o desenvolvedor controla diretamente o comportamento do sistema, nos modelos de aprendizado de máquina o desempenho do modelo é ditado pelos dados que ele recebe. O desenvolvedor pode escolher o tipo de modelo (por exemplo, redes neurais profundas ou florestas aleatórias) e o algoritmo a ser utilizado, mas a maneira como o modelo responde aos dados e, por consequência, como ele se comporta em diferentes cenários, é algo que emerge de forma dinâmica e não totalmente previsível.

Quando treinamos um modelo como um LLM, por exemplo, ele aprende a identificar padrões de linguagem, relacionamentos entre palavras e estruturas de frases a partir de enormes quantidades de textos. O modelo, então, ajusta seus parâmetros internos (algo que pode ser descrito como uma “programação automática”) para se tornar cada vez mais eficaz em prever ou gerar linguagem com base no que aprendeu. A inteligência do modelo é resultado direto da interação com os dados, e o papel do desenvolvedor é criar a infraestrutura que permita esse aprendizado, mais do que codificar explicitamente cada comportamento ou resultado.

A Emergência de Comportamentos Complexos

O mais fascinante sobre os LLMs é que seu comportamento não pode ser totalmente previsto ou controlado, mesmo por seus criadores. Eles “aprendem” de forma autônoma, ou seja, a partir dos dados com os quais são alimentados. Isso cria um software mais flexível, capaz de lidar com uma variedade de situações de forma adaptativa. No entanto, também significa que o controle direto sobre o comportamento do sistema não é tão claro quanto em um software tradicional.

Por exemplo, ao treinar um modelo de linguagem, um desenvolvedor pode não conseguir prever exatamente como o modelo irá responder a uma pergunta específica, porque sua resposta é uma combinação complexa de dados anteriores, padrões de linguagem e o contexto em que a pergunta foi feita. Isso é muito diferente de um software tradicional, onde o desenvolvedor pode prever e controlar precisamente o comportamento do programa em todas as situações.

A Nova Era do Software

Portanto, os LLMs e outros modelos de aprendizado de máquina nos mostram que a programação de software não é mais uma tarefa totalmente controlada pelo ser humano através de um algoritmo. Em vez disso, esses modelos demonstram uma nova forma de processamento de dados que é, em grande parte, determinada pela interação com dados reais. O papel do desenvolvedor é mais sobre criar as condições para que o aprendizado aconteça, do que programar diretamente cada aspecto do comportamento do software.

Isso nos leva a uma reflexão importante: à medida que avançamos para o futuro da tecnologia, as linhas entre o que é “programado” e o que é “aprendido” estão se tornando cada vez mais tênues. O software está se tornando mais inteligente, mas também mais imprevisível, e essa é uma das características mais emocionantes da inteligência artificial.


Leituras adicionais:

Comportamento Emergente:

Link para Four-week MBA