I've been coding professionally for 26 years across several languages, including C, Perl, ASP v1-3 in JScript, JavaScript since way back in the Before Time when it was LiveScript, CSS from its alpha, PHP and Node (its JavaScript runtime) from their betas, and more recently, Python, Dart, and lately a little Go. If you asked, I’d tell you with boundless confidence that I'm an expert developer, but how do I really know that? It’s easy to spot a bad engineer over time, but how do we qualify a good one? More importantly, how do we build one? What are the qualities or skills that we must not only identify in hiring, but actively cultivate in our teams and ourselves?
The following is an organically-developed model I’ve used in which developers descend deeper through a progression in a "Language Proficiency" skill set: how much they understand the core skills within a specific language. These skills are the same for all languages:
- Syntax and Grammar: Basic rules and structure of the language, as well as foundational programming concepts as implemented by the language (e.g., inheritance, abstraction, polymorphism, encapsulation).
- Idiomatic Coding: Writing code in a way that is natural and considered best practice within the language community, leveraging language-specific features and idioms.
- Patterns and Standards: Utilizing approaches deemed best practice by the language community, adhering to regulatory compliance, and being aware of relevant standards.
- Internals and Ecosystem (which I like to call the “Ins and Outs”): A deep understanding of applicable translators (e.g., compilers, interpreters, etc.), engines, runtimes, debugging techniques, and the intent and configuration of supporting technologies like IDEs, bundling, test runners, linters, and frameworks.
The levels of progression through these skills might be:
- novel familiarity: low proficiency (< 15%)
- actively learning: low-medium proficiency (15-50%),
- proficient: medium-to-high proficiency (50-75%),
- mastery: high proficiency (> 75%)
The naming here is not as important as the expertise each implies, nor are their exact values for proficiency percentages as important as the fact that the different levels exist.
This is the progression from intern to expert:
Here's a work-in-progress rubric for determining mastery level:
Achieving a level of mastery in a software language isn’t about ticking off boxes. It's about evolving as craftspersons through progressively deeper and broader understanding of the technologies we use. As we advance, each skill informs and reinforces the next, empowering us to craft code with an ever-growing appreciation for quality and maintainability, ultimately delivering more value to our products and to the developers with whom we collaborate to create that value.
Top comments (3)
Good article. "levels of progression" do correlate with my experience.
Good enough skills with React came after 2 years for me, probably there are way more tricky things.
Funny to see things like "learn React/C/Golang in 2 weeks", grasp of syntax !== proficiency.
Things tend to take a long time to learn because we learn them haphazardly. Typical learning often leaves us to stumble upon key understandings and moments of insight. Using a good model is a little like a super power. The formula for learning most topics is basically fundamentals, nuances, patterns, and content. Also important is that topics can stack, and even an imperfect understanding of an underlying topic can bolster your ability to grasp a new one. Something like React should be remarkably easy to learn for an experienced JavaScript developer. Its syntax and grammar are actually quite small. It's all about patterns, which are well documented. Languages like Go are easy to learn if you understand the principles—the underlying building blocks—of software languages (especially C-like languages).
Yes, React mostly about patterns and anti-patterns. There are different apps, somehow different approaches.