Not so weird.
We're now 30+ years from the dawn of the desktop PC marketplace. 20+ years from the dawn of the web and associated original internet startup mania. 10+ years from the post-collapse web 2.0 resurgence with Ajax and frameworks. Pushing a decade since the introduction of the smartphone.
Every bright-eyed twentysomething that could bask in the glory of their wunderkind youth at the start of each of those eras -- everybody who knew PG was talking to/about them in his essays -- has now wound the course that time dictates everybody's gotta take: they arrived at being older.
So of course there's a lot of interest in what that means in the software industry. And maybe some rueful reflection from some participants on what they thought that meant when they were younger.
This. I don't pump ridiculous amounts of code, but what I do, Works, and is mostly bug free or easily repairable. Thus I have a reputation as a guy who gets things done.
Companies should really be aware of the maintenance overhead caused by fixing old badly done code.
Maybe it's the market dynamics. Most code bases are new (their age is not measured in decades) so the organizations have not gained the institutional understanding what a sinkhole of profits badly executed code is. Some companies use this as a business model an charge "maintenance costs" and such things so there is also the pathological motivation to maintain this status quo of "implement cheaply, fix expensively"
However, there's a slight problem: We don't need that level of solidity. The rest of the stack is comparatively less solid, so his time would be better spent getting ten easy, frequently-hit bugs out of the rest of the codebase, rather than get one unlikely-to-hit bug out of his.
He hates producing code that's not up to his standard, but when our fleet of cars consists of a Lamborghini he built and a beat-up Yugo some other guy built, I'd rather my friend changed the rusty oil of the Yugo rather than make sure that all the bolts on the Lamborghini are within tolerance.
This is a fascinating theory on programming ageism. It's common knowledge that most software buyers undervalue tech debt and the costs of maintenance/upgrades. That presumably translates for less interest in planning, experience, and thoroughness compared to speed.
And most of that isn't controversial, but I rarely see it raised in the context of preferring young and inexperienced devs. I suspect there's at least some truth to it, because highly self-aware software companies seem uncommonly willing to poach older experts.
I love to build things and I am not keen on sliding into a management position. But this becomes the easiest career path once your soft skills start to increase to the detriment of raw coding skills.
On the other hand I've seen enough engineers with decades of experience who said no to going into management and who are now basically irrelevant.
Both these outcomes are scary but they seem to be the defaults for someone who goes with the flow.
A good way to stay relevant is to change jobs now and then (maybe every 5 years or so), and also using your own time to learn new things.
When you are a junior engineer you just crank out code and the level and employability of your skills automagically increase. But after some time this free lunch quietly stops. You suddenly have to manage your career.
You are absolutely correct: You should only go if you are interested. But if your alternative is to be jobless....
Or at least get setup, so you have money in the bank. You never know when you might need it later on in life. If you do experience tough times, for finding a job.
Do you really believe this is true? Do you think general industry culture reflects experience and maturity? No, it is the exact opposite!
Isn't this an advantage as well? How many ninja stunts have you seen without hundreds of bugs and being easily integrated into existing stuff and not requiring to change many existing things because they don't fit anymore with the genius code (and thus replacing well tested bits with alpha quality code)?
Being older helps to plan well before you code and get a result that does the job. As you said: getting things done.
I confess that, once upon a 5 A.M., I thought it would be clever to store X-Y position values not as a tuple but as two halves of a single int. There was a reason, but looking at it the next day there certainly wasn't a good enough reason. That set my low-water mark for coding while tired.
I am familiar with the stereotype you're referencing, and have seen it from myself and others. However, to genuinely answer your question of "how many ninja stunts have you seen without hundreds of bugs..." I must answer: Many.
For the first 3 years of my company's life, I a full half of the code was done as "late night ninja coding". In between getting steady work done, I would often think about a few harder problems/features/projects, and take notes from those thoughts over a few days/weeks,on what would be the best method of accomplishing said problem/feature/project. I called it the "think twice, code once" mentality.
Eventually it would culminate (almost always in the evening) when I would either realize one last detail that made it all click, or realize that there was nothing left to plan out, and it was time to dig in and code.
Cue an overnight session where all of that planning would be brought into reality. With tests.
Even now, when my lifestyle and product allows for less of this, I still do so occasionally and it brings me great joy, significant productivity and very few bugs. Think twice, code once, and of course YMMV.
If a manager doesn't think you will be up for a 36 hour shift, maybe they won't hire you.
> Why would we pay for someone with 10 years of generalist experience overall when we could hire someone with 5 years of experience in technology X.
They nominally claim to hire smart, generalist engineers.
I think I'm more similiar to what you describe about tourself than about young devs.
When I was 25 I also thought differently of myself. And I think when I reach 50, I'll look back and marvel at how silly I was at the age of 40 :-)
> This is idiotic. People over 40 trade one set of skills for another (source: I'm over 40). You lose short-term memory, can't juggle too many things simultaneously, and aren't always up to date on every latest fad. But what you gain is fantastically valuable: intuition, abstract thinking, systems thinking, ability to detect patterns in large systems, ability to notice that certain problems have been solved in a different field, and lots more. As I grow older, I notice these changes, and while I do regret not being able to remember IP addresses after switching to a different window (get a larger monitor, or just copy&paste), I am very happy with the overall shift.
To put this in other words, as I age, I found that yes, I do have less ability to do brilliant-late-night-ninja-coding stunts, but overall what I gained translates into Getting Things Done. Which is why I find this ageism trend mindboggling: is there a CEO out there that doesn't want his company to Get Things Done?
To give a tangible practical example: I just wrote and launched PartsBox.io (https://partsbox.io/) as a side project. I could only do it in the time constraints involved because I knew which shortcuts I could take and which code I should not write. My 25-year old self would likely have written brilliant ninja code (that no one would ever see), but would never have gotten the project shipped.