Could D have fit Microsoft's needs?

aliak something at something.com
Sun Jul 21 18:46:08 UTC 2019


On Sunday, 21 July 2019 at 00:22:11 UTC, Walter Bright wrote:
> On 7/18/2019 5:12 PM, Mike Franklin wrote:
>> ... and D could complete better with Rust if it had 
>> @safe-by-default and statically-check ownership/borrowing 
>> mechanism as Walter recently proposed.
>
> D has some huge advantages over Rust.
>
> For example, D has a familiar syntax and jargon. For another, 
> you'll be able to move to memory safety incrementally with D, 
> you won't have to rewrite your app from the start. D's 
> metaprogramming abilities far exceed Rust's. Etc.

Me and a colleagues/friends are currently in the process of 
starting up a startup aimed at the collaboration market, and we 
have this concept of integrations that integration with github, 
jira, bugzilla, and other software-related collaboration tools. 
And these integrations are largely very similar in nature and so 
we've started writing them in different languages just to see how 
they all feel - the three so far are D, Rust, and Typescript. Two 
of us have very heavy C++ backgrounds.

So far, Rust's unfamiliar syntax has not been a disadvantage - 
the person who has the least C/C++ exposure is mainly on that one 
- reviewing is also nice, because Rust is actually nice to read 
(IMO) once you get around the whole borrow semantics hoopla.

Moving incrementally to memory safety is not an issue, since we 
are not converting a C/C++ application - we are starting from 
scratch. So safe by default is the advantage in that case. But, 
it does slow down our development speed.

We have not found familiar jargon to be an advantage (i assume by 
familiar you mean to C++). Since D has its own unique jargon 
anyway (init/constructor differences, autodecoding, alias this, 
shared module ctors, mixin templates, VRP, for e.g.) - so same 
same.

Metaprogramming has been a huge advantage in the D version. It 
makes writing things like serialization/deserialization, 
algorithm specializations, and structuring our models much easier.

When everything is going smoothly the development speed with D 
far outweighs the Rust one because of the borrow checker. It's a 
constant battle. However, the D version suffers form its 
ecosystem - the other day I had to write jwt/crypto stuff - 
neither the typescript or rust version needed that. D-bugs is the 
other thing - A bug in Nullable cause of us to swear off working 
on the D version - but the same person got defeated by the Rust 
borrow checker but that for some reason did not make him swear it 
off.




More information about the Digitalmars-d mailing list