The right knowledge for each problem ...

A friend emailed me an interesting quote:

"... what little evidence we have about programmer productivity points to a productivity distribution that's skewed with a long tail of incompetence"

-- Larry O'Brien

However uncomfortable it might make you, I believe there's a certain amount of truth in this quote.

For any one given task, there are always developers able to complete it much faster than others - and I'm not talking 10% or 20%, I'm talking about delivery in a quarter or a tenth the time.

But is it always the same developers who deliver quickly, or does it differ from task to task?

I've been on both sides of this productivity ratio - once developing (from scratch) in a week a module that another developer had spent six months failing to complete (long, true, story that's not entirely mine to tell). Ratio of 26:1. And, seeing another developer deliver code in an afternoon that I was convinced would take three or four weeks. Ratio around 40:1.

While there are undoubtedly developers that are simply incompetent, I'm convinced that in most cases the underlying issue is one of knowledge - does the developer have the right skills, do they understand the right concepts, in order to get the job done effectively and quickly.

Given the wide variety of tasks that a typical developer has to perform, what concepts, knowledge and skills should they have?

I've come up with this list of concepts, distinctions, techniques and knowledge that every developer should know. Have I got everything? By no means - I've probably got half, if I'm lucky.

Here's the $64,000 question - how many of these items do you know thoroughly?

Bonus question: What would you add?

Abstraction vs Implementation

Amortisation

API Design – noun/verb vs Fluent

Authentication vs Authorisation

Bandwidth vs Latency

Caching:
Expiry strategies and memory use

Class Oriented vs Object Oriented

Class, Instance and Sequence diagrams

Colour Modelling

Compiled vs Interpreted code – byte-code, p-code, IL

Complexity:
O(x) notation, linear vs quadratic vs exponential vs factorial complexity

Connectionless vs Connected

Database management:
Schema design, query optimisation and indexing

Declarative vs Imperative programming

Dependency injection

Duck Typing vs Strict Typing - Type Inference

Encapsulation

Encryption vs Obfuscation

Entity Relationship modelling

Entropy, Compression, Encoding and Encryption

Ethernet, TCP/IP and UDP/IP

Events - Singlecast vs Multicast

Exceptions vs Error Codes

Explaining technical issues to non technical people

Functional vs Procedural programming

Hash tables and arrays

Identity

Indirection

Inheritance vs Composition

Instantiation

Liskov Substitution Principle

Lists/Stacks/Queues and Trees

Memory heaps and fragmentation

Memory management
Garbage collection vs malloc/free vs reference counting, stack frames and pointers

Method Missing

Mutability vs Immutability

Mutual Exclusion and Locks

Object vs Component Orientation

Pattern Matching and Regular Expressions

Polymorphism, Abstraction and Interfaces

Pre-emptive vs Cooperative multitasking

Proxies and Delegation

Recursion vs Iteration

Requirements vs Specifications vs Implementation

Semaphores, Spin Locks and Monitors

Single Responsibility Principle

Source code management - labels, branches and versioning

State machines - deterministic vs non-deterministic

Stateless vs Stateful

Teach a class and Present a seminar

Technical documentation

Testing
Unit vs Integration vs System vs Performance vs User Acceptance

Threads vs Fibres vs Processes

Transactions
Commit/Rollback vs Complete/Abort

Unicode vs ASCII, UTF-8 vs UTF-16

Write Training materials