About (http://sijinjoseph.com/about/) Programmer Competency Matrix (http://sijinjoseph.

com/programmer-competency-matrix/)

(http://sijinjoseph.com/)

Perspectives on Software, Technology and Business

Programmer Competency Matrix

Note that the knowledge for each level is cumulative; being at

level n implies that you also know everything from the
levels lower than n.

Computer Science

2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments

Knows space and time tradeoffs of Knowledge of advanced
Doesn’t know Able to explain and use the basic data structures, Arrays vs data structures like B-trees,
the difference Arrays, LinkedLists, LinkedLists, Able to explain how binomial and fibonacci
data structures
between Array Dictionaries etc in practical hashtables can be implemented and heaps, AVL/Red Black trees,
and LinkedList programming tasks can handle collisions, Priority queues Splay Trees, Skip Lists, tries
and ways to implement them etc. etc.
 Unable to find
Able to recognize and code
the average of
dynamic programming
numbers in an Working with someone
Tree, Graph, simple greedy and divide solutions, good knowledge
array (It’s hard Basic sorting, searching and who has a good
and conquer algorithms, is able to of graph algorithms, good
algorithms to believe but data structure traversal and topcoder ranking would
understand the relevance of the levels knowledge of numerical
I’ve retrieval algorithms be an unbelievable piece
of this matrix. computation algorithms,
interviewed of luck!
able to identify NP
such
problems etc.
candidates)

Understands the entire

Basic understanding of
compilers, linker and
Doesn’t know
interpreters. Understands
what a
systems what assembly code is and
compiler,
programming how things work at the
linker or
hardware level. Some
interpreter is
knowledge of virtual
memory and paging.
programming stack,
Understands kernel mode vs. user
hardware (CPU + Memory +
mode, multi-threading,
Cache + Interrupts +
synchronization primitives and how
microcode), binary code,
they’re implemented, able to read
assembly, static and
assembly code. Understands how
dynamic linking,
networks work, understanding of
compilation, interpretation,
network protocols and socket level
JIT compilation, garbage
programming.
collection, heap, stack,
memory addressing…

Software Engineering

2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments

Proficient in using CVS and SVN
Knowledge of distributed
source code Folder backups VSS and beginning CVS/SVN features. Knows how to branch and
VCS systems. Has tried out
version control by date user merge, use patches setup repository
Bzr/Mercurial/Darcs/Git
properties etc.

Can setup a script to build

the system and also
Only knows Knows how to build the
build Can setup a script to build the basic documentation, installers,
how to build system from the command
automation system generate release notes and
from IDE line
tag the code in source
control
 Understands and is able to
Thinks that all Has written automated unit
setup automated
automated testing is the tests and comes up with
Has written code in TDD manner functional,
testing job of the good unit test cases for the
load/performance and UI
tester code that is being written
tests

Programming

2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments

Use of appropriate data
structures and algorithms
Only straight
Able to come up with reusable and comes up with
problem line code with Able to break up problem
functions/objects that solve the generic/object-oriented
decomposition copy paste for into multiple functions
overall problem code that encapsulate
reuse
aspects of the problem that
are subject to change.

Able to visualize and design

complex systems with
multiple product lines and
Not able to Able to break up problem
integrations with external
systems think above space and design solution as Able to design systems that span
systems. Also should be
decomposition the level of a long as it is within the same multiple technologies/platforms.
able to design operations
single file/class platform/technology
support systems like
monitoring, reporting, fail
overs etc.
 This is an often under
rated but very critical
criteria for judging a
programmer. With the
increase in outsourcing
Cannot Able to understand and of programming tasks to
express communicate places where English is
Peers can understand what
thoughts/ideas Is able to effectively communicate thoughts/design/ideas/specs not the native tongue
communication is being said. Good spelling
to peers. Poor with peers in a unambiguous manner this issue has become
and grammar.
spelling and and adjusts communication more prominent. I know
grammar. as per the context of several projects that
failed because the
programmers could not
understand what the
intent of the
communication was.

File has license header,

code no evidence of Code is grouped into regions and well summary, well commented,
Methods are grouped
organization organization commented with references to other consistent white space
logically or by accessibility
within a file within a file source files usage. The file should look
beautiful.

2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments

Code organization at a
No thought
physical level closely
code given to Each physical file has a unique
Related files are grouped matches design and looking
organization organizing purpose, for e.g. one class definition,
into a folder at file names and folder
across files code across one feature implementation etc.
distribution provides
files
insights into design

The difference between

Physical layout of source
this and the previous
tree matches logical
item is in the scale of
No circular dependencies, binaries, hierarchy and organization.
source tree Everything in Basic separation of code organization, source
libs, docs, builds, third-party code all The directory names and
organization one folder into logical folders. tree organization relates
organized into appropriate folders organization provide
to the entire set of
insights into the design of
artifacts that define the
the system.
system.
 Code assumptions are
Good names for files, No long functions, comments verified using asserts, code
code Mono-syllable
variables classes, methods explaining unusual code, bug fixes, flows naturally – no deep
readability names
etc. code assumptions nesting of conditionals or
methods

Has his own library to help

Doesn’t Checks all arguments and Makes sure to check return values and
defensive with defensive coding,
understand the asserts critical assumptions check for exceptions around code
coding writes unit tests that
concept in code that can fail.
simulate faults

2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments

Codes to detect possible
exception before, maintain
Ensures that error/exceptions leave consistent exception
Basic error handling around
Only codes the program in good state, resources, handling strategy in all
error handling code that can throw
happy case connections and memory is all layers of code, come up
exceptions/generate errors
cleaned up properly with guidelines on
exception handling for
entire system.

Mostly uses Knows their way around the

Knows keyboard shortcuts for most
IDE IDE for text interface, able to effectively Has written custom macros
used operations.
editing use the IDE using menus.

Needs to look Has written libraries that sit E.g. of API can be Java
up the Has the most frequently Vast and In-depth knowledge of the on top of the API to simplify library, .net framework
API
documentation used APIs in memory API frequently used tasks and to or the custom API for
frequently fill in gaps in the API the application

Has not used Has heard about but not Has used more than one framework in
any framework used the popular a professional capacity and is well-
frameworks Author of framework
outside of the frameworks available for versed with the idioms of the
core platform the platform. frameworks.

2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments

 Takes the
Able to suggest better
given Come up with questions Understand complete picture and
alternatives and flows to
requirements requirements regarding missed cases in come up with entire areas that need
given requirements based
and codes to the spec to be speced
on experience
spec

No knowledge
Has written and published
scripting of scripting Batch files/shell scripts Perl/Python/Ruby/VBScript/Powershell
reusable code
tools

Can do basic database

administration,
performance optimization,
index optimization, write
Able to design good and normalized
advanced select queries,
database schemas keeping in mind
able to replace cursor usage
Knows basic database the queries that’ll have to be run,
Thinks that with relational sql,
concepts, normalization, proficient in use of views, stored
database Excel is a understands how data is
ACID, transactions and can procedures, triggers and user defined
database stored internally,
write simple selects types. Knows difference between
understands how indexes
clustered and non-clustered indexes.
are stored internally,
Proficient in use of ORM tools.
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

Imperative, Object-Oriented
and declarative (SQL),
languages with Imperative or added bonus if they Functional, added bonus if they
Concurrent (Erlang, Oz) and
professional Object understand static vs understand lazy evaluation, currying,
Logic (Prolog)
experience Oriented dynamic typing, weak vs continuations
strong typing and static
inferred types

platforms with
professional 1 2-3 4-5 6+
experience
years of
professional 1 2-5 6-9 10+
experience

Domain expert. Has

designed and implemented
several products/solutions
domain No knowledge Has worked on at least one Has worked on multiple products in
in the domain. Well versed
knowledge of the domain product in the domain. the same domain.
with standard terms,
protocols used in the
domain.

Knowledge

2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments

Good knowledge of editors,
Limited to debuggers, IDEs, open source
Knows about some Has actually written tools
tool primary IDE alternatives etc. etc. For e.g. someone
alternatives to popular and and scripts, added bonus if
knowledge (VS.Net, who knows most of the tools from
standard tools. they’ve been published.
Eclipse etc.) Scott Hanselman’s power tools list.
Has used ORM tools.

Imperative, Object-Oriented
and declarative (SQL),
Imperative or added bonus if they Functional, added bonus if they
languages Concurrent (Erlang, Oz) and
Object understand static vs understand lazy evaluation, currying,
exposed to Logic (Prolog)
Oriented dynamic typing, weak vs continuations
strong typing and static
inferred types

Has implemented multiple

Has never Basic knowledge of the Good working knowledge of code big features in the codebase
codebase
looked at the code layout and how to base, has implemented several bug and can easily visualize the
knowledge
codebase build the system fixes and maybe some small features. changes required for most
features or bug fixes.

Has played with the

Has not heard
knowledge of Has downloaded the alpha previews and has actually
of the Has heard of upcoming
upcoming preview/CTP/beta and read some built something with it and
upcoming technologies in the field
technologies articles/manuals as a bonus shared that with
technologies
everyone else
 2n (Level 0) n2 (Level 1) n (Level 2) log(n) (Level 3) Comments
Has written tools to
Zero Deep knowledge of platform internals enhance or provide
Has basic knowledge of
platform knowledge of and can visualize how the platform information on platform
how the platform works
internals platform takes the program and converts it into internals. For e.g.
internally
internals executable code. disassemblers, decompilers,
debuggers etc.

Structure and Interpretation

of Computer Programs,
Unleashed
Concepts Techniques,
series, 21 days Design Patterns, Peopleware,
Code Complete, Don’t Make Models of Computer
series, 24 hour Programming Pearls, Algorithm
books me Think, Mastering Programming, Art of
series, Design Manual, Pragmatic
Regular Expressions Computer Programming,
dummies Programmer, Mythical Man month
Database systems , by C. J
series…
Date, Thinking Forth, Little
Schemer

Reads
Has heard of Maintains a blog in which
tech/programming/software Maintains a link blog with some
them but personal insights and
blogs engineering blogs and collection of useful articles and tools
never got the thoughts on programming
listens to podcasts that he/she has collected
time. are shared
regularly.

Thanks to John Haugeland (http://fullof.bs/) for a

reformatting of it that works much more nicely on the web.

Share this:

Share 869 Tweet 2 points 5,149 Share 3.9K

  More
Guardar (https://es.pinterest.com/pin/create/button/?
guid=EZwxw9efARqH-
30

2&url=http%3A%2F%2Fsijinjoseph.com%2Fprogrammer-
competency-

117 Comments
matrix%2F&media=http%3A%2F%2Fsijinjoseph.com%2Fwp-
 Add your comment
content%2Fuploads%2F2016%2F05%2Fsijin-2016-s-
135x150.png&description=Programmer%20Competency%20Matrix)

Steven June 25, 2017 at 19:31 (http://sijinjoseph.com/programmer-competency-matrix/comment-page-6/#comment-7480)

Mo (and anyone else wondering what “n” is equal to):

The labels reference Big-O notation. They describe the rate of change as “n” approaches in nity; actually lling in “n” with any
value (especially values that close to zero) is not a useful application of the formula. If we assume that “n” is an in-
comprehensively large number, then think about the change in value between “n” and “1 + n”. It will help to plot these on a graph
and remember that smaller values are better.

– 2^n is the square of 2^(n – 1). This is the rate of gain as you bit-shift to the left: 2, 4, 8, 16, 32, 64, 128, 256, 512,1024, 2048, etc.
– n^2 performs less awfully than 2^n at extremely large values, but still really poorly: 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, etc.
– n is probably the rst rate where performance is predictably terrible: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, etc.
– log(n) is an algorithm that sucks at very small values, but becomes great at large values: 0, 1, 1.6, 2, 2.3, 2.6, 2.8, 3, 3.2, 3.3, 3.5,
etc.

Even at small values, the jump between n=10 and n=11 can be used to extrapolate the n=(in nity) performance of these functions.
Level 0 jumps a full 1024 units, while Level 1 jumps only 21 units, Level 2 jumps by 1 unit, and level 3 jumps by less than 1 unit.

Anon August 3, 2017 at 10:34 (http://sijinjoseph.com/programmer-competency-matrix/comment-page-6/#comment-7490)

>Blake Dietz
 ‘Their’ is plural. It would be better as ‘his or her,’ but it also isn’t even an issue, as ‘he’ or ‘his’ has historically been a kind of English,
neutered pronoun. ‘His’ simply works better when communicating in a terse, correct mode. Bias against women isn’t intended or
should even be considered.

Philip Attisano
(Https://Www.Facebook.Com/App_scoped_user_id/2003996742947731/) August 25,

2017 at 08:48 (http://sijinjoseph.com/programmer-competency-matrix/comment-page-6/#comment-7492)

I’ve been writing software for 10+ years, and this was a poignant reality check for me. My programming theory vocabulary sucks. I
constantly reference API docs. I rely heavily on the IDE. I usually write core code in ‘happy case’ and let exceptions bubble up the
stack. I self-rank somewhere around 1 or 2 (rarely 3). Either I’m modest in my assessment, or damn I’ve been lazy! lol

← Previous Comments (http://sijinjoseph.com/programmer-competency-matrix/comment-page-5/#comments)

Leave a Reply
 Enter your comment here...

139 Trackbacks
1. ??????????????????? | SAP???? (http://blog.sapchina.net/540.html) (Pingback)

2. ??????????????????? - ????
(http://hack.hk.cn/2017/07/06/%e5%af%b9%e5%bc%80%e5%8f%91%e8%80%85%e6%9c%89%e7%94%a8%e7%9a%84%e8%8b%b1
(Pingback)

3. Programistyczne znaleziska #3 - macierz kompetencji, ankiweb, TLDRLegal - Bartez.info (https://bartez.info/programistyczne-

znaleziska-3-macierz-kompetencji-ankiweb-tldrlegal/) (Pingback)
© 2017 - Sijin Joseph Designed on rtPanel WordPress Theme Framework (https://rtcamp.com/rtpanel/).