For example, it's pretty embarrassing that we're re-inventing databases because today's generation of "experts" can't be bothered to understand SQL. And don't get me started on how an entire generation of coders will be able to work professionally without knowing how to manage memory. It isn't difficult to find examples of youth and exuberance trumping wisdom in this field -- I've already encountered working developers who are happy to tell me how technologies invented in the early part of this decade are "totally outdated".
The evergreen underpinnings, the basic knowledge of how to build systems floats through languages and technologies.
Granted, there's some selection bias going on: I don't see many 40-something programmers in SOMA. That said: I don't see many 40-something programmers in SOMA.
Computers became cheap enough to have at home. BBSs and then the Internet took off. Computers were doing stuff -- but not common place yet. It was an odd window during a technologies birth that I think got people hooked in a way that is hard to emulate. Too early, you are on punch-cards and computers are rare. Too late, and you have app stores and iphones and stuff just generally works so it can be treated as a dumb tool. Sheer luck.
The nature of SW is to create abstractions that are reusable. So if you've built a good reusable abstraction, no one needs to know what's "under the hood" except in rare circumstances.
Ask your frontend web dev to explain some differences between the x86 and ARM ISA. Most won't have clue. Even much higher up the stack, most probably couldn't explain how TCP/IP work. For the most part it's irrelevant.
Other fields don't/can't build on lower levels in such a way that practitioners never have to learn the lower levels at all. How many surgeons are there that don't know cell biology?
Your best hope is to either continuously churn with the latest trends. Or pick a part in the stack that is likely to not change, and be a niche expert (aka, a networking guru, or x86 god). Your job opportunities will be much smaller, but if you can find your team (e.g., compiler architect or processor performance analyst) you'll likely to have a job for as long as you like.
However, and I know that people will take the opportunity to disrespect me for this, but I realized, after playing around with 3d C++ graphics in college, that I wanted to build interactive desktop applications quickly. So I learned to use a very powerful tool called Visual Basic 6. Not because I didn't understand memory management or anything else, but because it was a better software engineering decision for most projects since it allowed me to not repeat solving the same problems that had already been solved.
I know people aren't going to be able to understand this because of the reputation that Visual Basic has, and they will lose respect for me, but I am going to go ahead and say it anyway. Visual Basic 6 was and still is a better software engineering tool than C++. Why? One of the core principles of software engineering is DRY. Manual memory management means you are repeating yourself. It also means you are doing the memory management yourself rather than letting the computer do it for you. Another reason why Visual Basic 6 is superior software engineering over C or C++ is the component models.
I eventually moved on to .NET and C# because of the stigma of VB and also because the new frameworks provided better tools.
Eventually I realized that the closed source world of desktop Microsoft development was outdated since it was tied to one platform and old-fashioned business models. So I moved into web development. The most practical tool for web development was PHP. It was the best software engineering decision to select PHP to build a web application. Because it allowed me to avoid solving the same problems that many other engineers had already been faced with and solved on their own. Something that many software engineers don't understand is that not only is it important not to repeat yourself in your own code, but not to repeat solving the same problems other people have already solved for you.
So then I wanted to build a realtime interactive collaborative software application in the web browser. Because that is the most compelling, useful, and challenging type of application. So I tried to do it with PHP. Very awkward. I tried to use another popular server-side tool, Python. Again it turned out to be very awkward to do realtime collaborative software applications with Python (using things like Twisted).
So when I heard about this thing called Node.js that was built from the ground up to take full advantage of the single-threaded but asynchronous programming model of JavaScript as well as powerful underlying evented non-blocking I/O C libraries, I had to try it. Guess what? All of that software engineering done by the people who wrote those C libraries and the people who put together JavaScript and Node means that there are a lot of problems that I don't have to solve to write performant IO-intensive code on the back end! Continuation-based programming in JavaScript and Node.js just works better and is more maintainable (less code and less complexity) than the other solutions.
So I'm sorry, but if you're not adopting new programming languages, tools and frameworks, then I don't think you are a good software engineer. Because good software engineers only solve the problems that they have to, and don't continue to solve the same problems over and over.
Now -- NoSQL. So, it turns out that NONE of the many software applications I built over the years using Oracle, SQL Server or MySQL actually required 'real' db-level transactions or even involved very large datasets. And I believe that is the case for most programmers (not all of course). These days that is still true. Also, these days I only code in JavaScript (mostly CoffeeScript really). So when I heard about things like MongoDB that allowed me to store JSON directly, skip the object relational layer, and not even have to define a schema ahead of time, I had to seriously consider whether I needed a normalized relational database, SQL, to constantly reiterate joins, etc. When you examine it logically, it turns out that we were actually doing all of those things just because THAT WAS HOW YOU DID IT. With the current ecosystem of JavaScript and JSON, it is BAD SOFTWARE ENGINEERING for the MAJORITY of software projects to use a relational database, joins, etc. Why is it bad software engineering? Because you are creating a bunch of problems for yourself that you wouldn't have if you used a different set of tools.
Yes, and? You're arguing a straw man. I'm not claiming that things haven't changed for the better in 30+ years of coding, or that people should be writing web apps in FORTRAN, or that you shouldn't re-use code.
But you're being...imaginative...if you believe that the latest shiny webapp tool (e.g. Node.js) is actually as new and innovative as you're claiming it to be. Anyone who has been around long enough to have written early Windows or Mac apps will have a lot of experience with single-threaded, evented programming. (Certainly enough to know that Node.js is a wonky regurgitation of a very old idea.)
Same thing goes for your MongoDB apologetics: actually, no, the industry didn't settle on relational databases because "that was how you did it". They became widely adopted because they hit a sweet spot in terms of speed, reliability and flexibility (a spot that basically none of the current NoSQL products have yet to match).
In other words, even if you like new things, experience helps you know when the new thing you're evaluating is a pile of crap. And judicious decision-making is far more important than the latest shiny when it comes to being a good engineer.
So in your opinion Node.js and MongoDB are piles of crap?
Then, just curious, what system would you use to build the back end for a realtime collaborative web application, or an API that needs to hit several web APIs and do other IO to service each request?
And how do you recommend that we handle data storage for small business web applications? Really would like to know if there is something that is so much better than Mongo. You really think I should go back to building out fully normalized relational databases for small business web applications? What language/platform do you use, and how do you handle things like ORM?
I would like to know if you have ideas that are better. In my experience, Node.js and MongoDB (throw CoffeeScript in there too) are not crap, perform very well, reduce lines of code, and are better software engineering decisions in most cases. Have you actually tried building applications that way?
It could be that the powerful elder members of these groups ensure that their professions don't evolve in a way that would overly favor young people.
For instance, suppose that software engineers were required to hold S.D's (software doctorates, a three year professional doctoral degree that limits enrollment overall to ensure scarcity and severely limit the enrollment of international students). To get this this SJ, you are required to implement things in enterprise java, with massive amounts of complexity, in a way that is difficult to change. Also, scope is broad - making very minor changes to html code is ok for a para-software, but only under the supervision of a licensed member of the Software Bar. Anything involving "programming logic" counts as practicing software, and if you are not a member of the ASA and you do this, you can be imprisoned. In addition, suppose this group used influence over congress to place heavy and database requirements on the business world - in short, forcing them to spend a great deal of money on licensed members of the "American Software Association".
I suspect that under these circumstances, software wouldn't evolve quickly at all.
1) Doctors and lawyers are seen as exercising judgment, while engineers are seen as building things.
2) Training opportunities (in the "learn by doing" sense of "training") for doctors and lawyers are much harder to come by than for engineers. If you're looking for a lawyer who has taken half a dozen big commercial litigations through trial, you're probably looking for someone very old because there just aren't very many of those trials that happen. Same thing if you're looking for a doctor with half a dozen experiences treating a patient with aggressive cancer. But how hard is it to find a young software engineer with half a dozen big websites under his belt?
Now, I don't think either perception is completely true, in the sense that I think people underestimate how much judgment software engineers exercise and overestimate how quickly they can build up valuable experience.
For the same reason as engineers, it comes down to keeping up with the field. I don't know for a fact that an old physician hasn't kept up with the field, but I do know a younger one can only be so behind.
You have to be clear about the relative rate of change, though: it's nothing like software, where technical knowledge from a decade ago is completely irrelevant today. Medical appointments are pretty much the same as when I was a kid.
The more important point, for me, is judgment: older doctors are far less goofy and spastic than younger ones. That means more conservative treatment, discretion, etc.
I have a young child, and I have had enough conversations with doctors and nurses to see that standards for medical care _do_ change rapidly enough to matter. Some examples:
- At the hospital where my wife gave birth, the SOP is an epidural and continuous fetal monitoring. This means that very little equipment is available which supports mobility. The hospital staff had a hard time wrapping their heads around the idea _lying on your back is painful_ for someone in labor. The human body hasn't changed, but the medical practices are currently optimized around the assumption of an epidural and keeping to a schedule. Doctors who have let this assumption ossify will force the hands of patients who simply don't know otherwise.
- My pediatrician's practice currently recommends avoiding peanut butter until age... three? I think. However, there is recent research on some children of Jewish ancestry in the UK vs. Israel, suggesting that their very low rates of peanut butter allergy are probably due to environment rather than a genetic predisposition. If further studies confirm that finding, the AMA will probably revise its suggestions, causing all pediatricians to start offering the _opposite_ advice.
- Recent research (sorry, don't have the reference) showed higher rates of food-related allergies when children were exposed to solid foods earlier than 3 months.
[edit for list formatting]
Look at your examples: in the first, you're talking about the difference between laying down and...not laying down. And how long have people been giving birth in hospitals?
In the second example, you're discussing a subtle difference in the age at which kids are fed a specific food.
Medicine moves slowly and deliberately. Software does not.
In the U.S., we've been giving birth in a hospital under the supervision of a doctor for several generations now. When my grandparents were of childbearing age, there were some pretty horrific practices. Now they are recognized as such, but the turning point occurred during someone's lifetime. Likewise, it doesn't sound like a big deal, but the culture of "laying down" has a significant impact on how we as a culture have babies:
- The mother's position is not naturally conducive to popping a baby out. This adds difficulty to pushing.
- The mother's position puts all of the baby's weight onto her back, rather than on her legs. This causes more pain, which can lead to further medicinal intervention (e.g. epidurals or IIRC narcotics).
- Motion (walking, lunges, etc.) is helpful to get a fetus into the right position (head down, facing mother's back) and to advance its station. This benefit is lost while lying down.
- Gravity is not of assistance while lying down. It helps while squatting.
Etc. What sounds like such a little thing can end up making a world of difference. And today's ossified doctor who insists that the mother lay on her back is very similar to today's ossified developer who insists on using the Win32 C API for trivial data-entry UIs. Regardless of the rate of change of the field as a whole, ossification and inflexibility is problematic with whatever is changing right now.
Perspective, please.
The exact rate of change is moot. The rate of change is "enough" over the course of 5-10 years, that it makes an impression on me.
But its our (your doctor's) knowledge of the human body that has changed immensely every decade.
But often in programming you have managers that are ignorant, outdated and sometimes even complete idiots. Why do we put up with that? Why do accept that our managers are not more capable than we are?
I think its just human nature that your boss (or management in general) is out of touch and an idiot. It's why politicians are clueless -- until you get elected and then you suddenly are viewed as clueless too.
By that I mean that any explanation of why people over 30 really are worse programmers, will be interpreted as "discrimination" and therefore wrong. Any explanation of why people over 30 are better programmers, will be taken as evidence that there must be a lot of discrimination since the older programmers are not only not worse, but better.