Take Java for example.
When it came into scene we had Oberon and its variants, Ada, Modula-3 and Eiffel.
All supported JIT/AOT compilation, value types, and with exception of Oberon, generics.
Most of the last changes at the JVM level, and the upcoming ones on Java's roadmap are basically catching up with what was already possible in the mid-90's.
So how much money could Sun, Oracle and IBM have saved if those features were there from the beginning?
We will never know, but we will know how much the bill is going to be, given that it is 10+ year process currently.
All because the current hardware changes make it impossible for Java to continue to ignore those features, if it is to stay relevant against other languages.
Same applies to other languages in different ways.
Part of the answer is that Java still advance the state of the art for most people: It got safety and garbage collection accepted by the mainstream.
Oberon etc were not in reach for the average Joe, the tooling was too expensive and the cheap, resource constrained PCs couldn't run it. The language required sophistication from the programmers. Nobody was available to answer questions, the ecosystem wasn't there.
Java, o.t.o.h. had something for everybody. It was safer than C, important if you wanted a stable web server. It was faster than perl or shell scripting, so you also had a cheap web server. The browser got nicer graphics from applets. Enterprise architecture got a way forward from CORBA to JEE without having to admit something was wrong. Hardware vendors got a way to stay relevant in the face of Windows. Tooling vendors and consulting companies got a reason to sell. Managers got cogweel replaceable programmers. Schools got a reasonable and vendor-neutral language. Even if none of promises was completely fulfilled, it was close enough long enough.
So basically the language design resources for Oberon were in the end more wasted than those on Java. 'Worse is better' once again.
I'm sorry, but that's just nonsense. You can argue lack of documentation and user community, but Oberon is about as resource economic as it gets, and was originally designed for mid-80s hardware.
* It wasnt very visible in the ICT media. Sun did a full steam ahead Java Campaign
* Open source at the time was not seen as trustworthy. I did run Linux at the time. SO did you, probably. Corporations would not touch it with a 10 feet pole. I presume oberon was seen in the same light.
If Java was sold for the same price as lets say Delphi, most devs and university students would never have cared.
Same goes for the hardware resource. Changing to a bigger server cost less than than my time. That way again my time can save more time on useful stuff.
There's billions of hours wasted in business and government in long and meaningless tasks. Optimize that first please before micro optimizing your software.
For example you could get your product or services up and running in Ruby Rails with least amount of time, but I doubt it will ever be as efficient as Stack Exchange in resources. [1] and likely will cost a lot more reaching that scale.
Instruction-level (peephole) optimizations are omnipresent. You're not going to beat a compiler in register allocation (at least, not by enough to actually be worth the time writing in assembly), and optimizing for microarchitecture is generally within reach of the compiler, when the compiler is made aware of these details. Superoptimization means that automatic tools can write better patterns than you can for loop-free code, and maybe even small loops (although most compilers don't incorporate superoptimization for compile-time reasons).
The next level of optimization is loop nest. Compilers already do loop idiom recognition (if you write a memcpy as a loop, LLVM will recognize it as a memcpy and convert it to faster memcpy idioms). But recognition is of course limited to known kernels; we don't have good general-purpose tools. Automatic optimization for parallelization, vectorization, cache hierarchy (block loops out so everything sits in L1 cache, for example) are all well-known, but they tend to turn out to be extremely problematic to work in practice because languages suck, and many of the core kernels can be wrapped up in autotuned libraries (e.g., FFTW, ATLAS).
Whole-function optimization, interprocedural, and whole-program optimization are much less mature. Whole-function is used for many microoptimizations (dead code and various kinds of partial redundancy elimination), but it's not really feasible for higher-level algorithm analysis. Interprocedural optimization is largely limited to figuring out if inlining functions would help reduce code size or dead function analysis, and whole-program is used to improve the quality of these kinds of analyses.
The frontier of compiler research (and in terms of shifting research prototypes to product compilers) is in moving our techniques to larger and larger program slices. Program synthesis can already automatically generate specialized data structures from the queries you will make on them, for example. As the original paper points out, making these techniques easier and more readily available is likely going to the main program here for the next two decades or so.
Not true, because the lower-level languages introduce far more bugs which wastes user time even more because they can't get their work done.
Lower level languages these days are only used where performance and resource use must be controlled for. With Rust, that too will soon be a thing of the past.
Not if your application is being used by many users; optimising exclusively for development time is only for rarely-used/one-off things or if you don't value your user's time --- some of whom may be themselves developers. The more users you have, the more it matters.
We've somehow gotten ourselves into a situation where relatively few developers are making countless more users waste time and hardware resources for their own selfish benefit, and I think that's a very bad thing.