Faz muito tempo que problemas de computação passaram a ser resolvidos com força bruta. Otimização de código é considerado algo desnecessário, quando basta adicionar poder computacional no pool e tudo se resolve (exceto Ruby, que não escala).

Nem sempre foi assim. Houve uma época em que o auge da tecnologia de computação não permitia essas saídas fáceis. Era uma época onde o Talento ainda imperava, onde desenvolvedores dotados de poderes mágicos conjuravam programas impossivelmente eficientes, bons o suficiente para colocar um Homem na Lua.

A tarefa não era fácil. O computador de navegação das naves Apollo era tão fundamental que dois meses depois de John Kennedy proferir seu famoso discurso a NASA já estava fechando o contrato de desenvolvimento do sistema, antes sequer de saber como seria o foguete que ele controlaria.

Para surpresa do Complexo Industrial Americano, o contrato foi para as mãos do MIT, mais precisamente do laboratório de Instrumentação, liderado por um sujeito chamado Stark. Certo, era Charles Stark Draper, mas poderia muito bem ter sido Howard Stark, dado seu currículo.

Ele apenas inventou o sistema de navegação inercial para aviões, um conjunto de giroscópios e acelerômetros que determina com precisão a posição de uma aeronave, e associado ao piloto automático, bem… pilota o bicho até seu destino.

O sistema se baseia no conceito de que um giroscópio, quando em movimento giratório, mantém a mesma posição, fruto da inércia. Medindo a mudança de ângulo das estruturas presas ao giroscópio, temos direção. Some isso aos dados dos acelerômetros e é simples calcular a posição do objeto em relação a seu ponto de partida. E melhor ainda, giroscópios, ao contrário do acelerômetro do iPad, funcionam em gravidade zero.

No primeiro grande teste do sistema um avião levando Draper, sua equipe e jornalistas voaram de Boston até Los Angeles, sem usar referências externas, somente no automático. Quase no final da viagem o avião fez uma curva abrupta, o piloto por pouco não assumiu o controle, todo mundo achava que o sistema tinha pirado.

Não era o caso. Ele estava corrigindo a posição por causa dos ventos fortes, quando a curva parou o aeroporto de destino estava perfeitamente alinhado com a proa.

Draper pensou em usar essa mesma tecnologia para orientar a espaçonave, o que exigiu giroscópios bem mais precisos e duráveis que os existentes. E esse nem foi o maior problema. Num avião os controles eram simples, um sistema eletromecânico bastava pro sistema de navegação pilotar. Em uma nave viajando entre dois mundos, o buraco era muito mais embaixo. Ou em cima, dependendo de seu referencial.

Era preciso um computador. Isso em uma época onde computador ainda era sinônimo de algo que ocupava uma sala grande. Tinham que criar uma máquina funcional que ocupasse o volume máximo de 0,028 metros cúbicos. Qual o tamanho disso? Um PC desktop dos pequenos.



Produzir esse computador não seria fácil, principalmente em 1961. O jeito foi apelar pra uma tecnologia recém-inventada, os circuitos integrados. Um computador usava 4100 CIs, todos idênticos, cada um uma porta lógica NOR.

Isso mesmo, nada de processadores dedicados, o circuito era todo composto de unidades discretas. Eles literalmente montaram um processador, o que era compreensível, afinal o microprocessador em um único chip só seria lançado em 1971, com o Intel 4004.

Nessa brincadeira, no auge do programa Apollo a NASA consumia 60% da produção americana de chips, mesmo assim ainda havia mais problemas.



Não havia especificação do sistema. Era tudo especificado em tempo de desenvolvimento. Não se sabia nem se o sistema iria controlar totalmente a navegação ou apenas auxiliar os astronautas. Os projetistas acabaram incluindo um backup que se tornou vital: um sextante. Isso mesmo, navegação pelas estrelas, como os primeiros marinheiros. Primitivo talvez, mas funcional e à prova de tela azul.

Por falar em BSOD, os travamentos eram uma preocupação, pois a vida dos astronautas dependeria daquele computador. A solução foi uma ideia radical: em vez de um sistema de time sharing, com multitarefa cooperativa, onde cada tarefa entregava o controle de volta ao sistema operacional, optou-se por um sistema onde havia tarefas cooperativas e um sistema de interrupções onde tarefas prioritárias eram executadas mesmo que outras aplicações não houvessem devolvido o controle ao sistema.



Os programas eram escritos em assembly, com endereçamento de 16 bits e um conjunto de apenas 11 instruções diferentes, mas calma que melhora: como fazer cálculos complexos em assembler (minha geração chama assembly de assembler, quem não gostar, GFY) é, foi e sempre será um inferno, o MIT criou uma máquina virtual com um conjunto de instruções expandido, com capacidade de cálculo em ponto flutuante e até operações vetoriais.

Essa máquina virtual rodava em tempo real, em cima do computador de navegação da Apollo.
Especificações

O computador era uma obra-prima de tecnologia, fazendo tudo isso com 2 KB de RAM e 48 KB de ROM, rodando a um clock interno de 1,024 MHz, sendo usado nas Apollos IV e VI.

A segunda geração de computadores do sistema de navegação foi construída em 1966 com 2800 CIs cada um com duas portas lógicas NOR, a RAM aumentou pra 4 KB e a ROM para 73 KB.

Obviamente não havia HD, os discos da época eram frágeis e grandes demais. a ROM era gravada em um negócio genial que, apesar do nome, não foi inventado em Pernambuco: Memória de Corda.

Eram fios passando através ou em volta de núcleos magnetizados. O fio passando dentro era um 1, passando fora era um 0.



Como você já está imaginando, era um inferno escrever um programa, ou tecer, para ser preciso. Levava meses e qualquer erro significava jogar fora todo o trabalho, que era conhecido como Método LOL, de Little Old Lady, pois a maior parte dos funcionários que faziam a tecelagem do software eram velhinhas.





ÓBVIO que com tudo isso o projeto atrasou, a ponto da NASA nomear um interventor que foi explicar aos universitários como a banda tocava no mundo corporativo. Softwares inteiros foram reescritos, a própria função do sistema de navegação foi reduzida, de primário para auxiliar, e no final uma versão funcional foi entregue.

O sistema iria utilizar sinais de rádio da Terra como faróis de navegação, o módulo inercial seria um backup, usado somente em caso de emergência ou quando não houvesse contato.

O grande teste foi em 1968, com a Apollo VIII. Ao passar por trás da Lua ficaram sem o sinal de rádio, todo o controle foi feito pelos giroscópios e pelo software. Ao sairem da sombra o sistema enviou seus dados de telemetria para a Terra, e bateram com absoluta precisão com os valores calculados pela NASA.

Em 1969 foi a vez da Apollo XI usar o módulo mais complexo de todo o sistema, as rotinas de pouso. Em nenhum outro momento uma sequência contínua tão grande de instruções era necessária. Curioso é que esse módulo foi escrito quando 2/3 do sistema já estava pronto. O autor foi um jovem de 22 anos em seu primeiro emprego como engenheiro júnior chamado Don Eyles. Responsabilidade? Magina…

Durante a descida na superfície lunar, o computador disparou um alerta de erro, no caso, o famoso Erro 1202.

Problema é que na NASA ninguém sabia que diabos era aquilo, e sem idéia da gravidade, o natural seria abortar o pouso. Quem salvou o dia foi um sujeito chamado Jack Garman, engenheiro de software e que tinha a única cópia da lista de erros do sistema.

Ele levantou a mão, disse qual era o erro: overflow, o computador estava recebendo dados demais e não conseguia processá-los, mas graças ao sistema de prioridades de tarefas criado por Hal Lanning, as de baixa importância eram desconectadas enquanto o principal, relacionado ao pouso, era mantido rodando.



Depois descobriram qual havia sido o erro. A checklist estava errada, Buzz Aldrin, seguindo as instruções, ligou o radar de retorno, usado para acoplagem com a cápsula principal. Desnecessário para o pouso, só seria usado em caso de cancelamento, nunca havia sido testado nos simuladores enviando dados para o computador principal.

O resto, como dizem, é História. O sistema sofreu várias melhorias, inclusive a adição da possibilidade de reescrever parte dos programas em execução, função que foi fundamental para salvar a Apollo XIV, que teve problemas com um sinal intermitente nos circuitos de abortar o pouso. A 300 mil km de distância Don Eyles orientou os astronautas que entraram com uma rotina de bypass, em assembler. E você reclama do Java.



O computador de navegação da Apollo se dava ao luxo de ter processamento de sobra, permitindo até detalhes como converter os dados de sistema métrico para unidades imperiais, ao gosto dos astronautas. Hoje temos que esperar a próxima atualização do iPad, pois a Apple não incluiu teclado em português na primeira versão…