4 ms·
> While more modern languages benefit from the errors of the older ones, I do not think they will be exempt from this kind of responsible growth process when th
by TeMPOraL 3y ago
> While more modern languages benefit from the errors of the older ones, I do not think they will be exempt from this kind of responsible growth process when they will become decades old.
(content warning: below are just some thoughts without any kind of final point or argument; skip if you're not interested in random musings)
Makes me think of evolution, biological death, and the limits of lessons learned. C++[0] embeds decades of practical experience; many mistakes and pivots add up to how it looks today - but every change made meant complexity was growing, and today, it's hard to incorporate new experience into the language, because of all that accumulated complexity. New languages get to distill what works, and incorporate the lessons into their design directly - starting fresh, without the complexity baggage. However, some things are lost in translation - all that complexity thrown away wasn't just random noise, it was a record of mistakes and wrong turns that the new languages are now liable to repeat.
What I'm thinking is: evolving a language for decades keeps all the experience, but becomes superlinearly[1] expensive and slow. Starting from scratch resets the costs, but also loses some experience in the process. Where continuous evolution of a language, in the limit, will be approaching the point where incremental upgrade takes infinite effort to pay the "complexity debt", the "one funeral at a time" evolution seems like it could reach a different limit: the point at which it each generational transition loses as much experience as the subsequent generation will add.
Not sure what to make of it yet.
--
[0] - I'm including here both the language proper, standard library and compilers, which all co-evolved, and all form the larger body of C++ as a real tool, and not just paper abstraction.
[1] - Would say exponentially, but I'm not really sure how fast it grows - only that it grows faster than linear.
- einpoklum 3y ago> New languages get to distill what works, and incorporate the lessons into their design directly In principle. In practice, most new languages distill _some_ of what works and incorporate _some_ lessons. Which is ok, but the point is that when they hit those situations where things _don't_ work, they either ignore it or start becoming more complex themselves. > but becomes superlinearly[1] expensive and slow Are you talking about the language standard? The standard library API? Idiomatic use "cognitive load"? Advanced use brain load? For some of these, your statement is not true. Especially for the idiomatic use of the language: Quite a few things have gotten simpler, rather than more complex, for the lay user, with the addition of more functionality into the language.
- TeMPOraL 3y ago>> but becomes superlinearly[1] expensive and slow > Are you talking about the language standard? (...) I'm talking about effort to incorporate new lessons into language standard, and/or standard library, and/or compilers, while trying to maintain some backwards compatibility with at least few earlier "versions", and generally not reinvent half the language. This means you can't just add or modify a thing - you'll need to do some serious research, discuss things with compiler vendors and interest groups, etc. And you usually can't implement the new idea directly in the most clean/obvious way - you need to find a way that doesn't interfere with any of the existing rules of the language and surrounding customs.
- criddell 3y ago> New languages get to distill what works, and incorporate the lessons into their design directly - starting fresh, without the complexity baggage. I think that may be the motivation for Sutter's work on cpp2. https://github.com/hsutter/cppfront https://github.com/hsutter/cppfront