⚡️ Знакомьтесь с экспертом Proglib Academy: AI-архитектор Антон Будняк

Антон — мастер превращения сырых AI-идей в отказоустойчивые системы. Он знает, как запустить MVP за неделю и масштабировать его так, чтобы архитектура не рассыпалась под нагрузкой в сотни тысяч юзеров.

За что его ценит IT-комьюнити:

🟣 Опыт в финтехе и крупном бизнесе

Руководил разработкой ML-моделей в финтехе с экономическим эффектом более 100 млн ₽

🟣 Запуск продуктов на 6.000+ пользователей

Антон строит сервисы, которыми пользуются тысячи людей в реальном проде.

🟣 Ускоряет разработку

Оптимизировал ML-пайплайны и кратно сократил время от начала разработки до релиза

📚 Где Антон черпает знания (рекомендации эксперта):

- X* — главный источник новостей. Рекомендую блог Бориса Черни (создателя Claude Code) — там база про использование ИИ в разработке.
- Нетворкинг в ТГ: чаты LLM под капотом и AI-чат — здесь можно найти ответ почти на любой технический вопрос.
- Новости AI: каналы Сиолошная и Denis Sexy IT.

На курсе Agentops Антон учит строить «неубиваемый» бэкенд: работать с очередями, таймаутами и балансировкой нагрузки, чтобы ваши агенты работали стабильно 24/7.

🎁 Майские СКИДКИ в Proglib Academy!

До конца мая на все курсы академии (включая AgentOps и разработку ИИ-агентов) действует скидка -40%. Это лучший момент, чтобы войти в AI-разработку под присмотром практиков.

Узнать больше о программе и обучении у Антона:
👉 Курс о том, как внедрять AI-логику в бэкенд и сохранять стабильность сервиса

Продолжаем знакомить вас с командой?
👍 — Да, ждем новых лиц
🔥 — Пойду подпишусь на каналы из списка Антона

🏃‍♀️ Proglib Academy

* - запрещен в рф

🍕 constexpr аллокации в C++20: new при компиляции

C++20 разрешил использовать new и delete в constexpr-функциях. Звучит дико — как можно аллоцировать память, если программа ещё не запущена?

constexpr int sum() {
    int* p = new int(42);
    int result = *p;
    delete p;
    return result;
}
constexpr int x = sum(); // OK в C++20

⚡️ Под капотом: компилятор моделирует кучу как часть абстрактной машины. new создаёт объект в памяти интерпретатора, delete помечает его как освобождённый. Никакой реальной аллокации не происходит.

❗️ Ключевое ограничение — transient allocation: вся память, выделенная в constexpr-контексте, должна быть освобождена до выхода из этого контекста. Нельзя «пронести» указатель в runtime:

constexpr int* leak() {
    return new int(42); // Ошибка: non-transient allocation
}

❗️ Это значит, что constexpr std::vector работает: вектор аллоцирует в compile-time, используется, и деструктор освобождает. Но нельзя создать constexpr std::vector как глобальную переменную — деструктор вызовется, данные не переживут компиляцию.

💡 Transient allocation — это песочница: компилятор позволяет работать с динамической памятью, но не выпускает её наружу.

📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#под_капотом

🎓 Халява для новичков: Бесплатная база по Python и C++ с тонной практики

Забирайте отличный микросборник полностью бесплатных курсов на Stepik, где вас заставят кодить с первых минут.

Python: Мощный упор на практику 210 тестов и 243 интерактивные задачи. Программа построена грамотно: вас проведут от стартовой настройки PyCharm, систем счисления и таблицы ASCII через нюансы типа Decimal к серьезной работе с матрицами в NumPy и функциональным встроенным инструментам вроде map(), filter() и reduce().з

C++: Тоже не дадут расслабиться внутри 205 тестов и 197 интерактивных задач для жесткой прокачки синтаксиса и алгоритмического мышления.

👉 Забираем в закладки:
- C++
- Python

🔹 Курс «Программирование на языке Python»
🔹 Получить консультацию менеджера
🔹 Сайт Академии 🔹 Сайт Proglib

🏃‍♀️ Азбука айтишника

#магиякода

🪐 Алгоритмы диапазонов: Алгоритмы сортировки

Продолжаем серию о диапазонах — на очереди сортировка 🙂

Напомню: std::ranges::* принимают диапазоны целиком и поддерживают проекции. Если пропустили предыдущий пост про алгоритмы поиска — начните с него.


🧋 ranges::sort — классическая сортировка

std::vector<int> v = {5, 3, 1, 4, 2};

std::ranges::sort(v);                  // {1, 2, 3, 4, 5}
std::ranges::sort(v, std::greater{}); // {5, 4, 3, 2, 1}

Один аргумент вместо пары итераторов. Второй аргумент — компаратор: std::greater{} для сортировки по убыванию, {} (или ничего) — по возрастанию.

❗️ ranges::sort требует random access range — std::vector, std::array, std::deque подойдут, а std::list — нет (для него есть метод list::sort()).


🍿 ranges::stable_sort — сохраняем порядок равных

struct Task {
    std::string name;
    int priority;
};

std::vector<Task> tasks = {
    {"Почта", 2}, {"Код", 1}, {"Тесты", 2}, {"Деплой", 1}
};

std::ranges::stable_sort(tasks, {}, &Task::priority);
// {{"Код", 1}, {"Деплой", 1}, {"Почта", 2}, {"Тесты", 2}}
// Элементы с одинаковым priority сохранили исходный порядок

Если два элемента «равны» по компаратору, stable_sort гарантирует, что их взаимный порядок останется таким же, как в исходном диапазоне. Обычный sort такой гарантии не даёт.


🍨 ranges::partial_sort — сортируем только первые N

std::vector<int> v = {5, 3, 1, 4, 2};

std::ranges::partial_sort(v, v.begin() + 3);
// {1, 2, 3, ?, ?} — первые три отсортированы, остальные в произвольном порядке

Полезно, когда нужен «топ-N» без затрат на полную сортировку. Сложность O(N·log(K)) вместо O(N·log(N)), где K — количество нужных элементов.


🍋 ranges::partial_sort_copy — топ-N в отдельный буфер

std::vector<int> v = {5, 3, 1, 4, 2};
std::vector<int> top3(3); // буфер под результат

std::ranges::partial_sort_copy(v, top3);
// top3 == {1, 2, 3}
// v не изменился: {5, 3, 1, 4, 2}

Работает как partial_sort, но не трогает исходный диапазон — результат пишется в отдельный контейнер. Размер приёмника определяет K (сколько элементов попадёт в «топ»). Удобно, когда исходные данные нельзя модифицировать.

// Топ-2 самых старших — без изменения исходного вектора
std::vector<Person> oldest(2);
std::ranges::partial_sort_copy(people, oldest, std::greater{}, &Person::age);

👀 ranges::nth_element — найти N-й по порядку

std::vector<int> v = {5, 3, 1, 4, 2};

std::ranges::nth_element(v, v.begin() + 2);
// v[2] == 3 (медиана)
// Все элементы слева <= 3, справа >= 3, но внутри групп порядок произвольный

Элемент на позиции N оказывается тем же, что стоял бы там после полной сортировки. Идеален для поиска медианы или перцентилей. Средняя сложность — O(N).


🐾 ranges::is_sorted — проверка отсортированности

std::vector<int> a = {1, 2, 3, 4, 5};
std::vector<int> b = {1, 3, 2, 4, 5};

bool ok1 = std::ranges::is_sorted(a); // true
bool ok2 = std::ranges::is_sorted(b); // false

// Найти, где порядок нарушается
auto it = std::ranges::is_sorted_until(b);
// *it == 2 — первый элемент, нарушающий порядок

is_sorted — быстрая проверка перед бинарным поиском или мержем. is_sorted_until возвращает итератор на первый элемент, который «ломает» порядок.


🍕 Проекции — работают и в сортировках

struct Person {
    std::string name;
    int age;
};

std::vector<Person> people = {{"Алиса", 30}, {"Борис", 25}, {"Вера", 35}};

// Сортировка по возрасту — без лямбды
std::ranges::sort(people, {}, &Person::age);
// {{"Борис", 25}, {"Алиса", 30}, {"Вера", 35}}

// По убыванию возраста
std::ranges::sort(people, std::greater{}, &Person::age);

// Топ-2 самых старших
std::ranges::partial_sort(people, people.begin() + 2, std::greater{}, &Person::age);

is_sorted — быстрая проверка перед бинарным поиском или мержем. is_sorted_until возвращает итератор на первый элемент, который «ломает» порядок.

❗️ Проекция — третий аргумент (после компаратора). {} на месте компаратора означает std::less{} по умолчанию.


📍Навигация: Вакансии • Задачи • Собесы • Канал в Max

Библиотека C/C++ разработчика

#константная_правильность

🦾🧠🏋️ Качаем мозги к лету!

Все готовятся к пляжному сезону, а мы предлагаем прокачать хард-скилы, чтобы забрать крутой оффер, строить продукты будущего и работать из любой точки мира 😎

⚡️ Распродажа @proglib_academy: забирайте самые актуальные образовательные треки по сниженным ценам!

➡️ Разработка AI-агентов — от 49 000 ₽ (вместо 69 000 ₽).

➡️ Курс AgentOps — 129 000 ₽ (вместо 149 000 ₽).

➡️ Математика для разработки AI-моделей — 23 990 ₽ (вместо 31 990 ₽).

➡️ ML для старта в Data Science — 28 990 ₽ (вместо 38 990 ₽).

Почему мы?

⭐️Учим для продакшена. Наши программы заточены под реальные задачи бизнеса: как не слить бюджет на токены, как заставить LLM работать стабильно в бэкенде и как выстроить отказоустойчивую архитектуру.
⭐️Спикеры — суровые практики. Вы будете перенимать опыт у действующих AI-архитекторов, тимлидов и ML-инженеров из топовых IT-компаний.
⭐️Комплексный подход. Мы даем как мощный математический фундамент для понимания моделей «под капотом», так и передовые инструменты оркестрации агентов.
⭐️Много практики и фидбека. Вебинары, десятки практических заданий и живое общение с экспертами в чате Telegram на протяжении всего обучения.

⏳ Оставляйте заявку и бронируйте место со СКИДКОЙ 40%

⚡️ Последний шанс забрать курсы со СКИДКОЙ 40%! Прокачайте свой мозг правильно

До конца акции вы можете воспользоваться специальными ценами на самые востребованные IT-направления. Круто и выгодно прокачать свои скиллы, чтобы получить оффер, уехать на Бали и больше не быть онлайн 😎

➡️ Разработка AI-агентов — от 49 000 ₽ (вместо 69 000 ₽)
Курс про контролируемую разработку ИИ-агентов: качество, стоимость, наблюдаемость и тестирование. С первого занятия — только практическая работа.

➡️ Курс AgentOps — 129 000 ₽ (вместо 149 000 ₽)
Профессиональный трек для разработчиков и LLM инженеров о том, как правильно внедрять AI-логику в бэкенд и сохранять железную стабильность сервиса.

➡️ Математика для Data Science — от 29 990 ₽ (вместо 39 990 ₽)
Вы научитесь решать сложные математические задачи, которые дают на собеседованиях на позицию дата-сайентиста в бигтехе. Отличная база для мощного старта в DS.

➡️ Курс Специалист по ИИ — 89 000 ₽ (вместо 113 900 ₽)
Комплексная программа для получения профессии в сфере ИИ с нуля. За 8 месяцев вы соберете сильное портфолио из 5 реальных проектов и дипломной работы.

➡️ Архитектуры и шаблоны проектирования — 27 990 ₽ (вместо 37 900 ₽)
Интенсив для разработчиков, который поможет освоить основные паттерны проектирования и прокачать навыки архитектора программного обеспечения.

🌸 Выбирайте направление, оставляйте заявку на сайте распродажи, и наш менеджер подробно вас проконсультирует

🍪 Как выдать shared_ptr на себя из метода?

std::shared_ptr хранит рядом с объектом control block — счётчик владельцев. Несколько shared_ptr безопасны, пока делят один control block. Проблема: иногда объекту нужно отдать shared_ptr на себя, но внутри метода есть только сырой this, который о counter'е ничего не знает.


❌ Наивный способ:

struct S {
    std::shared_ptr<S> self() { return std::shared_ptr<S>(this); }
};
auto p = std::make_shared<S>();
auto q = p->self();

У p и q свои control block'и, у каждого счётчик = 1 → объект удалится дважды (UB).


✅ Решение — enable_shared_from_this:

struct S : std::enable_shared_from_this<S> {
    std::shared_ptr<S> self() { return shared_from_this(); }
};
auto p = std::make_shared<S>();
auto q = p->self();

База добавляет скрытый weak_ptr<S>. При первом заворачивании в shared_ptr его конструктор замечает эту базу и кладёт туда свой control block. Теперь q разделяет счётчик с p.


🍴 Что делает shared_from_this():

shared_ptr<S> shared_from_this() { return shared_ptr<S>(weak_this); }

Это конструктор из weak_ptr, а не lock(): без владельца он бросает bad_weak_ptr, а не молча возвращает пустой указатель.


🍙 Когда скрытый weak_ptr пуст:

S s;                            // на стеке — никто не владеет
s.shared_from_this();           // 💥 bad_weak_ptr (до C++17 — UB)

struct T : std::enable_shared_from_this<T> {
    T() { shared_from_this(); } // 💥 хук срабатывает после конструктора
};

Правила: наследовать публично, владеть через shared_ptr (лучше make_shared). Нужна проверка без исключения — в C++17 есть weak_from_this():


🍉 Правила:

• Наследуйте enable_shared_from_this публично.
• Владейте объектом через shared_ptr — лучше make_shared (одна аллокация + exception-safety).
• Не вызывайте shared_from_this() в конструкторе и на объектах со стека — будет bad_weak_ptr.
• Нужна проверка без исключения — в C++17 берите weak_from_this():

if (auto sp = obj.weak_from_this().lock()) { /* владелец есть */ }

📍Навигация: Вакансии • Задачи • Собесы • Канал в Max

Библиотека C/C++ разработчика

#под_капотом

🐾 Алгоритмы диапазонов: Алгоритмы модификации

Разберём copy, transform, fill/generate, а также remove, reverse и unique — и заодно увидим, почему «удаление» в C++ удаляет не сразу.


🍵 ranges::copy / copy_if — копирование

std::vector<int> src = {1, 2, 3, 4, 5};
std::vector<int> dst(5);

std::ranges::copy(src, dst.begin());  // dst == {1, 2, 3, 4, 5}

// Копирование с условием
std::vector<int> evens;
std::ranges::copy_if(src, std::back_inserter(evens),
                     [](int x) { return x % 2 == 0; });
// evens == {2, 4}

Приёмник — один итератор (куда писать). Под copy буфер должен быть нужного размера; для copy_if берут std::back_inserter — он сам расширяет контейнер.

❗️ copy не терпит перекрытия источника и приёмника (UB). Для пересечения — copy_backward.


⬆️ ranges::move / swap_ranges — перемещение и обмен

std::vector<std::string> src = {"alpha", "beta", "gamma"};
std::vector<std::string> dst(3);

// Перемещение вместо копирования
std::ranges::move(src, dst.begin());
// dst == {"alpha", "beta", "gamma"}
// src содержит валидные, но "опустошённые" строки

// Обмен содержимым двух диапазонов
std::vector<int> a = {1, 2, 3};
std::vector<int> b = {4, 5, 6};

std::ranges::swap_ranges(a, b);
// a == {4, 5, 6}, b == {1, 2, 3}

move переносит ресурсы, а не копирует — дёшево для строк, векторов и прочих «тяжёлых» типов.

❗️ После move источник валиден, но содержимое не определено (valid but unspecified). Пустыми строки не гарантированы — только присвоить заново или уничтожить.


🌳 ranges::transform — преобразование

std::vector<int> src = {1, 2, 3, 4, 5};
std::vector<int> squared(5);

std::ranges::transform(src, squared.begin(), [](int x){ return x * x; });
// squared == {1, 4, 9, 16, 25}

Применяет функцию к каждому элементу и пишет результат в приёмник. Источник не меняется.


🍩 ranges::fill / generate — заполнение

std::vector<int> dst(5);

std::ranges::fill(dst, 0);  // {0, 0, 0, 0, 0}

std::ranges::generate(dst, [n = 0]() mutable { return n++; });
// {0, 1, 2, 3, 4}

fill кладёт одно и то же значение, generate зовёт функцию на каждый элемент — удобно для счётчиков, случайных чисел или любой генерации «на лету».


🥳 ranges::remove — удаление (erase-remove стал проще)

std::vector<int> data = {1, 2, 3, 2, 4, 2, 5};

// Старый способ:
data.erase(std::remove(data.begin(), data.end(), 2), data.end());

// Новый способ (C++20):
auto [first, last] = std::ranges::remove(data, 2);
data.erase(first, last);
// data == {1, 3, 4, 5}

Важный момент: remove ничего физически не удаляет — он лишь сдвигает «выжившие» элементы в начало и возвращает поддиапазон «мусорного хвоста». Реально обрезает контейнер только последующий erase.

❗️ Если контейнер свой (а не чужой диапазон), ещё короче — свободная функция std::erase(data, 2): одна строка вместо пары.


🍿 ranges::reverse — разворот

std::vector<int> data = {1, 3, 4, 5};
std::ranges::reverse(data);  // {5, 4, 3, 1}

Переворачивает диапазон на месте, без дополнительной памяти.


🎵 ranges::unique — удаление соседних дубликатов

std::vector<int> dups = {1, 1, 2, 3, 3, 3, 4};

auto [u_first, u_last] = std::ranges::unique(dups);
dups.erase(u_first, u_last);
// dups == {1, 2, 3, 4}

Как и remove, возвращает поддиапазон хвоста и требует erase для реальной очистки.

❗️ Убирает только соседние повторы — чтобы вычистить все дубликаты, диапазон сначала надо отсортировать.


🍴 Проекции — работают и здесь

struct Task {
    std::string name;
    int priority;
};

std::vector<Task> tasks = {
    {"Код", 1}, {"Почта", 0}, {"Деплой", 2}, {"Черновик", 0}
};

// Удалить все задачи с priority == 0 — без лямбды
auto [first, last] = std::ranges::remove(tasks, 0, &Task::priority);
tasks.erase(first, last);
// Остались {"Код", 1} и {"Деплой", 2}

Проекция — последний аргумент: remove, copy_if, transform и другие умеют работать «по полю».

❗️ Но проекция — не предикат. У remove это лишь сравнение на равенство; для условий сложнее (priority > 0) нужен remove_if.


📍Навигация: Вакансии • Задачи • Собесы • Канал в Max

Библиотека C/C++ разработчика

#константная_правильность