🤔 В чем разница char и varchar в SQL?

CHAR — это тип фиксированной длины, используемый для хранения строк одинаковой длины. VARCHAR — это тип переменной длины, который экономит пространство, храня строки в соответствии с их фактическим размером.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Возможность менять реализацию без влияния на клиентскую часть — что это значит?

Эта возможность означает, что изменения во внутренней реализации модуля, класса или сервиса не требуют изменений в коде, который взаимодействует с ним (то есть в клиентской части). Это достигается за счёт строгого разделения интерфейса (контракта) и реализации, что является ключевым принципом инкапсуляции и модульного программирования.

🚩Почему это важно?

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

🟠Снижение затрат на поддержку
Упрощает рефакторинг, обновления или замену компонентов системы.

🟠Стабильность клиентского кода
Клиентский код остаётся неизменным и работает без ошибок, даже если внутренние детали реализации полностью поменялись.

🟠Лёгкость тестирования и замены
Упрощает тестирование и замену частей системы на новые реализации (например, подмена мока на реальную базу данных).

🚩Как это достигается?

🟠Абстракции и интерфейсы
Определяется контракт взаимодействия через интерфейс или абстрактный класс.
Клиентская часть работает с этим контрактом, не зная деталей реализации.
Пример: Интерфейс для работы с хранилищем данных IStorage определяет методы save() и load(). Реализация может быть файловой, базой данных или облачным сервисом.

🟠Принцип подстановки Барбары Лисков (LSP)
Реализация должна быть заменяемой без нарушения работы клиентского кода. Это гарантирует, что изменение реализации не повлияет на функциональность.

🟠Инкапсуляция
Внутренние детали модуля или класса скрыты за чётко определённым интерфейсом. Клиентский код взаимодействует только с публичным API, не имея доступа к внутренним данным или методам.

🟠Принципы SOLID
Принципы проектирования (особенно Dependency Inversion Principle) способствуют отделению деталей реализации от интерфейсов.

🟠Модульность и тестируемость
Модули должны быть максимально независимыми друг от друга. Использование dependency injection (внедрение зависимостей) упрощает замену реализаций.

🚩Пример из практики

🟠Рефакторинг хранилища данных
Клиентская часть работает с интерфейсом IStorage, который предоставляет методы для чтения и записи данных. Изначальная реализация использует локальные файлы. Позже её заменяют на работу с базой данных. Поскольку клиентский код взаимодействует только с IStorage, никаких изменений в нём вносить не нужно.

🟠Изменение алгоритмов
Допустим, класс обрабатывает данные с помощью метода process(). Реализация может меняться (например, использование нового алгоритма), но интерфейс остаётся неизменным, поэтому клиентский код продолжает работать.

🚩Плюсы

➕Упрощение внесения изменений в проект.
➕Снижение рисков, связанных с модификацией кода.
➕Улучшение поддержки и масштабируемости.

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём различие между LEFT JOIN, RIGHT JOIN и INNER JOIN?

LEFT JOIN возвращает все строки из левой таблицы и соответствующие строки из правой, добавляя NULL, если совпадений нет.
RIGHT JOIN делает то же самое, но с правой таблицей, возвращая NULL для отсутствующих строк из левой таблицы.
INNER JOIN возвращает только строки, где есть совпадения в обеих таблицах.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое предохранительный уровень (Anti-Corruption Layer, ACL)?

Это программный слой, предназначенный для защиты одной части системы от нежелательного влияния другой. Его основная задача — изолировать доменную логику вашей системы от сложностей или несовместимостей, возникающих при взаимодействии с внешними системами или устаревшими (легаси) модулями.

🚩Основная идея

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

🚩Когда нужен ACL?

🟠Интеграция с устаревшими системами (Legacy Systems)
Когда ваша новая система должна работать с устаревшими модулями, которые имеют несовместимые данные, структуры или API.
🟠Подключение к внешним сервисам
Например, при интеграции с внешним API, который использует сложные или нестандартные форматы данных.
🟠Сложные бизнес-правила
Когда внешняя система не соответствует вашей доменной модели, и требуется преобразование данных для их согласованности.
🟠Управление зависимостями
Для предотвращения прямой зависимости между вашим кодом и внешними библиотеками или сервисами, которые могут меняться.

🚩Как работает ACL?

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

🚩Плюсы

➕Чистота доменной модели
Ваша бизнес-логика остаётся независимой от деталей внешних систем.
➕Гибкость при изменениях
Изменения в внешних системах минимально затрагивают вашу внутреннюю логику — достаточно адаптировать ACL.
➕Повышение тестируемости
ACL можно тестировать отдельно от основной системы.
➕Снижение технического долга
Защищает от проникновения устаревших решений или несовместимых структур в ваш код.
➕Упрощение поддержки
Уменьшает сложность кода за счёт явного разделения зон ответственности.

🚩Пример использования

🟠Интеграция с внешним API
Ваше приложение взаимодействует с системой оплаты, которая возвращает данные в сложном JSON-формате. ACL преобразует этот JSON в понятный объект вашей системы, например, PaymentDetails.
🟠Работа с легаси-системой
Ваша новая система работает с устаревшей базой данных, где используются нестандартные структуры данных. ACL преобразует SQL-запросы и результаты в объекты вашего приложения, скрывая детали старой структуры.

🚩Как реализовать ACL?

🟠Создайте слой адаптера
Реализуйте интерфейс или набор методов, которые предоставляют доступ к функционалу внешней системы.

🟠Применяйте шаблон "Фасад"
Упростите взаимодействие, предоставив единый интерфейс для вызова сложных операций.

🟠Используйте мапперы
Для преобразования данных из формата внешней системы в объекты вашей системы.

🟠Обеспечьте тестируемость
ACL должен быть изолирован, чтобы можно было проверять преобразования без необходимости вызывать внешнюю систему.

🚩Ограничения ACL

🟠Сложность реализации
Для сложных систем может потребоваться значительное время на проектирование и реализацию ACL.
🟠Оверхед производительности
Преобразования данных или вызовы через ACL могут быть медленнее, чем прямое взаимодействие.
🟠Необходимость обновлений
ACL нужно поддерживать, чтобы он оставался актуальным при изменениях внешних систем.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие бывают ограничения в базе данных?

Ограничения включают:
PRIMARY KEY — уникальный идентификатор строки.
FOREIGN KEY — ссылка на ключ другой таблицы.
UNIQUE — значения в колонке должны быть уникальными.
NOT NULL — значение должно быть задано.
CHECK — проверка выполнения условий.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как правильно написать Thread-Safe Singleton?

Для современного подхода используйте static локальную переменную в методе getInstance, так как ее инициализация гарантированно потокобезопасна.

🚩Принципы реализации

🟠Ограничение создания нескольких экземпляров
Экземпляр создаётся только один раз за всё время жизни приложения.
🟠Безопасность в многопоточности
Реализация должна корректно работать при обращении из нескольких потоков.
🟠Ленивая инициализация
Экземпляр создаётся только тогда, когда он нужен, а не заранее.

🚩Способы реализации

🟠Использование блокировки (Double-Checked Locking)
Включает двойную проверку перед созданием экземпляра. Сначала проверяется, существует ли экземпляр без блокировки, а затем с блокировкой создаётся объект, если он ещё не существует.

public class Singleton {
    // Вариант с volatile для предотвращения оптимизаций компилятора
    private static volatile Singleton instance;

    // Закрытый конструктор для предотвращения создания объекта через `new`
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { // Первая проверка (без блокировки)
            synchronized (Singleton.class) { // Блокировка
                if (instance == null) { // Вторая проверка (с блокировкой)
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

🟠Инициализация с помощью внутреннего класса (Bill Pugh Singleton)
Реализуется с помощью статического внутреннего класса. Экземпляр создаётся лениво при первом вызове метода getInstance().

public class Singleton {
    // Закрытый конструктор
    private Singleton() {}

    // Внутренний статический класс
    private static class SingletonHelper {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

🟠Использование Enum
Реализация через enum гарантирует, что будет создан только один экземпляр.

public enum Singleton {
    INSTANCE;

    public void someMethod() {
        // Реализация методов
    }
}

🟠Thread-Safe Singleton на ранней инициализации
Экземпляр создаётся при загрузке класса. Не ленивая, но безопасная и простая.

public class Singleton {
    // Экземпляр создаётся при загрузке класса
    private static final Singleton INSTANCE = new Singleton();

    // Закрытый конструктор
    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

🚩Рекомендации

🟠Используйте Bill Pugh Singleton
Рекомендуется для большинства случаев из-за простоты, потокобезопасности и ленивой инициализации.
🟠Enum Singleton
Идеален, если требуется сериализация или простота реализации, но не подходит для классов, требующих параметров при создании.
🟠Double-Checked Locking
Подходит, если требуется максимальная гибкость, но код становится сложнее.

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём разница INNER JOIN и RIGHT JOIN?

INNER JOIN возвращает только строки, которые совпадают в обеих таблицах.
RIGHT JOIN возвращает все строки из правой таблицы и соответствующие строки из левой, добавляя NULL, если совпадений нет.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как тесты и TDD влияют на организацию кода?

Тесты и подход разработки через тестирование (Test-Driven Development, TDD) оказывают значительное влияние на структуру, организацию и качество кода. Они стимулируют разработчиков писать более чистый, модульный и тестируемый код, следуя принципам хорошего дизайна.

🟠Декомпозиция и модульность
Как тесты влияют: Для удобства тестирования разработчики разделяют большие методы и классы на мелкие, с чёткими зонами ответственности. В результате код становится более модульным, а его компоненты проще повторно использовать и изменять.

🟠Снижение зависимости (Loose Coupling)
Как тесты влияют: Для изолированного тестирования классов и методов зависимости инвертируются и предоставляются через интерфейсы или моки. Это приводит к использованию принципа инверсии зависимостей (Dependency Inversion Principle) и снижению связности между модулями.

🟠Чёткая ответственность (Single Responsibility Principle, SRP)
Как тесты влияют: Если метод или класс берёт на себя слишком много обязанностей, тестировать его становится сложно. Это побуждает разработчиков разделять функциональность, соблюдая SRP.

🟠Улучшение проектирования интерфейсов
Как тесты влияют: Разработка через тесты требует определения интерфейсов и API до написания кода. Интерфейсы проектируются с упором на удобство использования, минимальный набор методов и простоту.

🟠Стимуляция рефакторинга
Как тесты влияют: Наличие тестов создаёт уверенность, что изменения в коде не сломают существующую функциональность. Это стимулирует регулярный рефакторинг, что улучшает организацию и качество кода.

🟠Документация кода через тесты
Как тесты влияют: Хорошо написанные тесты документируют ожидаемое поведение кода, показывая, как он должен использоваться и какие результаты ожидать.

🟠Принципы разработки (SOLID, KISS, DRY)
Как тесты влияют: Чтобы код был тестируемым, разработчики чаще соблюдают принципы проектирования:
SOLID: Принципы проектирования для создания гибких и расширяемых систем.
KISS: Сохранение кода простым.
DRY: Избежание повторений.

🟠Мотивация к изоляции побочных эффектов
Как тесты влияют: Чтобы упростить тестирование, разработчики изолируют побочные эффекты (например, работу с БД, сетью, файловой системой) в отдельных компонентах.

🟠Обнаружение ошибок на ранних этапах
Как тесты влияют: Написание тестов до основного кода (TDD) выявляет проблемы в проектировании и требованиях на ранних стадиях.

🚩Ограничения и потенциальные проблемы

🟠Избыточность тестов
Если тесты плохо написаны, это может усложнить рефакторинг.
🟠Временные затраты
Написание тестов занимает больше времени на ранних этапах, но окупается в долгосрочной перспективе.
🟠Кривая обучения
Новички могут столкнуться с трудностями при проектировании тестируемого кода.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как "под капотом" работает аннотация @Transactional?

Аннотация @Transactional в Spring использует прокси для перехвата методов и управления транзакциями. Перед выполнением метода создаётся или используется существующая транзакция, а после выполнения транзакция коммитится или откатывается в случае исключения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Проблема N+1 и её решение?

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

🚩Как проявляется?

Представим, что у нас есть две сущности: User и связанные с ним Posts. Приложение запрашивает список всех пользователей, а затем для каждого пользователя делает отдельный запрос, чтобы получить связанные с ним посты. Вместо одного запроса к базе данных выполняется: Один запрос для получения всех пользователей. N запросов для получения постов каждого пользователя.
Итог: N+1 запросов.
Это неэффективно, так как количество запросов растёт линейно с увеличением количества данных, что приводит к большим задержкам.

🚩Причины возникновения
🟠Неправильная настройка ORM (например, использование ленивой загрузки (`lazy loading`)).
🟠Невнимательность при проектировании архитектуры приложения.
🟠Недостаток оптимизации при составлении SQL-запросов.

🚩Подходы к решению проблемы

🟠Жадная загрузка (Eager Loading)
Вместо выполнения N отдельных запросов для связанных данных, ORM можно настроить так, чтобы они загружались вместе с основным запросом. Например: В Hibernate это можно сделать с помощью fetch join. В Django ORM используется метод select_related() или prefetch_related().

🟠Оптимизация SQL-запросов вручную
Иногда автоматическая оптимизация ORM не работает идеально. В таких случаях можно написать кастомные SQL-запросы, используя соединения (JOIN) для получения всех необходимых данных в одном запросе.

🟠Кэширование
Если данные редко меняются, можно использовать кэш (например, Redis или Memcached), чтобы минимизировать количество обращений к базе данных.

🟠Анализ запросов
Использование инструментов мониторинга запросов (например, SQLAlchemy профайлеры или Django Debug Toolbar) позволяет вовремя выявить проблему N+1 и устранить её.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Расскажи про уровни изоляции?

Уровни изоляции транзакций:
READ UNCOMMITTED — видны незавершённые изменения.
READ COMMITTED — видны только зафиксированные изменения.
REPEATABLE READ — предотвращает изменения данных, прочитанных транзакцией.
SERIALIZABLE — полная изоляция, все транзакции выполняются последовательно.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Утечка памяти в Java: примеры и объяснение?

В Java происходит, когда объекты, которые больше не нужны, продолжают ссылаться в памяти, и сборщик мусора (Garbage Collector, GC) не может их освободить. Это может привести к росту потребления памяти и в конечном итоге к ошибке OutOfMemoryError.

🚩Примеры утечек памяти в Java

🟠Долгоживущие коллекции
Если объекты добавляются в коллекцию (например, List, Map) и никогда не удаляются, они могут остаться в памяти, даже если больше не используются.

public class MemoryLeakExample {
    private static List<Object> list = new ArrayList<>();

    public void addToList() {
        list.add(new Object()); // Объекты накапливаются, даже если они больше не нужны.
    }
}

🟠Ошибки в обработке слушателей (Listeners)
Часто утечка происходит, когда объекты, подписанные на события, не отписываются, даже если больше не используются.

class EventSource {
    private List<EventListener> listeners = new ArrayList<>();

    public void addListener(EventListener listener) {
        listeners.add(listener);
    }
}

class LeakingClass {
    public LeakingClass(EventSource source) {
        source.addListener(new EventListener() {
            @Override
            public void onEvent() {
                // Обработка события
            }
        });
    }
}

🟠Слабые ссылки, которые не используются правильно
Неправильное использование объектов с сильными ссылками, которые хранят данные временно, но остаются доступными слишком долго.

class Cache {
    private Map<Key, Value> cache = new HashMap<>();

    public void put(Key key, Value value) {
        cache.put(key, value); // Объекты накапливаются и не очищаются.
    }
}

🟠Замыкания (Closures)
Использование лямбда-выражений или анонимных классов, которые удерживают ссылки на внешние объекты.

public class MemoryLeak {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        Runnable task = () -> list.add(new Object()); // Лямбда удерживает ссылку на list
        task.run();
    }
}

🟠Потоки (Threads)
Если поток продолжает работать или удерживает ссылки на объекты, которые больше не нужны, это может привести к утечке.

class LeakingThread {
    public void startThread() {
        Thread thread = new Thread(() -> {
            while (true) {
                // Бесконечный цикл, который не позволяет завершить поток
            }
        });
        thread.start();
    }
}

🟠Закрытие ресурсов
Незакрытые соединения или потоки ввода/вывода могут удерживать ссылки на системные ресурсы.

public void readFile() {
    FileInputStream fis = new FileInputStream("file.txt");
    // Поток не закрыт
}

🚩Как избежать утечек памяти?

🟠Регулярно анализировать код
Использовать профилировщики памяти, такие как VisualVM, YourKit, или JProfiler. Искать "утекшие" объекты, которые удерживаются ссылками, но больше не нужны.

🟠Использовать слабые ссылки
Применять WeakReference или WeakHashMap для временных данных.

🟠Управлять жизненным циклом объектов
Удалять ненужные объекты из коллекций. Освобождать ресурсы, такие как потоки или соединения.

🟠Отписываться от событий
Удалять слушателей (listeners), когда они больше не нужны.

🟠Правильно закрывать ресурсы
Использовать try-with-resources для работы с потоками и соединениями.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как ты можешь описать абстракцию?

Абстракция — это принцип, скрывающий сложность и показывающий только существенные характеристики объекта. Она помогает сосредоточиться на логике использования, а не на деталях реализации, делая код проще и понятнее.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему возрастает интерес к функциональному программированию (FP)?

Интерес к функциональному программированию (Functional Programming) растёт из-за изменений в требованиях к разработке современных приложений, таких как потребность в масштабируемости, управлении сложностью и обработке больших данных. Функциональное программирование предлагает преимущества, которые позволяют решать эти задачи более эффективно.

🚩Основные причины роста интереса к FP

🟠Эффективная обработка многопоточности и параллелизма
Функциональное программирование делает акцент на чистых функциях, которые не имеют побочных эффектов. Это упрощает разработку многопоточных приложений, поскольку отсутствует необходимость синхронизации общего состояния. Языки, такие как Scala, Clojure, и Haskell, предоставляют мощные инструменты для работы с параллелизмом и потоками данных, что важно в эпоху многоядерных процессоров.

🟠Масштабируемость и управление состоянием
Современные распределённые системы требуют минимизации работы с изменяемым состоянием. FP, с его подходом к неизменяемым данным, позволяет избегать проблем, связанных с изменяемостью, таких как гонки данных или сложные состояния.

🟠Обработка больших данных
Фреймворки, такие как Apache Spark и Apache Flink, используют концепции функционального программирования (например, операции над коллекциями, как map, filter, reduce) для работы с большими данными. Это делает FP особенно полезным для обработки потоков данных и анализа больших объёмов информации.

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

🟠Популяризация функциональных возможностей в императивных языках
Основные императивные языки программирования (Java, Python, JavaScript, C#) добавляют функциональные возможности, такие как лямбды, стримы и функции высшего порядка. Это делает функциональный стиль более доступным для широкой аудитории разработчиков.

🟠Повышение надёжности кода
Исключение побочных эффектов уменьшает количество ошибок. Код становится проще для тестирования, так как функции можно протестировать в изоляции. Система типов в функциональных языках, таких как Haskell, гарантирует большую безопасность, что снижает вероятность ошибок в рантайме.

🟠Тенденции к модульности и повторному использованию кода
FP способствует созданию более модульного кода. Композиция функций позволяет легко строить новые функциональности из существующих компонентов.

🟠Популярность в веб-разработке и мобильных приложениях
Языки, такие как Elm, ReasonML, и фреймворки, например React (с концепцией функциональных компонентов), активно используют принципы функционального программирования. Это позволяет создавать приложения с минимальным количеством багов и высокой предсказуемостью поведения.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое столп "наследование"?

Наследование — это один из принципов ООП, позволяющий одному классу (наследнику) унаследовать свойства и методы другого класса (родителя). Оно способствует повторному использованию кода и упрощению расширения функциональности.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как обнаружить самые затратные запросы?

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

🚩Включение логирования медленных запросов (Slow Query Logging)

Многие системы управления базами данных (СУБД) поддерживают логирование запросов, выполнение которых занимает больше определённого времени.

🟠MySQL
Используйте slow_query_log. Активировать лог:

SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 1; -- Время выполнения в секундах

🟠PostgreSQL
Включите log_min_duration_statement.

SET log_min_duration_statement = 1000; -- Логировать запросы, выполняющиеся более 1 секунды

🚩Использование EXPLAIN или ANALYZE

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

MySQL

EXPLAIN SELECT * FROM orders WHERE status = 'pending';

PostgreSQL

EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE status = 'pending';

🚩Использование системных представлений и мониторинга запросов

🟠MySQL
Используйте таблицу performance_schema для анализа запросов.

SELECT * FROM performance_schema.events_statements_summary_by_digest
ORDER BY SUM_TIMER_WAIT DESC LIMIT 10;

🟠PostgreSQL
Используйте расширение pg_stat_statements.

CREATE EXTENSION pg_stat_statements;

Получите информацию

SELECT query, calls, total_time, mean_time
FROM pg_stat_statements
ORDER BY total_time DESC
LIMIT 10;

🚩Мониторинг с использованием внешних инструментов

🟠New Relic
Проводит анализ SQL-запросов, показывая самые медленные.
🟠Datadog
Позволяет отслеживать производительность запросов в реальном времени.
🟠SolarWinds DPA (Database Performance Analyzer)
Специализированный инструмент для анализа производительности баз данных.

🚩Оптимизация индексов

🟠MySQL

SELECT * FROM sys.schema_unused_indexes;

🟠PostgreSQL
Проверьте в плане выполнения запросов (EXPLAIN), используются ли индексы.

🚩Нагрузочное тестирование (Load Testing)

Используйте нагрузочные тесты, чтобы выявить запросы, создающие "бутылочные горлышки":
🟠Apache JMeter
Симулирует многопоточную нагрузку на базу данных.
🟠Gatling
Анализирует производительность системы под высокой нагрузкой.

🚩Анализ трассировки запросов

Включите трассировку (например, в MySQL — SHOW PROFILE):

SET profiling = 1;
SELECT * FROM orders WHERE status = 'pending';
SHOW PROFILE FOR QUERY 1;

Ставь 👍 и забирай 📚 Базу знаний

🤔 Принципы Agile-манифеста?

Это ключевой документ, который описывает подходы к гибкой разработке программного обеспечения. Он основан на 4 базовых ценностях и подкрепляется 12 принципами, которые помогают командам адаптироваться к изменениям, эффективно взаимодействовать и выпускать работающий продукт.

🚩4 ценности Agile

🟠Люди и взаимодействие важнее процессов и инструментов
Это подчёркивает, что успех проекта зависит от командной работы и коммуникации, а не от формальностей и процедур.

🟠Работающий продукт важнее исчерпывающей документации
Фокус на создании ценного результата, а не на написании огромного количества документации.

🟠Сотрудничество с заказчиком важнее согласования условий контракта
Постоянное взаимодействие с клиентом помогает лучше понять его потребности и вовремя внести изменения.

🟠Готовность к изменениям важнее следования первоначальному плану
Agile приветствует изменения, даже на поздних этапах разработки, чтобы продукт соответствовал текущим требованиям.

🚩12 принципов Agile-манифеста

🟠Приоритет — удовлетворение заказчика за счёт раннего и непрерывного предоставления ценного программного обеспечения
Команда должна выпускать работающий продукт регулярно, начиная с ранних этапов проекта.

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

🟠Частая поставка работающего программного обеспечения (раз в несколько недель или месяцев)
Это позволяет заказчику видеть прогресс и получать ценность на протяжении всего проекта.

🟠Плотное ежедневное взаимодействие разработчиков и бизнес-представителей
Это обеспечивает лучшее понимание задач и ускоряет принятие решений.

🟠Строить проекты вокруг мотивированных людей
Доверие, поддержка и автономия способствуют эффективной работе команды.

🟠Наиболее эффективный способ передачи информации — личное общение
Несмотря на технологии, живое взаимодействие остаётся наиболее продуктивным.

🟠Работающее программное обеспечение — основной показатель прогресса
Конечный результат важнее количества завершённых задач.

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

🟠Постоянное внимание к техническому совершенству и качеству проектирования
Это снижает технический долг и упрощает внесение изменений.

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

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

🟠Регулярная адаптация к изменениям через осмысление прошедших этапов
Ретроспективы помогают команде улучшать процессы и избегать повторения ошибок.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Из чего состоит ответ на сервере?

Ответ сервера состоит из статусного кода, заголовков и тела. Статусный код сообщает результат обработки запроса (успех, ошибка и т. д.). Заголовки содержат метаданные, а тело передает данные.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему синглтон может быть антипаттерном?

Это паттерн проектирования, который ограничивает создание объекта определённого класса только одним экземпляром и предоставляет глобальную точку доступа к нему. Хотя он полезен для некоторых случаев (например, управление конфигурацией или доступ к ресурсам), его использование может привести к серьёзным проблемам, из-за которых синглтон часто рассматривается как антипаттерн.

🚩Проблемы с синглтоном

🟠 Нарушение принципов ООП
Синглтон нарушает принципы единственной ответственности (SRP) и инверсии зависимостей (DIP):
Он выполняет две задачи: управляет своим жизненным циклом (ограничивает создание экземпляров) и предоставляет бизнес-логику.
Жёсткая связь с синглтоном делает код трудно тестируемым и менее гибким.

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

🟠Трудности с тестированием
Подменить синглтон в тестах сложно, так как он контролирует свой жизненный цикл. Это затрудняет использование мок-объектов.
Многоразовые тесты могут зависеть от состояния синглтона, что делает тесты нестабильными.

🟠Проблемы с многопоточностью
Если реализация синглтона не потокобезопасна, это может привести к:
Состояниям гонки при создании экземпляра.
Непредсказуемому поведению в многопоточных приложениях.

🟠Нарушение принципа открытости/закрытости (OCP)
Синглтон делает класс жёстко связанным со своей реализацией, что затрудняет расширение или изменение поведения. Например, нельзя легко заменить синглтон другой реализацией без изменения клиентского кода.

🟠Затруднения при модульном тестировании
Использование синглтона в нескольких местах увеличивает сложность изоляции компонентов. Выстраивать модульные тесты становится трудно, так как синглтон сохраняет состояние между вызовами.

🟠Проблемы в распределённых системах
В распределённых приложениях синглтон не гарантирует, что существует только один экземпляр объекта на всех узлах системы. Это требует дополнительных механизмов синхронизации.

🟠Склонность к неправильному использованию
Синглтон часто используется там, где можно обойтись другими механизмами (например, Dependency Injection). Это приводит к избыточной сложности и трудностям в поддержке.

🚩Примеры ситуаций, где синглтон становится проблемой

🟠Жёсткое связывание логики
Если объект доступа к базе данных реализован как синглтон, его сложно заменить другим объектом для тестирования.

🟠Изменения состояния
Если синглтон хранит состояние, это состояние может быть изменено одним компонентом, что приведёт к ошибкам в других частях программы.

🟠Непотокобезопасная реализация
В отсутствии надёжного механизма синхронизации попытки создать объект в многопоточном окружении могут вызвать дублирование.

🚩Как избежать проблем с синглтоном?

🟠Dependency Injection (DI)
Вместо синглтона передавайте зависимости через конструкторы или специальные контейнеры. Это упрощает тестирование и уменьшает связность.
🟠Использование слабых ссылок или провайдеров
Используйте шаблоны, которые позволяют создавать объекты по мере необходимости, избегая их глобальности.
🟠Паттерн "Одиночка с явной передачей"
Позвольте клиентам явно передавать экземпляры через методы, вместо использования глобального доступа.
🟠Сосредоточьтесь на композиции
Разделите логику синглтона на несколько отдельных классов, каждый из которых отвечает за одну задачу.

Ставь 👍 и забирай 📚 Базу знаний