Матрица компетенций для IT специалиста

Матрица пользователя : Марат

  • Заполненных тем 6
  • Заполненных навыков 16
  • Paradigms Logs SDLC Auth SOLID API
  • 467
  • 2024-10-14 22:43:46
  • Предыдущий триал 930
  • YAGNI
    • Знаю: Знаю что это, читал/изучал.

    AGNI («You aren't gonna need it»; с англ. — «Вам это не понадобится») — процесс и принцип проектирования ПО, при котором в качестве основной цели и/или ценности декларируется отказ от избыточной функциональности, — то есть отказ добавления функциональности, в которой нет непосредственной надобности.

    Согласно адептам принципа YAGNI, желание писать код, который не нужен прямо сейчас, но может понадобиться в будущем, приводит к следующим нежелательным последствиям:

    Тратится время, которое было бы затрачено на добавление, тестирование и улучшение необходимой функциональности.
Новые функции должны быть отлажены, документированы и сопровождаться.
Новая функциональность ограничивает то, что может быть сделано в будущем, — ненужные новые функции могут впоследствии помешать добавить новые нужные.
Пока новые функции действительно не нужны, трудно полностью предугадать, что они должны делать, и протестировать их. Если новые функции тщательно не протестированы, они могут неправильно работать, когда впоследствии понадобятся.
Это приводит к тому, что программное обеспечение становится более сложным (подчас чрезмерно сложным).
Если вся функциональность не документирована, она может так и остаться неизвестной пользователям, но может создать различные риски для безопасности пользовательской системы.
Добавление новой функциональности может привести к желанию ещё более новой функциональности, приводя к эффекту «снежного кома».

    https://ru.wikipedia.org/wiki/YAGNI

  • TDD
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Разработка через тестирование (англ. test-driven development, TDD) — техника разработки программного обеспечения, которая основывается на повторении очень коротких циклов разработки: сначала пишется тест, покрывающий желаемое изменение, затем пишется код, который позволит пройти тест, и под конец проводится рефакторинг нового кода к соответствующим стандартам. Кент Бек, считающийся изобретателем этой техники, утверждал в 2003 году, что разработка через тестирование поощряет простой дизайн и внушает уверенность (англ. inspires confidence).

    Преимущества

    Исследование 2005 года показало, что использование разработки через тестирование предполагает написание большего количества тестов, в свою очередь, программисты, пишущие больше тестов, склонны быть более продуктивными.[5] Гипотезы, связывающие качество кода с TDD, были неубедительны.[6]

    Программисты, использующие TDD на новых проектах, отмечают, что они реже ощущают необходимость использовать отладчик. Если некоторые из тестов неожиданно перестают проходить, откат к последней версии, которая проходит все тесты, может быть более продуктивным, нежели отладка.[7]

    Разработка через тестирование предлагает больше, чем просто проверку корректности, она также влияет на дизайн программы. Изначально сфокусировавшись на тестах, проще представить, какая функциональность необходима пользователю. Таким образом, разработчик продумывает детали интерфейса до реализации. Тесты заставляют делать свой код более приспособленным для тестирования. Например, отказываться от глобальных переменных, одиночек (singletons), делать классы менее связанными и легкими для использования. Сильно связанный код или код, который требует сложной инициализации, будет значительно труднее протестировать. Модульное тестирование способствует формированию четких и небольших интерфейсов. Каждый класс будет выполнять определенную роль, как правило, небольшую. Как следствие, зацепление между классами будут снижаться, а связность повышаться. Контрактное программирование (англ. design by contract) дополняет тестирование, формируя необходимые требования через утверждения (англ. assertions).

    Несмотря на то, что при разработке через тестирование требуется написать большее количество кода, общее время, затраченное на разработку, обычно оказывается меньше. Тесты защищают от ошибок. Поэтому время, затрачиваемое на отладку, снижается многократно.[8] Большое количество тестов помогает уменьшить количество ошибок в коде. Устранение дефектов на более раннем этапе разработки, препятствует появлению хронических и дорогостоящих ошибок, приводящих к длительной и утомительной отладке в дальнейшем.

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

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

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

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

    Слабые места

    Существуют задачи, которые невозможно (по крайней мере, на текущий момент) решить только при помощи тестов. В частности, TDD не позволяет механически продемонстрировать адекватность разработанного кода в области безопасности данных и взаимодействия между процессами. Безусловно, безопасность основана на коде, в котором не должно быть дефектов, однако она основана также на участии человека в процедурах защиты данных. Тонкие проблемы, возникающие в области взаимодействия между процессами, невозможно с уверенностью воспроизвести, просто запустив некоторый код.
Разработку через тестирование сложно применять в тех случаях, когда для тестирования необходимо прохождение функциональных тестов. Примерами может быть: разработка интерфейсов пользователя, программ, работающих с базами данных, а также того, что зависит от специфической конфигурации сети. Разработка через тестирование не предполагает большого объёма работы по тестированию такого рода вещей. Она сосредотачивается на тестировании отдельно взятых модулей, используя mock-объекты для представления внешнего мира.
Требуется больше времени на разработку и поддержку, а одобрение со стороны руководства очень важно. Если у организации нет уверенности в том, что разработка через тестирование улучшит качество продукта, то время, потраченное на написание тестов, может рассматриваться как потраченное впустую.[9]
Модульные тесты, создаваемые при разработке через тестирование, обычно пишутся теми же, кто пишет тестируемый код. Если разработчик неправильно истолковал требования к приложению, и тест, и тестируемый модуль будут содержать ошибку.
Большое количество используемых тестов может создать ложное ощущение надежности, приводящее к меньшему количеству действий по контролю качества.
Тесты сами по себе являются источником накладных расходов. Плохо написанные тесты, например, содержат жёстко вшитые строки с сообщениями об ошибках или подвержены ошибкам, дороги при поддержке. Чтобы упростить поддержку тестов, следует повторно использовать сообщения об ошибках из тестируемого кода.
Уровень покрытия тестами, получаемый в результате разработки через тестирование, не может быть легко получен впоследствии. Исходные тесты становятся всё более ценными с течением времени. Если неудачные архитектура, дизайн или стратегия тестирования приводят к большому количеству непройденных тестов, важно их все исправить в индивидуальном порядке. Простое удаление, отключение или поспешное изменение их может привести к необнаруживаемым пробелам в покрытии тестами.

    Видимость кода

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

    Из кода теста может не быть доступа к приватным (англ. private) полям и методам. Поэтому при модульном тестировании может потребоваться дополнительная работа. В Java разработчик может использовать отражение (англ. reflection), чтобы обращаться к полям, помеченными как приватные.[10] Модульные тесты можно реализовать во внутренних классах, чтобы они имели доступ к членам внешнего класса. В .NET Framework могут применяться разделяемые классы (англ. partial classes) для доступа из теста к приватным полям и методам.

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

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

    Fake-, mock-объекты и интеграционные тесты

    Модульные тесты тестируют каждый модуль по отдельности. Неважно, содержит ли модуль сотни тестов или только пять. Тесты, используемые при разработке через тестирование, не должны пересекать границы процесса, использовать сетевые соединения. В противном случае прохождение тестов будет занимать большое время, и разработчики будут реже запускать набор тестов целиком. Введение зависимости от внешних модулей или данных также превращает модульные тесты в интеграционные. При этом если один модуль в цепочке ведет себя неправильно, может быть не сразу понятно какой именно[источник не указан 4378 дней].

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

    Везде, где требуется доступ к внешним ресурсам, должен быть объявлен интерфейс, через который этот доступ будет осуществляться. См. принцип инверсии зависимостей (англ. dependency inversion) для обсуждения преимуществ этого подхода независимо от TDD.
Интерфейс должен иметь две реализации. Первая, собственно предоставляющая доступ к ресурсу, и вторая, являющаяся fake- или mock-объектом. Всё, что делают fake-объекты, это добавляют сообщения вида «Объект person сохранен» в лог, чтобы потом проверить правильность поведения. Mock-объекты отличаются от fake- тем, что сами содержат утверждения (англ. assertion), проверяющие поведение тестируемого кода. Методы fake- и mock-объектов, возвращающие данные, можно настроить так, чтобы они возвращали при тестировании одни и те же правдоподобные данные. Они могут эмулировать ошибки так, чтобы код обработки ошибок мог быть тщательно протестирован. Другими примерами fake-служб, полезными при разработке через тестирование, могут быть: служба кодирования, которая не кодирует данные, генератор случайных чисел, который всегда выдает единицу. Fake- или mock-реализации являются примерами внедрения зависимости (англ. dependency injection).

    Использование fake- и mock-объектов для представления внешнего мира приводит к тому, что настоящая база данных и другой внешний код не будут протестированы в результате процесса разработки через тестирование. Чтобы избежать ошибок, необходимы тесты реальных реализаций интерфейсов, описанных выше. Эти тесты могут быть отделены от остальных модульных тестов и реально являются интеграционными тестами. Их необходимо меньше, чем модульных, и они могут запускаться реже. Тем не менее, чаще всего они реализуются используя те же библиотеки для тестирования (англ. testing framework), что и модульные тесты.

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

    Метод TearDown, присутствующий в большинстве библиотек для тестирования.
try...catch...finally структуры обработки исключений, там где они доступны.
Транзакции баз данных.
Создание снимка (англ. snapshot) базы данных перед запуском тестов и откат к нему после окончания тестирования.
Сброс базы данных в чистое состояние перед тестом, а не после них. Это может быть удобно, если интересно посмотреть состояние базы данных, оставшееся после не прошедшего теста.

    Существуют библиотеки Moq, jMock, NMock, EasyMock, Typemock, jMockit, Unitils, Mockito, Mockachino, PowerMock или Rhino Mocks, а также sinon для JavaScript предназначенные упростить процесс создания mock-объектов.

    https://ru.wikipedia.org/wiki/Разработка_через_тестирование

  • DDD
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Предметно-ориентированное проектирование (реже проблемно-ориентированное, англ. domain-driven design, DDD) — набор принципов и схем, направленных на создание оптимальных систем объектов. Сводится к созданию программных абстракций, которые называются моделями предметных областей. В эти модели входит бизнес-логика, устанавливающая связь между реальными условиями области применения продукта и кодом.

    Предметно-ориентированное проектирование не является какой-либо конкретной технологией или методологией. DDD — это набор правил, которые позволяют принимать правильные проектные решения. Данный подход позволяет значительно ускорить процесс проектирования программного обеспечения в незнакомой предметной области.

    Основные определения

    Область (англ. domain) — предметная область, для которой разрабатывается программное обеспечение.
Модель (англ. model) — описывает отдельные аспекты области и может быть использована для решения проблемы.
Язык описания — используется для единого стиля описания домена и модели.

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

    Данный термин был впервые введен Э. Эвансом в его книге с таким же названием «Domain-Driven Design»

    Элементы DDD

    При проектировании на основе предметно-ориентированного подхода используются следующие понятия: Ограниченный контекст

    В большинстве систем для предприятий используются крупномасштабные зоны ответственности. В DDD этот высший уровень организации называется ограниченным контекстом. Например, система биллинга крупной телекоммуникационной компании может иметь следующие ключевые элементы:

    клиентская база
система безопасности и защиты
резервное копирование
взаимодействие с платежными системами
ведение отчётности
администрирование
система уведомлений

    Все перечисленные элементы должны быть включены в единую, работающую без перебоев систему. При проектировании система уведомлений и система безопасности выделяются как совершенно разные вещи. Системы, в которых при реализации не удаётся разделить и изолировать ограниченные контексты, часто приобретают архитектурный стиль, который имеет красноречивое название «Большой ком грязи» в 1999 г. Брайан Фут (Brian Foot) и Йозеф Йодер (Joseph Yoder).[2]

    Сутью предметно-ориентированного проектирования является конкретное определение контекстов и ограничение моделирования в их рамках. Сущность

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

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

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

    Иногда в предметной области есть операции или процессы, у которых нет обозначения или жизненного цикла. Службы области дают инструмент для моделирования этих концепций. Они характеризуются отсутствием состояния и высокой связностью, часто предоставляя один открытый метод и иногда перегрузку для действий над наборами. Если в поведение включено несколько зависимостей, и нет возможности найти подходящего места в сущности для размещения этого поведения, в этом случае используют службу. Хотя сам по себе термин «служба» в мире разработки перегружен различными значениями, но в данной тематике, это обозначает небольшой класс, не представляющий конкретного человека, место или вещь в проектируемом приложении, но включающий в себя какие-то процессы. Использование служб позволяет ввести многослойную архитектуру, так же интегрировать несколько моделей, что вносит зависимость от инфраструктуры.

    https://ru.wikipedia.org/wiki/Предметно-ориентированное_проектирование

  • MDD
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Разработка, управляемая моделями

    Разработка, управляемая моделями, (англ. model-driven development) — это стиль разработки программного обеспечения, когда модели становятся основными артефактами разработки, из которых генерируется код и другие артефакты[1].

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

    Модели описанные на предметно-ориентированном языке программирования могут быть использованы, как точки расширения каркасов.

    Источник https://ru.wikipedia.org/wiki/Разработка,_управляемая_моделями

  • GRASP
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Каталог шаблонов

    1. Информационный эксперт (Information Expert)

    2. Создатель (Creator)

    3. Контроллер (Controller)

    4. Слабое (низкое) зацепление (Low Coupling)

    5. Сильная (высокая) связность (High Cohesion)

    6. Полиморфизм (Polymorphism)

    7. Чистая выдумка (Pure Fabrication)

    8. Перенаправление (Indirection)

    9. Устойчивость к изменениям (Protected Variations)

    10. Информационный эксперт (Information Expert)

    Шаблон определяет базовый принцип распределения ответственностей. Обязанности должны быть назначены объекту, который владеет максимумом необходимой информации для выполнения обязанности. Такой объект называется информационным экспертом.

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

    Локализация же ответственностей, проводимая согласно шаблону:

    Повышает:
    Инкапсуляцию;
    Простоту восприятия;
    Готовность компонентов к повторному использованию;
Снижает:
    степень зацепления.
    1. Создатель (Creator)

    Проблема: Кто отвечает за создание объекта некоторого класса A?

    Решение: Назначить классу B обязанность создавать объекты класса A, если класс B:

    содержит(contains) или агрегирует(aggregate) объекты A;
записывает(records) объекты A;
активно использует объекты A;
обладает данными для инициализации объектов A

    Можно сказать, что шаблон «Creator» — это интерпретация шаблона «Information Expert» (смотрите пункт № 1) в контексте создания объектов.

    Большинство порождающих шаблонов проектирования так или иначе выводятся или опираются на шаблон «Creator».

    1. Контроллер (Controller)

      Отвечает за операции, запросы которых приходят от пользователя, и может выполнять сценарии одного или нескольких вариантов использования (например, создание и удаление); Не выполняет работу самостоятельно, а делегирует компетентным исполнителям; Может представлять собой: Систему в целом; Подсистему; Корневой объект; Устройство.

    2. Слабое (низкое) зацепление (Low Coupling) Основная статья: Зацепление (программирование)

    Зацепление — мера того, насколько взаимозависимы разные подпрограммы или модули[2].

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

    1. Сильная (высокая) связность (High Cohesion) Основная статья: Связность (программирование)

    Связность — мера силы взаимосвязанности элементов внутри модуля; способ и степень, в которой задачи, выполняемые некоторым программным модулем, связаны друг с другом[2].

    Сильная связность класса / модуля означает, что его элементы тесно связаны и сфокусированы.

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

    1. Полиморфизм (Polymorphism) См. также: Полиморфизм (информатика)

    Устройство и поведение системы:

    Определяется данными;
Задано полиморфными операциями её интерфейса.

    Пример: Адаптация коммерческой системы к многообразию систем учёта налогов может быть обеспечена через внешний интерфейс объектов-адаптеров (см. также: Шаблон «Адаптеры»).

    1. Чистая выдумка (Pure Fabrication)

    Не относится к предметной области, но:

    Уменьшает зацепление;
Повышает связность;
Упрощает повторное использование.

    «Pure Fabrication» отражает концепцию сервисов в модели предметно-ориентированного проектирования.

    Пример задачи: Не используя средства класса «А», внести его объекты в базу данных.

    Решение: Создать класс «Б» для записи объектов класса «А» (см. также: «Data Access Object»).

    1. Перенаправление (Indirection) См. также: Посредник (шаблон проектирования)

    Слабое зацепление между элементами системы (и возможность повторного использования) обеспечивается назначением промежуточного объекта их посредником.

    Пример: В архитектуре Model-View-Controller, контроллер (англ. controller) ослабляет зацепление данных (англ. model) с их представлением (англ. view).

    1. Устойчивость к изменениям (Protected Variations) Шаблон защищает элементы от изменения другими элементами (объектами или подсистемами) с помощью вынесения взаимодействия в фиксированный интерфейс, через который (и только через который) возможно взаимодействие между элементами. Поведение может варьироваться лишь через создание другой реализации интерфейса.

    https://ru.wikipedia.org/wiki/GRASP https://habr.com/ru/articles/92570/

  • Императивное программирование
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Императи́вное программи́рование — парадигма программирования (стиль написания исходного кода компьютерной программы), для которой характерно следующее:

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

    https://ru.wikipedia.org/wiki/Императивное_программирование

  • Функциональное программирование
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Функциона́льное программи́рование — парадигма программирования, в которой процесс вычисления трактуется как вычисление значений функций в математическом понимании последних (в отличие от функций как подпрограмм в процедурном программировании).

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

    https://ru.wikipedia.org/wiki/Функциональное_программирование

  • Структурное программирование
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

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

    https://ru.wikipedia.org/wiki/Структурное_программирование

  • Закон Деметры
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    https://ru.wikipedia.org/wiki/Закон_Деметры

  • Принципы ООП
    • Джун: Может объяснить базовые принципы.
    • Мидл: Разбирается в принципах ООП.
    • Синьор: Может на лафкодинге показать пример принципов ООП.

    Принципы:

    • Абстракция
    • Инкапсуляция
    • Наследование (Делегация, Композиция, Агрегация)
    • Полиморфизм

    Знания на сеньора:

    • Динамическое связывание методов
    • Динамическое создание и уничтожение объектов
    • Значительная глубина абстракции
    • Наследование «размывает» код
    • Инкапсуляция снижает скорость доступа к данным

    https://ru.wikipedia.org/wiki/Объектно-ориентированное_программирование

  • SOLID - S
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Знаю - знаю определение Понимаю - привести пример и досконально объяснить суть.

    https://ru.wikipedia.org/wiki/Принцип_единственной_ответственности

  • SOLID - O
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    https://ru.wikipedia.org/wiki/Принцип_открытости/закрытости

  • Канбан
    • Знаю: Знаю что это, читал/изучал.
    • Понимаю: Понимаю (знаю достоинства и недостатки) и был опыт применения.

    Канбан (от яп. 看板 «рекламный щит, вывеска») — метод управления разработкой, реализующий принцип «точно в срок» и способствующий равномерному распределению нагрузки между работниками. При данном подходе весь процесс разработки прозрачен для всех членов команды. Задачи по мере поступления заносятся в отдельный список, откуда каждый разработчик может извлечь требуемую задачу.

    https://ru.wikipedia.org/wiki/Канбан_(разработка)

  • Graylog
    • Джун: Начальные/Поверхностные знания.
    • Мидл: Средние знания. Можете объяснить суть и есть опыт применения..
    • Сеньор: Продвинутые знания. Можете показать на примере, знаете нюансы и можете научить.

    https://go2docs.graylog.org/current/home.htm