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...
