Ao contrário do que a mitologia sugere, as diretrizes da NASA para software crítico de segurança não apenas valorizam a simplicidade extrema; elas a tornam obrigatória. Uma disciplina férrea guia todo o trabalho dos programadores.
Programar para uma espaçonave não é como programar um app qualquer. Cada bug pode custar milhões de dólares e anos de missão. Por isso, a NASA desenvolveu um conjunto de 10 regras chamadas Power of Ten, criadas por Gerard J. Holzmann no Jet Propulsion Laboratory (JPL) e publicadas na IEEE Computer em 2006.
Essas regras não buscam performance nem elegância, mas simplicidade, previsibilidade e verificabilidade, características essenciais em programas críticos.
O que são as regras Power of Ten?
Elas são diretrizes para escrever código tedioso, seguro e confiável:
- Use apenas um subconjunto seguro da linguagem
Evite recursão, alocação dinâmica de memória, loops infinitos e fluxos complicados. Isso torna o código mais previsível e fácil de verificar. - Todos os loops devem ter limites fixos
Cada loop precisa ter um limite superior claro. Isso previne loops infinitos e garante tempo de execução previsível. - Não use memória dinâmica
Nada demalloc,free,newoudelete. Alocação dinâmica pode falhar ou fragmentar a memória, o que é inaceitável para sistemas espaciais. - Funções curtas e simples
Idealmente, menos de 60 linhas, com estado local mínimo e propósito único. Isso facilita leitura, testes e verificação. - Controle de fluxo claro e visível
Evitegoto, aninhamento profundo e múltiplos pontos de saída. Fluxos simples reduzem chances de erros lógicos. - Limite o uso de ponteiros
Eles aumentam risco de referências inválidas e corrupção de memória. Prefira arrays e índices. - Cheque todos os retornos de função
Toda função que pode falhar deve ser verificada. Se um sensor ou leitura retornar erro, ele precisa ser tratado. - Sem fluxos de dados ocultos
Evite variáveis globais ou efeitos colaterais “surpresa”. Todas as dependências devem ser explícitas. - Código sem avisos do compilador
Nenhum aviso deve passar despercebido. Eles muitas vezes indicam problemas reais. - Uso mínimo do pré-processador
Evite macros complexas e compilação condicional. Prefira constantes simples e estruturas claras.
Por que essas regras funcionam
Software de espaçonaves precisa ser previsível, verificável, robusto e seguro. A ideia da Power of Ten é domar a linguagem C/C++ para que ela se torne uma mini-linguagem interna, onde qualquer programador possa entender e revisar o código, nas piores condiçoes, e anos após o lançamento. O conceito-chave é controlar a complexidade para tornar o software quase matematicamente verificável. A questão não é sobre elegância, esperteza ou performance, mas sobre segurança e confiabilidade.
Filosofia da NASA
- Código simples vence código esperto: a melhor prática em sistemas críticos é a óbvia, linear e transparente.
- Programadores conservadores e convencionais prosperam: nada de “rock-star devs”; o trabalho é feito sobre métodos consistentes e previsíveis.
- Alta habilidade é redirecionada: para arquitetura, simulação, testes e análise de segurança, não truques ou abstrações complexas.
Exemplos práticos
1. Loop seguro e limitado
int sum_array(const int *data, int length){ int sum = 0; if (!data || length <= 0) return 0; for (int i = 0; i < length; i++) sum += data[i]; return sum;}- Sem aritmética de ponteiros
- Sem memória dinâmica
- Limites fixos, fácil de verificar
2. Máquina de estados clara
typedef enum {IDLE, RUNNING, ERROR} State;State update_state(int sensor_ok){ switch(sensor_ok) { case 1: return RUNNING; case 0: return ERROR; default: return ERROR; }}- Transições explícitas
- Sem “fall-through”
- Fácil de testar e auditar
3. Checagem de retorno
int safe_read_sensor(int *out){ if (!out) return -1; int rc = read_sensor_hardware(out); if (rc != 0) { *out = 0; return -1; } return 0;}- Nenhum erro é ignorado
- Comportamento definido em caso de falhas
4. Buffer estático seguro
#define LOG_SIZE 256static char log_buffer[LOG_SIZE];static int log_index = 0;void log_message(const char *msg){ if (!msg) return; int i = 0; while(msg[i] != '\0' && log_index < LOG_SIZE - 1) log_buffer[log_index++] = msg[i++]; log_buffer[log_index] = '\0';}- Sem heap
- Escritas limitadas
- Terminador nulo explícito
5. Aritmética segura
int safe_multiply(int a, int b, int *res){ if (!res) return -1; long long temp = (long long)a * (long long)b; if(temp > INT_MAX || temp < INT_MIN){ *res=0; return -1; } *res = (int)temp; return 0;}- Detecta overflow
- Evita comportamento indefinido
- Comprovável mecanicamente
Enfim
O estilo Power of Ten não é elegante, não é divertido e não é esperto; é seguro, previsível e auditável. Em sistemas críticos como espaçonaves o código não precisa ser impressionante; precisa funcionar sempre e ser compreensível mesmo sob pressão extrema.
Se você programar seguindo essas regras, mesmo como um desenvolvedor convencional, seu trabalho terá o mesmo impacto que os “rock stars” do código, mas com robustez garantida.
Voxle One 