Programmer Competency

Note that the knowledge for each level is cumulative; being at level n implies
Computer Science
2n (Level 0) n2 (Level 1)

Able to explain and use

Doesn't know the Arrays, LinkedLists,
difference between Dictionaries etc in practical
data structures Array and LinkedList programming tasks

Unable to find the

average of numbers in
an array (It's hard to
believe but I've Basic sorting, searching and
interviewed such data structure traversal and
algorithms candidates) retrieval algorithms

Basic understanding of
compilers, linker and
interpreters. Understands
what assembly code is and
how things work at the
Doesn't know what a hardware level. Some
compiler, linker or knowledge of virtual memory
systems programming interpreter is and paging.
Software Engineering

source code version Folder backups by VSS and beginning CVS/SVN

control date user

Knows how to build the

Only knows how to system from the command
build automation build from IDE line

Has written automated unit

tests and comes up with good
Thinks that all testing unit test cases for the code
automated testing is the job of the tester that is being written
Programming

Only straight line code

with copy paste for Able to break up problem into
problem decomposition reuse multiple functions
 Able to break up problem
Not able to think space and design solution as
above the level of a long as it is within the same
systems decomposition single file/class platform/technology

Cannot express
thoughts/ideas to Peers can understand what is
peers. Poor spelling being said. Good spelling and
communication and grammar. grammar.
no evidence of
code organization within a organization within a Methods are grouped logically
file file or by accessibility

No thought given to
code organization across organizing code across Related files are grouped into
files files a folder

Everything in one Basic separation of code into

source tree organization folder logical folders.

Good names for files, variables

code readability Mono-syllable names classes, methods etc.
Checks all arguments and
Doesn't understand asserts critical assumptions in
defensive coding the concept code

Basic error handling around

Only codes the happy code that can throw
error handling case exceptions/generate errors
Knows their way around the
Mostly uses IDE for interface, able to effectively
IDE text editing use the IDE using menus.
 Needs to look up the
documentation Has the most frequently used
API frequently APIs in memory
Has not used any Has heard about but not used
framework outside of the popular frameworks
frameworks the core platform available for the platform.
Takes the given Come up with questions
requirements and regarding missed cases in the
requirements codes to spec spec
No knowledge of
scripting scripting tools Batch files/shell scripts

Knows basic database

concepts, normalization,
Thinks that Excel is a ACID, transactions and can
database database write simple selects
Experience

Imperative, Object-Oriented
and declarative (SQL), added
bonus if they understand
static vs dynamic typing, weak
languages with Imperative or Object vs strong typing and static
professional experience Oriented inferred types
platforms with
professional experience 1 3-Feb
years of professional
experience 1 5-Feb

No knowledge of the Has worked on at least one

domain knowledge domain product in the domain.
Knowledge

Knows about some

Limited to primary IDE alternatives to popular and
tool knowledge (VS.Net, Eclipse etc.) standard tools.
 Imperative, Object-Oriented
and declarative (SQL), added
bonus if they understand
static vs dynamic typing, weak
Imperative or Object vs strong typing and static
languages exposed to Oriented inferred types

Basic knowledge of the code

Has never looked at layout and how to build the
codebase knowledge the codebase system
Has not heard of the
knowledge of upcoming upcoming Has heard of upcoming
technologies technologies technologies in the field

Zero knowledge of Has basic knowledge of how

platform internals platform internals the platform works internally

Unleashed series, 21
days series, 24 hour Code Complete, Don't Make
series, dummies me Think, Mastering Regular
books series... Expressions

Reads
tech/programming/software
Has heard of them but engineering blogs and listens
blogs never got the time. to podcasts regularly.
 Programmer Competency Matrix
s cumulative; being at level n implies that you also know everything from the levels lower than n.

n (Level 2) log(n) (Level 3)

Knows space and time tradeoffs of the

basic data structures, Arrays vs
LinkedLists, Able to explain how Knowledge of advanced data structures like
hashtables can be implemented and can B-trees, binomial and fibonacci heaps,
handle collisions, Priority queues and AVL/Red Black trees, Splay Trees, Skip Lists,
ways to implement them etc. tries etc.

Able to recognize and code dynamic

Tree, Graph, simple greedy and divide programming solutions, good knowledge of
and conquer algorithms, is able to graph algorithms, good knowledge of
understand the relevance of the levels numerical computation algorithms, able to
of this matrix. identify NP problems etc.

Understands kernel mode vs. user Understands the entire programming stack,
mode, multi-threading, synchronization hardware (CPU + Memory + Cache +
primitives and how they're Interrupts + microcode), binary code,
implemented, able to read assembly assembly, static and dynamic linking,
code. Understands how networks work, compilation, interpretation, JIT compilation,
understanding of network protocols garbage collection, heap, stack, memory
and socket level programming. addressing...

Proficient in using CVS and SVN

features. Knows how to branch and
merge, use patches setup repository Knowledge of distributed VCS systems. Has
properties etc. tried out Bzr/Mercurial/Darcs/Git

Can setup a script to build the system and

also documentation, installers, generate
Can setup a script to build the basic release notes and tag the code in source
system control

Understands and is able to setup automated

Has written code in TDD manner functional, load/performance and UI tests

Use of appropriate data structures and

algorithms and comes up with
Able to come up with reusable generic/object-oriented code that
functions/objects that solve the overall encapsulate aspects of the problem that are
problem subject to change.
 Able to visualize and design complex
systems with multiple product lines and
integrations with external systems. Also
should be able to design operations support
Able to design systems that span systems like monitoring, reporting, fail overs
multiple technologies/platforms. etc.

Able to understand and communicate

thoughts/design/ideas/specs in a
Is able to effectively communicate with unambiguous manner and adjusts
peers communication as per the context
Code is grouped into regions and well File has license header, summary, well
commented with references to other commented, consistent white space usage.
source files The file should look beautiful.

Code organization at a physical level closely

Each physical file has a unique purpose, matches design and looking at file names
for e.g. one class definition, one feature and folder distribution provides insights into
implementation etc. design

Physical layout of source tree matches

No circular dependencies, binaries, libs, logical hierarchy and organization. The
docs, builds, third-party code all directory names and organization provide
organized into appropriate folders insights into the design of the system.
No long functions, comments explaining Code assumptions are verified using asserts,
unusual code, bug fixes, code code flows naturally - no deep nesting of
assumptions conditionals or methods
Makes sure to check return values and
check for exceptions around code that Has his own library to help with defensive
can fail. coding, writes unit tests that simulate faults

Codes to detect possible exception before,

Ensures that error/exceptions leave maintain consistent exception handling
program in good state, resources, strategy in all layers of code, come up with
connections and memory is all cleaned guidelines on exception handling for entire
up properly system.

Knows keyboard shortcuts for most

used operations. Has written custom macros
 Has written libraries that sit on top of the
API to simplify frequently used tasks and to
Vast and In-depth knowledge of the API fill in gaps in the API
Has used more than one framework in a
professional capacity and is well-versed
with the idioms of the frameworks. Author of framework
Understand complete picture and come Able to suggest better alternatives and
up with entire areas that need to be flows to given requirements based on
speced experience

Perl/Python/Ruby/VBScript/Powershell Has written and published reusable code

Can do basic database administration,

performance optimization, index
Able to design good and normalized optimization, write advanced select queries,
database schemas keeping in mind the able to replace cursor usage with relational
queries that'll have to be run, proficient sql, understands how data is stored
in use of views, stored procedures, internally, understands how indexes are
triggers and user defined types. Knows stored internally, understands how
difference between clustered and non- databases can be mirrored, replicated etc.
clustered indexes. Proficient in use of Understands how the two phase commit
ORM tools. works.

Functional, added bonus if they

understand lazy evaluation, currying,
continuations Concurrent (Erlang, Oz) and Logic (Prolog)

5-Apr 6+

9-Jun 10+

Domain expert. Has designed and

implemented several products/solutions in
Has worked on multiple products in the the domain. Well versed with standard
same domain. terms, protocols used in the domain.

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 Has actually written tools and scripts, added
tools list. Has used ORM tools. bonus if they've been published.
Functional, added bonus if they
understand lazy evaluation, currying,
continuations Concurrent (Erlang, Oz) and Logic (Prolog)

Has implemented multiple big features in

Good working knowledge of code base, the codebase and can easily visualize the
has implemented several bug fixes and changes required for most features or bug
maybe some small features. fixes.
Has downloaded the alpha Has played with the previews and has
preview/CTP/beta and read some actually built something with it and as a
articles/manuals bonus shared that with everyone else

Deep knowledge of platform internals

and can visualize how the platform Has written tools to enhance or provide
takes the program and converts it into information on platform internals. For e.g.
executable code. disassemblers, decompilers, debuggers etc.

Structure and Interpretation of Computer

Design Patterns, Peopleware, Programs, Concepts Techniques, Models of
Programming Pearls, Algorithm Design Computer Programming, Art of Computer
Manual, Pragmatic Programmer, Programming, Database systems , by C. J
Mythical Man month Date, Thinking Forth, Little Schemer

Maintains a link blog with some

collection of useful articles and tools Maintains a blog in which personal insights
that he/she has collected and thoughts on programming are shared
han n.

Comments

Working with someone who

has a good topcoder ranking
would be an unbelievable
piece of luck!
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.

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.
E.g. of API can be Java
library, .net framework or
the custom API for the
application