5 ms·
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
by jcranmer 6y ago
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!
- rictic 6y agoIt'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.
- oarsinsync 6y agoApologies in advance for the nitpick: it’s sleight of hand.
- simonebrunozzi 6y agoI 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.
- ghaff 6y agoYeah. 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.
- oarsinsync 6y agoGenerally 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.
- pfdietz 6y agoThe effect on compiler robustness of high volume randomized testing is also very significant, I think. This was post-1996 (McKeeman in 1998).
- dataking 6y agoCSmith [0] also made significant strides in that area. [0] https://embed.cs.utah.edu/csmith/ https://embed.cs.utah.edu/csmith/
- pfdietz 6y agoOf 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.
- josephg 6y agoYeah; 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 https://www.usenix.org/conference/atc20/presentation/bittman
- sam_lowry_ 6y ago>Git for non-developers I was once amazed to learn that ClearCase was designed with the objective to be sold to lawyers, not developers.
- WalterBright 6y ago> 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 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.
- pfdietz 6y agoMasalin! I hope she's doing well.
- arendtio 6y agoYes, 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.