D dropped in favour of C# for PSP emulator

[Chris Cain]

On Friday, 11 May 2012 at 18:05:58 UTC, Mehrdad wrote:
> 1. "templates": they seem to take in just about anything, and 
> return just about anything. They can be pretty confusing, 
> especially when you have to worry about overloading vs. 
> specialization vs. constraints, or types vs. aliases...

I really have to disagree on this. I programmed in C++ for awhile 
and templates were always a huge stumbling block for me. The 
syntax didn't sync up for me and they were extremely difficult to 
implement well, which made any generic programming I attempted 
feel half-hearted (IMO).

When I started looking at D's templates, I was _afraid_ that it 
would be as much of a pain in the ass. After putting it off and 
shying away from it, I decided to dive in and discovered that 
they were significantly easier to work with ... and more 
importantly, it was nearly straightforward to implement them 
_well_. It's absolutely no problem specifying that data type with 
certain properties should use this function and everything else 
should use this other function. In C++, you have to learn 
complicated, arbitrary idioms such as SFINAE to get any serious 
work done at all ... and it looks like all of it was written in 
another language when you're done, making maintenance a nightmare.

It's not surprising that entire C++ books are dedicated to 
teaching the absurd complexities of C++ templates. If anything, 
my experience with C++ templates hindered me.

> 3. Ranges aren't confusing, but USING them certainly is.
>    ...
>    Consider: In C#, you say Array.BinarySearch(arr) to search 
> an array.

There's definitely not enough info on how to get stuff done with 
ranges. I knew about assumeSorted and the fact that 
std.algorithm.sort returns a sorted range, but only because I 
carefully combed through the libraries looking for stuff like 
that.

That said, the D way is actually very well designed once you 
discover it. Like Andrei said, the code clarifies its intentions.


Hilariously, this style also makes the code look more magical. 
You want to say something is unique and, thus, can be 
legitimately made immutable? assumeUnique. Oh, you want to have a 
memoized version of funct? memoize!funct. I leave my friends 
wondering how D knew how to do all this stuff just by being 
"told" to. Magic API, that's how.