Brutal observation (not just mine, based on conversations with numerous people from various work environments across diverse geographies and cultures): many engineering organizations try to tackle their problems by stacking up more & more complex countermeasures, while the real solutions are, in fact, very simple. But unfortunately, even their most experienced engineers do not see those simpler alternatives because they belong to the apostrophe-shaped caste.
Huh, what? According to the popular theory, there are underscore-shaped (generalists), I-shaped (specialists), T-shaped (generalists with a specialty) & E-shaped (versatilists) people - but you've probably never heard about apostrophe-shaped ones. There's a valid reason for that: I've coined that term out of the thin air.
According to the definition (the one I've just come up with ...), the apostrophe-shaped people (let's call them ASPs for the sake of brevity) are ...
... specialists who suck at the basic stuff. They lack (usually unconsciously) the strong foundations of their craft and rely only on much more detailed (usually memorized by heart), specialized knowledge from a narrow expertise area.
ASPs in the wild
Here are the most typical cases of ASP I usually encounter:
- 'framework programmers' - ones who know (by heart) a particular framework (Rails, Angular, Django), but have very limited knowledge about the ecosystem, toolchain, even the programming language they use (beyond basic syntax)
- smart, (mainly) self-taught developers who were the best in their small work environments but have never been appropriately challenged (e.g., regarding how to apply the basics in practice); they are in their (very) local optimum because they don't know any better
- fellows who are simply overconfident (and frequently impatient) - they neglect the importance of basic stuff ('it's beneath me') and are too ignorant (and arrogant) to see how it affects the quality of their work
What do they all have in common? They can discuss (for hours) the intricacies of a new syntax variant that's gonna be introduced next year or deliberate endlessly on advantages of event-sourcing over CRUD, but they ...
- ... don't know how to do OO/F modeling
- ... have no clue how to structure or name things properly
- ... lack practical knowledge when it comes to so-called 'good practices'
- ... can't recognize any branching model
- ... would not know how to perform an effective peer code review, etc.
- ... are not able to answer why their daily build takes 20 minutes each time they run it (because from their perspective, it's black-boxed magic)
That sounds like significant inefficiencies, so you may wonder - why no-one points that out? If I'm right and many of the most experienced engineers belong to this group, how is it possible that no-one raises a red flag?
Well, it's quite simple: the more detailed, specialized knowledge is also more visible & impressive. It's what other people (peers, stakeholders) pay attention to, because (in the most simple words I can find) they assume that if you know something from Level 10, you must have mastered Levels 1-9 before.
But that's not really how it works (at least in software craftsmanship).
The one crucial thing many people tend to forget about is that in software crafting even if you're a 'suppa-duppa distinguished engineer', you're still using the basics everyday. They were not just the intermediate step, so you could learn something more sophisticated and forget about the core stuff (or leave it to juniors) - they are (still) the essence of your work.
Working with ASPs
To be frank, ASPs are here, and they are not going anywhere soon. Quite the contrary - the more neophytes switch to programming, the more ASPs will be available on the job market. It's not necessarily a bad thing, as long as you're aware of what it means in practice:
- ASPs struggle with poorly defined, atypical problems - the foundations (they are missing) are like tenets or principles: necessary to make educated, technical decisions that are not obvious (covered directly in textbooks/tutorials)
- ASP career is very fragile - memorized, syntactic knowledge is not only shallow but also prone to frequent change, so it gets outdated quickly
- ASPs are good in solving well defined, repeatable problems of a limited scope what makes them ... 'tools' - specialized, sophisticated, but only tools (to be 'utilized' by someone with a 'bigger picture')
- they lack the higher level of understanding and a broader perspective necessary to lead others (of any expertise outside of ASP's area)
My piece of advice is simple, though - cultivate and celebrate the basics. Treat them like kata in 'martial arts' - pay attention to them and set high standards they need to meet. Otherwise, you may end up with a very well paid team of people with a high self-esteem who are in the same time incapable of the fundamental stuff (individually and together).
