Linguagem Ada: Por Que a NASA e Militares

O software do F-22 Raptor, o caca mais avancado da historia, roda em Ada. O sistema de navegacao do Boeing 777 roda em Ada. O controle de trafego aereo de varios paises roda em Ada. Uma linguagem criada nos anos 70 continua dominando os sistemas mais criticos do mundo em 2026.

Por que? Porque quando o software falha, avioes caem. E Ada foi projetada especificamente para nao falhar.

O desastre do Ariane 5, que voce pode ler em detalhes em A Historia Nao Contada do Desastre do Ariane 5, aconteceu parcialmente porque o software de navegacao nao tratou corretamente uma excecao de overflow. Ada tem mecanismos nativos para evitar exatamente esse tipo de falha.

A Origem: O Caos das Linguagens Militares nos Anos 70

Em 1974, o Departamento de Defesa dos EUA fez um levantamento chocante: estava usando mais de 450 linguagens de programacao diferentes em sistemas militares. Cada contratante usava o que queria. Cobol aqui, Fortran ali, assembly em outro lugar, linguagens proprietarias que ninguem mais mantinha.

O custo de manutencao era absurdo. Bugs eram impossíveis de rastrear entre sistemas diferentes. A integracao era um pesadelo. O DoD decidiu criar uma linguagem unica para todos os sistemas criticos.

O concurso de design

Em 1975, o DoD publicou requisitos detalhados para a nova linguagem. Quatro times competiram. Em 1979, o time de Jean Ichbiah na Honeywell venceu com o design que se tornaria Ada, batizada em homenagem a Ada Lovelace, a primeira programadora da historia.

O Que Faz Ada Diferente

Ada nao e so uma linguagem com sintaxe diferente. Ela tem caracteristicas de design que outras linguagens mainstream simplesmente nao tem.

Tipagem forte de verdade

-- Em Ada, tipos distintos nao sao intercambiaveis, mesmo com o mesmo tamanho
type Meters is new Float;      -- metros
type Seconds is new Float;     -- segundos
type Meters_Per_Second is new Float;  -- velocidade

function Calculate_Speed(
    Distance : Meters;
    Time     : Seconds
) return Meters_Per_Second is
begin
    -- Sem conversao explicita, o compilador rejeita a operacao
    -- return Distance / Time;  -- ERRO de compilacao!
    return Meters_Per_Second(Float(Distance) / Float(Time));  -- correto
end Calculate_Speed;

-- O famoso bug do Mars Climate Orbiter (1999):
-- Software enviava dados em libras-forca, receptor esperava Newtons.
-- Em Ada, isso seria um erro de compilacao. Em Fortran, foi um crash de US$ 125 milhoes.

O Mars Climate Orbiter se destruiu porque um modulo enviava forcas em libras e outro esperava Newtons. Em Ada, essa mistura seria detectada em tempo de compilacao. A sonda custou US$ 327 milhoes.

Ranges em tipos

-- Ada permite definir ranges diretamente no tipo
type Altitude_Meters is new Integer range 0 .. 50_000;
type Degrees_Celsius is new Float range -273.15 .. 1_000.0;
type Percentage is new Integer range 0 .. 100;

-- Tentar atribuir um valor fora do range causa
-- Constraint_Error em runtime (ou pode ser provado
-- em tempo de compilacao com SPARK)
Alt : Altitude_Meters := 60_000;  -- Constraint_Error!
Pct : Percentage := 150;          -- Constraint_Error!

Concorrencia nativa

-- Concorrencia e parte da linguagem, nao de uma biblioteca
task type Sensor_Reader is
    entry Read_Value(Value : out Integer);
end Sensor_Reader;

task body Sensor_Reader is
    Current_Value : Integer := 0;
begin
    loop
        select
            accept Read_Value(Value : out Integer) do
                Value := Current_Value;
            end Read_Value;
        or
            delay 0.1;  -- timeout de 100ms
            -- ler hardware aqui
        end select;
    end loop;
end Sensor_Reader;

Em Ada, tasks (threads) e sincronizacao sao primitivas da linguagem. Nao depende de bibliotecas externas que podem ter bugs ou comportamento nao especificado. O compilador entende concorrencia e pode verificar deadlocks potenciais.

SPARK: Verificacao Formal em Ada

Ada por si so ja e mais rigorosa que C ou Java. Mas SPARK Ada vai alem: e um subconjunto de Ada onde e possivel provar matematicamente propriedades do codigo.

Provar matematicamente significa que voce nao esta testando: esta demonstrando que certas categorias de bugs nao podem existir no seu codigo. Sem excepcao, sem caso especial, sem input que faca falhar.

-- SPARK Ada com contratos formais
package Safe_Arithmetic
   with SPARK_Mode
is
   function Safe_Add(A, B : Integer) return Integer
      with
         Pre  => A <= Integer'Last - B,  -- precondition
         Post => Safe_Add'Result = A + B  -- postcondition
      ;  -- GNATprove verifica que overflow e impossivel dado o Pre

end Safe_Arithmetic;

-- Se voce chamar Safe_Add com valores que possam causar overflow,
-- GNATprove vai REJEITAR o codigo antes de compilar.
-- Nao e um warning. E uma prova matematica.

Onde Ada Roda Hoje

Ignorar Ada por ser 'linguagem antiga' e nao entender o mercado. Ada nao e legado: e o estado da arte em sistemas de alta integridade.

Uma curiosidade: o Ariane 5 usava Ada. O bug que causou o desastre estava no codigo Ada, sim. Mas a causa foi desativar o tratamento de excecao (por motivos de performance) em um bloco critico. Ada tinha o mecanismo correto, mas os engenheiros escolheram ignorar a protecao. Humanos continuam sendo o problema.

Ada vs Rust: A Comparacao Inevitavel

Rust e a linguagem moderna que mais se aproxima de Ada em termos de seguranca. A comparacao e justa e as diferencas sao interessantes.

A verdade pratica: Rust esta entrando em alguns dominios de Ada, especialmente em sistemas embarcados novos. Mas Ada com SPARK ainda e a unica opcao quando voce precisa de certificacao formal em aviacao ou defesa. Rust e o futuro de muitos sistemas criticos. Ada e o presente inabalavel dos mais criticos de todos.

Por Que Devs Ignoram Ada

Ada e a linguagem que todo engenheiro deveria conhecer e quase nenhum conhece. Por que?

Primeiro: o mercado de Ada e pequeno e especializado. Nao tem vagas para junior em Ada. Voce vai para Ada depois de anos em sistemas embarcados ou aeroespacial.

Segundo: Ada e verbosa. Muito verbosa. O que em Python e uma linha, em Ada pode ser 20. Para quem esta acostumado com linguagens modernas, parece codigo dos anos 70, porque e.

Terceiro: o toolchain historicamente era caro. O compilador GNAT da AdaCore era pago. Hoje tem versao open-source (gnat-gpl), mas a reputacao ficou.

Quarto: Ada certa e dificil. Ela te forca a pensar em todos os casos de erro, todos os limites, todas as excecoes possiveis. Para software rapido de startup, isso parece burocracia. Para software que nao pode falhar, e exatamente o que voce quer.

O Legado de Ada

Ada mudou como pensamos sobre seguranca em linguagens. Muitas das ideias que consideramos modernas em Rust, TypeScript e Kotlin vieram de problemas que Ada ja resolvia nos anos 80: tipagem forte, tratamento de erros explicito, sem null implicito, concorrencia segura.

Quando voce usa option types em Rust ou Kotlin, esta usando uma ideia que Ada implementava como Constraint_Error ha 40 anos. Quando voce define um type alias em TypeScript para distinguir userId de productId, esta reimplementando a tipagem por dominio que Ada tinha desde o inicio.

Ada prova que e possivel construir software que nao falha. O custo e alto: mais tempo de desenvolvimento, mais verbosidade, mais rigor. Mas quando o software faz parte de um sistema que carrega 400 pessoas a 10 mil metros de altitude, esse custo e justificavel.

Os desastres de software como o Ariane 5 acontecem por escolhas de engenharia: reusar codigo sem validar suposicoes, desativar protecoes por performance, nao testar cenarios extremos. Ada nao previne decisoes ruins de engenheiros. Mas torna muito mais dificil escrever codigo perigoso sem perceber.