D on quora ...

[Laeeth Isharc]

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