Are there any languages that are good at this? I feel like I would not enjoy deeply working with old C++ (e.g. auto_ptr), old Java (e.g., no lambdas), old Pytho

Are there any languages that are good at this? I feel like I would not enjoy deeply working with old C++ (e.g. auto_ptr), old Java (e.g., no lambdas), old Python (e.g., string formatting with %), and so forth - if I were making more than maintenance changes I'd modernize the syntax. sh hasn't changed much, but old shell scripts are usually buggy and would benefit from, say, bash arrays and the ability to assume that bash is installed. Old Perl is the most likely to be subject to the "write-only code" epithet, old HTML using tables and images for layout is certainly foreign, and I hear PHP today looks nothing like it looked back in the early '00s. I think the only languages that don't look foreign are languages that are basically no longer developed because they basically don't have new developers / new projects at all. Fortran is a good example - the language hasn't changed much since 1990, but a new developer wanting to call existing routines in Fortran (like BLAS/LAPACK) would generally use a younger and more featureful language like Python (via NumPy), R, Julia, or even MATLAB. The same class of users who would have directly used Fortran some 20-40 years ago are writing their own code in an entirely different and foreign language today. Part of the problem is that programming language design is still a very young field. Compare with musical notation, for instance. Music written a hundred years ago is perfectly readable to modern musicians; music written over about five hundred years ago in plainchant notation is learnable (a reader of modern music can pick it up in well under an hour of study, but won't be able to read it cold); music written over about a thousand years ago, is pretty unreadable without training. Meanwhile, programming languages date from the 1950s, and various language features are very new (syntactic async/await first appeared about a decade ago, for instance, and even the Liskov substitution principle is only about 26 years old). There are clear reasons to prefer the incrementally improved notations for both music and software - neither Guido d'Arezzo nor Guido van Rossum got everything right on the first try, even though their original notations are readable to practitioners today - it's just that we've already figured out musical notation we're happy with and there haven't been significant incremental improvements in music hundreds of years.