Grading Myself Honestly on the “Programmer Competency Matrix”

The reality of my current skills

Update (Monday, November 6th, 2017)

I am on a new team now doing a ton of Python and C++ development. In addition, I am learning new technologies such as KDB. I think this is a great team to accelerate my re-learning.

I will come back to this post in the beginning of 2018 to grade myself again.

Introduction

So, to start off the technology and programming blog, I figured I would rate myself according to the “Programmer Competency Matrix.”

To give a little background about what my skills are like, I graduated Binghamton University with a double degree in Computer Science (BS) and Mathematics (BA). I have consistently said that the foundations I learned in school are shaky because I rushed through the degree having first been in school for three years for chemistry.

I currently am working full time as a software engineer at a bank and have been working there for a year and a half. My day to day work includes a lot of database development (something I never touched in school, so all my experience is from industry), some Python scripting, a little bit (and I mean a little bit) of Java (Spring) programming, the bulk of my programming is in an internal language. The other half (probably more) of my job is supporting our internal applications to monitor production failures and direct client support (our traders).

The reason for this post is to try to actively track myself as I practice and continue on with this industry. This is also for anyone that wants to realistically track their own progress as well. Baring it all out there and revisiting yourself a month, six months, two years down the line is a great way to show yourself how far you have come.

So, let’s get on with the rankings.

Computer Science

Data Structures

Level 3: “Knowledge of advanced data structures like B-trees, binomial and fibonacci heaps, AVL/Red Black Trees, Splay Trees, Skip Lists, tries, etc.”

One thing I really like looking into and reading is data structures. Data Structures was one of my favorite courses in school, and because of that, I would learn a lot about advanced data structures outside the typical arrays, linked lists, and dictionaries.

I still try to keep up knowledge of these things even if they aren’t a big part of my day to day work.

Algorithms

Level 1: “Basic sorting, searching, and data structure retrieval algorithms.”

This is one thing I haven’t kept up with since I graduated one and a half years ago. So, I am just gonna chalk it up to level 1, and maybe I’ll pleasantly surprise myself as I practice more in the coming weeks and months.

Systems Programming

I originally rated myself as 2 on this, but I’ll drop it down to 1 because of rusty abilities. I do however, know parts of level 2, so I might be able to claim 1.5

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, multithreading, synchronization primitives and how they’re implementing, able to read assembly code. Understands how networks work, understand of network protocols and socket level programming.”

Level 1.5: All of level 1 plus ability to read assembly code and understands kernel mode vs. user mode.

It’s tough when you are not actively practicing on a lot of these concepts, which is why I started blogging to begin with; I want to able to bring myself back up to speed, strengthen my foundations, and improve upon them.

Software Engineering

Source Code Version Control

Level 3: “Knowledge of distributed VCS systems. Has tried out Bzr/Mercurial/Darcs/Git.”

Pretty sure most of us are level 3 at this point, even if you just started yesterday since it is the de facto source control system.

Build Automation

Level 2: “Can set up a script to build the basic system.”

Automated Testing

I am between level 0 and 1 here.

I did basic testing in school and have written code in a TDD manner (level 2) during training but I really haven’t done much of anything here in quite some time.

So, I’ll create my own level again here.

Level 0: “Thinks that all testing is the job of the tester.”

I don’t actually think this but with my current skill level, I probably have about as much knowledge as this person.

Level 1: “Has written automated unit tests and come up with good unit test cases for the code that is being written.”

Yes, I have done this before, and even recently with the internal languages. But I am still not “good” at this.

Level 2: “Has written code in TDD manner.”

At work, we have trainings, and we did learn how to test in TDD but I have since forgotten all my knowledge here.

Level 1.5: I can test and I know what TDD is. I’m just not “good” at it and am not practiced enough.

Programming

Problem Decomposition

Level 2: “Able to come up with reusable functions/objects that solve the overall problem.”

Systems Decomposition

Level 1: “Able to break up problem space and design solution as long as it is within the same platform/technology.”

Communication

Level 3: “Able to understand and communicate thoughts/design/ideas/specs in an unambiguous manner and adjust communication as per the context.”

Many people believe that I am very good at communication so, I will put at this at level 3. Though, I will admit, it really depends on the context, and my knowledge. Realistically, I should shift towards level 2 since I am able to hold a conversation on many different things but communicating a solution in an environment I don’t know will hinder how effectively I communicate.

I guess this is the case with most people but some people actually thrive better than others in an unfamiliar environment and are able to pick things up quickly.

Code Organization within a File

Level 2: “Code is grouped into regions and well commented with references to other source files.”

Sometimes I feel like, on a rapid development team, that it’s hard to inherit some projects when you first come in because of the fact that a lot of stuff is not commented.

I do try my best to be able to do that for my code.

Code Organization Across Files

Level 1: “Related files are grouped into a folder.”

I can probably see myself as level 2 because I do try to separate files based on unique purpose at work, but for now, I will keep it at level 1.

Source Tree Organization

Level 1: “Basic separation of code into logical folder.”

Code Readability

Level 2: “No long functions, comments explaining unusual code, bug fixes, code assumptions.”

Defensive Coding

Level 1: “Checks all arguments and asserts critical assumptions in code.”

Error Handling

Level 1: “Basic error handling around code that can throw exceptions/generate errors.”

For some reason, I always forget about error handling in programming. I will do my best to make it an active part of my thought process.

Update: On the new team, my manager always reminds me about this so it’s being seared into my brain.

IDE

Level 3: “Has written custom macros.”

I can see myself shifting back into level 2 on this one because I haven’t written a custom macro in a while, but I did do that a lot in school.

API

Level 0: “Need to look up the documentation frequently.”

I have no shame in admitting this. I frequently have to do this, especially since I context switch a lot at work in terms of what I have to do during sprint cycles.

Frameworks

Level 1: “Has heard about but not used the popular frameworks available for the platform.”

I have used some frameworks but not extensively so, I’ll leave this at level 1.

Requirements

Level 1: “Comes up with questions regarding missed cases in the spec.”

Definitely a work in progress but I am much better at identifying missing points.

Scripting

Level 2: “Perl/Python/Ruby/VBScript/Powershell.”

Hard to believe to me that I have done a little of all of these.

Database

Level 3: “Can do basic database administration, performance optimization, index optimization, write advanced select queries, able to replace cursor usage with relation SQL, understand how data is stored internally, understands how index are stored internally, understands how databases can be mirrored, replicated etc. Understands how the two phase commit works.”

I have knowledge in much of level 3 except the last few points with database mirroring and replicating and how the two phase commit works. So, I should probably rate myself more of a 2.5, rather than 3.

Experience

Languages with Professional Experience

Level 2: “Functional, added bonus if they understand lazy evaluation, currying, continuations.”

I am more comfortable on level 1 here (Imperative, OOP, SQL) but a lot of the internal work I do with internal languages has to do with the functional paradigm.

Platforms with Professional Experience

Level 1: 2–3

Years of Professional Experience

My own made up level of Level 1.5 for 1.5 years of professional experience.

Domain Knowledge

Level 0: “No knowledge of the domain.”

Yep, none whatsoever especially since I really don’t know what people mean by “domain.” Once I research this, I’ll get back to this rating because the other levels kind of given me an idea what a domain is but I am unsure.

Update: This has since changed to Level 1: Has worked on at least one product in the domain.

After researching this, it turns out the internal language I was using is classified as a domain specific language and since that was the language I used most on the previous team, I have worked on a product in the domain.

Knowledge

Tool Knowledge

Level 2: “Good knowledge of editors, debuggers, IDEs, open source alternatives, etc. For e.g.s someone who knows most of of the tools from Scott Hanselman’s power tools list. Has used ORM tools.”

Languages Exposed to

Level 3: “Concurrent (Erlang, Oz) and Logic (Prolog)”

Did Prolog in school and found it fun. I am currently learning Elixir, which runs on the Erlang VM.

Codebase Knowledge

Level 2: “Good working knowledge of codebase, has implemented several bug fixes and maybe some small feature.”

Update: This has since been bumped down to Level 1: Basic knowledge of the code layout and how to build the system

I switched to the new team barely 2 months ago so I am still working out the kinks of the new codebase. I have however implemented a few bug fixes and a few small features so I can probably go for a 1.5 here but we will keep it 1.

Knowledge of Upcoming Technologies

Level 2: “Has downloaded the alpha preview/CTP/beta and read some articles/manuals.”

I definitely get tech happy and love to read about new things. Though, I rarely follow through in creating something in these new techs. But this is what blogging is for — to hold me accountable for trying new things out and showing them to the world.

Platform Internals

Level 1: “Has basic knowledge of how the platform works internally.”

Books

This is an interesting part of the matrix because level 3 states: “Structure and Interpretation of Computer Programs, Concept Techniques, Models of Computer Programming, Art of Computing Programing, Database Systems by C.J. Date, Thinking Forth, Little Schemer.”

I own a lot of these books because I bought them after I graduated college but I actually haven’t read through much of them because these are really dense books. I also own books from levels 2 and 1 as well. I am willing to read through them but they will take me quite a long time to read through.

So, I won’t rate myself on this one because it’s a bit of an odd question, at least to me.

Blogs

Level 2: “Maintains a link blog with some collection of useful articles and tools that he/she has collected.”

My actual level — Level 1.8: I am just now maintaining a blog and I am about to start writing a bunch of insights and thoughts on programming (which is level 3) on the matrix.

Conclusion

Well, there you have it; An honest as possible rating of myself on each of the matrix points. I am really excited to get started on blogging about technology. It’s honestly one of my favorite things to read up on and I want to share it with the world. In addition, I want to get incrementally better at what I do and will share with the world my projects from inception to finish with all the bad insights and programming practices on the way.

I would love, if you read this, to share with me your rankings. You can simply add up each part in each of the 5 sections and share the results. You don’t have to go specific but you can if you want!