Apple-1 a leilão: como o 6502 ainda ensina arquitetura a devs

Um Apple-1 funcionando vai a leilão em Nova Iorque. Assinado pelo Woz, com carta do Jobs no lote. Estimativa: meio milhão a 800 mil dólares. E eu fico pensando no que isso diz sobre a nossa relação com a história da computação — porque, na prática, essa placa de 1976 ainda ensina mais do que muita arquitetura “moderna” que aparece em tutoriais por aí.

Segundo o Sapo.pt, trata-se de uma das cerca de 75 unidades originais preservadas e uma das seis ainda em pleno funcionamento. O carimbo “NTI” indica que veio do segundo lote de produção — ou seja, é uma peça historicamente posicionada entre a primeira fornada (a “Byte Shop”) e o que viria a ser o Apple-II. Isso importa. Muita gente confunde “Apple-1 raro” com “qualquer Apple-1”, mas o contexto de produção muda completamente o valor de mercado.

Por que essa placa específica interessa a quem programa

Não é nostalgia. É pedagogia bruta. Quando você olha para um Apple-1, está vendo a stack completa da época exposta sem abstração nenhuma:

• CPU MOS Technology 6502 rodando a 1 MHz.
• 8 KB de RAM — e só. Sem MMU, sem cache, sem pipeline.
• ROM Wozniak com o monitor BASIC e o “system monitor”.
• PIA 6820 fazendo todo o I/O, incluindo a saída para o terminal serial.
• Três condensadores Sprague originais — detalhe que autenticadores como a Bonhams usam para validar procedência.

Na minha experiência como dev, quando alguém me pergunta “por onde começo a entender arquitetura de computadores de verdade”, eu respondo: estude o 6502. Não o ARM Cortex-M0, não o RISC-V didático. O 6502. Porque ele força você a pensar em ciclos de clock, em páginas zero, em endereçamento indexado sem nenhum hardware moderno te salvando.

O 6502 em perspectiva: o que 8 KB de RAM realmente significam

Hoje a gente reclama se um container Docker ocupa 256 MB. Em 1976, 8 KB era luxo. O Wozniak escreveu o Integer BASIC cabendo em menos de 4 KB de ROM — algo que, em qualquer métrica moderna, beira o impossível. O Apple-1 não tinha vídeo framebuffer: o terminal era externo (um teletype ou um CRT serial). Isso reduzia o hardware, mas também significava que toda a interação era via PIA.

Comparando com o que a gente usa hoje:

Esse último ponto é o que mais me impressiona. Liga e está pronto. Zero init system, zero service, zero driver de GPU para negociar. Você aperta reset e o Woz Monitor aparece esperando `R` (read), `W` (write), `G` (go). É dev sênior puro: nada entre você e o silício.

Na Prática: programando o Apple-1 em assembly 6502

Vamos ao que interessa. Para você entender o porquê dessa máquina ser um marco, veja como era escrever um “Hello, World” no Apple-1. Não tinha printf. Não tinha terminal buffer. Você escrevia caractere por caractere direto na PIA, verificando se ela estava pronta.

; Hello.s - Apple-1 6502 assembly
; Envia "HELLO" para o terminal serial via PIA no endereço $D012
; Cada caractere: espera o flag de "transmit ready" e escreve.

    ORG $8000          ; endereço típico de carga no Apple-1

START:
    LDX #$00           ; índice da string
LOOP:
    LDA MSG,X          ; carrega caractere
    BEQ DONE           ; se for zero (null terminator), acabou
    JSR PUTCHAR        ; envia
    INX                ; próximo caractere
    JMP LOOP

DONE:
    JMP DONE           ; trava (halt)

; -------------------------------------------------
; PUTCHAR: escreve um caractere em A na PIA serial
; Apple-1: PIA base em $D010
;   $D010 = porta A (dados)
;   $D011 = direção porta A
;   $D012 = porta B (dados, controla a serial)
;   $D013 = direção porta B
; -------------------------------------------------
PUTCHAR:
    PHA                ; salva caractere na pilha
WAIT:
    LDA $D013          ; lê DDR/control B
    BPL WAIT           ; bit 7 = ready; espera ficar alto
    PLA                ; recupera caractere
    STA $D012          ; escreve na porta serial
    RTS

MSG:
    DC "HELLO", $00

Perceba o que está acontecendo. Não tem syscall. Não tem driver. Não tem buffer de linha. Cada caractere é uma escrita bloqueante num registrador de hardware. Quando você lê código assim, entende por que linguagens de alto nível viraram commodities e por que engenheiros do Bell Labs e do MIT ficavam obcecados com tempo de execução em ciclos — porque cada ciclo custava um clock real que você podia ver no osciloscópio.

Se quiser testar isso sem ter um Apple-1 (spoiler: você não tem um), use o emulador Apple-1js no navegador. É fiel o suficiente para você sentir a dor (e o prazer) de depurar com o Woz Monitor.

O que evitar: erros comuns que devs cometem ao olhar pro retro

Quando alguém descobre essa peça em leilão e quer “colecionar” ou “emular”, vejo três armadilhas clássicas:

1. Confundir Apple-1 com Apple-II. O Apple-II tem vídeo framebuffer, BASIC em ROM colorido, slots de expansão. O Apple-1 não tem nada disso. São máquinas de gerações diferentes dentro da mesma empresa, com um ano de diferença.
2. Subestimar o custo de manter um funcionando. Os condensadores Sprague envelhecem. Sem reforma eletrolítica, a placa vira peso de papel caro. Reparos em Apple-1 funcional exigem técnico especializado — poucos no mundo.
3. Achar que emulador = mesma coisa. Não é. Emulador tira o ruído elétrico, a fiação artesanal e a sensação de digitar programa diretamente em RAM via switch. Quem programa Apple-1 de verdade sabe: você digita o opcode em hex, caractere por caractere, e vê a luz do terminal piscar.

Se você é dev e quer entender de verdade, programe num emulador e leia o “Assembly Lines” de Roger Wagner para o Apple-II — que é a evolução didática direta do que o Woz fez no Apple-1.

Por que essa carta do Jobs importa além do valor monetário

O lote inclui uma carta assinada por Steve Jobs. Em termos de proveniência, isso é ouro. Mas para quem programa, o detalhe simbólico é o que vale: Jobs e Wozniak trabalhavam em par — Woz projetava, Jobs vendia. Essa placa com assinatura dos dois é, literalmente, o documento físico da divisão de trabalho que fundou a indústria de PCs.

Quando você escreve software hoje, está usando abstrações que essa máquina ajudou a criar. O 6502 influenciou o design do 65C816 (Apple IIGS), que influenciou o ARM (porque Sophie Wilson trabalhou no Acorn, descendente direto da cultura 6502). Seu iPhone, seu M1, seu Raspberry Pi — todos carregam DNA dessa placa de 1976 que está indo a leilão.

FAQ — perguntas que devs realmente fazem

1. Por que o Apple-1 vale tanto se a CPU é tão simples?

Porque sobraram menos de 75 unidades e só 6 funcionam. Em tecnologia, raridade + condição funcional é o que define preço, não utilidade prática. Um Picasso “simples” também vale milhões.

2. Dá para programar um Apple-1 hoje sem comprar um?

Sim. Emuladores como Apple-1js, MAME e o MESS emulam o hardware fielmente, incluindo a PIA e o comportamento serial. Você perde o chiado da chave, mas ganha praticidade.

3. O que exatamente o Woz escreveu na ROM do Apple-1?

O “System Monitor” (Woz Monitor), um interpretador mínimo que aceita comandos `R` (read memory), `W` (write memory) e `G` (go/run). Em cima dele rodava o Integer BASIC, também escrito por Wozniak em assembly, em menos de 4 KB.

4. O 6502 ainda é relevante para devs modernos?

Muito. O chip é didático, simples de simular e usado em consoles (NES), emuladores, sistemas embarcados e como base didática para ensinar arquitetura. Se você programa em Rust, C, ou Go, entender o 6502 te dá vocabulário sobre registradores, modos de endereçamento e ciclos de barramento que nenhuma faculdade moderna cobre direito.

5. Vale a pena investir em hardware retrô como dev?

Não como investimento financeiro — valor de leilão é imprevisível. Vale como formação técnica. Montar um kit 6502, programar num emulador fiel ou contribuir com projetos como o Commander X16 ensina mais sobre sistemas do que anos lendo blogs de arquitetura.

Se essa placa for arrematada na faixa dos 800 mil dólares — como alguns preveem —, não será pelo silício. Será pelo significado. Porque naquela placa de 1976 está a prova de que, antes de frameworks, antes de Kubernetes, antes de LLMs, dois caras numa garagem decidiram que programadores mereciam uma máquina só para eles. E esse é o ethos que ainda move quem escreve código de verdade.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto — posso fazer um próximo post emulando o Apple-1 em Rust, se a comunidade pedir.