One of the big mistakes I see in the list is choosing to ignore the developments in software that are old. For example, the author cites Python as pre-1996, yet the adoption of Python as a mainstream language largely postdates 1996.

Taking a very narrow view of software (i.e., looking only at compiler-related technologies), I can easily list several advancements that the author neglects:

* Profile-guided and link-time optimization aren't really feasible until circa 2010.

* Proper multithreaded memory models in programming languages don't come into existence until Java 5, from whence the C/C++11 memory model derives.

* Compiler error messages have improved a lot since the release of Clang around 2011.

* Generators, lambdas, and async/await have been integrated into many major programming languages.

* Move-semantics, as embodied by C++11 and Rust.

* OpenMP came out in 1997.

* Automatically-tuned libraries, e.g., ATLAS and FFTW are also late 90s in origin.

* Superoptimization for peephole optimizers (Aiken's paper is 2006; souper is 2013).

* Heterogeneous programming, e.g., CUDA.

* Undefined behavior checkers, such as IOC, ASAN. Even Valgrind only dates to 2000!

Yeah; but thats all so incremental. Better compiler error messages? Really? That makes the top 10 list from 25 years of work?

Async/await matters. But compared to inventions like threading, filesystems, java's write-once run anywhere, HTTP/HTML and the invention of the URL? I agree with the author. We've lost our mojo.

Computing is pretty unique in that we have near-complete freedom to define what a program even is. A sorting method implemented in haskell is a different sort of expression than the same idea implemented in C. The abstractions we all take for granted - processes, applications, RAM & disks, databases, etc - all this stuff has been invented. None of these ideas are inherent to computing. And yet apparently we only know how to make three kinds of software today: Web apps, electron apps and mobile apps.

Here's some hairbrained ideas that are only a good implementation away from working:

- HTML/React inspired UI library that works on all platforms, so we can do electron without wasting 99% of my CPU cycles.

- Opaque binary files replaced with shared objects (eg smalltalk, Twizzler[1]). Or files replaced with CRDT objects, which could be turned to support collaboratively editable global state.

- Probabilistic computing, merging ML and classical programming languages. (Eg if() statements in an otherwise normal program which embed ML models)

- SQL + realtime computed views (eg materialize). Or caching, but using an event stream for proactively updating cached contents. DB indexes as separate processes outside of a database, using an event stream to keep up to date. (Potentially with MVCC to support transactional reads from the index & DB.)

- Desktop apps that can be run without needing to be installed. (Like websites, but with native code.). And that can run without needing to trust the developer. (Using sandboxing, like web apps and phone apps).

- Git but for data. Git but realtime. Git, except with a good UI. Git for non-developers.

- Separate out the model and view layers in software. Then have the OS / network handle the models. (Eg SOLID.)

- An OS that can transparently move apps between my devices. (Like erlang but for desktop / phone / web applications)

- Docker's features on top of statically linked executables.

The entire possibility space of what computing is is open to us. Why settle for POSIX and javascript+HTML? Our platforms aren't even very good.

[1] https://www.usenix.org/conference/atc20/presentation/bittman

There are React Native forks for Windows, MacOS and Linux. I have no idea whether any of them is "good implementation" though.

> SQL + realtime computed views (eg materialize)

ClickHouse (OLAP DB) has materialized views (but only for inserts). Also Oracle and (I guess!) Materialize DB should have it too.

> Desktop apps that can be run without needing to be installed. (Like websites, but with native code.)

AppImage (and maybe Snap and Flatpak) is like this. Also technically, with Nix you can just run something like

    nix-shell -p chromium --command chromium

> Git but for data

https://github.com/dolthub/dolt (again, never tried it yet, but would like in future)