The differences between the way younger and older programmers think
Modern programmers tend to not have the same level of understanding of the machines they work on. It's weird but when I'm trying to figure out why my Java-based web service that uses Hibernate
Modern programmers tend to not have the same level of understanding of the machines they work on. It's weird but when I'm trying to figure out why my Java-based web service that uses Hibernate to talk to an Oracle database (as an example) isn't returning data like I expect, my brain automatically goes down into levels that, frankly, it doesn't need to. For example, my brain starts thinking about what the line traffic must look like and what the JVM is doing at a low level. It thinks about what OS messages are being passed to make a connection happen. It thinks about how memory is being paged in and out and even how the CPU is being switched into different modes as a result. It's viewing the problem through the entire technology stack, all the way down to the bear electronics (I was an EE major for a while in addition to all the CS stuff).
To be clear, virtually all of this is subconscious and entirely irrelevant to the problem I'm solving. But, what it does is it provides me a holistic view of what I'm working on that few others can match. How this usually manifests is a "gut feeling" about what the problem is and more times than not it's either the right answer or at least on the right track. It's often times hard to explain to others what I'm thinking or how I arrived at the solution, though I always try to do so, for my own benefit as much as theirs.
Basically, there's an intuitiveness that people of my age and experience tend to have that is unmatched by most younger programmers and it's not strictly a function of experience, it's something more ingrained. There's a deeper level of understanding of how it all fits together because we started at a time where you necessarily worked at those lower levels, and then because we stuck with computers as they got more complicated we had the opportunity to learn each layer as it was added. Nowadays, you basically see these giant, monolithic systems that are so complex it's no wonder few people gain a deep understanding of them.
So, in that regard, I'd claim people like me are superior.
But, here's the flip side of that: there's a down side to all of this and it's where the younger programmers can actually say they're superior and I'd agree and that's that people like me don't handle abstractions as well.
When a younger developer is drawing boxes on a whiteboard and describing an architecture, it's very natural for them. For me, it's difficult because my brain is trying to work out the details in the boxes! In fact, it's difficult for me to turn that off and focus just on the high-level! I've had no choice but to learn how to do this because I'm an architect these days, not coding as much as I used to, but it's still difficult and I still struggle and I see younger programmers not struggling with it. It's more natural for them to think more abstractly, and given that most of their work IS more abstract that gives them an advantage.
So in that regard, I'm the inferior one.
So, basically, I don't think any modern developer should feel inferior. You should recognize that the time someone of my age grew up in gave us a unique experience. I wrote about this in another thread in more detail but for those of us that were deep into computers in the 70's and 80's, we had an experience that is entirely unique. We started low-level, because that's all there was, and then we grew WITH the machines. Modern devs don't have that benefit so it's very natural that you wouldn't have the same perspective. But, you've got your own advantages that people like me don't (at least not to the same extent) so it's six of one, half-dozen of another in my mind. Just be the best developer you can be today, that's all you can do.