🧠 Топ языков от евангелиста функционального программирования

Один из известных проповедников Haskell выложил свою субъективную классификацию языков программирования — от «святых граалей» до «цифровых окаменелостей».

Вот кратко по категориям:

Евангелист функционального программирования выложил свой рейтинг языков — и, как всегда, без компромиссов:

S: OCaml, C++
A: Haskell, Python, Rust, Kotlin
B: Scala, Go, Ruby, Swift, C#, TypeScript
C: PHP, Clojure, Java, C, Ассемблер
D: JavaScript, Bash
E: Fortran, Objective-C, COBOL, Perl

🍿 Комментарии уже взрываются — кто-то радуется за Kotlin в A, кто-то негодует за Java в C, кто-то вообще считает, что JS заслуживает отдельной категории «F».

А вот философский вопрос на подумать:

👉 Разработчики, которые всё ещё пишут на категории E — это уверенные мастера или уже цифровые археологи?

(Спойлер: COBOL-разработчики зарабатывают больше нас всех вместе взятых.)

#языкипрограммирования #fp #разработка #devюмор #tirlist

@cpluspluc

⚡️ DOSBox Staging — современная эволюция легендарного эмулятора DOS с поддержкой новых технологий и активным развитием. Этот форк сохраняет совместимость с классической версией, но добавляет улучшенную обработку звука, поддержку современных кодеков и удобные функции вроде записи игрового процесса.

Проект использует SDL2, предлагает кроссплатформенные сборки для Windows, Linux и macOS, а также поддерживает динамическую загрузку библиотек вроде FluidSynth. Для разработчиков есть интеграция с Tracy Profiler и система CI.

🤖 GitHub

@cpluspluc

🚀 Хотите мониторить загрузку вашей NVIDIA GPU прямо из C++?

Вот минимальный пример на C++, который использует nvidia-smi через системный вызов для получения текущей загрузки GPU и использованной памяти.

🛠 Требования:
• Установленный драйвер NVIDIA и утилита nvidia-smi
• C++17 или выше

📄 Код:

#include <iostream>
#include <cstdlib>
#include <memory>
#include <array>

void get_gpu_utilization() {
    std::array<char, 128> buffer;
    std::string result;

    std::unique_ptr<FILE, decltype(&pclose)> pipe(
        popen("nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total --format=csv,nounits,noheader", "r"),
        pclose
    );

    if (!pipe) {
        std::cerr << "❌ Ошибка при вызове nvidia-smi" << std::endl;
        return;
    }

    int gpu_id = 0;
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        std::string line(buffer.data());
        size_t pos1 = line.find(',');
        size_t pos2 = line.rfind(',');

        std::string util = line.substr(0, pos1);
        std::string mem_used = line.substr(pos1 + 1, pos2 - pos1 - 1);
        std::string mem_total = line.substr(pos2 + 1);

        std::cout << "🖥 GPU " << gpu_id++ << ": " << util << "% load | "
                  << mem_used << " MiB / " << mem_total << " MiB";
    }
}

int main() {
    get_gpu_utilization();
    return 0;
}

📦 Компиляция:

bash
Копировать
Редактировать
g++ gpu_monitor.cpp -o gpu_monitor -std=c++17
📌 Вывод:

🖥 GPU 0: 17% load | 512 MiB / 8192 MiB

🧠 Подходит для:
• Мониторинга GPU в реальном времени
• Интеграции в бэкенды, боты, системы логгинга
• Лёгкой отладки ML/AI-приложений на C++

Sane C++ Libraries — обновление за июнь 2025

🔧 Библиотека продолжает закрывать боль C++-разработчиков: теперь ещё больше асинхронщины и удобных обёрток без лишнего шаблонного ада.

Новое:
✅ Асинхронные операции с файлами и папками
- copy/remove/rename {file|folder}
- open/close/read/write file

✅ Асинхронный UDP:
- SendTo, ReceiveFrom

✅ Улучшения в файловой системе:
- Iterator, Watcher
- Убраны лишние зависимости от памяти

🔗 https://pagghiu.github.io/site/blog/2025-06-30-SaneCppLibrariesUpdate.html
🔗 https://github.com/Pagghiu/SaneCppLibraries/releases/tag/release%2F2025%2F06

@cpluspluc

📥 Palanteer — инструмент для глубокого анализа производительности C++ и Python-приложений. Этот проект предлагает детальную телеметрию: от временных меток выполнения функций до отслеживания потребления памяти и переключений контекста.

Инструмент обладает минималистичной интеграцией: в C++ достаточно подключить один заголовочный файл, а Python-код анализируется автоматически. Визуализация в реальном времени включает временные графики, flame graphs и логи с наносекундным разрешением.

🤖 GitHub

@cpluspluc

🗄️ MyDumper — параллельный бэкап MySQL без головной боли. Этот инструмент делает логические дампы MySQL в 5-10 раз быстрее стандартного mysqldump за счёт многопоточной работы. Данные сохраняются в отдельных файлах для каждой таблицы, а встроенная поддержка регулярных выражений позволяет гибко выбирать, какие базы или таблицы включать в бэкап.

Разработчики интересно реализовали согласованность данных: инструмент сначала блокирует таблицы глобальным read-lock, затем создаёт транзакционные снимки для каждого потока и только потом отпускает блокировки. Для восстановления есть параллельный загрузчик myloader

🤖 GitHub

@cpluspluc

🎯 C++ Задача для опытных разработчиков: «Хитрый итератор»

У вас есть следующая структура:

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Нужно реализовать итератор, который будет проходить по data следующим образом:
- сначала возьмёт первый элемент,
- затем последний,
- затем второй,
- затем предпоследний,
- и так далее — «сжимая» список с двух концов.

🧠 *Вопрос:* Как бы вы реализовали такой итератор в стиле STL (`begin()` / `end()`), совместимый с range-based for?

🧩 Подсказка:
Нужно симулировать два указателя: left и right, с шагом +1 и -1 соответственно, и внутри итератора отслеживать, с какой стороны взять следующий элемент.

✅ Возможный подход:

Создаём кастомный класс ZigZagIterator, внутри которого:
- operator++() переключает сторону (`left` / `right`),
- operator*() возвращает нужный элемент в текущем шаге,
- operator!=() сравнивает позиции указателей.

🔍 Пример:

class ZigZagIterator {
public:
    ZigZagIterator(const std::vector<int>& vec, bool end = false)
        : data(vec), left(0), right(vec.size() - 1), useLeft(true), done(end) {}

    int operator*() const {
        return useLeft ? data[left] : data[right];
    }

    ZigZagIterator& operator++() {
        if (useLeft) ++left;
        else --right;
        if (left > right) done = true;
        useLeft = !useLeft;
        return *this;
    }

    bool operator!=(const ZigZagIterator& other) const {
        return done != other.done;
    }

private:
    const std::vector<int>& data;
    size_t left, right;
    bool useLeft;
    bool done;
};

class ZigZagRange {
public:
    ZigZagRange(const std::vector<int>& vec) : data(vec) {}
    ZigZagIterator begin() const { return ZigZagIterator(data); }
    ZigZagIterator end() const { return ZigZagIterator(data, true); }

private:
    const std::vector<int>& data;
};

📌 Использование:

for (int val : ZigZagRange(data)) {
    std::cout << val << " ";
}
// Output: 1 10 2 9 3 8 4 7 5 6

📎 *Что здесь интересно:*
- Работа с нестандартной логикой обхода в рамках C++ STL-подобного интерфейса.
- Умение проектировать удобные и безопасные итераторы.
- Поддержка range-based for без копирования данных.

🛠️ *Идея для расширения:* добавить operator--() и реализовать двунаправленный итератор.

🎓 Комьюнити Cursor собрало огромную библиотеку гайдов и инструментов для вайбкодеров. Тут есть всё, чтобы работать с ИИ было проще и эффективнее:

— Готовые промты под разные задачи
— MCP-серверы для общения с внешними приложениями
— И самое крутое: генератор уникальных промт-правил под ваш проект

Налетай — всё это бесплатно и уже доступно.
🔗 https://cursor.directory/

📦 PcapPlusPlus — мощный C++ инструмент для работы с сетевыми пакетами. Этот мультиплатформенный проект предлагает удобные C++ обёртки для популярных движков захвата трафика — от классических libpcap/WinPcap до высокопроизводительных DPDK и PF_RING.

Библиотека поддерживает огромное количество протоколов: от базовых Ethernet и IP до специализированных вроде WireGuard или S7Comm. При работе с пакетами, помимо стандартного парсинга в проекте доступны функции сборки TCP-сессий с учётом ретрансмитов и обработки фрагментации IP. Для разработчиков приложений под Linux ценна интеграция с eBPF AF_XDP — это позволяет достичь линейной скорости обработки.

🤖 GitHub

@cpluspluc

🧠 C++ Задача: "Живые итераторы"

У тебя есть вектор указателей на строки. Некоторые строки могут быть nullptr, а некоторые — валидные. Напиши функцию, которая:

1. Удаляет все nullptr из вектора.
2. Преобразует каждую строку в верхний регистр на месте.
3. Возвращает отсортированный вектор строк по длине (по убыванию).

✳️ Ограничение: нельзя копировать строки. Можно только перемещать (`std::move`).

Пример:

std::vector<std::string*> data = {
    new std::string("apple"),
    nullptr,
    new std::string("banana"),
    new std::string("kiwi"),
    nullptr
};

После обработки ты должен получить std::vector<std::string> вида:

["BANANA", "APPLE", "KIWI"]

💡 Разбор
1) Удаляем nullptr с помощью std::erase_if или std::remove_if + erase.

2) Используем std::transform и std::toupper — с учётом, что строки по указателю.

3) Перемещаем строки в новый std::vector<std::string>, не копируя.

4) Сортируем с кастомным компаратором [](const std::string& a, const std::string& b) { return a.size() > b.size(); }.

Важно:

- Не забыть удалить указатели или использовать unique_ptr с std::move_if_noexcept.

- Верхний регистр через std::transform(s.begin(), s.end(), s.begin(), ::toupper).

📌 Попробуй сам — задача ловит на управлении памятью и семантике перемещения.

@cpluspluc

🔥 Совет дня: быстро посчитать частоты элементов в C++ с `std::unordered_map`

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

#include <iostream>
#include <vector>
#include <unordered_map>

int main() {
    std::vector<std::string> items = {"apple", "banana", "apple", "orange", "banana", "apple"};
    std::unordered_map<std::string, int> freq;

    for (const auto& item : items) {
        ++freq[item];
    }

    for (const auto& [key, count] : freq) {
        std::cout << key << ": " << count << "\n";
    }
    // 👉 apple: 3, banana: 2, orange: 1
}

📌 Удобно для:
— анализа строк
— парсинга логов
— простых хэш-агрегаций


@cpluspluc

🧠 C++ Задача для продвинутых: безопасный счётчик с автоматическим сбросом

Условие:
Реализуйте потокобезопасный счётчик, который:
1. Увеличивается при вызове increment()
2. Возвращает текущее значение при get()
3. Автоматически сбрасывается в 0 через N миллисекунд после последнего increment()
4. Не сбрасывается, если за это время пришёл новый increment()

🔧 Условия:
- Нельзя использовать сторонние библиотеки (только стандарт C++17+)
- Нельзя вручную управлять потоками (используйте std::thread, std::mutex, `std::condition_variable`)
- Нужно обеспечить корректный RAII (автоматическое завершение потоков при разрушении объекта)

🔍 Пример:

SafeCounter counter(1000); // сброс через 1000 мс
counter.increment();       // value = 1
std::this_thread::sleep_for(500ms);
counter.increment();       // value = 2, таймер сброса перезапускается
std::this_thread::sleep_for(1500ms);
std::cout << counter.get(); // value = 0

💡 Подсказка:
Нужно реализовать "отложенный сброс", который перезапускается при каждом increment(). Используйте фоновый поток и condition_variable.

✅ Ожидаемое решение (упрощённый скелет):

#include <iostream>
#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <chrono>

class SafeCounter {
public:
    SafeCounter(int timeout_ms) : timeout(timeout_ms), value(0), stop(false) {
        worker = std::thread([this] { this->watch(); });
    }

    ~SafeCounter() {
        {
            std::lock_guard<std::mutex> lock(mtx);
            stop = true;
        }
        cv.notify_all();
        worker.join();
    }

    void increment() {
        {
            std::lock_guard<std::mutex> lock(mtx);
            ++value;
            last_action = std::chrono::steady_clock::now();
        }
        cv.notify_all();
    }

    int get() const {
        return value.load();
    }

private:
    void watch() {
        std::unique_lock<std::mutex> lock(mtx);
        while (!stop) {
            cv.wait_for(lock, timeout, [this] {
                return stop || std::chrono::steady_clock::now() - last_action >= timeout;
            });

            if (stop) break;

            if (std::chrono::steady_clock::now() - last_action >= timeout) {
                value = 0;
            }
        }
    }

    std::chrono::milliseconds timeout;
    std::chrono::steady_clock::time_point last_action = std::chrono::steady_clock::now();
    std::atomic<int> value;
    std::mutex mtx;
    std::condition_variable cv;
    std::thread worker;
    bool stop;
};

🎯 Отличная задача, чтобы потренировать:

понимание RAII

работу с condition_variable

атомарные переменные

и правильную остановку фоновых потоков

Можешь доработать под конкретные кейсы — например, логирование событий сброса или работу с несколькими счётчиками.

Когда впервые сталкиваешься с type_traits в C++, они кажутся чем-то из мира метапрограммирования для продвинутых Сеньоров.

Но чем глубже разбираешься в плюсах, тем чаще ловишь себя на мысли: «А как вообще этот кусок кода собирается?», «Почему одна перегрузка сработала, а другая нет?», «Как можно элегантно отфильтровать типы на этапе компиляции?»

И тут внезапно узнаешь, что именно type_traits — это та самая опора, с которой можно решать такие задачи красиво и без хаков. Особенно если писать универсальный код, библиотеки, или хочешь просто понимать, как работает стандартная библиотека.

Сегодня прочитал пост Вани Ходора, бэкенд-разработчика из Яндекс Лавки, который как раз сделал гайд по type_traits — не про то, *что* они делают, а за что их можно полюбить. Не учебник, не документация, а маленькое путешествие по любимым трейтам с примерами, идеями и попытками реализации.

Будет полезно, даже если вы давно знакомы с шаблонами — с другой стороны посмотрите на знакомые конструкции, а может, и вдохновитесь на свой маленький эксперимент в шаблонном коде.

🧠 Продвинутая задача на C++ — Оптимальный доступ к матрице с кешированием

Задача:
У вас есть матрица N x M, хранящаяся в виде одномерного массива (row-major).
Нужно реализовать класс Matrix, поддерживающий:
- Быстрый доступ get(i, j) и set(i, j, value)
- Локальность данных при сканировании по строкам и по столбцам
- При этом: сравнить производительность строкового и столбцового прохода

int main() {
    Matrix mat(10000, 10000);
    // Заполнить матрицу числами
    for (int i = 0; i < 10000; ++i)
        for (int j = 0; j < 10000; ++j)
            mat.set(i, j, i + j);

    // Сумма по строкам
    long long row_sum = 0;
    for (int i = 0; i < 10000; ++i)
        for (int j = 0; j < 10000; ++j)
            row_sum += mat.get(i, j);

    // Сумма по столбцам
    long long col_sum = 0;
    for (int j = 0; j < 10000; ++j)
        for (int i = 0; i < 10000; ++i)
            col_sum += mat.get(i, j);
}

Вопрос:
Почему сканирование по строкам быстрее, чем по столбцам, даже если данные одинаковые?

---

Разбор:

class Matrix {
private:
    int rows, cols;
    std::vector<int> data;

public:
    Matrix(int r, int c) : rows(r), cols(c), data(r * c) {}

    int get(int i, int j) const {
        return data[i * cols + j];
    }

    void set(int i, int j, int value) {
        data[i * cols + j] = value;
    }
};

Ответ:
Память в C++ выделяется линейно.
В std::vector<int> data, элементы строки хранятся подряд в памяти.
То есть mat[0][0], mat[0][1], ..., mat[0][9999] идут подряд.

Когда мы сканируем по строкам, процессор использует кеш строк памяти эффективно.
Когда же мы сканируем по столбцам, мы прыгаем по памяти через cols шагов → кеш не успевает подгружать нужные блоки → больше cache misses → медленнее.

---

🧠 Вывод:
- Даже при правильном коде, порядок доступа к памяти критически важен
- Понимание устройства кеша CPU помогает писать реально быстрый код
- Такие задачи полезны для подготовки к системному программированию, оптимизации и собеседованиям

#cpp #performance #cache #memory #optimize