Как написать чистый код? Угадываем что ввел юзер и дизайним с нуля(общий подход) Clean Code Approach

• Видео посвящено написанию программы с нуля в полу-лайф режиме.  

• Полезно для начинающих и опытных программистов, сталкивающихся с проблемами в начале работы.  

• Цель - помочь разобраться в последовательности действий и избежать "каши в голове".  

• Обсуждение чистого кода, SOLID, HICPP, Low-Code.  

• Основное внимание уделяется созданию гессера для обработки запросов пользователей.  

• Пример: пользователь вводит запрос, но ошибается, и система предлагает варианты.  

• Идея: предложить пользователю варианты запросов, если его запрос неверен.  

• Цель: быстро реализовать функционал без использования баз данных и библиотек.  

• Пример: приложение, которое помогает пользователям, но может быть не идеальным.  

• Программа принимает пользовательский ввод и обрабатывает его.  

• Пример: ввод команды в гид, но пользователь ошибается.  

• Цель: предложить пользователю варианты команд, если его ввод неверен.  

• Создание базового функционала без ошибок.  

• Пример: вывод сообщения о правильном выполнении запроса.  

• Создание файла и функции для обработки команд.  

• Создание словаря команд и обработчиков для каждой команды.  

• Пример: обработчик, который просто сообщает, что запрос обработан.  

• Проверка работы обработчиков.  

• Получение пользовательского ввода и его обработка.  

• Пример: вывод пользовательского ввода в консоль.  

• Цель: максимально упростить программу, избегая сложных конструкций.  

• Проверка существования команды перед обработкой.  

• Пример: проверка наличия команды в словаре.  

• Реализация функции для получения пользовательского ввода и его обработки.  

• Рассматривается негативный вариант, когда пользователь вводит неверный запрос.  

• В этом случае система пытается угадать, что хотел пользователь.  

• Процесс включает в себя различные функции и модули.  

• Процесс включает в себя функции и модули, которые работают в процедурном стиле.  

• В случае неудачи система вызывает функцию для обработки ошибки.  

• Программа работает в двух режимах: успешный и негативный.  

• Рассматривается алгоритм для угадывания запроса пользователя.  

• Алгоритм включает перебор команд и подсчет совпадений символов.  

• Чем больше совпадений, тем ближе команда к запросу пользователя.  

• Перебор команд для нахождения тех, которые содержат общие символы с запросом пользователя.  

• Команды, которые содержат больше совпадений, считаются более подходящими.  

• Результат перебора возвращается для дальнейшей обработки.  

• Алгоритм включает подсчет общих символов между запросом пользователя и командой.  

• Подсчет общих символов помогает определить, какая команда наиболее близка к запросу.  

• Результат возвращается для дальнейшей обработки в функции.  

• Код пишется максимально подробно, чтобы понять логику работы программы.  

• Высокий уровень функций описывает бизнес-логику, а низкий уровень – манипуляцию данными.  

• Код структурируется по уровням абстракции, начиная с самого высокого и заканчивая самым низким.  

• Верхний уровень абстракции описывает бизнес-логику.  

• Нижний уровень инкапсулирует алгоритмы и структуры данных.  

• Важно писать код, который легко читается и поддерживается.  

• Лоу-каплинг: избегать пересечения функций.  

• Хай-каплинг: избегать зависимости функций друг от друга.  

• Важно, чтобы каждая функция решала одну задачу.  

• Пересечение функций усложняет понимание кода.  

• Каждая функция должна быть четко определена.  

• Важно, чтобы функции делали одну вещь и не пересекали логику.  

• Код должен быть легко читаемым и поддерживаемым.  

• Важно понимать название функции, а не читать весь код.  

• Каждая функция должна делать одну задачу, чтобы избежать когнитивной сложности.  

• Примеры функций, которые делают одну вещь.  

• Избегать пересечения функций и зависимости между ними.  

• Стремиться к тому, чтобы каждая функция была четко определена.  

• Накидывать высокоуровневые детали и аккуратно добавлять детали.  

• Избегать пересечений и зависимостей для упрощения отладки.  

• Пример реализации функции для фильтрации команд.  

• Подсчет количества символов в команде.  

• Использование уникальных ключей для фильтрации.  

• Добавление минимального количества символов для каждого ключа.  

• Обсуждение зависимости от пользовательского ввода.  

• Необходимость изменения кода при замене пользовательского ввода на текст.  

• Понимание, что функция должна быть универсальной и абстрактной.  

• Удаление связей с внешними функциями.  

• Возможность изменения функции без влияния на другие части кода.  

• Тестирование и фиксация результатов.  

• Обсуждение использования текста вместо пользовательского ввода.  

• Генерализация кода для работы с любыми типами данных.  

• Упрощение кода и уменьшение зависимостей.  

• Применение алгоритма Левенштейна для сравнения строк.  

• Объяснение работы алгоритма и его преимуществ.  

• Имплементация алгоритма для улучшения фильтрации.  

• Декомпозиция кода для упрощения и улучшения читаемости.  

• Использование фильтров и алгоритмов для фильтрации данных.  

• Применение паттернов для упрощения кода.  

• Реализация функции для сравнения команд с использованием Левенштейна.  

• Упрощение кода и минимизация зависимостей.  

• Перебор команд и вычисление дистанции Левенштейна.  

• Передача команд в функцию для вычисления дистанции.  

• Использование функции для нахождения левинштейн дистанции.  

• Применение левинштейн дистанции к словам и сущностям.  

• Упрощение алгоритма для пустых строк.  

• Преобразование символов для пустых и непустых строк.  

• Подмена символов для одинаковых строк.  

• Кодирование значений для оптимизации.  

• Фильтрация команд для удаления лишних.  

• Создание блока для получения лучших команд.  

• Разделение логики на отдельные функции для удобства отладки.  

• Логирование каждого этапа для отслеживания данных.  

• Сортировка команд по левинштейн дистанции.  

• Добавление этапа форматирования для улучшения интерфейса.  

• Удаление лишних данных и возврат только нужных команд.  

• Абстрагирование от деталей реализации для упрощения кода.  

• Пользователь видит четкий результат, но не знает, как он был достигнут.  

• Гэсинг реализован с помощью пайплайна, который фильтрует и форматирует данные.  

• Абстракция позволяет легко понять логику программы через полгода.  

• Гэсинг фильтрует команды по корректорам и находит дистанции Левинштейна.  

• Лучшие команды форматируются для читаемого вида.  

• Программа становится понятной без необходимости читать все функции.  

• Возможность рефакторинга и улучшения кода без изменения логики.  

• Пример с функцией, которая может быть написана более идиоматично.  

• Важно выносить функции, описывающие действия, для читаемости кода.  

• Код должен быть читаемым и понятным для других разработчиков.  

• Важно, чтобы функции описывали свои действия, а не просто выполняли их.  

• Ответственность за реализацию функций лежит на их создателях.  

• Пример с функцией sort, которую можно реализовать быстрее без сортировки.  

• Нахождение минимального значения и добавление команд с таким значением.  

• Возможность изменения функции без влияния на остальную логику.  

• Функция не связана с внешним миром и работает автономно.  

• Можно менять функцию без влияния на внешний код.  

• Тесты фиксируют, что функция выдает ожидаемый результат.  

• Код становится более читаемым, если функции описаны подробно.  

• Функции описываются текстом, что упрощает понимание.  

• Это помогает переписывать код на другие языки без необходимости изучать детали реализации.  

• Подробное название функций упрощает их понимание и перепись.  

• Удаление ненужных элементов ускоряет процесс разработки.  

• Важно называть функции так, чтобы их было легко понять.  

• Разработка начинается с высокоуровневого планирования.  

• Продумываются возможные проблемы и пути их решения.  

• Важно детально описывать алгоритмы и функции для лучшего понимания.  

• Подсчет символов и пересечений помогает найти лучшие решения.  

• Описание функций человеческим языком улучшает читаемость кода.  

• Важно понимать, что делает функция, чтобы избежать необходимости разбирать весь код.  

• Читаемый код позволяет быстро находить нужные фрагменты.  

• Не нужно разбирать весь код, если функция понятна по названию.  

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

• Читаемый код упрощает процесс разработки и поддержки.  

• Важно называть функции так, чтобы их было легко понять и переписать.  

• Это помогает избежать необходимости изучать весь код, что экономит время и усилия.