🔥 4 привычки кодеров

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

но, я собрал 4 привычки адептов «чистого кода», (которые обычно все практикуют) 🤡

• Бесконечный рефакторинг рабочего кода.
Кажется, что так ты делаешь продукт лучше. Итог: жестко падаешь в перфекционизм. Переписываешь функцию по три раза, а бизнес ждет релиз. Закрываешь вкладку и в голове абсолютная пустота, время потрачено, а новых фичей ноль.

• Упарывание в сложную архитектуру
Сеньоры на ютубе обещают золотые горы, если внедрить микросервисы куда угодно. Итог: получаешь красивый overengineering-проект для мамы и 0 запущенных продуктов в срок, пока конкуренты клепают MVP на коленке.

• Душные споры на ревью
Неплохо, но как итог: ты пишешь полотна текста и тратишь часы на поиск глупой придирки к стилю, потому что банально фокус сместился с реальной задачи на эго.

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

Проблема в том, что ни один из этих путей не дает самого главного - скорости и проверки гипотез. Реальному рынку плевать на твой идеальный код за 3 дня. Бизнес предпочтет код от ИИ-агента за 5 минут, который уже завтра начнет приносить деньги.

Хочешь обкатанный на нас лично и 100х учениках метод, как перестать кодить руками и начать делегировать задачи автономным системам?

👉 Заходи сюда, но у нас осталось всего 4 места, набор идет до завтрашнего дня.

P. S. Если интересно еще что-нибудь почитать от меня, то заходите в «Азбуку Айтишника», там я рассказываю об айти-базе, также у меня там есть бесплатный гайд на 15 глав по ии-агентам

🍙 views::take и views::drop — срезы в C++

Если views::transform превращает элементы, то views::take и views::drop управляют тем, сколько элементов обработать. Та же ленивая логика, никакого лишнего копирования.

🌸 views::take — первые N элементов

#include <ranges>
#include <vector>
namespace views = std::views;

std::vector<int> v = {10, 20, 30, 40, 50};

auto first_three = v | views::take(3);
// При итерации: 10, 20, 30

Лямбда не нужна — достаточно числа. Адаптер остановит итерацию сам, как только наберёт нужное количество.


🍪 take_while — берём пока условие истинно

auto while_lt_40 = v | views::take_while([](int x) { return x < 40; });
// При итерации: 10, 20, 30

В отличие от take(n), здесь количество элементов заранее неизвестно — решает предикат.


🍀 views::drop — пропустить первые N элементов

auto skip_two = v | views::drop(2);
// При итерации: 30, 40, 50

// drop_while — пропускаем пока условие истинно
auto after_twenties = v | views::drop_while([](int x) { return x <= 20; });
// При итерации: 30, 40, 50

❗️Важный нюанс: drop_while проверяет предикат только до первого несовпадения, а затем отдаёт все оставшиеся элементы подряд — даже те, что снова удовлетворили бы условию. Это не фильтр — это одноразовый пропуск.


🌱 Срез в середине: drop + take

Комбинируя два адаптера, получаем аналог Python-срезов:

// Элементы с индекса 1 по 3 включительно (аналог v[1:4])
auto slice = v | views::drop(1) | views::take(3);
// При итерации: 20, 30, 40

Весь конвейер по-прежнему ленив: элементы не вычисляются до начала итерации.


🍙 Связка с filter и transform

struct Employee {
    std::string name;
    double salary;
    bool is_active;
};

std::vector<Employee> employees = { /* ... */ };

// Топ-2 активных сотрудника по имени
auto top_two = employees
    | views::filter([](const Employee& e) { return e.is_active; })
    | views::transform([](const Employee& e) { return e.name; })
    | views::take(2);

❌ Ловушка: drop на бесконечном диапазоне

// OK — take ограничивает бесконечный iota
auto ok = std::views::iota(1) | std::views::take(5);
// 1, 2, 3, 4, 5

// OK — drop сам по себе безопасен, view создаётся без проблем
auto dropped = std::views::iota(1) | std::views::drop(3);

// ОПАСНО — итерирование без терминатора зависнет навсегда
for (auto x : dropped) { /* никогда не остановится */ }

drop на бесконечном диапазоне создаётся без проблем. Опасность — в цикле без ограничителя. Всегда добавляйте take или аналог, если диапазон потенциально бесконечен.


🐸 Продолжение следует...

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

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

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

🏆 Задача на выходные: string_view vs string в API

Перед тобой два варианта API логгера. Выбери лучший и обоснуй. Нет единственно верного ответа — важна аргументация.

#include <string>
#include <string_view>

// Вариант А
class LoggerA {
public:
    void log(const std::string& msg);
    void setPrefix(const std::string& prefix);
    std::string getLastMessage() const;
};

// Вариант Б
class LoggerB {
public:
    void log(std::string_view msg);
    void setPrefix(std::string_view prefix);
    std::string_view getLastMessage() const;
};

// Контекст использования:
// 1. log() вызывается тысячи раз в секунду
// 2. setPrefix() — один раз при старте
// 3. getLastMessage() — для диагностики
// 4. Логгер хранит последнее сообщение внутри

✏️ Напиши в комментариях: какой метод в каком варианте правильный, а какой — нет. Предложи «идеальный» LoggerC.


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

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

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

🍿 Что скрывает auto(x): новый синтаксис C++23

В C++23 появился синтаксис auto(x) и auto{x}. Это не очередной сахар для объявления переменных. На самом деле — это именованная операция, у которой есть точная семантика.


🥳 Что происходит под капотом:

auto(x) — это decay-copy: создаётся prvalue того же типа, что и x, но после применения std::decay. То есть:

• Ссылки снимаются
• Cv-квалификаторы (const/volatile) удаляются
• Массивы → указатели
• Функции → указатели на функции

const int& r = 42;
auto copy = auto(r); // int, не const int&

⚡️ До C++23 для того же результата писали:

auto copy = std::decay_t<decltype(r)>(r);

❓ Зачем нужна явность?

В простых случаях auto copy = r тоже даст int — auto и так делает decay. Но в обобщённом коде важно явно сигнализировать намерение: "я хочу копию, а не прокси или view".

Главное применение — защита от UB при модификации контейнера. Классический пример — реализация pop_front:

void pop_front(auto& container) {
    std::erase(container, auto(container.front()));
    // Без auto() — UB: front() может инвалидироваться
    // в процессе удаления элементов
}

Без auto() мы передаём ссылку на элемент, который erase может разрушить до сравнения. С auto() — сначала создаётся копия значения, потом происходит удаление. Безопасно и читаемо.

❗️ auto(x) закрывает целый класс subtle-багов в шаблонном коде — там, где случайная ссылка вместо копии приводит к UB или неожиданному поведению.


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

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

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

🔪 Разбиение диапазонов: views::split, chunk, chunk_by

Ranges-библиотека умеет не только фильтровать и трансформировать, но и разбивать диапазоны на части. Разберём три инструмента — каждый для своей задачи.


🍴 views::split — разбивка по разделителю

std::string csv = "один,два,три,четыре";

// Разбиваем по запятой
for (auto part : csv | views::split(',')) {
    // part — под-диапазон символов, не строка
    // В C++20 явно конструируем string:
    std::cout << std::string(part.begin(), part.end()) << "\n";
}
// один
// два
// три
// четыре

В C++23 появился std::ranges::to, и конвертация стала лаконичнее:

for (auto part : csv | split(',')) {
    std::cout << std::ranges::to<std::string>(part) << "\n";
}

❗️views::split возвращает под-диапазоны, а не строки — явное преобразование обязательно в обоих стандартах.


🥨 views::chunk(n) — разбивка на блоки фиксированного размера (C++23)

std::vector<int> data = {1, 2, 3, 4, 5, 6, 7};
for (auto chunk : data | views::chunk(3)) {
    for (int x : chunk) std::cout << x << " ";
    std::cout << "\n";
} /
/ 1 2 3
// 4 5 6
// 7

❗️ Если размер диапазона не делится на n нацело — последний блок содержит оставшиеся элементы.



🍪 views::chunk_by — разбивка по условию (C++23)

Группирует соседние элементы, пока выполняется предикат между двумя соседями.

std::vector<int> v = {1, 1, 2, 3, 3, 3, 4, 4};
// Группируем подряд идущие равные элементы
for (auto group : v | views::chunk_by(std::equal_to{})) {
    for (int x : group) std::cout << x << " ";
    std::cout << "| ";
} /
/ 1 1 | 2 | 3 3 3 | 4 4 |

// Вариант с std::equal_to<>{} — лаконичнее:
for (auto group : v | chunk_by(std::equal_to<>{})) { ... }

❗️ Предикат принимает два соседних элемента — новая группа начинается там, где он вернул false.


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

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

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

🍋 Just My Code в Visual Studio

По умолчанию, когда вы нажимаете F11 (Step Into) в Visual Studio, отладчик проваливается в каждую функцию — включая стандартную библиотеку, runtime и сторонний код?

Функция Just My Code решает эту проблему. При включении отладчик автоматически перешагивает через код, который не принадлежит вашему проекту — будь то STL, CRT или любые внешние библиотеки.


🍀 Включить просто:

Tools → Options → Debugging → General → Enable Just My Code

🍬 Пример:

#include <vector>
#include <algorithm>
#include <iostream>

int doubleValue(int x) {
    return x * 2;  // ← ВАШ код
}

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

    // F11 здесь без JMC → провалится в std::sort
    std::sort(v.begin(), v.end());

    // F11 здесь без JMC → провалится в std::transform
    std::transform(v.begin(), v.end(), v.begin(), doubleValue);

    return 0;
}

Без JMC: F11 на std::sort уводит вас в дебри introsort внутри STL.
С JMC: отладчик перепрыгивает sort и останавливается на следующей вашей строке.


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

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

#буст