This was supposed to come to this list not the learn list.

On Thu, 2018-10-11 at 07:57 +0100, Russel Winder wrote:
> It seems that in the modern world of Cloud and Kubernetes, and the charging
> model of the Cloud vendors, that the startup times of JVMs is becoming a
> financial problem. A number of high profile companies are switching from
> Java
> to Go to solve this financial difficulty.
> 
> It's a pity D is not in there with a pitch.
> 
> I suspect it is because the companies have heard of Go (and Rust), but not
> D.
> 
-- 
Russel.
===========================================
Dr Russel Winder      t: +44 20 7585 2200
41 Buckmaster Road    m: +44 7770 465 077
London SW11 1EN, UK   w: www.russel.org.uk

On Thursday, 11 October 2018 at 07:58:39 UTC, Russel Winder wrote:
> This was supposed to come to this list not the learn list.
>
> On Thu, 2018-10-11 at 07:57 +0100, Russel Winder wrote:
>> It seems that in the modern world of Cloud and Kubernetes, and the charging
>> model of the Cloud vendors, that the startup times of JVMs is becoming a
>> financial problem. A number of high profile companies are switching from
>> Java
>> to Go to solve this financial difficulty.
>> 
>> It's a pity D is not in there with a pitch.
>> 
>> I suspect it is because the companies have heard of Go (and Rust), but not
>> D.

I doubt D could make a pitch that would be heard, no google behind it and all that jazz. D is better aimed at startups like Weka who're trying to disrupt the status quo than Java shops trying to sustain it, while shaving off some up-front time.

On Thursday, 11 October 2018 at 11:50:39 UTC, Joakim wrote:
> On Thursday, 11 October 2018 at 07:58:39 UTC, Russel Winder wrote:
>> This was supposed to come to this list not the learn list.
>>
>> On Thu, 2018-10-11 at 07:57 +0100, Russel Winder wrote:
>>> It seems that in the modern world of Cloud and Kubernetes, and the charging
>>> model of the Cloud vendors, that the startup times of JVMs is becoming a
>>> financial problem. A number of high profile companies are switching from
>>> Java
>>> to Go to solve this financial difficulty.
>>> 
>>> It's a pity D is not in there with a pitch.
>>> 
>>> I suspect it is because the companies have heard of Go (and Rust), but not
>>> D.
>
> I doubt D could make a pitch that would be heard, no google behind it and all that jazz. D is better aimed at startups like Weka who're trying to disrupt the status quo than Java shops trying to sustain it, while shaving off some up-front time.

Personally I think this is going to change soon depending on what options are available.  The amount of time and money that companies, especially companies using Java and AWS, are putting in to saving money with Nomad or Kubernetics on the promise of having more services per server is quite high.  However, these JVM based services run in maybe 1-2GB of RAM at the minimum, so they get maybe 4 services per box.

A microservice built using D and vibe.d could easily perform the same work using less CPU and maybe only 500MB of RAM.  The scale of improvement is roughly the same as what you would get by moving to containerization.

If D has the proper libraries and integrations available with the tools that are commonly used, it could easily break through and become the serious language to use for the competitive business of the future.

But libraries and integrations will make or break that.  It's not just Java you're up against, it's all the libraries like SpringBoot and all the integrations with AWS systems like SQS, SNS, Kinesis, MySQL, PostGREs, Redis, etc.

My hope is that D will be part of that future and I'm trying to add libraries as time permits.

On Thursday, 11 October 2018 at 07:58:39 UTC, Russel Winder wrote:
> This was supposed to come to this list not the learn list.
>
> On Thu, 2018-10-11 at 07:57 +0100, Russel Winder wrote:
>> It seems that in the modern world of Cloud and Kubernetes, and the charging
>> model of the Cloud vendors, that the startup times of JVMs is becoming a
>> financial problem. A number of high profile companies are switching from
>> Java
>> to Go to solve this financial difficulty.
>> 
>> It's a pity D is not in there with a pitch.
>> 
>> I suspect it is because the companies have heard of Go (and Rust), but not
>> D.

Suggestions?

My guess is that the reason they've heard of those languages is because their developers were writing small projects using Go and Rust, but not D.

On Thursday, 11 October 2018 at 12:22:19 UTC, Vijay Nayar wrote:
> On Thursday, 11 October 2018 at 11:50:39 UTC, Joakim wrote:
>> On Thursday, 11 October 2018 at 07:58:39 UTC, Russel Winder wrote:
>>> This was supposed to come to this list not the learn list.
>>>
>>> On Thu, 2018-10-11 at 07:57 +0100, Russel Winder wrote:
>>>> It seems that in the modern world of Cloud and Kubernetes, and the charging
>>>> model of the Cloud vendors, that the startup times of JVMs is becoming a
>>>> financial problem. A number of high profile companies are switching from
>>>> Java
>>>> to Go to solve this financial difficulty.
>>>> 
>>>> It's a pity D is not in there with a pitch.
>>>> 
>>>> I suspect it is because the companies have heard of Go (and Rust), but not
>>>> D.
>>
>> I doubt D could make a pitch that would be heard, no google behind it and all that jazz. D is better aimed at startups like Weka who're trying to disrupt the status quo than Java shops trying to sustain it, while shaving off some up-front time.
>
> Personally I think this is going to change soon depending on what options are available.  The amount of time and money that companies, especially companies using Java and AWS, are putting in to saving money with Nomad or Kubernetics on the promise of having more services per server is quite high.  However, these JVM based services run in maybe 1-2GB of RAM at the minimum, so they get maybe 4 services per box.
>
> A microservice built using D and vibe.d could easily perform the same work using less CPU and maybe only 500MB of RAM.  The scale of improvement is roughly the same as what you would get by moving to containerization.
>
> If D has the proper libraries and integrations available with the tools that are commonly used, it could easily break through and become the serious language to use for the competitive business of the future.
>
> But libraries and integrations will make or break that.  It's not just Java you're up against, it's all the libraries like SpringBoot and all the integrations with AWS systems like SQS, SNS, Kinesis, MySQL, PostGREs, Redis, etc.
>
> My hope is that D will be part of that future and I'm trying to add libraries as time permits.

I'm skeptical of that cloud microservices wave building up right now. I suspect what's coming is a decentralized mobile wave, just as the PC once replaced big iron like mainframes and minicomputers, since top mobile CPUs now rival desktop CPUs:

"the [Apple] A12 outperforms a moderately-clocked Skylake CPU in single-threaded performance"
https://www.anandtech.com/show/13392/the-iphone-xs-xs-max-review-unveiling-the-silicon-secrets/4

Many of the crypto-coins are trying to jumpstart a decentralized app ecosystem: someone will succeed.

On Thu, 2018-10-11 at 13:00 +0000, bachmeier via Digitalmars-d wrote: […]
> Suggestions?
> 
> My guess is that the reason they've heard of those languages is because their developers were writing small projects using Go and Rust, but not D.

I fear it may already be too late. Go, and now Rust, got marketing hype from an organisation putting considerable resources into the projects. This turned into effort from the community that increased rapidly, turning the hype into frameworks and libraries, and word of mouth marketing. It is the libraries and frameworks that make for traction. Now the hype is gone, Go and Rust, and their libraries and frameworks, are well positioned and with significant penetration into the minds of developers.

Talk to Java developers and they have heard of Go and Rust, but not D. Go is
more likely to them because of Docker and the context of The Web, for which Go
has a strong pitch. They have heard of Rust but usually see it as not relevant
to them, despite Firefox.

Talk to Python developers and they know of Go, many of them of Rust, but
almost never D. C and C++ are seen as the languages of performance extensions,
though Rust increasingly has a play there.

D has vibe.d, PyD, GtkD, and lots of other bits, but they've never quite had the resources of the equivalents in Go and Rust.

Also the D community as a whole is effectively introvert, whereas Go and Rust communities have been quite extrovert. "Build it and they will come" just doesn't work, you have to be pushy and market stuff, often using guerilla marketing, to get mindshare.

D has an excellent position against Python (for speed of development but without the performance hit) but no chance of penetrating the places where Python is strong due to lack of libraries and frameworks that people use – cf. Pandas, SciKit.Learn, etc.

D has an excellent position against Go as a language except that Go has goroutines and channels. The single threaded event loop and callback approach is losing favour. Kotlin is introducing Kotlin Coroutines which is a step on from the observables system of Rx. Structured concurrency abstracting away from fibres and threadpools. Java may well get this via Project Loom which is Quasar being inserted into the JVM directly. Whatever D has it doesn't seem to be going to compete in this space.

D without the GC has a sort of position against Rust, but I think that battle has been lost. Rust has won in the "the new C that isn't Go and doesn't have a garbage collector, and isn't C++, but does have all the nice monads stuff, oh and memory safety mostly".

When it comes down to it D will carry on as a niche language loved by a few unknown to most.

-- 
Russel.
===========================================
Dr Russel Winder      t: +44 20 7585 2200
41 Buckmaster Road    m: +44 7770 465 077
London SW11 1EN, UK   w: www.russel.org.uk

On Friday, 12 October 2018 at 07:13:33 UTC, Russel Winder wrote:
> On Thu, 2018-10-11 at 13:00 +0000, bachmeier via Digitalmars-d wrote: […]
>> Suggestions?
>> 
>> My guess is that the reason they've heard of those languages is because their developers were writing small projects using Go and Rust, but not D.
>
> I fear it may already be too late. Go, and now Rust, got marketing hype from an organisation putting considerable resources into the projects. This turned into effort from the community that increased rapidly, turning the hype into frameworks and libraries, and word of mouth marketing. It is the libraries and frameworks that make for traction. Now the hype is gone, Go and Rust, and their libraries and frameworks, are well positioned and with significant penetration into the minds of developers.
>
> Talk to Java developers and they have heard of Go and Rust, but not D. Go is
> more likely to them because of Docker and the context of The Web, for which Go
> has a strong pitch. They have heard of Rust but usually see it as not relevant
> to them, despite Firefox.
>
> Talk to Python developers and they know of Go, many of them of Rust, but
> almost never D. C and C++ are seen as the languages of performance extensions,
> though Rust increasingly has a play there.
>
> D has vibe.d, PyD, GtkD, and lots of other bits, but they've never quite had the resources of the equivalents in Go and Rust.
>
> Also the D community as a whole is effectively introvert, whereas Go and Rust communities have been quite extrovert. "Build it and they will come" just doesn't work, you have to be pushy and market stuff, often using guerilla marketing, to get mindshare.
>
> D has an excellent position against Python (for speed of development but without the performance hit) but no chance of penetrating the places where Python is strong due to lack of libraries and frameworks that people use – cf. Pandas, SciKit.Learn, etc.
>
> D has an excellent position against Go as a language except that Go has goroutines and channels. The single threaded event loop and callback approach is losing favour. Kotlin is introducing Kotlin Coroutines which is a step on from the observables system of Rx. Structured concurrency abstracting away from fibres and threadpools. Java may well get this via Project Loom which is Quasar being inserted into the JVM directly. Whatever D has it doesn't seem to be going to compete in this space.
>
> D without the GC has a sort of position against Rust, but I think that battle has been lost. Rust has won in the "the new C that isn't Go and doesn't have a garbage collector, and isn't C++, but does have all the nice monads stuff, oh and memory safety mostly".
>
> When it comes down to it D will carry on as a niche language loved by a few unknown to most.

There is truth in much of what you say, but D has to pick its battles. Given the design of the language, I see two primary use-cases right now:

1. apps that need some level of performance, ie Tilix
2. Low-level tools that need a lot of performance, ie Weka or Sociomantic

Going after some established tool like Pandas and its mix of Python and C is likely to fail right now, as D is never going to be as easy as Python, and presumably Pandas has already sped up whatever it needs to in C. Maybe you could create a better tool in D some day when the D ecosystem is larger, but I don't think it would be the best approach today.

We need to think about what markets D would be best suited for and aim for those, while at the same time resisting the temptation to make D too specialized for those initial markets, which is a trap many other languages fall into.

On Friday, 12 October 2018 at 07:13:33 UTC, Russel Winder wrote:
> On Thu, 2018-10-11 at 13:00 +0000, bachmeier via Digitalmars-d wrote: […]
>> Suggestions?
>> 
>> My guess is that the reason they've heard of those languages is because their developers were writing small projects using Go and Rust, but not D.
>
> I fear it may already be too late. Go, and now Rust, got marketing hype from an organisation putting considerable resources into the projects. This turned into effort from the community that increased rapidly, turning the hype into frameworks and libraries, and word of mouth marketing. It is the libraries and frameworks that make for traction. Now the hype is gone, Go and Rust, and their libraries and frameworks, are well positioned and with significant penetration into the minds of developers.
>
> Talk to Java developers and they have heard of Go and Rust, but not D. Go is
> more likely to them because of Docker and the context of The Web, for which Go
> has a strong pitch. They have heard of Rust but usually see it as not relevant
> to them, despite Firefox.
>
> Talk to Python developers and they know of Go, many of them of Rust, but
> almost never D. C and C++ are seen as the languages of performance extensions,
> though Rust increasingly has a play there.
>
> D has vibe.d, PyD, GtkD, and lots of other bits, but they've never quite had the resources of the equivalents in Go and Rust.
>
> Also the D community as a whole is effectively introvert, whereas Go and Rust communities have been quite extrovert. "Build it and they will come" just doesn't work, you have to be pushy and market stuff, often using guerilla marketing, to get mindshare.
>
> D has an excellent position against Python (for speed of development but without the performance hit) but no chance of penetrating the places where Python is strong due to lack of libraries and frameworks that people use – cf. Pandas, SciKit.Learn, etc.
>
> D has an excellent position against Go as a language except that Go has goroutines and channels. The single threaded event loop and callback approach is losing favour. Kotlin is introducing Kotlin Coroutines which is a step on from the observables system of Rx. Structured concurrency abstracting away from fibres and threadpools. Java may well get this via Project Loom which is Quasar being inserted into the JVM directly. Whatever D has it doesn't seem to be going to compete in this space.
>
> D without the GC has a sort of position against Rust, but I think that battle has been lost. Rust has won in the "the new C that isn't Go and doesn't have a garbage collector, and isn't C++, but does have all the nice monads stuff, oh and memory safety mostly".
>
> When it comes down to it D will carry on as a niche language loved by a few unknown to most.

In my opinion, I don't think the game is over just yet.  One of D's biggest strengths has been its ability to adapt and innovate.  Despite being around since 2001, it is still forging ahead and many of the new features coming out in programming languages are coming to fruition in D before being back-ported to other languages.

The D crowd is certainly very introverted and very technically minded, it really seems to be an amazing hub for innovators and compiler designers.  But the D community has also been very receptive of changes to the language which allows it to evolve at a pace few other languages can match.

My personal opinion is that languages that grow up too fast get stuck because they have too much legacy code and certain options that they may have originally wanted become unavailable.

Go and Rust are gaining traction, especially among developers getting tired of very hard to work with languages.  Java is very very slow to evolve and there's a huge amount of effort invested in learning other JVM languages like Scala, I think largely because people are looking for alternatives.

Rust, while intriguing, is very alien in syntax and concept for many developers.  Go gets wider adoption than other languages I've seen, but the race is still on in my book.


One thing that does concern me, is the avenues in which people can discover D.  For me personally, after a particularly nasty C++ project, I just googled for "alternatives to C++" and that's how I found D back in 2009 or so.  But the same search today turns up nothing about D.  I'm not sure sure how people are supposed to find D.

On Friday, 12 October 2018 at 07:13:33 UTC, Russel Winder wrote:
> On Thu, 2018-10-11 at 13:00 +0000, bachmeier via Digitalmars-d wrote: […]
>> Suggestions?
>> 
>> My guess is that the reason they've heard of those languages is because their developers were writing small projects using Go and Rust, but not D.
>
> I fear it may already be too late.
>
> [...]

I don't think it's ever too late. Python was stagnant for a long time but exploded in popularity in recent years due to Pandas, TensorFlow, SciPy etc.  Similar things have happened in other languages, and it can happen for D.

The technical differences between languages is mostly immaterial as well IMO. Plenty of awful languages have succeeded despite being really terrible for the domain they won. As long as there are libraries and integrations that help solve a problem, people will use them. PHP is the obvious example here. R is another.

As long as D continues to be a nice language to work in for hobbyists, there will always be potential for a killer use case to come along. D just needs to make sure it doesn't piss off its fans. vibe.d happened because a single person was a fan of D. You don't need a lot of marketing for that to happen. Maybe vibe.d hasn't been the killer app for D, but the next thing might be, so you just need fans.

I do believe in "Build it and they will come", but "it" needs to be something of value. At the moment, the "it" of D on its own just isn't valuable enough. Lots of marketing without a strong value proposition will just be a waste of effort.

On Friday, 12 October 2018 at 10:27:53 UTC, Peter Alexander wrote:

> As long as D continues to be a nice language to work in for hobbyists, there will always be potential for a killer use case to come along. D just needs to make sure it doesn't piss off its fans. vibe.d happened because a single person was a fan of D. You don't need a lot of marketing for that to happen. Maybe vibe.d hasn't been the killer app for D, but the next thing might be, so you just need fans.

I periodically look at how I can make use of D for small projects. Most often, I shy away because I want to build a GUI and none of the libraries that I can find look mature and well maintained enough to put my faith in. For C++ there's Qt, which is *phenomenally* good (despite some warts), but there's been at least half a dozen attempts at creating D bindings for that, all in various states of completion/negligence.

I think that there is just no good story for D on the graphical desktop. The language would be well suited for bread and butter CRUD applications with desktop UIs and similar boring stories. These things get made, but mostly in complete isolation behind company walls. This is a kind of market that is willing to pay good money if you have a believable story about how to develop large amounts of boring, moderately complex logic with drab cookie-cutter user interfaces *quickly*. D is far from having that story. Almost all successful languages offer good solutions.

A lot of other library bindings to existing stand-out libraries are the same as the Qt bindings (with the Derelict set of bindings being a noteworthy exception!). It's a chicken and egg problem to some extent. I would want to use D to get my project done fast. But the prospect of missing or incomplete/buggy bindings consistently turns me off. I freely admit that I don't want to mess with that kind of stuff - it's really, really boring work to maintain bindings and I feel that I can put my time to use on more interesting things. Certainly, I'm not the only one who thinks that way. But on the other hand, libraries thrive best when they have a large set of dependent projects that puts them through their paces. Also, it seems to me that many library maintainers get more motivated if they see their libraries being picked up and used actively by others.

Looking back at the last ~25 years, it seems to me that the programming language market has actually been very stable or stagnant. C++ and Perl were introduced in the 90s, Java, JS, PHP and Python in the 90s, C# is one of the youngest of the big programming languages with its release in the early 2000s. Newer languages have had to stay at the sidelines for very long. The only serious new contenders are Go (Google), Rust (Mozilla) and Swift (Apple). All three of them needed a big push from a wealthy company to get where they are today and they are still in niches. Part of the stagnation is certainly because heaps of existing code that work and cannot just be thrown away and rewritten.  But how big is this effect really?