On Saturday, 30 December 2017 at 03:07:57 UTC, IM wrote:
On Friday, 29 December 2017 at 17:29:47 UTC, Adam D. Ruppe
wrote:
On Friday, 29 December 2017 at 07:53:51 UTC, IM wrote:
-- Better compiler errors, better compiler errors, better
compiler errors.
This is the only thing I greatly care about anymore. Biggest
problem D has in real world use.
Please allow me to give an example of how first impressions of
maturity really matter! Recently at some company, a group of
engineers started advocating for using Rust. They wrote a doc
explaining the differences and benefits of Rust over C++ (which
is heavily used). People started experimenting, and immediately
the maturity and good user experience of rustc and cargo were
quite obvious. The result was that Rust is now more appealing,
some new projects were written in Rust, some old ones have or
are being migrated from C++ to Rust.
(**This is a real story by the way**)
Now, given the fact that I love D despite some of the annoying
issues I encounter with it frequently, I would like to call my
colleagues to give it a try and experiment with it. People
start getting interested. They start writing some code, and
eventually they hit one of those unhelpful compile error
messages, which could indicate one of the following:
- An error in the engineer's knowledge of the language which
the compiler didn't help to understand what it is so that s/he
goes to look it up.
- A bug in Phobos.
- An actual compiler bug or inconsistency.
Remember, those engineers are experimenting with D to use it
for serious projects at work, not personal toy projects. What
do you think? Is it likely that they decide to invest a lot of
time and resources migrating projects to D?
Looking forward to seeing more of that in the compiler, which
is the single most important thing in a programming language,
the reason it exists, the thing I interface with most of the
time.
Remember, those engineers are experimenting with D to use it
for serious projects at work, not personal toy projects. What
do you think? Is it likely that they decide to invest a lot of
time and resources migrating projects to D?
Then probably you did the right thing in not suggesting they move
to using D at work at the current time.
There are all kinds of coordination costs in adopting D
immediately for serious projects where the people involved don't
know the language yet and where the benefits of D don't seem
compelling at this point.
It's much better if the people involved start using D on the side
for things that aren't mission critical or that don't have a
tight deadline, unless D solves a particular sort of problem you
have or theres much receptivity to it.
I don't think D is at a point where it should be sold. People
need to be receptive and ready to move towards you. And they
need to be able to take decisions on the basis of intrinsic
merits and not have to consider social factors. They means that
the natural sphere of adoption is startups run by creative and
independent minded people, smaller firms and small groups within
large firms where people have autonomy. That's really quite okay
- in the US, more than 100% of new jobs are created by smaller
firms.
Its a mistake to use a language you don't know for a mission
critical project with a tight deadline, unless it solves so many
problems that it is worth the inevitable teething problems.
Doing so is a recipe for brittleness because it's hard to
anticipate any difficulties and hard to plan for them.
D naturally is spread much thinner than many other languages
because it's more ambitious and is useful for many different
domains, so if you're in a particular one of them then you will
know many fewer people using D then would be the case for
languages that are more adapted for particular domains.
Also, there's much difference in how much people in different
areas tend to talk about what they are doing. Web guys talk a
lot; finance guys not do much. The people I have met who use D at
work mostly don't develop open source stuff at work and they
don't post all that much in the forums.
We are rewriting our core analytics used across the firm (about
95 people) to D. Why? Because they need to be accessible from
other languages so C ABI is necessary and it's not even a
contest, D vs C++. And the person in charge of that project is a
Fellow in Maths at Cambridge, and the one helping him is also a
Cambridge mathematician so they realise how important beauty is
in taming complexity, and D does exceptionally well on that
front. We can then programmatically generate wrappers for other
languages and we can connect the analytics and some micro
services with a little domain specific language written using
pegged.
So it's highly unusual sets of people like that, or like the
founders of Sociomantic, or like the EMSI guys, or Liran's guys
at Weka that are likely to be D adopters in the next wave. Not
people who can't see through error messages (which are much
better than C++ anyway).
I like what the D foundation did to the website, the language
and library docs, the Learn section, the forums, the resources
... etc. That definitely gives the impression of maturity.
I'm not sure those changes were primarily a consequence of things
the D Foundation did, though maybe I'm wrong.
You know how the runnable examples appeared? Seb Wilzbach, who
appeared out of nowhere, decided to make them happen. Initially
people didn't even see the point of them and there was some
modest resistance.
Maturity (or at least approaching it as much as possible) is
VERY VERY VERY important.
D is rough around the edges as an ecosystem. That's because the
people involved care deeply about technical things and less so
about making things incredibly comfortable for new users.
Language ecosystems have difjferent values - when you pick a
language you're marrying into that ecosystem, and whether it's
right for you depends on the values you hold.
The cost of that is obvious, but the benefit comes in other ways,
including the capabilities of the set of people involved with D.
That D isn't a shiny thing for now does act as a filter to
discourage people who can't see through that.
I don't think you can act mature when you aren't. In time D
ecosystem will be mature and we will be reminiscing about those
days when one could know the people involved and it was intrinsic
rather than career motivation that attracted newcomers. For the
time being that isn't the case, so one has to pick one's poison
and decide what's important. Maybe for those who can't recognise
what D offers at this point, D isn't the language for them and
they should try Rust or Go.
Maturity for the ecosystem will come.. In the meantime taking
action or giving money is a much more effective way to shape
things than saying "you know what you should do if you were a
billionaire is this". It would be nice to have more resources -
one could do things with them, but for the time being one is
where one is, so suggesting that the Foundation should do X or Y
isn't likely to have nearly as much impact as figuring out one
tiny step towards it and becoming in part the change you wish to
see.
Maturity of the language is something else. The compilers seem
quite usable - in 2014 I would regularly have segfaults and
that's rare these days. The documentation has gone from being
terrifying to non sophisticated programmers to my being able to
say to colleagues we should have documentation as good as
this,and runnable examples is good motivation to write unit tests
too.
I agree that better error messages would be nice. They're
already a lot better, and I guess that will continue.
