Over the past few years, as I've been working and talking with many developers, I noticed a repetitive pattern. It's been troubling me a lot, and I keep thinking and talking about, trying to understand, or even excuse.
Why are you taking this approach?
- I don't know. It was in some article.
- I don't know. I copy-pasted it from X.
- I don't know. I was doing it in my previous project.
- I don't know. Someone told me so.
This pattern is consuming — instead of creating. Consuming — without questioning. Consuming and hiding behind an authority.
I saw developers taking other people's solutions for granted. Not thinking twice about the approach, not bothering about analyzing it. Ok, when this is Dan Abramov telling you how to use React or documentation saying that this is the only way to use its API, then yes, you probably should agree with it. Yet, when you're using some tech content without at least a bit of skepticism, then well, you still might go far in your career, but it also may hold you back.
At the beginning of my career, I would never, ever, post anything technical on the internet. I thought that if someone was brave enough to post a blog post or take part in a tech discussion, they always know what they are doing. I couldn't be more wrong!
At some point, I realized that most of the technical content on the internet is bullshit (this blog may be bullshit as well). Tutorials show harmful patterns. Articles have plenty of conceptual mistakes. And people are not perfect, either! Senior developers are not always good developers. Tech leads' solutions may be far from perfect. Well-selling, correctly working app's architecture may be entirely fucked up. I saw people in senior positions who don't know shit about programming! And yet they write on the internet about it! And then someone comes and be like I used solution suggested by this person, they're a senior at company X. There is, of course, some reasoning to it. However, appeal to authority is deeply flawed.
One of the great commandments of science is, "Mistrust arguments from authority." ... Too many such arguments have proved too painfully wrong. Authorities must prove their contentions like everybody else.
~ Carl Sagan
The sooner you realize that there's bullshit everywhere, the better. We all try to do our best, yet are all humans who make mistakes and years of experience, the number of blog posts or salary doesn't account for the person's knowledge. After all, we can all post on the internet whatever we want.
We are lazy. We're mostly not stupid, but just lazy. If someone's giving us a solution to the problem and it works, then why think about it? Why not copy-paste it and let it be shipped in the production code?
We don't have time. Coming up with logical arguments may cost someone reading source code for a couple of hours, writing plenty of code to prove their point or spending a significant amount of time on research! Though, we all have deadlines, don't we?
It's comfortable. Logical reasoning often requires coming out of your comfort zone, as you need to get some new knowledge, think harder than usual to understand some concepts, or do some extra work. Whereas staying in the comfort zone is something we tend to (unconsciously) embrace.
We don't believe in ourselves. People, especially in the beginning of their careers, tend to think that their solutions won't ever be good enough. Thus they rely on the mentioned earlier authorities and never question them.
Realize that there's tons of misconception in the world. People and their solutions aren't flawless.
Adapt solutions to your particular use case. There's no one-size-fits-all solution for everything. Compare different approaches, analyze them. Tutorials or articles show an idea, but may not present production-ready code. Always analyze it before you decide to use it.
Believe in yourself. Your solutions are not any worse than the ones on the internet.
Keep learning, and be curious. Being a developer is about constant learning. Be sure you understand the library or framework you're using. This is the way to make the most out of it. People sometimes use libraries without a more profound understanding. It leads to misusing the core concepts and writing more complicated or less performant code that they could have.
Don't consume. Create. Ask questions. Stay curious.