O que significa F90 no contexto de programação
F90 é a abreviação de FORTRAN 90, a versão do idioma FORTRAN padronizada em 1991 (revisada em 1997 como Fortran 95). Foi o primeiro grande salto no FORTRAN depois de décadas de praticamente não evoluir desde o FORTRAN 77. Se você abrir um código com extensão .f90 ou .f95, está lidando com essa especificação. A coisa mais importante que o F90 introduziu foi a programação modular com module, arrays com allocate e deallocate, recursividade nativa, e interface genérica. Antes disso, o FORTRAN 77 era basicamente código livre sem funções recursivas e sem gerenciamento dinâmico de memória.
Entendendo o que significa F90 na prática
Na prática, F90 significa que você pode escrever código com estruturas que se parecem muito mais com FORTRAN moderno do que com aquele velho código fixo de colunas. As rotinas passam a ficar em arquivos separados, organizadas em módulos, e o compilador pode realmente otimizar entre arquivos. Um detalhe que pouca gente menciona: o Free Form do F90 removeu a restrição de que o código teria que começar na coluna 7. Antes, qualquer coisa antes da coluna 7 era ignorada ou causava erro. Com F90, você pode indentar normalmente. Isso simplifica coisas, mas também significa que arquivos .f do FORTRAN 77 precisam de tratamento diferente.
Outro ponto: use modulo_nome é a forma padrão de importar funcionalidades. Diferente do include do FORTRAN 77, isso é resolução de símbolos real, não expansão textual cega.
Compilando código F90 hoje em dia
Se você tem um arquivo main.f90 e quer compilar, o comando básico com GCC é: gfortran main.f90 -o executavel -O2
Com Intel Compiler: ifort main.f90 -o executavel -O2
Com gfortran, a opção -O2 já dá uma otimização razoável. Se estiver fazendo simulações de CFD ou estruturais, -O3 ou -O2 -march=native fazem diferença real no tempo de execução — em alguns casos, até 30-40% mais rápido dependendo do código. Para projetos maiores com múltiplos arquivos e módulos, é melhor usar um Makefile. Compilar um por um na mão funciona para scripts pequenos, mas quando você tem 20 módulos e 5 rotinas principais, o Makefile é o que separa alguém que trabalha com FORTRAN de alguém que só faz experimentos esporádicos.
Problemas reais que eu encontrei com F90
Uma vez precisei rodar um código legado que tinha arquivos com extensão .f (formato fixo) misturados com arquivos .f90 (formato livre) no mesmo projeto. O compilador tentava interpretar o .f como free form e quebrou tudo. A solução foi compilar os dois grupos separadamente e depois linkar. No GNU Fortran, você pode forçar o formato com -ffixed-form e -ffree-form, então o comando ficaria algo como: gfortran -ffixed-form antiga.f -ffree-form moderna.f90 -o programa
👉 Clique no botão abaixo para saber mais sobre o assunto!
Isso resolveu. Não tente converter tudo para .f90 — a migração completa de um código legado grande consome tempo demais e geralmente traz bugs novos. Outro problema: variáveis não inicializadas em arrays alocados dinamicamente. No F90, quando você usa allocate(matriz(n,m)), os valores não são zerados automaticamente. Em código numérico, isso gera resultados errados silenciosamente. A solução é usar allocate(matriz(n,m), source=0.0d0) ou chamar call c_f_pointer se estiver integrando com C, mas a forma mais comum é simplesmente chamar matriz = 0.0d0 após o allocate.
Pegadinhas e insights que ninguém ensina
A primeira coisa: implicit none é obrigatório em qualquer código F90 sério. Sem isso, o compilador assume que variáveis que começam com I-N são inteiras e todas as outras são reais. Isso é a origem de metade dos bugs difíceis em código FORTRAN legítimo. Coloque implicit none como a primeira linha de todo módulo e subrotina. A segunda: a função selected_real_kind(p, r) é o jeito correto de lidar com precisão portátil. Em vez de declarar real*8 ou double precision direto, use:
integer, parameter :: dp = selected_real_kind(15, 307) Depois declare real(dp) :: variavel. Isso garante que o código vai rodar com a precisão correta em qualquer plataforma. real*8 funciona na maioria dos compiladores modernos, mas é uma extensão, não parte do padrão F90, e pode causar problemas em arquiteturas RISC ou em ambientes HPC específicos.
Uma terceira pegadinha: arrays com limites arbitrários. No F90, você pode declarar real :: arr(0:99) ou real :: arr(-50:49). No FORTRAN 77, os índices começavam em 1 e não havia essa flexibilidade. Isso parece inocente, mas causa bugs sérios se você misturar códigos escritos em épocas diferentes sem prestar atenção nos limites dos arrays.
Limitações do F90 que você precisa saber
FORTRAN 90 não suporta ponteiros de forma tão flexível quanto C++. Ele tem ponteiros, mas são orientados a target e a manipulação é mais restrita. Se você está trabalhando com estruturas de dados complexas como listas encadeadas ou árvores binárias, FORTRAN F90 não é a melhor ferramenta. FORTRAN 2003 melhorou isso com orientação a objetos, mas ainda assim é limitado comparado a linguagens modernas. O outro ponto fraco: IO paralelo. Para simulações que rodam em milhares de núcleos, o F90 não tem suporte nativo a IO paralelo. Você precisa de bibliotecas externas como PnetCDF ou depender de MPI-IO com wrappers. Se o seu código lê e escreve muitos arquivos grandes, isso vai se tornar um gargalo rápido.
Se o seu projeto exige MPI avançado, CUDA ou OpenMP pesado, considere migrar para FORTRAN 2008/2018 ou mesmo converter para C++/Fortran moderno. O F90 ainda roda muito código de produção, mas é uma especificação de 1991 e tem limitações que versões mais recentes resolveram.
Alternativas e quando considerar mudá-las
Se você está começando um projeto novo em FORTRAN hoje, o recomendado é pelo menos F2008. A diferença prática é suporte a IO assíncrono, classes, e melhor manipulação de strings. Se puder, vá direto para F2018. Mas se o código já existe em F90, não há motivo para migrar só por migrar — a stabilidade do F90 é comprovada há décadas em codes de energia nuclear, clima e mecânica dos fluidos. Para aprendizado, o livro "Modern Fortran Explained" do Metcalf, Reid e Cohen é o padrão do setor. Não é leve, mas cobre todos os detalhes que a documentação oficial deixa implícitos.
Se quiser testar, o GCC com gfortran é gratuito e roda em Linux, macOS e Windows (via MinGW). A compilação básica é simples, mas o investimento em Makefiles e testes de regressão é o que separa código que funciona do código que continua funcionando depois que o pessoal sai do projeto.
