Comment by jcranmer | Hacker News Reader

Comment by jcranmer | Hacker News Reader

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!

It's a good bit of rhetorical slight of hand. Anything that existed in any form prior to the date isn't new (even if it was only in an experimental, near-unusable form). Anything that exists today but hasn't yet had much impact on the world is a toy.

The only things that remain are those few which appeared seemingly out of nowhere and rose to prominence over a short period of time.

Apologies in advance for the nitpick: it’s sleight of hand.

I always appreciate people correcting others - I love when it's done to me. Best way to learn. Mostly driven by just good intentions.

Thanks for doing it.

Yeah. Sure, there were service-based architectures (SOA), some automated testing (so CI/CD I guess), containers have been around forever (BSD jails and then Solaris Zones), configuration management, etc., etc. But all of those things are vastly different than they were 25 years ago. [EDIT: Not 15. Can't do math this morning. Though even 15 is pre-iPhone/most mobile.]

This is an "Oh, the cloud is just timesharing" take.

Generally in agreement with most of this (and others takes that are similar).

Except that Linux containers are a huge regression on what BSD jails gave us 20 years ago. They’re catching up for sure, but it’s still just badly reinventing a wheel that already exists, for philosophical, political, or selfish reasons.

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

Had that in the 90s:

https://www.digitalmars.com/ctg/trace.html

The idea dates back even earlier from a product called the Segmentor.

The Superoptimizer comes from a paper in the 1980s, and what it discovered was promptly integrated into several compilers.

Masalin! I hope she's doing well.

Yes, the real problem is the perspective and not the actual development. New languages are of no value by themselves. It is like counting the tools in your toolbox instead of the things you built with them.

So looking at the number of projects that are hosted on the internet (e.g. Github, Sourceforge etc.) we are likely to see a different story.

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

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

Aren't good error messages very hard to implement and also a _major_ productivity increase? They're also a boon to beginners.

Both are very important as the most powerful resource we have is people.

Sure; important and took a lot of work, but they’re still incremental improvements over what came before. I could name dozens of equally important improvements - typescript, css grids, llvm, http2, the M1 processor, WSL, C++ smart ptrs, io_uring, zfs, SeL4 and so on.

This is all important work, but none of it makes you think of computing in a new way. Not like the web did, or Haskell, or the idea of a compiler & high level language, a preemptive kernel, or TCP/IP. These were all invented by people, and a lot of the people who invented them are still around.

There are plenty of sibling ideas in the idea space. But for some reason computing cooled down and tectonic shifts of that scale don’t seem to happen anywhere near as frequently now. How long has it been since an interesting new OS appeared on the scene? Feels like a very long time. And even Haiku uses POSIX internally anyway.

Side comment: most new developers tend to ignore/not read compile or runtime error messages and ask for help before even realizing the cause of the problem they're trying to fix is right there in front of them. Better error messages for 'beginners' has questionable benefits for developers just getting started, until they get to the point where they realize error messages are actually useful

There are two kinds of new developers:

a) new developers in general (totally new to programming)

b) developers new to this specific programming language

I'd be curious what the percentages are, but my personal hunch is that for any specific language there are more in category b) than a).

And for category b), those are definitely helped by error messages.

>Git for non-developers

I was once amazed to learn that ClearCase was designed with the objective to be sold to lawyers, not developers.

the name makes so much more sense !

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

Unfortunately this won't ever happen, at least not something production ready that will be usable on all 5 major platforms (Android, Windows, iOS, MacOS and I'm generously including Linux desktop here :-) ).

It's a very costly super long term investment and the incentives are not there as every platform (including desktop Linux!) is fighting against it.

React Native is the closest thing we have and the development experience is awful, from what friends that are using it are telling me, plus I don't think it's well supported on desktops. I, for one, don't think I've ever seen a Windows React Native app, for example.

So the best we'll ever get is modified browser engines, ergo Electron.

Flutter is react inspired and it appears to be slowly getting twoards cross environment support.

I know about Flutter but I would be never build a product on top of Google tech unless I'd be confident I'm able to easily migrate away from it.

Flutter is also the kind of project Google seems worst at: it will require a lot of tedious work going forward, to support all the platforms. Thankless work that doesn't foster promotions.

I'm not counting Go, I consider it a community project now.

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

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

(without root), but it feels like cheating.

> Git but for data

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

> java's write-once run anywhere

Java didn't invent that, it is only a new iteration on an old idea.

I remember that when they announced Java in 1994 I thought about the p code system from UCSD I used in 1986 on a Z8000 Unix machine from Onyx (sp?).

More info at https://en.wikipedia.org/wiki/P-code_machine

Other commercial development tools popular in the same time period just before Java's release also used p-code, e.g. Powerbuilder.

> Git, except with a good UI. Git for non-developers.

The reason we all suffer without this is not because we have failed to solve it. It's that Git itself is preventing any forward development in this space.

We had Mercurial 15 years ago, but Git is a massive usability dumpster fire that blocks all further progress (and GitHub continually pours gasoline on the fire so we can never escape).

The effect on compiler robustness of high volume randomized testing is also very significant, I think. This was post-1996 (McKeeman in 1998).

CSmith [0] also made significant strides in that area.

[0] https://embed.cs.utah.edu/csmith/

Of course (and jsfunfuzz in 2007, and some others, and now a continuing stream of elaboration and improvement.)

I think this made it easier to firm up new language implementations. I feel like we started getting more of them because of this.

Reply on news.ycombinator.com