April 1st, 2018
Effective software developers know how to manage their ignorance. Studying the inner workings of each dependency and every layer of your stack is a luxury you often can't afford, so it's important to know how and when to make leaps of faith.
More than any explicit technical knowledge, this intuition is perhaps the biggest thing that differentiates experienced programmers from inexperienced ones. When I first started coding, painful awareness that I didn't understand how every piece worked paralyzed me. I felt like I couldn't possibly move forward until I had a grasp of everything my task depended on. Now, I realize that's just part of the job.
Now of course you don’t want to idly accept that fate! It's worth diving in when you can in order to learn more of the layers at play. Curiosity is valuable and rewarded—the best developers are those who can't help but go down rabbit holes of technical arcana, the ones who love to reverse-engineering systems, the ones who are never satisfied with the depth of their knowledge.
But you can't always do this. Sometimes, you just don't have the mental bandwidth, and sometimes deep knowledge of the marginal tool or library works is not important to achieving the goal at hand. Technological complexity is a fractal, with each layer in the stack giving way to another infinite layer of interestingness. People build entire careers on distributed systems, chip designs, programming languages, core libraries... the list goes on and on. A key component of strategic ignorance is differentiating when diving in to learn something more deeply is productive towards your goals versus when it simply feels virtuous. (The hard part is that you have to decide what that means!)
When to apply this strategic ignorance is less a transferrable set of rules than an intuition. As far as I know, it can only be learned with time and learning from mistakes.
Each layer shown here is an entire career in and of itself. And many dozens of careers, if you zoom in to that layer. You just need to decide which level you want to focus on for now.
After all, that's the real magic of software engineering: building abstractions on top of one another, starting from electrical signals, silicon, and transistors on to bits, registers, and machine code on to virtual memory, higher-level languages, and libraries. Understanding the systems underlying your code is valuable, but it's not a blocking prerequisite to being productive. Allowing yourself to be swallowed into the infinite cycle of "I need to learn more before I can start" certainly will block you, however.
Once you realize that the complexity of technology is scale-free—that every layer has as much nuance as one abstraction above it—you can accept that ignorance is normal, and you can move on and actually write the software you set out to build.
Keep in touch!