git show 2008:programmer-competency-matrix

Programmer Competency Matrix (2008)

The original 32 skills, as published in April 2008. Kept here so old links and citations still resolve.

The current edition is at /programmer-competency-matrix/.

computer science

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
data structures
2ⁿDoesn’t know the difference between Array and LinkedList
n²Able to explain and use Arrays, LinkedLists, Dictionaries etc in practical programming tasks
nKnows 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.
log(n)Knowledge of advanced data structures like B-trees, binomial and fibonacci heaps, AVL/Red Black trees, Splay Trees, Skip Lists, tries etc.
algorithms
2ⁿUnable to find the average of numbers in an array (It’s hard to believe but I’ve interviewed such candidates)
n²Basic sorting, searching and data structure traversal and retrieval algorithms
nTree, Graph, simple greedy and divide and conquer algorithms, is able to understand the relevance of the levels of this matrix.
log(n)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
2ⁿDoesn’t know what a compiler, linker or interpreter is
n²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.
nUnderstands 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.
log(n)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

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
source code version control
2ⁿFolder backups by date
n²VSS and beginning CVS/SVN user
nProficient in using CVS and SVN features. Knows how to branch and merge, use patches setup repository properties etc.
log(n)Knowledge of distributed VCS systems. Has tried out Bzr/Mercurial/Darcs/Git
build automation
2ⁿOnly knows how to build from IDE
n²Knows how to build the system from the command line
nCan setup a script to build the basic system
log(n)Can setup a script to build the system and also documentation, installers, generate release notes and tag the code in source control
automated testing
2ⁿThinks that all testing is the job of the tester
n²Has written automated unit tests and comes up with good unit test cases for the code that is being written
nHas written code in TDD manner
log(n)Understands and is able to setup automated functional, load/performance and UI tests

programming

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
problem decomposition
2ⁿOnly straight line code with copy paste for reuse
n²Able to break up problem into multiple functions
nAble to come up with reusable functions/objects that solve the overall problem
log(n)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
2ⁿNot able to think above the level of a single file/class
n²Able to break up problem space and design solution as long as it is within the same platform/technology
nAble to design systems that span multiple technologies/platforms.
log(n)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

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.

2ⁿCannot express thoughts/ideas to peers. Poor spelling and grammar.
n²Peers can understand what is being said. Good spelling and grammar.
nIs able to effectively communicate with peers
log(n)Able to understand and communicate thoughts/design/ideas/specs in a unambiguous manner and adjusts communication as per the context
code organization within a file
2ⁿno evidence of organization within a file
n²Methods are grouped logically or by accessibility
nCode is grouped into regions and well commented with references to other source files
log(n)File has license header, summary, well commented, consistent white space usage. The file should look beautiful.
code organization across files
2ⁿNo thought given to organizing code across files
n²Related files are grouped into a folder
nEach physical file has a unique purpose, for e.g. one class definition, one feature implementation etc.
log(n)Code organization at a physical level closely matches design and looking at file names and folder distribution provides insights into design
source tree organization

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.

2ⁿEverything in one folder
n²Basic separation of code into logical folders.
nNo circular dependencies, binaries, libs, docs, builds, third-party code all organized into appropriate folders
log(n)Physical layout of source tree matches logical hierarchy and organization. The directory names and organization provide insights into the design of the system.
code readability
2ⁿMono-syllable names
n²Good names for files, variables classes, methods etc.
nNo long functions, comments explaining unusual code, bug fixes, code assumptions
log(n)Code assumptions are verified using asserts, code flows naturally – no deep nesting of conditionals or methods
defensive coding
2ⁿDoesn’t understand the concept
n²Checks all arguments and asserts critical assumptions in code
nMakes sure to check return values and check for exceptions around code that can fail.
log(n)Has his own library to help with defensive coding, writes unit tests that simulate faults
error handling
2ⁿOnly codes the happy case
n²Basic error handling around code that can throw exceptions/generate errors
nEnsures that error/exceptions leave program in good state, resources, connections and memory is all cleaned up properly
log(n)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
2ⁿMostly uses IDE for text editing
n²Knows their way around the interface, able to effectively use the IDE using menus.
nKnows keyboard shortcuts for most used operations.
log(n)Has written custom macros
API

E.g. of API can be Java library, .net framework or the custom API for the application

2ⁿNeeds to look up the documentation frequently
n²Has the most frequently used APIs in memory
nVast and In-depth knowledge of the API
log(n)Has written libraries that sit on top of the API to simplify frequently used tasks and to fill in gaps in the API
frameworks
2ⁿHas not used any framework outside of the core platform
n²Has heard about but not used the popular frameworks available for the platform.
nHas used more than one framework in a professional capacity and is well-versed with the idioms of the frameworks.
log(n)Author of framework
requirements
2ⁿTakes the given requirements and codes to spec
n²Come up with questions regarding missed cases in the spec
nUnderstand complete picture and come up with entire areas that need to be speced
log(n)Able to suggest better alternatives and flows to given requirements based on experience
scripting
2ⁿNo knowledge of scripting tools
n²Batch files/shell scripts
nPerl/Python/Ruby/VBScript/Powershell
log(n)Has written and published reusable code
database
2ⁿThinks that Excel is a database
n²Knows basic database concepts, normalization, ACID, transactions and can write simple selects
nAble 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.
log(n)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

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
languages with professional experience
2ⁿImperative or Object Oriented
n²Imperative, Object-Oriented and declarative (SQL), added bonus if they understand static vs dynamic typing, weak vs strong typing and static inferred types
nFunctional, added bonus if they understand lazy evaluation, currying, continuations
log(n)Concurrent (Erlang, Oz) and Logic (Prolog)
years of professional experience
2ⁿ1
n²2-5
n6-9
log(n)10+
domain knowledge
2ⁿNo knowledge of the domain
n²Has worked on at least one product in the domain.
nHas worked on multiple products in the same domain.
log(n)Domain expert. Has designed and implemented several products/solutions in the domain. Well versed with standard terms, protocols used in the domain.

knowledge

skill
2ⁿ level 0
n² level 1
n level 2
log(n) level 3
tool knowledge
2ⁿLimited to primary IDE (VS.Net, Eclipse etc.)
n²Knows about some alternatives to popular and standard tools.
nGood 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.
log(n)Has actually written tools and scripts, added bonus if they’ve been published.
languages exposed to
2ⁿImperative or Object Oriented
n²Imperative, Object-Oriented and declarative (SQL), added bonus if they understand static vs dynamic typing, weak vs strong typing and static inferred types
nFunctional, added bonus if they understand lazy evaluation, currying, continuations
log(n)Concurrent (Erlang, Oz) and Logic (Prolog)
codebase knowledge
2ⁿHas never looked at the codebase
n²Basic knowledge of the code layout and how to build the system
nGood working knowledge of code base, has implemented several bug fixes and maybe some small features.
log(n)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
2ⁿHas not heard of the upcoming technologies
n²Has heard of upcoming technologies in the field
nHas downloaded the alpha preview/CTP/beta and read some articles/manuals
log(n)Has played with the previews and has actually built something with it and as a bonus shared that with everyone else
platform internals
2ⁿZero knowledge of platform internals
n²Has basic knowledge of how the platform works internally
nDeep knowledge of platform internals and can visualize how the platform takes the program and converts it into executable code.
log(n)Has written tools to enhance or provide information on platform internals. For e.g. disassemblers, decompilers, debuggers etc.
books
2ⁿUnleashed series, 21 days series, 24 hour series, dummies series…
n²Code Complete, Don’t Make me Think, Mastering Regular Expressions
nDesign Patterns, Peopleware, Programming Pearls, Algorithm Design Manual, Pragmatic Programmer, Mythical Man month
log(n)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
2ⁿHas heard of them but never got the time.
n²Reads tech/programming/software engineering blogs and listens to podcasts regularly.
nMaintains a link blog with some collection of useful articles and tools that he/she has collected
log(n)Maintains a blog in which personal insights and thoughts on programming are shared