Я взглянул на апрельский рейтинг TIOBE за 2026 год и протёр глаза. Python, C, C++, Java, C# — скучно. Но вот на 10-й строчке восседает Delphi. А Fortran, язык, на котором писали ещё при царе Горохе и который, по мнению всей «модной» тусовки, давно должен лежать на свалке истории, стабильно держится в топ-15. В марте 2025 года он вообще ворвался в двадцатку вместе с такими «мамонтами», как Ada и COBOL.

Что за чертовщина? Rust, который кричали на каждом углу как «убийцу С++», пыжится на 16-м месте, а его рост, по словам генерального директора TIOBE Пола Янсена, замедляется. В это же время Fortran, тихо и без лишнего шума, продолжает быть фундаментом, на котором держится вся мировая наука. Почему компании не переписывают миллионы строк легаси на Python или Go? Потому что цена ошибки в коде, который считает ядерный реактор или прогноз погоды на завтра, исчисляется не в часах разработчика, а в миллиардах долларов и человеческих жизнях.

Давайте разбираться, что такое современный Fortran и почему ваш скепсис по поводу «динозавра» не имеет под собой никаких оснований.

Глава 1. Исторический экскурс: Fortran — это не только прошлое, но и настоящее

Многие до сих пор представляют Fortran как нечто среднее между перфокартами и каменным веком с синтаксисом FORTRAN 77, где всё пишется капсом и с отступами в 6 пробелов. Друзья, это как судить о современных авто по телеге.

Да, FORTRAN 77 был суров. Но эволюция не стояла на месте: Fortran 90 ввёл модули, динамическую память и работу с массивами как с объектами. Fortran 2003/2008 добавили полноценную объектно-ориентированную парадигму и ко-массивы (coarrays) для параллельных вычислений.

А в конце 2023 года тихо и буднично вышел стандарт Fortran 2023 (ISO/IEC 1539-1:2023). Вы думаете, там просто подкрутили старые гайки? Как бы не так. Вот лишь пара «вкусных» фич, от которых у любого современного разработчика загорятся глаза:

• Условные выражения: Теперь можно писать не громоздкие IF-блоки, а элегантный тернарный оператор прямо как в Си: value = ( a > 0.0 ? a : 0.0 ).

• Автоматическое размещение строк: Больше никакого ручного выделения буферов под строки переменной длины — язык делает это сам.

• Тригонометрия в градусах: Функции acosd, sind и другие — мелочь, а сколько боли она снимает у инженеров и учёных, которым надоело постоянно умножать на pi/180.

• Максимальная длина строки программы: Увеличена до 10 000 символов, а длина одного оператора — до миллиона символов. Как утверждается, одной из целей является облегчение написания программ искусственным интеллектом.Fortran не просто жив — он активно развивается и впитывает в себя современные фишки.

Глава 2. «Кровавый энтерпрайз»: Почему Fortran не умирает

Представьте, что вы — директор аэрокосмического агентства. У вас есть 5 миллионов строк Fortran-кода, который 40 лет считает аэродинамику крыла. Он проверен в десятках тысяч лётных часов, и в нём нет ни одной математической ошибки. Вам предлагают переписать это на Rust. За 3 года, командой из 50 человек, с бюджетом в 100 миллионов долларов. Вы согласитесь?

Аналитики TIOBE подтверждают: Fortran живёт не потому, что его любят, а потому, что на нём держится критическая инфраструктура: авионика, ядерные реакторы, метеорологические суперкомпьютеры, астрофизические симуляции. Переписать — значит с вероятностью 99% внести сотни новых багов, каждый из которых может стоить как крыло самолёта.

Более того, этот «древний» код часто работает быстрее, чем его «современные» порты. Давайте посмотрим на классику жанра — вычисление числа π методом Монте-Карло. Это идеальный пример для демонстрации эволюции языка: первый — старый FORTRAN 77, второй — современный Fortran 2018+.

! Старый добрый FORTRAN 77 (Fixed format)
! Обратите внимание: метки, отступы в 6 символов, всё капсом
      PROGRAM PI_MONTE_CARLO_77
      INTEGER I, N, COUNT
      REAL X, Y, PI
      
      N = 100000000
      COUNT = 0
      
      DO 10 I = 1, N
         CALL RANDOM_NUMBER(X)  ! В 77 стандарте не было встроенного random_number,
         CALL RANDOM_NUMBER(Y)  ! но многие компиляторы добавляли свои функции
         IF (X*X + Y*Y .LE. 1.0) COUNT = COUNT + 1
   10 CONTINUE
      
      PI = 4.0 * REAL(COUNT) / REAL(N)
      WRITE(*,*) 'Вычисленное значение Pi = ', PI
      END

! Современный Fortran 2018 (Free format)
! Чисто, модульно, с векторизацией
program pi_monte_carlo_modern
    use, intrinsic :: iso_fortran_env, only: real64
    implicit none
    integer, parameter :: n = 100_000_000
    integer :: i, count
    real(real64) :: x(n), y(n), pi
    
    ! 1. Генерируем массивы сразу целиком (векторная операция)
    call random_number(x)
    call random_number(y)
    
    ! 2. Считаем точки внутри круга одной строчкой без цикла
    !    (операции над массивами как над объектами)
    count = count(x**2 + y**2 <= 1.0_real64)
    
    pi = 4.0_real64 * real(count, real64) / real(n, real64)
    
    print '(A, F12.10)', 'Вычисленное значение Pi = ', pi
end program pi_monte_carlo_modern

Разница, как между «Жигулями» и «Теслой», хотя оба едут. Легаси-код (первый) до сих пор работает на каком-нибудь суперкомпьютере NOAA, и его никто не трогает — работает? Не лезь! А современная версия (второй) уже читается как код на Python с элементами Julia, но при этом компилируется в нативный машинный код и использует векторные инструкции процессора (count(array)).

Глава 3. Производительность: Танцы с компилятором и кэшем

Я постоянно слышу: «Но ведь С++ такой же быстрый, если не быстрее!». Давайте посмотрим правде в глаза. В синтетических тестах на целочисленной арифметике или парсинге строк — возможно. Но когда дело доходит до «чистой» математики с многомерными массивами, Fortran уходит в отрыв.

Почему? Два ключевых слова: алиасинг и память.

1. Column-major. В отличие от C/C++ (где массивы хранятся по строкам, row-major), в Фортране массивы в памяти идут по столбцам. Это идеально ложится на математику линейной алгебры (BLAS/LAPACK), где операции над векторами-столбцами — хлеб насущный. Компилятор может смело векторизовать циклы, не боясь за кэш-промахи.

2. Правило restrict. В С/C++, чтобы компилятор мог агрессивно оптимизировать цикл с указателями, вы должны гарантировать ему через ключевое слово restrict, что области памяти не пересекаются. В Фортране это правило встроено в язык по умолчанию для аргументов-массивов. Компилятор всегда знает, что при умножении матрицы C = A * B данные не наложатся друг на друга и не испортят результат.

Давайте сравним код умножения матриц. Я написал наивный алгоритм (три вложенных цикла) на Фортране и на Си, чтобы показать, в чём подвох.

subroutine matmul_fortran(A, B, C, n)
    implicit none
    integer, intent(in) :: n
    real(8), intent(in) :: A(n,n), B(n,n)
    real(8), intent(out) :: C(n,n)
    integer :: i, j, k

    C = 0.0d0
    do j = 1, n
        do k = 1, n
            do i = 1, n
                ! Здесь компилятор видит: A(:,k) и B(k,j) — это четкие массивы.
                ! Нет пересечения с C, так как C объявлен как intent(out).
                ! Смело векторизуем внутренний цикл по 'i'.
                C(i,j) = C(i,j) + A(i,k) * B(k,j)
            end do
        end do
    end do
end subroutine matmul_fortran

// ВНИМАНИЕ: Это наивный и потенциально опасный код!
void matmul_c(int n, double A[n][n], double B[n][n], double C[n][n]) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            double sum = 0.0;
            for (int k = 0; k < n; ++k) {
                // Алиасинг! Компилятор не знает, не указывает ли A на ту же память,
                // что и C. Вдруг это C = C * A? Тогда менять порядок циклов
                // или векторизовать может быть НЕЛЬЗЯ!
                sum += A[i][k] * B[k][j];
            }
            C[i][j] = sum;
        }
    }
}

В Си-версии компилятор вынужден «перестраховываться» и генерировать менее оптимальный код, если вы явно не использовали restrict или прагмы. В Фортране же проблема алиасинга отсутствует по определению для аргументов с разными атрибутами intent.

Инструментарий не дремлет:Раньше бытовало мнение, что компилятор GNU Fortran (gfortran) проигрывает проприетарным гигантам вроде Intel Fortran. Сейчас в игру ворвался LLVM Flang. В марте 2025 года с выходом LLVM 20 драйвер Flang был официально переименован из flang-new в просто flang, что говорит о полной уверенности разработчиков в его продакшен-готовности. Исследования показывают, что производительность Flang уже сопоставима с лидерами рынка HPC.

Глава 4. Fortran и GPU: не только для CPU

Я часто слышу: «Fortran — это чисто про CPU, а для GPU нужен Python/CUDA/C++». Это опасное заблуждение, за которое в HPC-среде бьют канделябром.

Современный Fortran — это первоклассный гражданин в мире ускорителей. У нас есть три мощных инструмента, которые позволяют не переписывать тонны легаси, а просто «включить ускорение»:

1. CUDA Fortran: Прямой доступ к ядрам NVIDIA. Вы пишете атрибуты attributes(global), запускаете ядра через <<<...>>> и работаете с памятью устройства. Полный контроль, как в C++.

2. OpenACC: Директивный подход. Вы добавляете в свой старый код строчки типа !$acc parallel loop, и компилятор (например, nvfortran из NVIDIA HPC SDK) сам разбирается, как затащить вычисления на видеокарту.

3. DO CONCURRENT: Стандартный цикл Фортрана, который говорит компилятору: «Здесь нет зависимостей по данным, делай что хочешь, хоть на 1000 ядер GPU размажь». NVIDIA HPC SDK умеет автоматически разгружать такие циклы на GPU с флагом -stdpar=gpu.

Давайте посмотрим, как это выглядит в коде. Вот пример использования директив OpenACC для расчета какого-нибудь тяжелого потенциала (например, гравитационного):

program gpu_acceleration
    implicit none
    integer, parameter :: n = 1000000
    real(8) :: pos(3, n), forces(3, n)
    integer :: i, j
    real(8) :: dx, dy, dz, dist_sq, inv_dist
    
    ! Инициализация данных на хосте (CPU)
    call random_number(pos)
    forces = 0.0d0
    
    ! --- Самое интересное: директивы OpenACC ---
    ! Копируем данные на GPU перед расчетами
    !$acc data copyin(pos) copy(forces)
    
    !$acc parallel loop
    do i = 1, n
        ! Локальные переменные, которые будут приватными для каждого потока GPU
        real(8) :: fx, fy, fz
        fx = 0.0d0; fy = 0.0d0; fz = 0.0d0
        
        !$acc loop reduction(+:fx, fy, fz)
        do j = 1, n
            if (i == j) cycle
            
            dx = pos(1, i) - pos(1, j)
            dy = pos(2, i) - pos(2, j)
            dz = pos(3, i) - pos(3, j)
            
            dist_sq = dx*dx + dy*dy + dz*dz + 1.0d-12
            inv_dist = 1.0d0 / sqrt(dist_sq)  ! Тяжелая математика
            
            fx = fx + dx * inv_dist**3
            fy = fy + dy * inv_dist**3
            fz = fz + dz * inv_dist**3
        end do
        
        forces(1, i) = fx
        forces(2, i) = fy
        forces(3, i) = fz
    end do
    
    !$acc end data
    
end program gpu_acceleration

Здесь мы просто сказали компилятору nvfortran -acc=gpu -O3, какие данные скопировать на ускоритель и какие циклы распараллелить. Всё! Никаких аллокаций через cudaMalloc и ручных копирований, хотя, если захочется полного контроля, CUDA Fortran даст вам эти инструменты.

Глава 5. Fortran и AI: Странная, но мощная синергия

Казалось бы, AI и Fortran — две параллельные вселенные. AI живёт в Python с PyTorch/TensorFlow, а Fortran — в мире уравнений Навье-Стокса. Но, как любил говорить один мой научрук, «в точке сингулярности сходятся даже противоположности».

Проблема классического подхода: у вас есть CFD-расчет на Фортране, который считает поле течения. Вы хотите заменить дорогой блок модели турбулентности на нейросеть. Что обычно делают? Выгружают данные, передают в Python-скрипт, тот вызывает PyTorch, результат возвращается обратно в Fortran. Это называется «костыль через файловую систему», и он сжирает всю производительность насмарку.

Решение пришло из двух ведущих лабораторий:

1. Fiats (Berkeley Lab): Это нативная библиотека глубокого обучения на чистом современном Фортране. Без Python, без Torch, без внешних зависимостей. Её фишка в использовании нативных параллельных конструкций языка, таких как do concurrent, для обучения нейросетей прямо внутри фортрановского кода. Представьте: климатическая модель E3SM (Energy Exascale Earth System), вся написанная на Фортране, получает блок нейросетевого ускорения, который исполняется на GPU без единого байта Python. Fiats уже используется для суррогатного моделирования микрофизики облаков в ICAR и аэрозольной динамики в E3SM. Результат — ускорение расчётов на порядки без переписывания кодовой базы.

2. FTorch (Cambridge/ICCS): А если у вас уже есть обученная на Python модель PyTorch и вам лень её переписывать? FTorch — это мост между мирами. Вы сохраняете модель в TorchScript, а затем вызываете её напрямую из своего фортрановского кода, передавая тензоры туда и обратно. Это официальная библиотека с поддержкой CPU и GPU, написанная на Fortran 2008 и протестированная в боевых научных проектах.

Давайте глянем, как просто выглядит вызов PyTorch модели из Fortran с помощью FTorch:

program ai_in_fortran
    use ftorch
    implicit none
    
    type(torch_module) :: model
    type(torch_tensor), dimension(1) :: input_tensor, output_tensor
    
    real, dimension(:,:), allocatable :: input_data, output_data
    
    integer :: i, j
    integer, parameter :: input_dim = 10
    integer, parameter :: output_dim = 1
    
    ! 1. Готовим входные данные для нейросети (как обычно в Фортране)
    allocate(input_data(input_dim, 1))
    allocate(output_data(output_dim, 1))
    
    ! Заполняем входной массив (например, параметры турбулентности из CFD)
    call random_number(input_data)
    
    ! 2. Грузим модель, обученную в Python (сохраненную как TorchScript)
    call torch_module_load(model, 'turbulence_model.pt', torch_kCPU)
    
    ! 3. Оборачиваем фортрановские массивы в тензоры, понятные Torch
    call torch_tensor_from_array(input_tensor(1), input_data, torch_kCPU)
    call torch_tensor_from_array(output_tensor(1), output_data, torch_kCPU)
    
    ! 4. Делаем инференс! Модель считает, результат падает прямо в output_data
    call torch_module_forward(model, input_tensor, output_tensor)
    
    ! 5. Работаем с результатом в Фортране дальше
    print *, 'Результат работы нейросети:', output_data(:,1)
    
    ! 6. Чистим за собой
    call torch_tensor_delete(input_tensor(1))
    call torch_tensor_delete(output_tensor(1))
    call torch_module_delete(model)
    
end program ai_in_fortran

Это не магия. Это просто грамотная инженерная работа, которая избавляет нас от адского файлового обмена и позволяет делать гибридные модели «физика + ML» нативно.

Глава 6. Fortran vs Julia vs Rust: Битва за HPC-трон

Научное сообщество сейчас напоминает мне «Игру престолов». За Железный Трон HPC сражаются три основных претендента. Давайте расставим точки над «i» без лишних эмоций.

Мой субъективный вердикт:

• Если вы строите новый проект с нуля, где критически важна безопасность памяти, и у вас есть опытные системные программисты — берите Rust.

• Если вы учёный-одиночка, который хочет быстро прототипировать алгоритм и сразу видеть красивые графики, не вылезая из REPL — берите Julia.

• Но если у вас лежит 500 тысяч строк проверенного кода CFD-решателя, вы работаете в большой коллаборации вроде CERN или NOAA, и ваша главная задача — считать быстрее на миллиардах ячеек сетки — у вас нет выбора, кроме Fortran. Точнее, он у вас есть, но он глупый. Fortran тут не просто инструмент, это инфраструктура.

Заключение. Кому и зачем учить Fortran в 2026 году

Я не агитатор и не буду кричать: «Срочно бросай свой React и беги учить Fortran!». Это глупо. Fortran — это не язык общего назначения. Это скальпель хирурга, а не швейцарский нож.

Учить Fortran в 2026 году стоит, если:

• Вы идёте работать в CFD, вычислительную гидродинамику или аэродинамику (Ansys, OpenFOAM — это всё врапперы над Fortran/C ядрами).

• Вы планируете карьеру в ядерной физике, астрофизике или космологии (все крупные симуляции, от N-body до переноса излучения, написаны на нём).

• Вы — климатолог, метеоролог, океанолог или геолог (суперкомпьютерные модели Земли — это царство Fortran).

• Вы занимаетесь квантовой химией или молекулярной динамикой.

• Вы просто устали от того, что ваш Python-код с NumPy упирается в GIL и пересылку данных, и хотите понять, как работает настоящая производительность.

Проходите мимо, если:

• Вы веб-разработчик, мобильный разработчик, геймдев или дата-сайентист, работающий исключительно в pandas/sklearn. Fortran вам не нужен. Ваш инструментарий — Python, JS, Swift, Kotlin, C#.

Fortran не умер. Он просто перестал быть языком для всех. Он превратился в узкоспециализированный, отточенный десятилетиями инструмент для тех, кто двигает вперёд фундаментальную науку. И пока человечество будет запускать ракеты в космос и пытаться предсказать погоду на послезавтра, старый добрый Fortran будет работать.

И работать он будет быстро. Очень быстро.