Dicebot on leaving D: It is anarchy driven development in all its glory.

[Walter Bright]

On 8/26/2018 11:16 PM, Manu wrote:
>> The code looks the same, and in fact, is about 98% the same.
> This code appears to be a mechanical translation.

It's not. It's by hand. But I had a specific goal of minimizing the diffs, so 
that if the translation didn't work, it reduced the number of places to look for 
the mistake. And in fact, this has saved me a LOT of grief :-)


> That's not what
> happened in this case; he wrote his game in D from scratch.
> It was just that he arrived at mostly the same place. He was googling
> for styling and sample material, but I suspect the problem was a lack
> of topical material demonstrating how he might write his D code
> differently.

It takes time to learn how to write idiomatic D effectively. I'm still learning 
how to do it right, too.


> It's also the case that the significant difference between C++ and D
> (in my experience) mostly come down to: D has modules, tidier meta,
> UDA's, slices, and ranges/UFCS. In trade, D struggles with const, and
> ref is broken.
> If your code doesn't manifest some gravity towards one of those
> features, it will tend to be quite same-ey, and advantage may not be
> particularly apparent.

I suspect that is still a bit stuck on looking at individual instruments and not 
seeing the orchestra.

Let's take the much-maligned D const. It isn't C++ const (let's call that 
"head-const", because that's what it is). Head-const for a function parameter 
tells us very little about what may happen to it in the function. You can pass a 
head-const reference to a container, and have the function add/change/delete 
every element of that container, all without a peep from any C++ tool. Looking 
at the function signature, you've really got no clue whatsoever.

The reason people have trouble with transitive-const is that they are still 
programming in C++, where they *do* add/change/delete every member of the 
"const" container.

That includes me. I try to add transitive-const, and it won't compile, because I 
as well am used to replacing the engine and tail lights in my head-const car. In 
order to use transitive-const, it's forcing me to fundamentally re-think how I 
organize code into functions.

For example, dmd is full of functions that combine data-gathering with 
taking-action. I've been reorganizing to separate data-gathering and 
taking-action into separate functions. The former can be transitive-const, maybe 
even pure. And I like the results, the code becomes much easier to understand.