https://github.com/bepb/programmer_competency_matrix
https://github.com/bepb/programmer_competency_matrix
Last synced: 5 months ago
JSON representation
- Host: GitHub
- URL: https://github.com/bepb/programmer_competency_matrix
- Owner: BEPb
- License: mit
- Created: 2023-03-13T08:16:14.000Z (over 3 years ago)
- Default Branch: master
- Last Pushed: 2023-03-19T18:52:06.000Z (over 3 years ago)
- Last Synced: 2025-02-17T10:48:58.105Z (over 1 year ago)
- Size: 383 KB
- Stars: 29
- Watchers: 2
- Forks: 2
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Programmer Competency Matrix
Read in other languages: [Русский](README.ru.md)
## Hi all.
Today is March 13, 2023, and it just so happens that for more than 3 years I have been actively studying python
programming as well as data science. The contract ends in half a year and I decided that it was time to change
activities from a radio engineer to a machine learning specialist. But how to evaluate myself, how to show the
future employer what I know, how I can develop??? Divide and rule (lat. divide et impera) - says the maxim of the
Roman Senate, let's approach the answer to the question asked systematically. Let's separate all the components of
my specialist knowledge and evaluate them using the competence matrix.
Of course, I didn’t reinvent the wheel and took a ready-made matrix (the most common version was proposed by Sijin
Joseph [here](https://sijinjoseph.netlify.app/programmer-competency-matrix/)) and honestly answered these questions,
the answer was diligently put into separate files.
#### in progress...
Computer Science
in progress...
- [ ] **Data structures**
- [x] Level 0 - Doesn’t know the difference between Array and LinkedList
- [x] Level 1 - Able to explain and use Arrays, LinkedLists, Dictionaries etc in practical programming tasks
- [x] Level 2 - Knows space and time tradeoffs of the basic data structures, Arrays vs LinkedLists, Able to explain
how hashtables can be implemented and can handle collisions, Priority queues and ways to implement them etc.
- [x] Level 3 - Knowledge of advanced data structures like B-trees, binomial and fibonacci heaps, AVL/Red Black trees,
Splay Trees, Skip Lists, tries etc.
- [ ] **Algorithms**
- [x] Level 0 - Unable to find the average of numbers in an array (It’s hard to believe but I’ve interviewed such candidates)
- [x] Level 1 - Basic sorting, searching and data structure traversal and retrieval algorithms
- [x] Level 2 - Tree, Graph, simple greedy and divide and conquer algorithms, is able to understand the
relevance of the levels of this matrix.
- [ ] Level 3 - Able to recognize and code dynamic programming solutions, good knowledge of graph algorithms,
good knowledge of numerical computation algorithms, able to identify NP problems etc.
- [ ] **Systems programming**
- [x] Level 0 - Doesn’t know what a compiler, linker or interpreter is
- [x] Level 1 - Basic understanding of compilers, linker and interpreters. Understands what assembly code is and
how things work at the hardware level. Some knowledge of virtual memory and paging.
- [ ] Level 2 - Understands kernel mode vs. user mode, multi-threading, synchronization primitives and how they’re
implemented, able to read assembly code. Understands how networks work, understanding of network protocols and
socket level programming.
- [ ] Level 3 - Understands the entire programming stack, hardware (CPU + Memory + Cache +
Interrupts + microcode), binary code, assembly, static and dynamic linking, compilation, interpretation, JIT
compilation, garbage collection, heap, stack, memory addressing…
Software Engineering
in progress...
- [ ] **Source code version control**
- [x] Level 0 - Folder backups by date
- [x] Level 1 - VSS and beginning CVS/SVN user
- [x] Level 2 - Proficient in using CVS and SVN features. Knows how to branch and merge, use patches setup repository
properties etc.
- [ ] Level 3 - Knowledge of distributed VCS systems. Has tried out Bzr/Mercurial/Darcs/Git
- [ ] **Build automation**
- [x] Level 0 - Only knows how to build from IDE
- [x] Level 1 - Knows how to build the system from the command line
- [x] Level 2 - Can setup a script to build the basic system
- [ ] Level 3 - Can setup a script to build the system and also documentation, installers, generate release notes
and tag the code in source control
- [ ] **Automated testing**
- [x] Level 0 - Thinks that all testing is the job of the tester
- [x] Level 1 - Has written automated unit tests and comes up with good unit test cases for the code that is being written
- [x] Level 2 - Has written code in TDD manner
- [ ] Level 3 - Understands and is able to setup automated functional, load/performance and UI tests
Programming
in progress...
- [ ] **Problem decomposition**
- [x] Level 0 - Only straight line code with copy paste for reuse
- [x] Level 1 - Able to break up problem into multiple functions
- [x] Level 2 - Able to come up with reusable functions/objects that solve the overall problem
- [ ] Level 3 - Use of appropriate data structures and algorithms and comes up with generic/object-oriented code
that encapsulate aspects of the problem that are subject to change.
- [ ] **Systems decomposition**
- [x] Level 0 - Not able to think above the level of a single file/class
- [x] Level 1 - Able to break up problem space and design solution as long as it is within the same platform/technology
- [x] Level 2 - Able to design systems that span multiple technologies/platforms.
- [ ] Level 3 - Able to visualize and design complex systems with multiple product lines and integrations with
external systems. Also should be able to design operations support systems like monitoring, reporting, fail
overs etc.
- [ ] **Communication**
- [x] Level 0 - Cannot express thoughts/ideas to peers. Poor spelling and grammar.
- [x] Level 1 - Peers can understand what is being said. Good spelling and grammar.
- [x] Level 2 - Is able to effectively communicate with peers
- [ ] Level 3 - Able to understand and communicate thoughts/design/ideas/specs in a unambiguous
manner and adjusts communication as per the context
- This is an often under rated but very critical criteria
for judging a programmer. With the increase in outsourcing of programming tasks to places where English is not
the
native tongue this issue has become more prominent. I know of several projects that failed because the
programmers
could not understand what the intent of the communication was.
- [ ] **Code organization within a file**
- [x] Level 0 - no evidence of organization within a file
- [x] Level 1 - Methods are grouped logically or by accessibility
- [x] Level 2 - Code is grouped into regions and well commented with references to other source files
- [ ] Level 3 - File has license header, summary, well commented, consistent white space usage. The file should look
beautiful.
- [ ] **Code organization across files**
- [x] Level 0 - No thought given to organizing code across files
- [x] Level 1 - Related files are grouped into a folder
- [x] Level 2 - Each physical file has a unique purpose, for e.g. one class definition, one feature implementation etc.
- [ ] Level 3 - Code organization at a physical level closely
matches design and looking at file names and folder distribution provides insights into
design
- [ ] **Source tree organization**
- [x] Level 0 - Everything in one folder
- [x] Level 1 - Basic separation of code into logical folders.
- [x] Level 2 - No circular dependencies, binaries, libs, docs, builds, third-party code all
organized into appropriate folders
- [ ] Level 3 - Physical layout of source tree matches logical hierarchy and organization.
The directory names and organization provide insights into the design of the system.
- The difference between
this and the previous item is in the scale of organization, source tree organization relates to the entire set
of
artifacts that define the system.
- [ ] **Code readability**
- [x] Level 0 - Mono-syllable names
- [x] Level 1 - Good names for files, variables classes, methods etc.
- [x] Level 2 - No long functions, comments explaining unusual code, bug fixes,
code assumptions
- [ ] Level 3 - Code assumptions are verified using asserts, code flows naturally – no deep nesting of
conditionals or methods
- [ ] **Defensive coding**
- [x] Level 0 - Doesn’t understand the concept
- [x] Level 1 - Checks all arguments and asserts critical assumptions in code
- [x] Level 2 - Makes sure to check return values and check for exceptions around code that can fail.
- [ ] Level 3 - Has his own library to help with defensive coding, writes unit tests that simulate faults
- [ ] **Error handling**
- [x] Level 0 - Only codes the happy case
- [x] Level 1 - Basic error handling around code that can throw exceptions/generate errors
- [x] Level 2 - Ensures that error/exceptions leave program in good state, resources, connections and memory is
all cleaned up properly
- [ ] Level 3 - Codes to detect possible exception before, maintain consistent exception handling strategy in all
layers of code, come up with guidelines on exception handling for entire system.
- [ ] **IDE**
- [x] Level 0 - Mostly uses IDE for text editing
- [x] Level 1 - Knows their way around the interface,
able to effectively use the IDE using menus.
- [x] Level 2 - Knows keyboard shortcuts for most used operations.
- [ ] Level 3 - Has written custom macros
- [ ] **API**
- [x] Level 0 - Needs to look up the documentation frequently
- [x] Level 1 - Has the most frequently used APIs in memory
- [x] Level 2 - Vast and In-depth knowledge of the API
- [ ] Level 3 - Has written libraries that sit on top of the API to simplify frequently used tasks and to fill in gaps
in the API
- E.g. of API can be Java library, .net framework or the custom API for the
application
- [ ] **Frameworks**
- [x] Level 0 - Has not used any framework outside of the core platform
- [x] Level 1 - Has heard about but not used the popular frameworks available for the platform.
- [x] Level 2 - Has used more than one framework in a professional capacity and is well-versed with the idioms of
the frameworks.
- [ ] Level 3 - Author of framework
- [ ] **Requirements**
- [x] Level 0 - Takes the given requirements and codes to spec
- [x] Level 1 - Come up with questions regarding missed cases in the spec
- [x] Level 2 - Understand complete picture and come up with entire areas that need to be speced
- [ ] Level 3 - Able to suggest better alternatives and flows to given requirements based on experience
- [ ] **Scripting**
- [x] Level 0 - No knowledge of scripting tools
- [x] Level 1 - Batch files/shell scripts
- [x] Level 2 - Perl/Python/Ruby/VBScript/Powershell
- [ ] Level 3 - Has written and published reusable code
- [ ] **Database**
- [x] Level 0 - Thinks that Excel is a database
- [x] Level 1 - Knows basic database concepts, normalization, ACID, transactions and can write simple selects
- [x] Level 2 - Able to design good and normalized database schemas keeping in mind the queries that’ll have to
be run, proficient in use of views, stored procedures, triggers and user defined types. Knows difference
between clustered and non-clustered indexes. Proficient in use of ORM tools.
- [ ] Level 3 - Can do basic database administration, performance optimization, index optimization, write
advanced select queries, able to replace cursor usage with relational sql, understands how data is stored
internally, understands how indexes are stored internally, understands how databases can be mirrored,
replicated etc. Understands how the two phase commit works.
Experience
in progress...
- [ ] **Languages with professional experience**
- [x] Level 0 - Imperative or Object Oriented
- [x] Level 1 - Imperative, Object-Oriented and declarative (SQL), added bonus if they understand static vs dynamic
typing, weak vs strong typing and static inferred types
- [x] Level 2 - Functional, added bonus if they understand lazy
evaluation, currying, continuations
- [ ] Level 3 - Concurrent (Erlang, Oz) and Logic (Prolog)
- [ ] **Platforms with professional
experience**
- [x] Level 0 - 1
- [x] Level 1 - 2-3
- [x] Level 2 - 4-5
- [ ] Level 3 - 6+
- [ ] **Years of professional experience**
- [x] Level 0 - 1
- [x] Level 1 - 2-5
- [x] Level 2 - 6-9
- [ ] Level 3 - 10+
- [ ] **Domain knowledge**
- [x] Level 0 - No knowledge of the domain
- [x] Level 1 - Has worked on at least one product in the domain.
- [x] Level 2 - Has worked on multiple products in the same domain.
- [ ] Level 3 - Domain expert. Has designed and implemented several products/solutions in the
domain. Well versed with standard terms, protocols used in the domain.
Knowledge
in progress...
- [ ] **Tool knowledge**
- [x] Level 0 - Limited to primary IDE (VS.Net, Eclipse etc.)
- [x] Level 1 - Knows about some alternatives to popular and standard tools.
- [x] Level 2 - Good knowledge of editors, debuggers, IDEs, open source alternatives etc. etc. For e.g.
someone who knows most of the tools from Scott Hanselman’s power tools list. Has used ORM tools.
- [ ] Level 3 - Has actually written tools and scripts, added bonus if they’ve been published.
- [ ] **Languages exposed to**
- [x] Level 0 - Imperative or Object Oriented
- [x] Level 1 - Imperative, Object-Oriented and declarative (SQL), added
bonus if they understand static vs dynamic typing, weak vs strong typing and static inferred
types
- [x] Level 2 - Functional, added bonus if they understand lazy evaluation, currying, continuations
- [ ] Level 3 - Concurrent
(Erlang, Oz) and Logic (Prolog)
- [ ] **Codebase knowledge**
- [x] Level 0 - Has never looked at the codebase
- [x] Level 1 - Basic knowledge of the code layout and how to build the system
- [x] Level 2 - Good working knowledge of code base, has implemented several bug fixes and maybe some small features.
- [ ] Level 3 - Has implemented multiple big features in the codebase and can easily visualize the changes
required for most features or bug fixes.
- [ ] **Knowledge of upcoming technologies**
- [x] Level 0 - Has not heard of the upcoming technologies
- [x] Level 1 - Has heard of upcoming technologies in the field
- [x] Level 2 - Has downloaded the alpha preview/CTP/beta and read some articles/manuals
- [ ] Level 3 - Has played with the previews and has actually built something with it and as a bonus shared that
with everyone else
- [ ] **Platform internals**
- [x] Level 0 - Zero knowledge of platform internals
- [x] Level 1 - Has basic knowledge of how the platform works internally
- [x] Level 2 - Deep knowledge of platform internals and can visualize how the platform takes the program and
converts it into executable code.
- [ ] Level 3 - Has written tools to enhance or provide information on platform internals.
For e.g. disassemblers, decompilers, debuggers etc.
- [ ] **Books**
- [x] Level 0 - Unleashed series, 21 days series, 24 hour series, dummies series…
- [x] Level 1 - Code Complete, Don’t Make me Think, Mastering Regular Expressions
- [x] Level 2 - Design Patterns, Peopleware, Programming Pearls, Algorithm Design Manual, Pragmatic Programmer,
Mythical Man month
- [ ] Level 3 - Structure and Interpretation of Computer Programs, Concepts Techniques, Models of
Computer Programming, Art of Computer Programming, Database systems , by C. J Date, Thinking Forth, Little
Schemer
- [ ] **Blogs**
- [x] Level 0 - Has heard of them but never got the time.
- [x] Level 1 - Reads tech/programming/software engineering blogs and listens to podcasts regularly.
- [x] Level 2 - Maintains a link blog with some collection of useful articles and tools that he/she has collected
- [ ] Level 3 - Maintains a blog in which personal insights and thoughts on programming are shared
---
Full table
Computer Science
(Level 0)
(Level 1)
(Level 2)
(Level 3)
Comments
data structures
Doesn’t know the difference between Array and LinkedList
Able to explain and use Arrays, LinkedLists, Dictionaries etc in practical programming tasks
Knows space and time tradeoffs of the basic data structures, Arrays vs LinkedLists, Able to explain
how hashtables can be implemented and can handle collisions, Priority queues and ways to implement them etc.
Knowledge of advanced data structures like B-trees, binomial and fibonacci heaps, AVL/Red Black trees,
Splay Trees, Skip Lists, tries etc.
algorithms
Unable to find the average of numbers in an array (It’s hard to believe but I’ve interviewed such candidates)
Basic sorting, searching and data structure traversal and retrieval algorithms
Tree, Graph, simple greedy and divide and conquer
algorithms, is able to understand the relevance of the levels of this matrix.
Able to recognize and code
dynamic programming solutions, good knowledge of graph algorithms, good knowledge of numerical computation
algorithms, able to identify NP problems etc.
<>
systems programming
Doesn’t know
what a compiler, linker or interpreter is
Basic understanding of compilers, linker and interpreters.
Understands what assembly code is and how things work at the hardware level. Some knowledge of virtual memory
and
paging.
Understands kernel mode vs. user mode, multi-threading, synchronization primitives and how they’re
implemented, able to read assembly code. Understands how networks work, understanding of network protocols and
socket level programming.
Understands the entire programming stack, hardware (CPU + Memory + Cache +
Interrupts + microcode), binary code, assembly, static and dynamic linking, compilation, interpretation, JIT
compilation, garbage collection, heap, stack, memory addressing…
Software
Engineering
2n (Level 0)
n2
(Level 1)
n (Level 2)
log(n) (Level 3)
Comments
source code version
control
Folder backups by date
VSS and beginning CVS/SVN user
Proficient in using CVS and
SVN features. Knows how to branch and merge, use patches setup repository properties etc.
Knowledge of
distributed VCS systems. Has tried out Bzr/Mercurial/Darcs/Git
build
automation
Only knows how to build from IDE
Knows how to build the system from the command
line
Can setup a script to build the basic system
Can setup a script to build the system and also
documentation, installers, generate release notes and tag the code in source
control
automated testing
Thinks that all testing is the job of the
tester
Has written automated unit tests and comes up with good unit test cases for the code that is being
written
Has written code in TDD manner
Understands and is able to setup automated functional,
load/performance and UI tests
Programming
2n (Level 0)
n2 (Level 1)
n (Level 2)
log(n) (Level 3)
Comments
problem decomposition
Only straight line code with copy paste for
reuse
Able to break up problem into multiple functions
Able to come up with reusable
functions/objects that solve the overall problem
Use of appropriate data structures and algorithms and comes
up with generic/object-oriented code that encapsulate aspects of the problem that are subject to change.
systems decomposition
Not able to think above the level of a single
file/class
Able to break up problem space and design solution as long as it is within the same
platform/technology
Able to design systems that span multiple technologies/platforms.
Able to
visualize and design complex systems with multiple product lines and integrations with external systems. Also
should
be able to design operations support systems like monitoring, reporting, fail overs etc.
communication
Cannot express thoughts/ideas to peers. Poor spelling and grammar.
Peers can understand what is being said. Good spelling and grammar.
Is able to effectively
communicate with peers
Able to understand and communicate thoughts/design/ideas/specs in a unambiguous
manner and adjusts communication as per the context
This is an often under rated but very critical criteria
for judging a programmer. With the increase in outsourcing of programming tasks to places where English is not
the
native tongue this issue has become more prominent. I know of several projects that failed because the
programmers
could not understand what the intent of the communication was.
code organization within a
file
no evidence of organization within a file
Methods are grouped logically or by
accessibility
Code is grouped into regions and well commented with references to other source
files
File has license header, summary, well commented, consistent white space usage. The file should look
beautiful.
code organization across files
No thought given to organizing code
across files
Related files are grouped into a folder
Each physical file has a unique purpose, for e.
g. one class definition, one feature implementation etc.
Code organization at a physical level closely
matches design and looking at file names and folder distribution provides insights into
design
source tree organization
Everything in one folder
Basic separation
of code into logical folders.
No circular dependencies, binaries, libs, docs, builds, third-party code all
organized into appropriate folders
Physical layout of source tree matches logical hierarchy and organization.
The directory names and organization provide insights into the design of the system.
The difference between
this and the previous item is in the scale of organization, source tree organization relates to the entire set
of
artifacts that define the system.
code readability
Mono-syllable names
Good names
for files, variables classes, methods etc.
No long functions, comments explaining unusual code, bug fixes,
code assumptions
Code assumptions are verified using asserts, code flows naturally – no deep nesting of
conditionals or methods
defensive coding
Doesn’t understand the
concept
Checks all arguments and asserts critical assumptions in code
Makes sure to check return
values and check for exceptions around code that can fail.
Has his own library to help with defensive coding,
writes unit tests that simulate faults
error handling
Only codes the happy
case
Basic error handling around code that can throw exceptions/generate errors
Ensures that
error/exceptions leave program in good state, resources, connections and memory is all cleaned up
properly
Codes to detect possible exception before, maintain consistent exception handling strategy in all
layers of code, come up with guidelines on exception handling for entire system.
IDE
Mostly uses IDE for text editing
Knows their way around the interface,
able to effectively use the IDE using menus.
Knows keyboard shortcuts for most used operations.
Has
written custom macros
API
Needs to look up the documentation
frequently
Has the most frequently used APIs in memory
Vast and In-depth knowledge of the
API
Has written libraries that sit on top of the API to simplify frequently used tasks and to fill in gaps
in the API
E.g. of API can be Java library, .net framework or the custom API for the
application
frameworks
Has not used any framework outside of the core platform
Has
heard about but not used the popular frameworks available for the platform.
Has used more than one framework
in a professional capacity and is well-versed with the idioms of the frameworks.
Author of
framework
requirements
Takes the given requirements and codes to spec
Come
up with questions regarding missed cases in the spec
Understand complete picture and come up with entire
areas that need to be speced
Able to suggest better alternatives and flows to given requirements based on
experience
scripting
No knowledge of scripting tools
Batch files/shell
scripts
Perl/Python/Ruby/VBScript/Powershell
Has written and published reusable
code
database
Thinks that Excel is a database
Knows basic database
concepts, normalization, ACID, transactions and can write simple selects
Able to design good and normalized
database schemas keeping in mind the queries that’ll have to be run, proficient in use of views, stored
procedures,
triggers and user defined types. Knows difference between clustered and non-clustered indexes. Proficient in use
of
ORM tools.
Can do basic database administration, performance optimization, index optimization, write
advanced select queries, able to replace cursor usage with relational sql, understands how data is stored
internally,
understands how indexes are stored internally, understands how databases can be mirrored, replicated etc.
Understands how the two phase commit works.
Experience
2n (Level 0)
n2 (Level 1)
n (Level 2)
log(n)
(Level 3)
Comments
languages with professional experience
Imperative or Object
Oriented
Imperative, Object-Oriented and declarative (SQL), added bonus if they understand static vs dynamic
typing, weak vs strong typing and static inferred types
Functional, added bonus if they understand lazy
evaluation, currying, continuations
Concurrent (Erlang, Oz) and Logic (Prolog)
platforms with professional
experience
1
2-3
4-5
6+
years of professional
experience
1
2-5
6-9
10+
domain knowledge
No
knowledge of the domain
Has worked on at least one product in the domain.
Has worked on multiple
products in the same domain.
Domain expert. Has designed and implemented several products/solutions in the
domain. Well versed with standard terms, protocols used in the domain.
Knowledge
tool
knowledge
Limited to primary IDE (VS.Net, Eclipse etc.)
Knows about some alternatives to popular and
standard tools.
Good knowledge of editors, debuggers, IDEs, open source alternatives etc. etc. For e.g.
someone who knows most of the tools from Scott Hanselman’s power tools list. Has used ORM tools.
Has
actually written tools and scripts, added bonus if they’ve been published.
languages
exposed to
Imperative or Object Oriented
Imperative, Object-Oriented and declarative (SQL), added
bonus if they understand static vs dynamic typing, weak vs strong typing and static inferred
types
Functional, added bonus if they understand lazy evaluation, currying, continuations
Concurrent
(Erlang, Oz) and Logic (Prolog)
codebase knowledge
Has never looked at the
codebase
Basic knowledge of the code layout and how to build the system
Good working knowledge of
code base, has implemented several bug fixes and maybe some small features.
Has implemented multiple big
features in the codebase and can easily visualize the changes required for most features or bug fixes.
knowledge of upcoming technologies
Has not heard of the upcoming
technologies
Has heard of upcoming technologies in the field
Has downloaded the alpha
preview/CTP/beta and read some articles/manuals
Has played with the previews and has actually built
something with it and as a bonus shared that with everyone else
platform
internals
Zero knowledge of platform internals
Has basic knowledge of how the platform works
internally
Deep knowledge of platform internals and can visualize how the platform takes the program and
converts it into executable code.
Has written tools to enhance or provide information on platform internals.
For e.g. disassemblers, decompilers, debuggers etc.
books
Unleashed series, 21
days series, 24 hour series, dummies series…
Code Complete, Don’t Make me Think, Mastering Regular
Expressions
Design Patterns, Peopleware, Programming Pearls, Algorithm Design Manual, Pragmatic Programmer,
Mythical Man month
Structure and Interpretation of Computer Programs, Concepts Techniques, Models of
Computer Programming, Art of Computer Programming, Database systems , by C. J Date, Thinking Forth, Little
Schemer
blogs
Has heard of them but never got the time.
Reads
tech/programming/software engineering blogs and listens to podcasts regularly.
Maintains a link blog with
some collection of useful articles and tools that he/she has collected
Maintains a blog in which personal
insights and thoughts on programming are shared