[OT] Unity's HPC#

[Nick Sabalausky (Abscissa)]

On 2/28/19 3:31 PM, Manu wrote:
> 
> I've raised a bunch of issues I've been facing from this angle
> recently; the `shared` stuff, dll stuff, inline stuff.

My sympathies, I feel your pain :/

But on a side note, this makes me think: We could *really* use a 
different format for all this argumentative stuff. Forums are too 
transient. What we need is something like a Wiki, but organized like this:

- Ideas
    - Arguments For/Against, and/or possible Cautions
       - Rebuttals
          - Counter-Rebuttals

...For everything, all in one canonical place. Wouldn't that be nice? I 
get so tired of everyone's arguments about everything having no viewable 
structure whatsoever...it's no wonder nobody's arguments ever get 
anywhere!!! This would be so much more practical as a standard 
base-of-operations for (hopefully) a meritocracy, don't you think?

>> To be honest, I'm not entirely happy with how D compares:
>>
>> + Expressiveness: The only aspects where I think D has a clear advantage.
> 
> Yes, and no. DIP1016 failed, and for all my colleagues, that is the
> most annoying thing that appears, every single time, within minutes of
> opening their code editors.
> It's proven hard to keep people excited and motivated, when they're on
> the back foot over something so trivial right off the mark.
> 

Ugh, I had to look up "DIP1016"...It's rvalue references, 
and...just...ugh...

See, this is something we should've had ten freaking years ago. It's so 
freaking basic, it's so freaking obvious. I mean, I'm all for the *idea* 
of some sort of DIP system, as long as it isn't too red-tape-y. Heck, I 
started working on a DIP rough draft recently and the need for technical 
details has really *helped* it, but...rvalue references?? That should 
never have even needed a DIP: You make a freaking temporary as 
necessary. Done! Worried about start/end lifetime of the temporary? 
Interactions? It's pretty freaking obvious what choices do/don't work, 
and if we *still* get it wrong, the test suite will tell us. That's the 
*point* of the test suite - to tell us when/how we've broken something. 
But NO! We've gotta define a manual process to soak up as much time as 
it takes to catch things BEFORE the test suite has a chance to!

>> - Cross-architecture: D has improved here from the past, but it's still
>> nowhere near as mature on as wide a range of platforms as Unity is.
> 
> I think this is actually okay in a practical sense. I don't think D
> has an answer for PS4, but all other targets I'm aware of are okay.

This surprises me actually. My perception was that the PS4/XB1 were very 
on-par with each other in terms of architecture: Both are x64-based with 
PC-like GPUs (and without all the hardware variation within a single 
platform, like on desktop/laptop). Wouldn't have expected any 
significant differences regarding a compiler's ability to generate 
machine code. Or is this more an OS issue than a hardware one? (Or not 
allowed to say?)

> 
>> - Machine code viewer: We have disassembly and such, but judging by
>> their screenshot, no tool that's quite that nice.
> 
> This is a function of VisualD having low man-power. VisualD has a nice
> feature which will compile and disassemble a single source file and
> focus on the code at your cursor location, so you can get a quick
> disassembly of the code as you're editing it.
> The implementation is a little big janky, it needs a little more
> polish, but it could get there.

I guess that sounds promising at least, y'know, considering. 'Least it's 
not something fundamental that requires changing any higher-ups minds ;)

> People need to care about VisualStudio to nail this checkmark. The
> entire industry uses VS, 100's of thousands of native code developers,
> there are practically no exceptions.
> VS is not popular in this forum, but people NEED TO CARE about it if
> they want to succeed generally, even if they don't use it themselves.
> It's the most important piece of tooling by lightyears.

A good point. I guess at some point D has to decide where its priorities 
are: Increased adoption of D vs meeting the needs of existing D users, 
or a more equitable balance of both. Or perhaps D's already made it's 
decision here...*shudder*...

>> - Concurrency Safety: We're way beyond many languages, but we have
>> nothing that goes nearly as far as the job scheduling system they describe.
> 
> Are we? What do we have?
> I argue that we have literally nothing. Shared is straight-up broken,
> and `const` is often such that you can't use it... what else is there
> to say on this story?

I guess I was just thinking of TLS-by-default. Perhaps I overstated D's 
case.

> I write job scheduling systems of the kind they describe, that's my
> job. I tried to work one in D. I started that thread about `shared`,
> it went no where... I write it in C++ instead with no meaningful loss
> of safety (ie, there is none either way, and we depend on convention).

That's sad to hear :(

> Infact, in C++ we have const, which helps us a lot. In D we don't even
> have `const`, because it falls over so often...

I admit, I don't really use it much myself. Partly because of bad 
experiences attempting to do so.

Do you think the lack of both tailconst and logical-const are the 
ultimate issues here, or does it go deeper than that?

>> Being basically a better C++, this is exactly the sort of software that
>> D should excel at, so it's rather disappointing how D seems to stack up
>> to HPC#. We *should* be absolutely demolishing it.
> 
> I agree, we should we killing this. I've asked for help over the last
> 6 months, we've made no progress.
> `shared`s broken, inline's broken.
> The thread about making -H (.di output) also able to output .h files
> is a big part of it.
> We have a lot of fundamental issues too, some are in progress like
> copy construction, maybe move construction?
> 

I honesty find D very frustrating these days. On one hand, it's still by 
far my favorite language, due to expressiveness, ranges, the low-level 
abilities it does have (unlike most languages these days), and all of 
the basic common-sense pragmatism that went into its early design about 
ten or so years ago. But OTOH, I feel the focus on pragmatism and common 
sense has been thrown straight out the window for the past many years, 
and its already accelerating down the same paths that led C++ to become 
the mess that it is today. I feel like D's obsessively doing *exactly* 
what Scott Meyers warned us against, in stark contrast to the early 
principles that made D worthwhile in the first place.