Go 1.9

[Laeeth Isharc via Digitalmars-d]

On Saturday, 24 June 2017 at 11:18:10 UTC, Ecstatic Coder wrote:
> On Saturday, 24 June 2017 at 10:34:07 UTC, Ola Fosheim Grøstad 
> wrote:
>> On Saturday, 24 June 2017 at 09:35:56 UTC, Ecstatic Coder 
>> wrote:
>>>>> I'm assuming that D is for general purpose programming as 
>>>>> well.
>>>>
>>>> That seems to be where it is heading.  I don't think D 
>>>> stands a chance in that domain, but we'll see.
>>>
>>> With all due respect, on the contrary I think that promoting 
>>> D as a general purpose programming language could be its only 
>>> chance to really improve its popularity, and thus 
>>> significantly grow its current user base.

I know that in certain other sectors, people have high 
expectations of growth, but I really am at a loss to know what it 
is that people might expect significant growth to be when we 
already have some pretty impressive developments in the numbers 
that we do have.

http://erdani.com/d/downloads.daily.png

Daily unique dmd downloads in Jan 2013 were 150-200 much of the 
time.  This year they have been between 1200 and 1700.  What kind 
of growth would it take for you to be satisfied - I am curious?  
Bearing in mind that the availability of all three compilers via 
distributions has been improving over time.

And it seems to be unlikely to be a mere artefact of some sort 
because it lines up with what one observes in the forums, in what 
one hears about dconf lately versus prior years (I only went to 
the past couple) and more importantly in development activity - 
commercial and organic.

Weka.io hadn't even heard of D about three years ago and now they 
have one of the largest D projects there is.  3.5 years ago me 
neither - and soon I will be paying for about 4.5 full time 
equivalent people to work on D (maybe a bit more than that in 
time).  This little web company called eBay seems to be using it  
- never heard of them before, but they seem pretty smart.  Remedy 
Games released Quantum Leap, which I guess sold millions of 
copies - it used D for scripting and they will be using D much 
more throughout the firm shortly.  It's used by a $20+bn hedge 
fund for their trading systems, and will gain greater adoption 
within a $3.5bn hedge fund quite soon.

https://dlang.org/orgs-using-d.html

And somebody else remarked to me: "just look at code.dlang.org 
these days - some interesting libraries and I don't know even 
half the names that wrote them".

D doesn't need to persuade most C++ users to switch over to 
succeed.  It doesn't need to persuade anyone you know to succeed. 
  It's at a stage where it's easy to keep growing without anything 
particularly dramatic happening.  All it needs to do is appeal 
just that little bit more to people who are already minded to use 
D, or for whom people who are in pain and looking for an answer 
(which D might be in part) to find out about the language - as 
happened recently with Weka.  And if I compare the documentation, 
libraries, and general quality of things today compared to 2014 
when I started looking at the language, it's improving much 
faster than just a little bit every year.  One doesn't notice 
such change necessarily quickly.


> I agree, but it will be hard for D to beat C++, because people 
> who *need* to use C++ as a "systems programming language" won't 
> use D for the same reasons they don't use C#, Java or Go.

Finance is still one of the larger spenders as an industry.  C++ 
is used quite broadly within it for analytics.  Not because 
people want a system language and need to use malloc and free and 
freely drop down to assembly, but because there isn't an adequate 
alternative that's widely known about for now.  In 3-5 years 
time, I think number of users in finance of D will be higher, 
because it's the solution to pain.  Also, people tend to have 
end-users working in many different languages.  Writing separate 
clients for each one isn't ideal, and wrapping automatically 
makes much more sense.  SWIG works, after a fashion, but D offers 
some more pleasant and more maintainable alternatives.  R is done 
(thanks bachmeier); Python is done (PyD); Excel is done (me, 
Stefan + Atila); C/C++ is easy enough; C# will be done shortly, 
and I have already done some work on Java.  If you say that 
finance guys will never consider adopting D, I beg to differ 
because I think I know that world quite well.  And that's just a 
world I am familiar with, and there are plenty of others.

The web guys get the attention because they are doing interesting 
things, have particular challenges, and can afford to talk - 
because their edge doesn't mostly come from code, which is why 
they open-source so much of it.  It's a mistake to think that the 
people who talk are a good representation of the total number of 
lines of code that are written each year, let alone the total 
code that exists.  Visual Basic for Applications (Excel) 
programmers for example do not tend to get much attention - yet 
there's still a lot of code in VBA, a lot of new code being 
written each year.  And it's not an ideal language.  Spreadsheets 
themselves are a kind of functional code too.  And there are many 
other languages used from which D can pick up market share 
without anyone noticing.

Extended Pascal doesn't come up much.  But there's a 500k SLOC 
codebase used to design great big ships and I was speaking to a 
chap who spoke at dconf (Bastiaat) about his work on and use of 
Pegged, and there's a decent chance that will be ported to D.  
It's D or Ada - I never hear anyone talk about D vs Pascal and D 
vs Ada.  But that would be a big and important project over time.

The truth of it as I see it is that the opinions of most 
technical people are first order irrelevant for the adoption of 
D, because even if they were fanatics about its adoption they 
simply are not in a position to make decisions.  So the people 
that matter are those who can make decisions, and of those it is 
principals that matter and not agents - people who have the 
authority to decide without having to consider primarily social 
factors, and not managers who are primarily responsible to other 
people and have to not just make the right decision, but justify 
it.  And in fact that's my understanding of how D was frequently  
adopted in the firms where it is used.  Liran at Weka didn't do a 
bureaucratic study of the alternatives to justify his case to the 
board.  He knew his problem domain, and what was important, and 
when he heard about D from Kent Beck he recognised a solution, 
and he had earned the authority to decide because of his past 
accomplishments and it's difficult building a startup, but I 
doubt having to justify his language choices is one of the main 
things he worries about in life.  The Sociomantic founders didn't 
have to persuade anyone in the beginning, and I guess when they 
got bought Dunhumby didn't make their language choices a sticking 
point but were probably more happy to have found such talented 
people - if the purchase price is anything to go by.

When you have a small market share - and D's is not tiny, but 
it's not a top 10 language either, you don't need to achieve mass 
conversion to keep growing.  Just appeal to a slightly broader 
set of people, or have a higher appeal to those that already are 
sympathetic to the language - that's not something difficult to 
achieve once the ball is rolling.

These ideas are all fairly standard.  I don't completely agree 
with it, but Geoffrey Moore's Crossing the Chasm books etc get 
the idea across well.  And the idea is actually much older - it 
dates back to Toynbee's idea of creative minorities (new things 
come from the fringes), to the ideas about Ibn Khaldun (the 
founder of economics, one might say) about civilisational 
renewal, and the same insight is in Ecclesiastes in the Bible (if 
you think it through carefully).

> Just its GC keeps many C++ developers away from it, whether is 
> justified or not, despite D is as low level and performant.

Yes - but read the Reddit comments this year.  There's a subtle 
change in tone that's quite important.  Over the years people 
have developed a standard set of excuses not to explore the 
language - as Andrei observes, people develop these as a defence 
in the face of a rapid rate of change.  If one looked into 
everything, there'd be no time to do any work at all.

These standard sales objections are receding because they simply 
don't hold water at all, or not nearly so.  There are no jobs in 
D - well, if you are good I'm always open to working with the 
right sort of people; and I was at DConf on a large table of 
people all working for a living with D, and it was a funny line 
because there are jobs in D, and for some people it's been pretty 
good career-wise.  The blog posts on the GC have been very good 
at getting people to think more carefully about this blanket 
dismissal too.  (And I guess when we have ref-counted exceptions 
and much more of Phobos is truly no-gc that will help too).  By 
the way, the fact that people are committing their energy to work 
on blog posts and so on tells you something about the increasing 
commitment of energy from the community.

There's a C++ guy I work with now, and I was wondering what his 
response might be to suggesting we consider using D in the part 
of the business he is involved in.  He wasn't particularly 
concerned about the GC, but I showed him that it didn't matter 
for what we do, and that in any case you can avoid using it for 
much and keep the heap small.  That wasn't the obstacle.  Main 
thing is just needing to change our build process, which isn't 
hard but will take a little bit of time.  He didn't need 
persuading - he could just recognise it as leading to more 
readable, more componentised code and it  also - with a bit more 
investment upfront - solves our wrapping problem.

People have very different contexts, and it's worth bearing that 
in mind when one reads forum comments too.  Somebody who earns a 
living teaching people popular languages but has invested lots of 
time in D and hasn't found it paid off commercially - yes, of 
course that will shape their attitude towards D from here.  But 
that hasn't got to do much with the prospects for the further 
development of the language, which isn't to say one can't learn 
from them about what to improve.  Another guy who loves talking 
about languages in a very theoretical way - but there's some 
debate about whether he has written anything serious in D at all. 
  Well everyone is welcome to an opinion, but probably some 
perspectives may be a better guide to the likelihood of broader 
adoption than others.  Walter himself -
  a man who not just survived but flourished in a very competitive 
field operating as a leanly-staffed underdog - has remarked that 
in his experience non-customers would tell you all kinds of 
things, but when you satisfied what they wanted it never actually 
lead to a change.  What works is paying attention to people who 
are already customers, or at least using your product in some way 
seriously.

And enterprise users generally don't have time to post much in 
forums because they have work to do - how often do you see people 
from Weka and Sociomantic post here in relation to the number of 
people they have?

The above about listening to your real users could be seen as 
self-serving, but I don't mean it in that way - I find the 
leadership perfectly responsive as a commercial user (and I don't 
really need much).  Rather it's just to observe there's a lot of 
"what D really needs is this", but I'm not sure these 
perspectives are always a good guide to what will help.

Wulfklaue:
"Agrees with that. The problem with a language trying to scope 
away a specific group of developers, from a existing ecosystem is 
that your fighting the entire ecosystem, not just the language. 
That is a mistake that many new languages make."

Nobody in their right minds would try to target an 
abstractly-defined category of developers.  The world doesn't 
work that way, and it's not what anyone is doing.  People are 
drawn to things that offer them something better, and what's 
better very much depends in the situation you are in, and what 
your constraints are - and situations that might appear identical 
from the outside really aren't from the inside because these 
things are shaped by culture, history, perceptions and emotional 
factors within the group, not to mention different basic 
conditions (industry and firm challenges, the kinds of people you 
have already), and so on.

"Maybe this was mentioned before but a lot of programmers prefer 
to lazy program. They want to write there code, move forward with 
there project and not spend time on trying to get "things" to 
import/convert/work. D has more people who have no issue doing 
things the "hard" way. I applaud that resolve, i really do. But 
at the same time its a barrier, a attitude that makes it hard to 
accept those lazy people like me :)"

I don't know if D is a language for everybody.  I agree that D 
has people who don't mind a bit of discomfort and doing things 
the hard way.  I wouldn't be here if it were any different.  I 
agree that it's a barrier, but complex living things can't grow 
without a barrier, membrane or border.  I live in Barnes, and 
it's in London, only 40 minutes to Mayfair, but like a little 
English village.  And the reason for that is there is no tube and 
it's a bit difficult to get here.  If there were a tube station 
its character would be very different.  And that's true of all 
social groups - if there is no price to be paid for admission, 
implicit or not, then the group won't develop a character of its 
own.  So I see the features of D that concern you as a positive - 
it's a nice filter to be able to find the people that I would 
like to work with.  My industry is a tough and demanding industry 
and the people who do best in it are those who are resourceful 
and able to figure things out for themselves when needed.  It's 
not difficult to find excellent D programmers - one has to go 
through many more candidates to find excellent C# programmers 
that are aware of developments beyond the MS micro-culture.

A chap called Nassim Taleb talks about some of these ideas in his 
work on hormesis and antifragility.  The D community creates 
hormesis and this is a healthy filter.  And not being as 
dependent on pretty labour-saving tools (and not needing them) 
has some positive effects too.  Taleb talks about seeing a 
businessman in the lobby, giving his bags to a porter to take up 
to his room.  Twenty minutes later he sees him in the gym lifting 
weights.  And his point is that taking advantage of natural 
organic challenges to build fitness can build much more strength 
than synthetic approaches to try to replace what we have lost.  
I've personally benefited from having to figure many more things 
out for myself than I would have needed to had I stuck with 
Python or learnt C#.  The extra time invested wasn't significant 
compared to the payoff even so far, but building a capability is 
a gift that keeps on giving.

I wanted to contribute a small token amount to BountySource as I 
thought I should.  You mention crystal at $2.3k/month.  Well I've 
contributed much more than that personally per month on average 
in the time I have been involved in the community for things that 
I have open-sourced.  Not the same thing as bounties, but for 
example the work we did on dub came out of my own pocket.  And 
I'm sure Weka's investment to date dwarfs my modest contribution, 
and we have all benefited from it.  In other words this language 
community works differently - I think commercial users would 
often rather approach someone directly than post a bounty.

And as Adam says, the kind of people that work on D aren't 
necessarily motivated by money to do such work.  Studies suggest 
that when you pay someone to do something it often takes the joy 
out of it by turning motivation from autotelic to instrumental.  
So it's not clear that it's even healthy for the community.  
Pragmatically, maybe it's one solution to get people to work on 
tedious but important things - but I really wouldn't consider it 
likely to be the main driver of developments for a community such 
as the one we have.

It's happened to me by the way that I've asked somebody who 
contributes a lot to the community if he would be interested in 
helping me for a fee, and he really wasn't.  And that's sometimes 
because people are very good programmers, and for some that can 
lead to pretty good career or business success and they 
contribute to D because they like it.  It's a fortunate position 
for such a community to have such people working on the language 
or ecosystem that couldn't be paid by a company to do the same 
because their price is too high - provided any one person isn't 
ultra critical.

"The whole D foundation is nice and well but to me it feels like 
cloak and daggers. It something hiding in the background, 
something obscure. Maybe i am not expressing myself good again 
but D its fund raising seems to be largely corporate focused but 
they seem to lose a big market potential. Corporate funding is 
harder to get then a lot of small donations."

Give it a chance - it's barely got off the ground yet.  Best way 
to get a foundation to listen to you is to give them a little bit 
of money if you can afford it, or do something helpful for them 
if you have time and some talent but not money to spare.  I think 
corporate funding is easier to get than lots of small donations, 
because not all corporates are vast enterprises - it's by far 
easier to persuade entrepreneurial people who want to support 
something anyway then a legion of smaller supporters.  
Nonetheless the language needs both.  Do you contribute yet?

" Syntax is more about preference."

If you look at the reactions of people around the world, beauty 
isn't something utterly idiosyncratically subjective - tastes 
vary, but less than some would say.  And tastes may differ about 
language design (some might say part of that is that some people 
have better taste than others, but let's not discuss that for 
now) too.  But in my experience idiomatic D code is very readable 
and clear, and if you compare it say to Boost or quite a lot of 
Python code that isn't always the case.  And readability and 
clarity and ability to express intent matter a lot because code 
is read much more than it is written and code lives a long time.  
So it's not simply a question of preference - it's much more 
important than that.

"Electronic wire transfer or bank check *bwahaaha*. What are we: 
1980? Even worse, "Wire transfer information will be announced 
soon.". How long as that text been there??? Does the D team even 
look at there own website???"

I paid via PayPal.  It was easy.  If you have a suggestion for 
improving, I am sure people would welcome a pull request.  If 
you're not willing to do the work, then that's quite reasonable, 
but it's less reasonable to insist on others doing it...

"I was under the impression that D with a bountysource account 
was going to be able to raise monthly funds on a higher level 
then Crystal and Nim. I really do not know what to say. No wonder 
when most new people do not even know its exists and the lack of 
acknowledgment on the website only reinforces this."

$24k a year is a completely trivial amount that means nothing in 
the scheme of things, and it's a mistake to be distracted by such 
noise.

"There is no focus on raising funds."
Raising more substantial amounts of money works very differently 
from raising the sorts of sums you discuss.  It makes sense given 
where D starts, the people involved, and the fact that it's quite 
a lean team, to start with more substantial amounts because the 
return on time and attention is much higher (and it's working in 
a domain that's easier to understand).

"Its easy to see why Nim and Crystal out fund D on bountysource."

If you have commercial users who have been using your language at 
a reasonable scale in production (Weka manage 100s of Petabytes 
using D, I think, and most people know the scale of Sociomantic's 
use too) then your approach is going to be different from 
languages that are newer and with less commercial adoption.  Your 
strategy depends on where you are, but that's something that may 
not be obvious to a newcomer or someone who hasn't had to think 
about how to raise money.

https://news.ycombinator.com/item?id=14431315
Xored, and who else?
https://dlang.org/orgs-using-d.html
There are others not listed here even




Of course it's always interesting to hear ideas for improvement.



Laeeth