On 10/6/2017 10:19 PM, Adam Wilson via Digitalmars-d wrote:
> What if we stop focusing on the C/C++ people so much? The
> like their tools and have no perceivable interest in moving
> away from them (Stockholm Syndrome much?). The arguments the
> use are primarily meant as defensive ploys, because they
> compare everything to C/C++ and when it doesn't match in
> some way or another the other language must be deficient.
> They've already decided that C/C++ is the meter stick
> against which all other languages are to be judged.
> Unsurprisingly, nothing that is NOT C/C++ meets their
> exacting demands.
Yes - as Andrei said in a talk, people are looking for an excuse
not to have to take the time to learn something new. There's an
inordinate strength of feeling in discussions in relation to D.
If it's not your cup of tea, why do you care so much? The
raising of spurious objections is much better than indifference
at this point, and you can see this year that there has been a
shift. People got downvoted for repeating the same old talking
points that are now demonstrably not correct, whereas before it
was a matter of judgement and people could reasonably differ.
On Friday, October 06, 2017 23:19:01 Brad Roberts via
Or recognize that painting huge diverse groups as if there's a
single brush with which to do so is a huge fallacy. Consider
that the two leaders, as well as a large number of the
contributing developers, come from the c++ community and
that's not a bad thing, but rather a big part of _why_ they
came to D.
As always, focusing on the users of the language tends to pay
a lot more dividends than focusing on nay sayers. Luckily,
that's how things tend to proceed here, so yay for that.
Long tail. We really couldn't care less about what most people
think. In fact it's good that most people won't try D because
what they will be expecting isn't yet what we offer (glossiness
and hand-holding).
At any one time there is a proportion of people who are unhappy
with their existing choices and looking for something better.
It's easy to grow in the early days - you don't need to appeal to
most programmers. You just need to have a slightly stronger
appeal to those who are already predisposed to like you (and to
those who are already using your language and would like to use
it for more things).
And people conceive of the market in too small a way. People
talk as if languages are in a battle to the death with each other
- D can't succeed because it's too late, or because Rust has
momentum. But the world is a very big place, and the set of
people who talk much to a broad audience about what they are
doing is a small one and thinking it reflects reality leads to
distorted perceptions.
Who would have thought that probably one of the larger code bases
(500k SLOC) to be rewritten/converted in D might come from
Pascal, with D competing with ADA? I don't know what has been
decided there, but whatever the outcome, that's highly
interesting, because it's probably true of others.
Similarly Weka came from nowhere. A random tweet by Fowler led
to them building their entire company on a language the founders
hadn't used before.
Because D is a highly ambitious language that isn't confined to a
single domain, and that's a potential replacement in some domains
for many other languages, most people won't know anyone who uses
D because use is much more spread out. Enterprise users outside
of web + big tech/startups don't talk about their choices that
much. Microsoft didn't send out a press release when they used D
in their COM team, for example - someone there just figured it
was a good tool for the job and got on with it. Similarly the
company that Andy Smith worked for (a money management company)
didn't say anything, and it only happened that he talked about it
because I suggested it and he happened to have time.
Inordinately at this point in its development D is going to
appeal to principals over agents, to people who have at least
local authority to make decisions and don't have to persuade
others, because the dynamics of how you persuade a committee are
based on quite different things than making a decision and living
or dying by how it turns out.
That's okay. If people don't feel they can use D at work, they
shouldn't. Some people will be able to, and as they have some
success with it, others will start to imitate them. And in the
meantime maybe it will be an advantage of sorts for the earlier
adopters.
It matters who your customers are, because that shapes what you
become. And it's better early on to have people who make
decisions on technical merits and who have the authority to do
so, then to have a representative enterprise buyer!
On Saturday, 7 October 2017 at 08:36:01 UTC, Jonathan M Davis
wrote:
Honestly, I've gotten to the point that I don't care much about
trying to appeal to folks who complain about D. If we just make
the language the best that we can, that will attract folks -
that's largely what's attracted them in the past. Sure, we
could and probably should do better with marketing D, and some
of the complaints that get leveled at the language are valid
and should be addressed, but trying to convince folks who are
already convinced that they don't like D just doesn't seem like
a good way to spend our time and energy.
I agree with both parts. It doesn't do any harm to continue to
work on getting the language's merits across. There's no point
entirely hiding our light under a bushel. But doing good work
and making the language and ecosystem better is by far more
important because that's what matters and we're in a time when
people will eventually get it even if they don't all currently.
Complaints from folks not using D _can_ help shows us areas in
which we're deficient, but they're not necessarily right, and
they're not our actual user base.
Yes. (I'd put the emphasis on _help_)
And really, what we need is a good language with good tools
that supports a vibrant community of those who want to use it.
We want that community to grow, because it will help the
language and make it easier to get jobs using it, but it's not
like we need to convince the whole world to use D - not to
mention that there are classes of folks that we don't want;
their views and goals just differ too much from ours
People seem to think language decisions are only about technical
questions. But they're as much about values, and you're never
going to get people to agree about values because people are
facing different problems and are themselves different kinds of
people.
https://vimeo.com/230142234 Bryan Cantrill of Joyent nails it
which is part of why having a diverse set of languages out
there can actually be valuable. Different folks prefer
different languages, and trying to get everyone to agree is
never going to work. As long as D is sucessful enough that
those of us who want to use it can use it and do what we need
to get done, then that should be plenty. If more folks decide
that they like what D's offering, then great. If they prefer
C++ or C# or Rust or whatever, then they can have fun doing
whatever they need to do with those languages, and we won't
have to make changes to D just to make them happy.
- Jonathan M Davis
In a polyglot environment, D's code generation and introspection
abilities might be quite valuable if it allows you to write core
building blocks once and call them from other languages without
too much boilerplate and bloat. One could use SWIG, but...
