Last week I wrote about the difference between an engineer and a technician. Another way to think about it is where in the technology stack you operate. 30+ years ago the tech stack was a CPU, some ROM, some RAM, and maybe a persistent storage device. And that was enough to go to the moon. Today you can find that amount of processing and storage in the wall charger for your phone. Now we've got languages that manage all of your memory for you, IDEs that point out your mistakes, refactor your code, and suggest what you want before you type it, and serverless clouds to run you code in. Or, as others have said, we're "Standing on the shoulders of giants"
Best practices and the environment we're operating in might have changed, but the core problems really haven't. Functional may have replaced Object Oriented as the new hotness, but if you go back to first principles, you find they should live together. It's just a matter of understanding/expanding the scope.
Cognitive load of the developer is still one of the biggest limiting factors of system scale. We just have new ways (microservices, Domain Driven Design, smarter IDEs, etc) to help manage the load. Execution time is still important. Now we have more/faster processors, so we can spend time making it easier (if less efficient in isolated single case) to parallelize, distribute, and scale things out without increasing cognitive load. But we're still limited by cognitive load
Perceived wait time is still important to users. But now we have enough local horsepower/bandwidth to do a bunch of local validation instead of waiting for a round trip. We have spinning circles of hope on the screen during the roundtrip. We can send bigger/higher resolution images instead of reducing everything to some standard 128 colors. But wait time, bandwidth, and resolution are still things we need to worry about.