Fortran в 2026 году: зачем смотреть на язык из 1957 года

Fortran в 2026 году: зачем смотреть на язык из 1957 года

Когда я впервые услышал про Fortran, первая мысль была простой: это же язык из 1957 года, зачем его вообще трогать? Есть Python, JavaScript, Go, Rust — зачем смотреть в такую древность?

Но потом стало интересно: почему Fortran вообще выжил? Почему на нём до сих пор считают физики, климатологи и инженеры? Что в нём такого, что он не исчез окончательно?

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

Это не просто обзор — это небольшой вводный туториал по Fortran 90/95. Мы разберём базовые вещи: переменные, типы, простые вычисления и одну очень важную особенность языка, которая сразу меняет отношение к коду.

Если вы школьник, студент или просто хотите лучше понять, что происходит под капотом программы — читайте дальше.

---

Почему Fortran вообще до сих пор жив

Fortran не нужен большинству разработчиков. Если ваша цель — веб, автоматизация или продуктовая разработка, логичнее взять Python или что-то из современного набора.

Но у Fortran другая ниша. Десятилетиями он использовался в научных и инженерных вычислениях: моделирование физических процессов, климат, численные методы, большие расчётные пакеты. В таких областях важны не модные фичи языка, а предсказуемость, производительность и огромный пласт уже существующего кода. Поэтому он не исчез — просто остался там, где компьютер нужен для тяжёлых вычислений, а не для интерфейсов.

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

---

Переменные и типы данных

Любая программа начинается с данных. Где-то нужно хранить возраст, имя, длину окружности, результат вычисления.

В Fortran переменная — это именованная область памяти, и перед использованием её нужно объявить. Язык хочет заранее знать, что именно будет лежать в этой ячейке.

Четыре базовых типа, которые нужны в самом начале:

• INTEGER — целые числа: 10, -3, 0

• REAL — числа с дробной частью: 3.14, -0.5, 1.0

• CHARACTER — текстовые данные

• LOGICAL — логические значения: .TRUE. и .FALSE.

PROGRAM variables_example
    IMPLICIT NONE

    INTEGER :: user_age
    REAL :: pi_approx
    CHARACTER(LEN=20) :: user_name

    user_age  = 30
    pi_approx = 3.14159
    user_name = "John Doe"

    WRITE(*,*) "Имя:", TRIM(user_name)
    WRITE(*,*) "Возраст:", user_age
    WRITE(*,*) "Пи:", pi_approx

END PROGRAM variables_example

Вывод программы:

Имя:John Doe
Возраст:          30
Пи:   3.14159012

Здесь хорошо видно главное: каждая переменная объявлена заранее, и у каждой есть свой тип. Также обратите внимание: вместо PRINT * используется WRITE(*,*) — это стандартный способ вывода в современном Fortran.

Небольшая особенность строк. Если вы пишете CHARACTER(LEN=20), переменная получает фиксированную длину — 20 символов. Если записали туда "John", оставшиеся позиции заполнятся пробелами. Чтобы убрать хвостовые пробелы при выводе, используют функцию TRIM() — она и стоит в примере выше.

В Fortran строка — это не «гибкий объект», а конкретный участок памяти с заданной длиной. Это непривычно после Python, но зато честно.

---

IMPLICIT NONE — одна строка, которая экономит часы

Есть одно правило, которое стоит усвоить сразу: каждая программа должна начинаться с IMPLICIT NONE.

В старых версиях Fortran действовало неявное правило: если переменная не объявлена явно, компилятор сам назначает ей тип по первой букве имени. Имена на I, J, K, L, M, N считались INTEGER, остальные — REAL. Когда-то это считалось удобством. На практике — источник очень неприятных ошибок.

Разработчик хотел использовать velocity, но случайно написал velacity:

PROGRAM bad_practice
! Нет IMPLICIT NONE — это опасно

    REAL :: distance, velocity, time

    velocity = 100.0
    time = 9.5

    distance = velacity * time  ! Опечатка: velocity → velacity

    WRITE(*,*) "Расстояние:", distance, "метров"

END PROGRAM bad_practice

Без IMPLICIT NONE компилятор не ругается. Он считает, что velacity — новая переменная типа REAL, тихо присваивает ей 0.0 и продолжает сборку. Программа запускается и выводит:

Расстояние:   0.00000000     метров

Никаких ошибок. Это логическая ошибка — самая неприятная: код работает, но считает не то. Искать такое без подсказки можно очень долго.

Теперь та же программа с одной добавленной строкой:

PROGRAM good_practice
    IMPLICIT NONE

    REAL :: distance, velocity, time

    velocity = 100.0
    time = 9.5

    distance = velacity * time  ! Та же опечатка

    WRITE(*,*) "Расстояние:", distance, "метров"

END PROGRAM good_practice

Компилятор немедленно останавливает сборку:

Error: Symbol 'velacity' at (1) has no IMPLICIT type; did you mean 'velocity'?

Одна строка превращает тихую логическую ошибку в явную ошибку компиляции. Компьютер не «понимает, что вы имели в виду». Он работает только с тем, что вы реально написали.

---

Арифметика и встроенные функции

Когда переменные объявлены и типы понятны, можно переходить к вычислениям.

Оператор	Действие	Пример	Результат
+	Сложение	5 + 3	8
-	Вычитание	5 - 3	2
*	Умножение	5 * 3	15
/	Деление	5.0 / 2.0	2.5
**	Возведение в степень	5 ** 2	25

На этом месте почти все новички сталкиваются с одной деталью: целочисленное деление.

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

PROGRAM division_example
    IMPLICIT NONE

    REAL :: result

    result = 5 / 2        ! Оба числа целые — результат тоже целый
    WRITE(*,*) "5 / 2 =", result

    result = 5.0 / 2      ! Одно вещественное — результат вещественный
    WRITE(*,*) "5.0 / 2 =", result

    result = 5 / 2.0
    WRITE(*,*) "5 / 2.0 =", result

    result = 5.0 / 2.0
    WRITE(*,*) "5.0 / 2.0 =", result

END PROGRAM division_example

Вывод:

5 / 2 =   2.00000000
5.0 / 2 =   2.50000000
5 / 2.0 =   2.50000000
5.0 / 2.0 =   2.50000000

Чтобы получить дробный результат, хотя бы одно число должно быть вещественным. Это простое правило, но оно хорошо показывает разницу между математикой на бумаге и вычислениями в программе: компьютеру важен не только результат, но и тип данных с которым он работает.

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

• SQRT(x) — квадратный корень

• ABS(x) — модуль числа

• SIN(x), COS(x) — тригонометрия (угол в радианах)

• EXP(x) — экспонента

• LOG(x) — натуральный логарифм

Небольшая рабочая программа — считаем площадь круга и длину окружности:

PROGRAM circle_calculator
    IMPLICIT NONE

    REAL :: radius, area, circumference
    REAL, PARAMETER :: pi = 3.14159265

    radius = 10.0

    area = pi * radius**2
    circumference = 2.0 * pi * radius

    WRITE(*,*) "Радиус:", radius
    WRITE(*,*) "Площадь:", area
    WRITE(*,*) "Длина окружности:", circumference

END PROGRAM circle_calculator

Вывод:

Радиус:   10.0000000
Площадь:   314.159271
Длина окружности:   62.8318558

Обратите внимание на REAL, PARAMETER :: pi. Атрибут PARAMETER превращает переменную в константу — её значение задаётся один раз и изменить его потом нельзя. Если значение не должно меняться, лучше сразу сказать об этом компилятору.

---

Что дальше

Мы разобрали три базовые вещи: переменные и типы, защиту через IMPLICIT NONE и арифметику. Этого уже достаточно для первых осмысленных программ — калькуляторов, физических формул, учебных расчётов.

Следующий шаг — ввод данных от пользователя, условия и циклы. После этого Fortran перестаёт быть просто «языком для формул» и становится полноценным инструментом для небольших расчётных программ.

Если тема зашла и хочется двигаться дальше системно — все эти темы с заданиями и практикой разобраны в моём курсе на Stepik. Ссылка в профиле.