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