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
