Defining Development Experience

Friday morning, one of my colleagues asked, “What do you consider to be the difference between a junior, mid-level, and senior developer?”

Being a .NET shop, the obvious answer would be to head over to Scott Hanselman’s blog and pull up this post: What Great .NET Developers Ought To Know (More .NET Interview Questions).  Scott has broken out what he considered, at the time, to be the relevant platform- and framework-related knowledge required of a .NET developer at various points in their career.

However, I do not believe that knowledge of a programming language and hosting platform solely defines a great developer, no matter the depth or detail of the knowledge.  If a developer is unable to apply that knowledge to a problem domain, it is useless knowledge – a mere parlor trick.

Given a developer has an affinity towards coding and technology, that developer should be able to learn new programming languages, new platforms, and new tools.  If a senior developer in a ASP.NET shop moves to a Ruby shop, what would define him or her as a Senior level? Language syntax and idiomatics should only be a small part of the equation.

 

A Different Perspective

I believe developer levels are determined by a combination of autonomy, mastery, and trust.  I have a started a list below. This list is not scientific – it just represents my current viewpoint.

 

Junior Developers

Autonomy: LOW

  • Not self-directed
  • Need tasks rather than requirements/user stories
  • Tasks are expected to be implemented as defined
  • Often under the watchful eye of a senior developer
  • May need assistance in finding/deriving appropriate solutions

Mastery: LOW->MEDIUM

  • Comfortable with the constructs of their main language/platform
  • Basic understanding of object-oriented programming
  • May have understanding of architectural design patterns and principles (MVC, Single Responsibility Principle)
  • Limited comprehension of problem domain
  • Can write basic tests/specifications

Trust: LOW

 

Mid-Level Developers

Autonomy: MEDIUM

  • Self-directed
  • Can work from user stories
  • Can normally find/derive appropriate solutions

Mastery: MEDIUM

  • Comfortable with the constructs of their main language and platform
  • Basic understanding of constructs of additional languages or platforms
  • Moderate understanding of object-oriented programming
  • Basic understanding of functional programming
  • Basic understanding of messaging architectures
  • Understands several design patterns and principles
  • Can write both state and interaction tests/specifications
  • Comprehends problem domain
  • Committed to continuous learning

Trust: MEDIUM

  • Can represent the needs of the development team
  • Is respected in the community

Senior Developers

Autonomy: HIGH

  • Self-directed
  • Can develop user stories
  • Can elucidate requirements
  • Can generally find, derive, or create appropriate solutions

Mastery: MEDIUM->HIGH

  • Comfortable with two or more languages/platforms
  • Moderate to high understanding of object-oriented and functional programming
  • Moderate to high understanding of messaging
  • Can explain design patterns and principles to developers, as well as non-technical staff
  • Comprehends problem domain and common domain patterns
  • Can write state, interaction, integration tests/specifications
  • Committed to continuous learning

Trust: HIGH

  • Can represent the needs of the development team
  • Can represent the needs of the customer
  • Can represent the needs of management
  • Is respected in the community

Please note that I do have emphasis on language in each level, but language is dwarfed by the need to understand and communicate the problem domain.  Also, mastery of a particular platform is less important than autonomy or trust.

What do you think defines a junior, mid, or senior developer?

12 thoughts on “Defining Development Experience”

  1. @algorithm guy I did not purposefully include or exclude any specific computer science or software engineering topic. I wanted to express the things I valued, while giving an opportunity to let others express theirs also. Much like the wording of the agile manifesto: while I value the technical expertise (language syntax, algorithm, etc.), I value these other things more (understanding of problem domain, architectural practices, community involvement, etc.).

    That said, I wanted others’ perspectives. So, from your perspective, the depth of knowledge of algorithms is what sets a senior developer apart from a junior developer. That’s great. Thanks for your input.

Comments are closed.