What are (were) the most difficult parts of D?

[Guillaume Piolat]

On Wednesday, 11 May 2022 at 05:41:35 UTC, Ali Çehreli wrote:
> What are you stuck at? What was the most difficult features to 
> understand? etc.

     - How to do deterministic destruction with programs that use 
everything (struct / class / dynamic dispatch / GC / manual / 
etc). This requires to understand what the runtime does, what the 
gc does.
       Interesting nonetheless.

     - Some traps. Accidental TLS is a thing, top-level should 
probably not be silently TLS.
       People will loose hours on this completely preventable 
thing.
       What was the idea, optimize code without people knowing?

     - `shared static this()` vs `static this()` is another trap.
       Honestly would have preferred `__threadlocal`. It's not 
like being thread-local is something completely normal or without 
consequence for platform support.

     - Some features lack an escape hatch, notably `pure`. pure 
leaks into identifiers, like `pureMalloc`. Trying to add `pure` 
fails on a large codebase.

     - `@safe`/`@trusted`/`@system` is good but the definition of 
what `@trusted` means has to be remembered from the programmer.
       For example `Mutex.lock()` is `@trusted`, it could have 
been `@system` to let user review their usage of locks. You have 
to wonder "can a lock()/unlock() corrupt memory?". People can use 
that to mean "@reviewed" instead. Because it is up to us, the 
exact meaning will float in the D subcultures. A function which 
has been marked `@trusted` does not receive any review whan 
changed later. It will not mean the same as `@trusted` in another 
codebase.

     - Generic code typically has bad names (domain-less) and 
worse usability. It's often not pretty to look at. Mostly 
cultural, since D has powerful templates so they had to be 
everywhere. UFCS chains are not that convincing when you are 
worried about maintenance.
       Phobos take short names for itself, this leads to pretty 
complicated operations having a small screen estate.

     - `assert(false)` being different and not removed by 
`-release`. Keyword reuse seems entrenched but honestly a "crash 
here" keyword would be more readable.
       It is really 3 different things: assert, crash, and 
unreachable.


Otherwise D is glorious and get syntax and usability right, which 
puts it ahead of almost every other language.