[OT] Leverage Points

[John Carter]

On Wednesday, 22 August 2018 at 13:17:00 UTC, Kagamin wrote:
> On Monday, 20 August 2018 at 03:57:10 UTC, John Carter wrote:
>> * Choice. ie. Programmers _want_ to use it, not are 
>> constrained to use it.
>> * For programming activity, not new projects. ie. The era of 
>> vast tracts of green field programming is long gone. We're 
>> mostly in the era tinker toys and tidying.
>
> That's a matter of choice, some are tidying, but there's a lot 
> of green field programming even in C, and new languages are all 
> green fields.

I suspect if you actually lean of the shoulder of the vast 
majority programmers earning their daily bread, they aren't 
writing a brand new program... they enhancing, and fixing an 
existing one.

>> There is a big difference between "Doing a lot of" and "Being 
>> Good at".
>
> That's why you can't be tidying all the time, you can improve, 
> but can't become good this way.

Oh, I would argue it's the best way. Or this wouldn't be funny....
   http://bonkersworld.net/building-software


>
>> By tidying I mean refactoring legacy code that is way too 
>> large and complex to rewrite all at once.
>
> Nobody is going to deep refactoring; example: C/C++ (well, you 
> mention them too) and pretty much everything. And it's that 
> large because it accumulated garbage and rewrite will cut it to 
> a manageable size; example: s2n (fun fact: it's written in C, 
> but uses slices for safety just like D).

Whenever I see a rewrite which claims it has made things so 
wondrously simpler / better, closer inspection reveals it does 
wondrously less, and supports wondrously less legacy cruft.

Thus I do not believe these "experiments" have isolated the 
effect deleting unneeded or little used features and support for 
legacy platforms, vs the effect of rewriting vs refactoring.

> Nobody is going to deep refactoring

That I believe could be the paradigm shifting advantage of D. 
Every time I have written a refactoring or code analysis tool for 
C or C++, the preprocessor has amplified the complexity of my 
task by orders of magnitude.

And every transformation I might propose.... it is incredibly 
hard to guarantee that it is safe and behaviour preserving, a 
sentiment echo'd by every optimization pass writer for C/C++.