Что такое компилируемые ЯП?

Компилируемые языки программирования: зачем они нужны

Компилируемые языки — это языки, в которых исходный код переводится в машинный код или промежуточное представление до запуска программы. Это отличает их от интерпретируемых языков, где код выполняется построчно.

1. Процесс компиляции

Компилируемый язык (C, C++, Rust, Go):

Исходный код (.c/.cpp/.rs/.go)
         ↓
   [Компилятор]
         ↓
Машинный код / Bytecode (.exe/.bin)
         ↓
   [Загрузчик ОС]
         ↓
   Выполнение

Интерпретируемый язык (Python, JavaScript):

Исходный код (.py/.js)
         ↓
   [Интерпретатор]
         ↓
   Построчное выполнение

2. Процесс компиляции (детально)

// Пример на C
#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3);
    printf("Result: %d\n", result);
    return 0;
}

Шаги компиляции:

# 1. Препроцессор (раскрывает макросы, подключает файлы)
gcc -E program.c > program.i

# 2. Компилятор (переводит в ассемблер)
gcc -S program.c
# Результат: program.s (ассемблер)

# 3. Ассемблер (переводит в объектный код)
as program.s -o program.o

# 4. Линкер (связывает объектные файлы с библиотеками)
ld program.o -o program

# Или всё в одном:
gcc program.c -o program
./program  # Выполнить скомпилированный файл

3. Преимущества компилируемых языков

Скорость выполнения

Компилированный код работает 10-100 раз быстрее интерпретируемого:

# Python (интерпретируемый) — медленный
import time

start = time.time()
result = 0
for i in range(1_000_000_000):  # 1 миллиард итераций
    result += i
print(f"Python: {time.time() - start:.2f}s")  # ~45 секунд

// C++ (компилируемый) — быстрый
#include <iostream>
#include <chrono>
using namespace std;

int main() {
    auto start = chrono::high_resolution_clock::now();
    
    long long result = 0;
    for (long long i = 0; i < 1_000_000_000; i++) {
        result += i;
    }
    
    auto end = chrono::high_resolution_clock::now();
    auto duration = chrono::duration_cast<chrono::milliseconds>(end - start);
    cout << "C++: " << duration.count() << "ms" << endl;  // ~1 сек
    
    return 0;
}

Результат:

• Python: 45 секунд
• C++: 1 секунда (45x быстрее!)

Причина: компилятор оптимизирует код на уровне машинных инструкций.

Проверка типов во время компиляции

int x = 5;
x = "hello";  // ОШИБКА КОМПИЛЯЦИИ! Тип не совпадает
// error: incompatible types when assigning to type 'int' from type 'char *'

В Python это выявляется только во время выполнения:

x = 5
x = "hello"  # OK, но может привести к ошибке потом
result = x + 10  # TypeError: can only concatenate str ("str") to str, not "int"

Управление памятью

Оптимальное использование памяти, возможность ручного управления:

// C — полный контроль над памятью
int *arr = malloc(1000000 * sizeof(int));  // Выделить память
for (int i = 0; i < 1000000; i++) {
    arr[i] = i;  // Быстрый доступ
}
free(arr);  // Освободить память

В Python автоматический garbage collection медленнее:

# Python — автоматическое управление (медленнее)
arr = list(range(1000000))  # Выделяет память автоматически
# Сборка мусора срабатывает периодически, тратит ресурсы

4. Недостатки компилируемых языков

Долгие цикл разработки

# Много шагов: изменение → компиляция → запуск
vi program.c
gcc program.c -o program
./program
# Изменение → ещё раз компилировать

Сложность для новичков

// C требует ручного управления памятью
char *str = malloc(50);
strcpy(str, "hello");
free(str);  // Забыть — утечка памяти

Платформозависимость

# Скомпилировано на Linux
gcc -o program program.c

# Не запустится на Windows без переком
ming-w64-x86_64-gcc -o program.exe program.c  # Другой компилятор

5. Популярные компилируемые языки

6. Компилируемые языки в Data Science

Data Scientist'ы редко пишут на компилируемых, но они критичны для performance:

# Python медленный для ML
import time

start = time.time()
for i in range(1_000_000_000):
    x = i * i
print(f"Pure Python: {time.time() - start:.2f}s")  # ~20 сек

Решение: компилированные расширения:

# NumPy использует C/BLAS под капотом (компилируемые языки)
import numpy as np
import time

start = time.time()
arr = np.arange(1_000_000_000)
result = arr * arr  # Выполняется на C
print(f"NumPy: {time.time() - start:.2f}s")  # ~1 сек (20x быстрее!)

7. Гибридный подход

# Python + компилированные расширения (best of both worlds)
import numba  # JIT компилятор для Python
import numpy as np

@numba.jit(nopython=True)  # Компилировать в машинный код
def sum_squares(arr):
    result = 0
    for i in range(len(arr)):
        result += arr[i] ** 2
    return result

arr = np.arange(1_000_000_000)
sum_squares(arr)  # Скорость C++, синтаксис Python!

8. JIT компилятор (компромисс)

# PyPy — JIT компилятор для Python
# Компилирует горячие части кода во время выполнения

# Обычный Python (CPython): медленный
result = sum(i*i for i in range(100_000_000))  # ~5 сек

# PyPy (с JIT): быстрый
result = sum(i*i for i in range(100_000_000))  # ~0.5 сек (10x быстрее!)

Выводы

Компилируемые языки:

• Зачем: скорость (10-100x), проверка типов, контроль памяти
• Когда: системное ПО, high-performance, встроенные системы, игры
• Примеры: C, C++, Rust, Go
• Для Data Science: NumPy/TensorFlow используют компилированный код под капотом

Data Scientist'ы работают на Python (удобно), но производительность обеспечивают компилируемые расширения (NumPy, TensorFlow на C/CUDA).