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

	A	B	C	D	E	F	G	H
1		Скил	Начинающий		Средний уровень		Профессионал
2		Скил	А1	А2	B1	B2	C1	C2

3	кодинг	Написание кода	Без посторонней помощи могу написать реализацию простой функции, для которой есть подробная спецификация поведения и интерфейса.	Без посторонней помощи могу определить подходящий интерфейс для простой функции, для которой есть хоть какая-то спецификация. Могу декомпозировать спецификацию сложной функции на более простые функции.	Могу оценить требуемые ресурсы на выполнение моего кода. С помощью чётко определённых метрик, включая время выполнения и объём памяти, могу эмпирически сравнить различие в реализации нескольких спецификаций одной и той же функции. В своём коде использую предусловия, сравнения и постусловия. В процессе разработки использую моки, чтобы добиться гибкости процесса реализации.	Я осознанно и эффективно использую типизирование и интерфейсы, чтобы планировать свою работу. Если мне дать подробные спецификации, то я могу спроектировать и реализовать целые сервисы самостоятельно. Я систематически пытаюсь рефакторить функции, чтобы повысить их переиспользуемость.	Я могу систематически выявлять неконсистентные и противоречивые требования в спецификациях. Я могу декомпозировать сложную архитектуру системы на более мелкие компоненты, которые могут быть независимо реализованы, в том числе другими людьми. Я умею использовать существующие DSL и паттерны метапрограммирования, чтобы улулчшить свою эффективность.	Я с уверенностью могу распознать ситуации, когда занижение спецификаций является преднамеренным или нет. Я могу использовать занижение спецификаций, чтобы увеличить свою эффективность. Я умею создавать новые DSL или новые паттерны метапрограммирования, чтобы повышать свою эффективность и эффективность других разработчиков.
4		Рефакторинг	Если я знаю, что изменение инкрементальное, то я могу адаптировать свой код под изменившиеся требования, не переписывая код полностью. Я могу рефакторить свой код по подробным инструкциям от более опытных разработчиков.	Я могу самостоятельно определить является ли изменение спецификаций инкрементальным или потребует большого рефакторинга. Я могу рефакторить свой код даже по беглым наброскам более опытных разработчиков.	В случае небольших изменений требований, я могу самостоятельно разработать стратегию рефакторинга своего кода. Я могу рефакторить чужой код, если человек, знакомый с кодом, предоставляет точные инструкции.	Я довольно точно могу определить требуемые ресурсы на рефакторинг своего кода в случае изменения требований. Я могу рефакторить чужой код по чужой стратегии рефакторинга. Я с полной ответственностью могу интегрировать патч другого разработчика в свой код.	С помощью предыдущих требований я могу провести реверс-инженеринг чужой кодовой базы и довольно точно оценить требуемые усилия для рефакторинга кода по новым спецификациям.	Даже без исходных требований я могу провести реверс-инженеринг чужого кода и довольно точно определить требуемые усилия для реализации новых спецификаций.
5		Интеграция кода	Я знаю входные и выходные точки своего кода. Я могу использовать базовые каналы ввода-вывода известного мне языка чтобы вывести простой текст и числа.	Я знаю рекомендуемые механизмы приёма аргументов программы из окружения и ошибок. Я использую эти механизмы в своём коде.	Я умею делегировать функции внешнему процессу. Я знаю как эффективно использовать потоки и буферы для работы с большими наборами данных и использую эти инструменты в своей работе. Я знаком с понятием локальности (скоупы) и использую его для адаптации своего кода.	Я знаком хотя бы с одним API двунаправленного взаимодействия между процессами. Я могу писать клиентский код для простых интернет протоколов. Я знаком с самой распространённой системой пакетов и дистрибуции этих пакетов в рамках хотя бы одной платформы и использую их. Я умею использовать предопределённые паттерны программирования чтобы эффективно использовать средства параллелизации платформы.	Я умею реализовывать и клиентскую, и серверную часть приложения по спецификациям произвольного протокола. Я довольно точно могу определить оверхед по производительности и затрачиваемым ресурсам разных механизмов взаимодействия (например, системные вызовы, сокеты и т.п.). Я знаком с аппаратной архитектурой и могу предсказать как поведёт себя последовательность выполнения программ в случае изменения железа. Я могу оценить масштабируемость фрагментов кода по данной платформе.	Я знаком с большинством архитектур ПО. Я умею работать в паре с системным архитектором, чтобы оптимизировать мой собственный код в соответствии с общей архитектурой системы. Я знаю большинство плюсов и минусов систем, в рамках которых я разрабатываю приложения.
6	понимание	Переиспользование кода	Я умею приводить код в консистентное состояние, путём переименования переменных в рамках составления приложения из фрагментов функционала.	Я могу эффективно использовать библиотеку, если по ней имеется подробная документация.	Я могу распознать ситуации, в которых для существующего кода требуется использование общей архитектуры (например, event-loop). Я умею писать код так, чтобы в нём можно было использовать несколько разных библиотек.	В большой кодовой базе я могу выявить и вытащить фрагменты, которые можно переиспользовать, даже если автор не предполагал переиспользования этих фрагментов. Я умею создавать пакеты/библиотеки и распространять их между другими разработчиками. Я могу написать интерфейс для кода без состояния (stateless code) на разных языках.	Я могу систематически устранять ограничения кода, которые не предусмотрены требованиями, чтобы повысить его переиспользуемость. Я могу читать и понимать код, который использует самые распространённые API в рамках моей текущей платформы, даже если для этих API нет документации. Я могу написать чистый семантичный интерфейс для кода на разных языках программирования.	Я могу исследовать и грамотно использовать недокументированные возможности кода на языке, который я понимаю, даже если этот код писал не я.
7	понимание	Объяснение/обсуждение кода	Я могу прочитать свой собственный код и объяснить, чего я хотел добиться, более опытному разработчику.	Я могу прочитать код кого-то моего уровня или ниже и объяснить его. Я могу определить простые расхождения реализации и требований в своём коде или коде кого-то моего уровня или ниже.	Я могу объяснить фрагменты кода, написанные в императивном или декларативном стиле, кому-нибудь, кто знает другой язык программирования, где приемлем такой же стиль. При этом, этот человек сможет воспроизвести ту же функциональность в своём языке.	Без предоставления своего кода, я могу объяснить используемые мной структуры данных, алгоритмы и паттерны проектирования кому-то другому, используя стандартную терминологию.	Я могу оценить уровень экспертизы моей аудитории и подстроиться под него соответствующим образом. Я могу понять, когда объяснение либо чрезмерно детализировано, либо чрезмерно усложнено для текущей аудитори и могу дать грамотную обратную связь в связи с этим.	Я без всяких проблем могу принять участие в обсуждении языка (языков), который я использую и с идиоматическими коснтрукциями которого знаком. Я легко могу написать импровизированный корректный код для объяснения обсуждаемых концепций.
8	взаимодействие	Изучение, самообучение	Я могу отличить командную строку от запроса аргументов программой. Без посторонней помощи я могу изучать тему по гайдам и получать ожидаемый эффект. Я умею искать информацию по сообщениям ошибок и адаптировать опыт других разработчиков под свои нужды.	Я могу отличить базовые возможности языка от специфических фич конкретной реализации языка. Я могу понять смысл сообщений об ошибках без посторонней помощи.	При необходимости я могу обратиться к документации по языку или API, который использую, чтобы уточнить понимание различных фрагментов кода. Я понимаю общие концепции статей и докладов экспертов. Я могу отследить и определить кто несёт ответственность за различныеые фрагменты кода системы, которую я использую, либо для которой пишу код.	Без документации я могу определить абстрактную модель API и написать небольшие тесты, чтобы проверить её. Я могу определить что документация по языку или API не полная, либо противоречит реализации.	Я способен читать и понимать большинство профессиональной литературы по языкам, которые использую. Я способен определить, что академическая концепция, инновация применима в моём случае и способен адаптировать её для своих проектов.	Я способен улавливать смысл между строк в профессиональной профильной литературе. Даже без непосредственного тестирования я способен определить ситуации, в которых суть или описание разработки не решает поставленную задачу или делает это неверно..
9		Бытовое мастерство	Чтобы тестировать и запускать программы я способен следовать базовым пошаговым инструкциям с базовым окружением.	Я могу настроить своё окружение так, чтобы автоматизировать большую часть моей рутины. Чтобы отслеживать свой прогресс и откатываться от неудачных изменений я использую систему контроля версий.	Чтобы избежать лишних проблем в своём цикле разработки, я использую трекер зависимостей. Для различных задач разработки я использую разные ветки в системе контроля версий.	В зависимости от различных целей я могу использовать различные подходы к разработке, выбирая между ценой оверхеда исходной настройки и оверхеда дальнейшей поддержки. С минимальными усилиями я могу вносить измменения в код в чужом окружении.	Я вношу изменения в своё окружение и могу понять, как они отражаются на моей эффективности. Я могу эффективно использовать предпочтительные окружения не менее 80% разработчиков моего уровня или ниже.	Я могу довольно точно определить связность других разработчиков с их окружениями. Пользу от моих реркомендаций по улучшению окружений других разработчиков, с которыми я работаю, нацеленными на повышение эффективности можно легко измерить.
10		Решение проблем	Я легко определяю корректный и неверный вывод моих программ. Я знаком с этикетом задавания вопросов экспертам.	Я уверенно различаю неверный вывод из-за неверного ввода и некорректный вывод из-за ошибки программы. В сложной программе я могу определить источник проблемы, сведя его до модуля или функции. Я могу определить и исправить Борбаги (ошибки, которые не меняют свои свойства при попытках их обнаружения - противополжность гайзенбагам) в своём коде.	Я могу перевести человеческие знания или требования в условия или ограничения типов в своём коде. Я умею отлаживать состояние программы в рамках выполнения, чтобы проверить соответствие требуемым значениям. Везде, где уместно, я пишу юнит-тесты.	Я могу эмулировать простейшую программу, воспроизводящую ошибку исходного приложения. У меня есть несколько рабочих стратегий поиска и устранения гайзенбагов (ошибки, которые меняют свои свойства при попытках их обнаружения - противоположность борбагам) в коде, который я понимаю. Я пишу регрессионные тесты на код, с которым непосредственно работаю.	Я могу разработать стратегию по выявлению и исправлению мандельбагов (ошибки, которые настолько сложные, что кажутся хаотичными, Мандельброт - основоположник фрактальной геометрии) в коде, который понимаю. Я способен определить аппаратную ошибку в системе, которая преимущественно управляется приложением, которое спроектировал я.	Я могу выяснить и точно определить что является причиной большинства неожиданного/нежелательного поведения в системах, в разработке которых я участвую. Я способен отследить и точно определить аппаратные ошибки в системах, где у меня есть доступ ко всем исходникам ПО.
11
12			Это перевод матрицы https://dr-knz.net/programming-levels/prog-skill-matrix.pdf
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100