Has software changed much in the last 5 yrs?

Yes and no. There are always new things coming along, and there are always old things still being used and built on.

Just as an example, here are the top 10 languages on GitHub in 2020, according to https://octoverse.github.com/, along with the years they were introduced:

  JavaScript 1995
  Python 1991
  Java 1995
  TypeScript 2012
  C# 2000
  PHP 1995
  C++ 1985
  C 1972
  Shell 1971
  Ruby 1995

Only 2/10 were invented in this millennium, and both of those are at least to some degree offshoots of other languages (TypeScript <- JavaScript, C# <- Java / C family). Granted, Python today is not the Python of 1991, and similarly for all of those other languages. So obviously you do have to keep up with the changes to the language, the libraries, the programming environments, etc.

I thing the big difference is that software is gradually becoming more declarative. It's less about coding how it does things, more about coding what it is doing. This has been the flow for many decades, but it's more common now than 5 years ago.

Something like React is the norm now. It's not necessarily any simpler or faster, but it's more efficient past N hours, which is the case for many larger companies.

It's also why functional programming has regained popularity, or at least writing functions the way you would for functional (immutable, output of one is the input of another).

However, we're still using a lot of old techniques. The best book on Design Patterns was written in 1997. Pragmatic Programmer was written in 1999 (though revisited a few years ago). The best TDD book is still from 2002; a lot of modern takes on TDD gets the philosophy completely wrong. TDD was meant to reduce fear, not improve test coverage.

Three programming languages - Julia, Nim, and Crystal - reached the all-important version 1 milestone in the last 5 years. That feels like a substantial achievement.

What impact have these languages had on the industry? Small impact so far but it is early days.

Anecdotal observation: Julia seems to be gaining greater traction that Nim and Crystal. However, although Julia is a general-purpose programming language, the close association with scientific computing may see it pigeonholed by some developers as suitable only for that domain.

It's refreshing that all three languages count performance as a key feature. Together with Rust and Go, this has had some impact in making developers aware of the importance of performance in programming, and the advantage these languages have over less-performant languages.

What is stale is your knowledge of whatever tech peaked five years ago. Wasn't Flash still a thing in 2015? Ruby on Rails had already peaked. Scala was hot. The most popular tool for infrastructure sysadmin was Puppet, and a guy playing a flamethrower guitar stole the show in Mad Max: Fury Road

From one viewpoint computer science is a branch of math and is universal and eternal.

Aliens live under the ice on under a moon somewhere and they have their Alan Turing who proved they can’t solve the halting problem.

Another aspect of it is random and ephemeral; how you use ‘extern’ in both the .h and the .c file, the use of base 2 exponents in floating point numbers despite writing them in base 10 (e.g. ‘0.2’ doesn’t exist in your computer)

Mistakes like that last a long time, and new and better things face an uphill battle.

Thus is it always changing but stays mostly the same.

5 yrs of what? Not working with a specific tool? Not learning anything new, somehow? Not working in tech at all?