On Tuesday, 1 May 2018 at 12:26:25 UTC, Joakim wrote:
I realize it's right before the conference, but I'd like to put
out a request for Walter and Andrei to spend five minutes
during your talks laying out some overarching strategy for how
you see D evolving. It could be during the keynotes or leading
off the Q panel, but I think it's worth laying a broad
strategy out there.
Specifically, what uses do you see D being put to for the next
five years and how do we make it better in those directions.
For example, in what way you'd like to see D get better as a
language for writing apps, or what particular niches you see D
as a systems language doing well in first.
For another example, here's what I'd say, ie my strategic
vision: the pendulum is about to swing hard back towards the
client, towards the billion and a half mobile devices sold each
year, and D is ideally positioned with its native efficiency to
do well there. However, since it's not the blessed language for
any mobile platform, like Kotlin or Swift, it will take much
work on libraries to pull that off.
Some caveats: since D is not controlled by a company with W
as co-CEOs, they cannot obviously order people to follow their
vision. However, that should leave you free to really share
your unexpurgated thoughts, after all, we're all free to ignore
it. ;)
Another is that perhaps D has chosen to evolve tactically as
opposed to strategically, carefully picking off wins with a new
feature or mode of programming but not following any grand
strategy, similar to how Linus Torvalds claims he didn't have
any grand vision for linux either. However, a strategic vision
can inspire people to work towards that goal, if there is one
to be shared.
My 2 cents. I have been following D for a long time and started
using it in a very small project. I am a very long term C++ user.
Many people say that D does not offer anything over C++,
improvements-wise. Or people tell you that there is Go and Rust.
Because D does not have these fancy algebraic data types, or that
borrow checker... no, no and NO. I think we do not need to enter
that game. I have tried all 3. Here is my opinion.
1. Go --> excellent...!!! For what it does: namely, intensive
communication client/server. It falls short of abstraction power
in some areas, has no compile-time evaluation, no
metaprogramming... though I must recognize it works pretty smooth
for its simplicity.
2. Rust --> the borrow checker... excellent, in theory: in
practice, as Andrei Alexandrescu once mentioned: you spend a lot
of effort on something that in reality is not a problem most of
the time. It is a problem, yes, but these problems can be avoided
with much more lightweight solutions or simply, as D does, being
able to avoid GC where it is needed. A much more practical
solution. Rust has other things of value, such as Algebraic data
types and Traits, but the borrow checker has a big impact for
several reasons: it takes time to get used to, socially, people
cannot use Rust from day one, so... you need added training for
teams. But also remember... an "alien" type system makes it more
difficult for integration with previous systems.
How should be D advertised? Well, I think that Ali Çehreli did a
good job explaining in one of his keynotes the conveniencies of
D, but this will not make people migrate. Why I am myself
starting to take a look into D? I am a person that if I publish a
project as open source, I want people to be able to contribute.
Coding is, above all, a social activity, so:
- Come from Java, C#, want faster alternative? D will take little
effort.
- Come from C, abstractions are too low level? D will take the
same effort as alternatives with native performance, but you can
start coding today.
- Come from C++ (like myself)? D is way cleaner and more
convenient: modules, better metaprogramming, pervasive CTFE,
*much better introspection* and also easy to learn.
Those are all good reasons, but, for me, what sets D apart is its
level of integration with C/C++. If I come for D in the first
place is because I can reuse my old code. This is true for most
businesses: they have older code to integrate.
So my opinion is that D is a very pragmatic language that has
this real, also management-perceivable advantages over all these
nice algebraic data types integrated into the language and so on:
- if I pick up D in a team, it is very likely that D will be
easier to pick up because many, many people know C++/Java/C# or
similar things. This is a very important social factor and
usually not mentioned or underestimated.
- if I have some C/C++ code to integrate, I can do it *way
smoother* than with other languages to do it: please guys keep
working on this.
- if I want safety, there are mechanisms that take you 90% there.
Why would you pick up an alien like Rust where you have to
relearn all, but not only that, you have to train full teams?
This
