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
  • Writing Training materials


blog comments powered by Disqus