There's a lot more technology-choice-by-fad today. We didn't have as many choices or the instant access and bombardment of opinions back in the day, so decisions were slower, IE: we didn't just switch out tools on a whim because it "sounded like a good idea"
20 years ago: your boss says I want X. You wouldn't ever tell them it was impossible or hard work. You'd hack it together and bend the hardware to your will.
Today: your boss says I want X. You spend a lot of time arguing if it's a necessary business function, spend a few months designing it, and then implement it in such a way that makes Fizz-Buzz Enterprise Edition look simple.
To put it shortly, incredible creative hacks are looked down on, while "elegant" solutions are a must. At least that is what it looks like from my experiences.
1. We're releases and code changes as common as it is now or once you finished writing it's more less that except for bug fixes?
2. Nowadays a lot of non-technical people are also involved in the development process like product owners, project managers, scrum masters, engineering managers, etc. Was this so then?
3. Size of the teams? Was it generally smaller or larger compared to today?
1. Releases were less often, usually in the range of a couple releases (4-6) a year. We had dedicated bug fixing time for two weeks before a release with extensive QA.
2. Mostly the same, except scrum master (or equivalent) was usually the project manager.
3. Generally about the same size teams, but teams had total ownership over what they built. Code bases and services were never split among multiple teams.
"Since we have much faster CPUs now, numerical calculations are done in Python which is much slower than Fortran. So numerical calculations basically take the same amount of time as they did 20 years ago."
I get the humor but it's also not true... if using numpy, you're essentially running C code where speed matters.
1- If using numpy properly
2- Various numpy modules use FORTRAN 77, so it's not always C code.
The more recent grads I work with mock me for this. Things have indeed changed.
This is one of the reasons I am making a career transition this year. I don't have the time to think about good solutions, just cheap, quickly thrown together ones. It's exhausting and doesn't feel like good work. Deep thinking is an under appreciated opportunity in our culture.
The other thing I really appreciate is garbage collection and static typing with type inference. We get this with good edit-compile-run ergonomics. We even have good interoperability of languages in run- or compile-time VMs. What we have today I didn't even dream of back in the day.
He hasn't heard of Android apparently.