On Saturday, 7 September 2013 at 19:35:47 UTC, Russel Winder
wrote:
On Sat, 2013-09-07 at 10:08 -0700, Walter Bright wrote:
[…]
Having 3 different D compilers with different strengths and
weaknesses spurs improvements in all of them. When I was at
GoingNative2013, it was pretty obvious to me that the playful
and friendly competition between gcc, clang, and vc has
improved all three greatly.
As has been proved in many areas of life, having multiple
players in a
game validates the game. Having multiple compilers, books, IDEs
etc. for
D programming is a mark that D is player in the programming
languages
game.
Sadly D is still not competing against C++ in the way it
deserves. Of
course C++ is now a niche language. The primary "war" just now
is native
vs. VM, and VM remains in the ascendency. Go and Rust are the
"poster
children" for native due to their backers. The questions is
whether D
should position itself in this "war". I say yes.
There needs to be more books on D, and use of D in various
areas. QtD,
GtkD, (wxD?), D drivers for SQL, Mongo, Couch, Redis, Neo,
Riak, etc.
all need to be high quality and pushed via reports and talks at
non-D
conferences. Vibe.d is a huge possibility now that Node.js is
losing
it's "lustre" and Vert.x and Go are getting serious traction.
(At least
in the small start-ups arena.)
D in GCC and D on LLVM are, for me, far more important than
DMD, since
they provide penetration into the market via the market
leaders. D on
Linux via GCC and LLVM, D on OX S via LLVM, (and on Windows, I
suppose,
via any route :-).
That also my concern, LLVM tends to replace gcc as C/C++ compiler.
LLVM promise to simplify languages compatibility, Apple show us
how
much is important to improve developers productivity.
Google think in the same way with the Go.
I think the LLVM message is :
developers would be more productive if compiler generate better
reports, can aggregate more pieces of software and have better
tools (IDE, static analyzer, debugger).
In this way D and LLVM philosophies seems compatible.
The issue for me is to stop worrying about internal
contemplative
reflection on 10 years of D evolution, and get knowledge of the
real-world use of D out there and in people's faces. Stop
looking inward
and start looking outward. This is the trick Go and Rust have
picked up,
albeit not as well as they could. D is a major player in the
GCC and
LLVM worlds, let's take this as read and exploit it for the
future of
high-quality, effective and pleasurable native code development.
