Coding - Dillon Shook

Below is a breakdown of my self-rated skills including comments on each category from the Programmer Competency Matrix that circulated the internet.

(From the description: 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.)

Many of the categories I’ve reached level 3 in have several more levels to attain in my opinion. I also think another missing piece from the matrix is having the judgement to make the tradeoff between a completely robust solution and acquiring some technical debt to launch a solution right away.

Computer Science
	2ⁿ (Level 0)	n² (Level 1)	n (Level 2)	log(n) (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.	While it's rare for me to need to use any of the top level algorithms in my day to day work it is very important to have them in your toolbox to pull out when the situation is right.
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.	I have a good understanding of graph algorithms and NP problems, but dynamic programming and numerical computation algorithms are something that I encounter very rarely.
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...	Understanding "the whole stack" is something that I think maybe the top 0.01% of programmers actually can try to claim. The concepts I'm familiar with but the intimate details aren't something I can claim to know.
Software Engineering
	2ⁿ (Level 0)	n² (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	I've been using Git over a year now and have also trained several people in its use. I've also beaten the fun githug.
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	Setting up a build automation system from scratch is something I've done in the past for a few projects, but not something I particularly enjoy.
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	I've done a fair bit of automated testing in JavaScript primarily on a sales API and some other projects. I haven't done UI automated tests yet though.
Programming
	2ⁿ (Level 0)	n² (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.	Even though I think I have reached level 3, architecting a project with very mutable requirements is a life-long skill.
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.	Making the change in the right part in the stack is one of the key parts of being a functional developer.
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	As the original comment said, this is a very crucial area. I'd put myself about 80% to level 3, the only thing holding me back is lots of experience writing spec documents.
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.	Consistent white space usage and consistency is one of my programmer OCD ticks so I've got that checked off. File license headers and a summary seems over the top to me though.
	2ⁿ (Level 0)	n² (Level 1)	n (Level 2)	log(n) (Level 3)	Comments
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	Even writing C# that maintains your file structure in your project is a huge step up from C++;
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.	Reorganizing previous contributors projects is a necessary pain.
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	Level 3 except but haven't used libraries/asserts to do pre/post condition checks.
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	I've been working more and more on this one, but a great tool is a centralized error monitor that captures uncaught errors for anything that slips by for a user to see.
	2ⁿ (Level 0)	n² (Level 1)	n (Level 2)	log(n) (Level 3)	Comments
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.	Arguably the same as defensive coding.
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	VIM FTW.
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	C# would be level 3 for me, other API's I'm looking at the docs for nitty gritty stuff.
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	Finding the right framework for the job (outside of the braindead ones that are widely used can be an art. My advice is to find well supported ones.
	2ⁿ (Level 0)	n² (Level 1)	n (Level 2)	log(n) (Level 3)	Comments
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	I don't have much experience following or writing formal spec docs though.
scripting	No knowledge of scripting tools	Batch files/shell scripts	Perl / Python / Ruby / VBScript / Powershell	Has written and published reusable code	The line between a "script" and "program" is very vague.
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.	Level 3 is not the top, but I fit the criteria of this level 3. Designing schema's, optimizing queries, processing data, and performing DB maintenance is all a day in the life for me.
Experience
	2ⁿ (Level 0)	n² (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)	Who actually uses Erlang, Oz, or Prolog these days? Async JavaScript and threaded C# should meet the bill though I think.
platforms with professional experience	1	2-3	4-5	6+	Platform is also somewhat ambiguous here.
years of professional experience	1	2-5	6-9	10+	This is an easy to misuse metric in my opinion. There are both good programmers with less than a year of "pro" experience and bad programmers with more than 10 years of "pro" experience. I've met some of both.
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.	Web development is my primary domain.
Knowledge
	2ⁿ (Level 0)	n² (Level 1)	n (Level 2)	log(n) (Level 3)	Comments
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.	I've tried and used a lot of tools, Visual Studio with a Vim plugin is hard to beat though.
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)	I've been exposed to Prolog briefly, but as I said before, those languages seem mostly academic to me.
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.	I've written entire codebases so I think that counts.
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	I've been excided for the upcoming (or perhaps released when you're reading this) Svelte 5 release and built BreezyTerm with it.
	2ⁿ (Level 0)	n² (Level 1)	n (Level 2)	log(n) (Level 3)	Comments
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.	Writing a compiler (even a toy one) really takes your knowledge of programming to the next level.
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	Working on some of these at the moment. Gödel, Escher, Bach was one of the last I got through.
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	Keeping up the passion and effort to to maintain a blog takes serious effort but having you read it makes it worth it.