On Thursday, 22 November 2018 at 05:19:25 UTC, Stanislav Blinov wrote:
> On Thursday, 22 November 2018 at 04:40:37 UTC, NoMoreBugs wrote:
>
>> In the 2 weeks so far, I've been accused (by a select few - always the same few though) of being a 'non-contributor', of misrepresenting facts, and being a socket puppet.
>
> - Honey, be careful. They say on the news there's a lunatic speeding in the wrong lane.
> - A lunatic?!? There's loads of them!..

That's funny, cause I every day I drive to work, and the vast majority of people seem to speed past me (even though I drive at the speed limit).

Either sane people are now the minority, or the minority are the actual lunatics.

i.e. I can't work out whether I'm the sane driver (for not speeding), or the lunatic (for not speeding like everyone else).

I might do on these forums, what I have to do everyday, and just pull over for a while ;-)

On Thursday, 22 November 2018 at 10:08:06 UTC, Chris wrote:
> The thing is that - as you mentioned yourself - there's loads of stuff out there already: Dpp, DStep, Joakims ARM stuff, Polyglot.h etc. Is it so unreasonable to expect the D Foundation to focus on collecting all the brilliant work that's been done by volunteers so far (fair play to them!) and package it as a nice product that can be extended as needed? That'd be a killer package and a good selling point for D. It's only common sense.
>
> The D Foundation initially gave me hope that something like that would happen, and then you could get medium to big players on board (what's a million dollars to IBM or the like?) However, it got worse than before. While the development of D used to be a bit chaotic it has now become an autocratic chaos. The focus has shifted from improving D as a language (including tooling, packaging etc) to obsessing over the pet feature of the day. It's more of a hobby project now than ever before. And mind you, the D Foundation is young, but D is 18+ years old.

The lack of vision is problematic indeed, and I am doing something about it. The foundation is due to meet with industry users in a few weeks to resolve issues and set a clear direction, which will cover many of those points (hopefully a better replacement for those vision documents that are long overdue). Watch this space...

On Thursday, 22 November 2018 at 11:26:03 UTC, Nicholas Wilson wrote:
> On Thursday, 22 November 2018 at 10:08:06 UTC, Chris wrote:
>> [...]
>
> The lack of vision is problematic indeed, and I am doing something about it. The foundation is due to meet with industry users in a few weeks to resolve issues and set a clear direction, which will cover many of those points (hopefully a better replacement for those vision documents that are long overdue).

Finally!

> Watch this space...

I will.

On Thursday, 22 November 2018 at 10:24:44 UTC, rikki cattermole wrote:
> On 22/11/2018 10:44 PM, Dave Jones wrote:
>> Welcome to the internet dude. Chill out, stop taking Look mate most people will ignore you, some of the nice guys will try to be nice to you, some of the bored loonies will poke you to get a reaction.. (wait thats me!), but at the end of the day wtf do you expect?
>
> That is quite enough, no need to respond if you won't be civil in response.

Jeez I bet you're a hoot after a few beers. ;)

On Thursday, 22 November 2018 at 11:14:54 UTC, Chris wrote:
> On Thursday, 22 November 2018 at 04:07:32 UTC, Laeeth Isharc wrote:
>
> [snip]
>
> By the way, you keep mentioning that you use D for your own internal stuff, and as far as I can see a lot of companies that use D do the same. They have their own in-house ecosystem, and that's fine. Of course, for this kind of usage D might be OK (apart from the facepalm flaws it still has) - or any language for that matter.
>
> However, a lot of IT companies (small, medium and big) also have to adapt to the market in terms of third party products like Android and iOS and other technologies (including those that do not yet exist). Once that's the case, D is one of the worst choices possible.

D doesn't have the best GUI libraries, that's quite true.  JNI is not that bad so if you wanted everything but the front end in D would it be so tough?  You might be right about the situation on ios as I haven't heard of people doing much there in D - last I heard the hard work was done but the last stage - something relating to bitcode if I recall right.

> Everything takes years

True.  Why does it bother you? Did somebody suggest it would be otherwise? If one puts some energy behind making something happen it's not that bad, I think.  Eg autowrap for JNI shouldn't take more than a couple of months of work to be mostly useful I think.

> anything that is not directly related to (some specific features of) the language is treated as lowest priority

Who is treating, and what is this word priority I keep hearing.

It's open source, ordered anarchy.  It's hard enough persuading a creative person that you pay to do something he doesn't want to do.  How do you suppose it is that Walter and Andrei can assign priorities more to your liking and make people work on what you would wish?   They cannot.

I think you're applying rules from your work domain to an environment where they don't apply.   That's simply not how volunteer open source works.

If there's a single corporate backer of course it's different if by solving their problems they solve yours too or if can influence them.  That's intrinsically not the kind of community D is, so if you want to achieve a generative result here then your means do not suit your ends.

, and a small or medium
> sized company may not be able "to roll its own" all the time,

Indeed, not unless they have fairly talented and creative programmers and the management is technical.

Most companies probabily shouldn't introduce D in a top down way.  They're just not cut out for it.

Elsewhere I called D a secret weapon that is only available to the few (because you have to have the culture, capabilities and will to be willing to trade off less easy today for more simple tomorrow).

That's okay, isn't it?  It's a big wide world and I think there won't be fewer people writing native code in a decade but rather more.

You don't need to appeal to everyone if you are the challenger and it is pointless to do so.

> especially if everything is still raw and has a lot of loose ends as in the case of D. And you know what, customers don't care about your problems. They simply go somewhere else, if you can't deliver.

Yes.  For example if you have a storage system that is not performant or does not add features sufficiently quickly you will lose customers. Its tough having customers but I think its a matter of picking your poison after deciding what's important to you. If you don't want to use D, I wouldn't dream of trying to change your mind.  Maybe it's not for you, or not for you right now.

But really one must consider one's ends and pick means to serve those.  The means of complaining on the forum doesn't actually accomplish anything.  If there's something you want in D that you would use, then probably the most effective route will be to make a small beginning yourself and try to persuade others to be involved.  Or you could just pay for it yourself, or try to persuade others to club together to pay for it.

> So what you need is a language that provides adaptability out of the box.

D notably is adaptable.  It just doesn't come ready adapted.

>this is why a lot of new languages
> invest in exactly this

Where do you think the money will come from to invest, exactly?  Grumble enough on the forum until Google decide to sponsor the language and invest in the things you want?

I don't think it works like that.

Being an entrepreneur is quite difficult.  How does one create something from nothing?

In my experience when you are ready for it you figure out where you want to go, don't worry too much if your goal seems audacious or unrealistic, and make a humble little start and persist, correcting course along the way as new information arrives.

I think that's the way in general to push the world in a direction you think would be a good one.  An honest, thought through proposal by far beats complaining.  And working code beats a proposal.

>Only in
> this way they will be adopted by users.
That's not how it works for a language like D.  Read the innovators dilemma by Christensen as well as Thiel Zero to One.

Your "cosmos" is D and
> your own company. But most other people have to cater for third party software as well and adapt to an ever changing market.

I don't have time to look but I'm curious.  My guess would be most software is written within the enterprise for internal use and then add software as a service and I should think that's a very significant chunk of the total market.  So maybe D isn't right for some users or not sufficiently mature in ecosystem and tooling right now. Okay. Do you find that especially surprising?


> I think this is a fact you're not really aware of. You can talk all you like about the cosmos and the universe, but all you see are your own needs for which D might be fine. But reality is different for other people.

My impression is the opposite.  I don't doubt that D isn't right for many, but you seem to be suggesting that what you feel is true for you must inevitably be true for the whole world.  I think that's contradicted by observed experience.

And as far as my world goes, finance is quite a decent employer of programmers and market for technology.

If you're the challenger you really don't need to appeal to everyone to grow.  You just need to increase awareness and appeal a bit to people who are already poised on the edge.

It's better to not be taken seriously if you are the challenger and that camouflage may well be a matter of survival.  You do not want the dominant players to take you seriously and try to imitate your advantages or to fight dirty until you are more than ready for it.

Not that it's calculated, but it's how natural waves of adoption unfold.

On Thu, Nov 22, 2018 at 10:04:36PM +0000, Laeeth Isharc via Digitalmars-d wrote:
> On Thursday, 22 November 2018 at 11:14:54 UTC, Chris wrote:
[...]
> > However, a lot of IT companies (small, medium and big) also have to adapt to the market in terms of third party products like Android and iOS and other technologies (including those that do not yet exist). Once that's the case, D is one of the worst choices possible.
> 
> D doesn't have the best GUI libraries, that's quite true.  JNI is not that bad so if you wanted everything but the front end in D would it be so tough?  You might be right about the situation on ios as I haven't heard of people doing much there in D - last I heard the hard work was done but the last stage - something relating to bitcode if I recall right.
[...]

Joakim has done an amazing job making LDC cross-compile to Android. Currently I'm working on an Android project that has Java talking to D code via JNI.  It works fairly well, though with some amount of boilerplate that at some point I'm expecting to factor out into a template that auto-generates JNI wrappers. So far I have the majority of my code in D, so the need for JNI wrappers has been pretty minimal, but at some point I'll probably be wanting more convenient ways of interacting with Java, and D's metaprogramming power will be brought to bear.


T

-- 
Let X be the set not defined by this sentence...

On Wednesday, 21 November 2018 at 14:38:07 UTC, Chris wrote:
> On Wednesday, 21 November 2018 at 13:26:34 UTC, Joakim wrote:
>
>> What did you think about this bit?
>>
>> "There's one thing that we don't really have and I don't really want it in the language: it's meta-programming... instead we had a very good experience doing compiler plugins."
>> https://www.youtube.com/watch?v=PsaFVLr8t4E?t=2126
>>
>> Also, no "first-class immutability."
>
> I watched the whole keynote. Well, to begin with it's still a very young language (not 18+ years old) and keeps getting better and better. Things that were a bit tricky just recently are now much easier and part and parcel of the language. It shows that they listen to their user base and make things as easy as possible. In many ways it's already miles ahead of D in terms of what you need as a programmer to get things done fast, e.g. tooling, interop, multi-platform, handling of deprecations etc. There are useful features (I already knew from D) that make life easier (e.g. lambdas).

You would expect that from a language coming out of a tools provider. I thought it was interesting how he mentioned that one of the main reasons he didn't want meta-programming in Kotlin is because it's extremely hard for an IDE like theirs to deal with.

That's potentially one of the big advantages of D's string-based mixin approach: the IDE can tell the compiler to dump them to files and then just treat them as regular D source, though I don't know that anybody is doing that yet.

> And as for meta-programming (I knew this would come up ;)), I don't really miss it / use it anymore. There was only one case where I said it would have been nice, but it wasn't _really_ necessary (it was just an old D habit, really). In fact, meta-programming in D can cause a lot of unnecessary headaches (cryptic compiler warnings galore, code breakage) and stall the whole development process unnecessarily - and often for very little extra value. It says a lot that Adam D. Ruppe stated that if you don't want your code to break, use non-idiomatic D. So what's the point of it then? It's just absurd.

It's probably D's biggest differentiator, the one feature that people always say blows their mind when they use D, both from its power and relative ease of use. Of course, it's not for everyone, just like lisp macros, so I asked you what you thought, without saying "Kotlin sucks" or whatever.

> D could have been a real contender here (e.g. C interop) but instead of investing in a good infrastructure / tooling, cleaning up and stabilizing the language, the community has turned D into a "feature laboratory" where ideas are discussed to death and really important issues are swept under the rug. Other new languages focus on tooling and interop from the very beginning as they realize that this is very important these days, more so than fancy features (that can be added later).

This is a common theme in open source: OSS devs are often much more interested in trying their hand at writing some whizbang tech, which they may not get to do at their day job, than fixing bugs and taking out the trash. Another is that they simply write a clone of some expensive proprietary software that only has some strict subset of its features, say Linus writing the linux kernel because he wanted to run UNIX on his home desktop.

Neither are conducive to production, stable environments: it took many companies coming in and polishing up the linux kernel or LLVM before they became core components at many companies today. The same will have to be done for D.

> Then, of course, the inevitable "X doesn't have feature Y, but D does! That's why X sucks." Only: are all these super features indispensable for production? Why hasn't D got backing from big players yet? Because of the community's elitist and parochial mindset and the overall lack of consistency.

Why hasn't ruby/rails, Rust, or Nim gotten backing from big players yet? Most things don't get backing from big players, especially initially. What you hope is to create a superior tool that helps small companies grow into the big players someday.

> Joakim, you have done some great work as regards Android / iOS and I believe we are on the same page here. But see that the D Foundation didn't pick up on it and say "Let's take this and create some sound tooling for ARM cross-compilation." If it's not about fancy super-sophisticated allocators, contributors are completely on their own. This is no way to treat people who make an effort.

I agree that D has had perhaps too much of an emphasis on breaking new ground rather than the boring nuts-and-bolts of adding new platforms and bug-fixing. Now that multiple multi-million-valued and several small companies are built on D, let's hope they get together and make a push with the community in that direction, as Nicholas indicates.

In the meantime, you are a commercial user of D, one who has always been _extremely_ positive about the language over the years in these forums. What changed your mind recently?

I'm asking for specifics: bugs not fixed or concrete incidents that indicate the wrong mindset. We can all wave our hands in the air over perceived generalities, but nothing can change without specifics.

On Friday, 23 November 2018 at 10:25:57 UTC, Joakim wrote:
> On Wednesday, 21 November 2018 at 14:38:07 UTC, Chris wrote:
>> I watched the whole keynote. Well, to begin with it's still a very young language (not 18+ years old) and keeps getting better and better. Things that were a bit tricky just recently are now much easier and part and parcel of the language. It shows that they listen to their user base and make things as easy as possible. In many ways it's already miles ahead of D in terms of what you need as a programmer to get things done fast, e.g. tooling, interop, multi-platform, handling of deprecations etc. There are useful features (I already knew from D) that make life easier (e.g. lambdas).
>
> You would expect that from a language coming out of a tools provider. I thought it was interesting how he mentioned that one of the main reasons he didn't want meta-programming in Kotlin is because it's extremely hard for an IDE like theirs to deal with.
>
> That's potentially one of the big advantages of D's string-based mixin approach: the IDE can tell the compiler to dump them to files and then just treat them as regular D source, though I don't know that anybody is doing that yet.

-debug-mixin=file was recently added so that should be possible.
I'd bet money that Manu will pester Rainer for it at some point :)

>> And as for meta-programming (I knew this would come up ;)), I don't really miss it / use it anymore. There was only one case where I said it would have been nice, but it wasn't _really_ necessary (it was just an old D habit, really). In fact, meta-programming in D can cause a lot of unnecessary headaches (cryptic compiler warnings galore, code breakage) and stall the whole development process unnecessarily - and often for very little extra value. It says a lot that Adam D. Ruppe stated that if you don't want your code to break, use non-idiomatic D. So what's the point of it then? It's just absurd.
>
> It's probably D's biggest differentiator, the one feature that people always say blows their mind when they use D, both from its power and relative ease of use. Of course, it's not for everyone, just like lisp macros, so I asked you what you thought, without saying "Kotlin sucks" or whatever.

What I would really interesting from that they reckoned people would write compiler plugins as a substitute. Having dealt with both, I can say that doing what you can in the library is immensely easier. I've seen what clang does to support CUDA: it ain't pretty or simple. Obviously not all thing are going to be that complicated, but I'm not particularly convinced that that will be a common thing to do.

On Friday, 23 November 2018 at 10:25:57 UTC, Joakim wrote:


>
> You would expect that from a language coming out of a tools provider. I thought it was interesting how he mentioned that one of the main reasons he didn't want meta-programming in Kotlin is because it's extremely hard for an IDE like theirs to deal with.

> That's potentially one of the big advantages of D's string-based mixin approach: the IDE can tell the compiler to dump them to files and then just treat them as regular D source, though I don't know that anybody is doing that yet.

>
> It's probably D's biggest differentiator, the one feature that people always say blows their mind when they use D, both from its power and relative ease of use. Of course, it's not for everyone, just like lisp macros, so I asked you what you thought, without saying "Kotlin sucks" or whatever.

No, in fairness, you didn't say Kotlin sucks. To be honest meta-programming is really hard for the compiler and the D user. And when you look back at the code after all the headache you wonder was it really worth it. Also, an IDE / compiler that immediately tells you what's wrong is _very_ handy.


>
> This is a common theme in open source: OSS devs are often much more interested in trying their hand at writing some whizbang tech, which they may not get to do at their day job, than fixing bugs and taking out the trash. Another is that they simply write a clone of some expensive proprietary software that only has some strict subset of its features, say Linus writing the linux kernel because he wanted to run UNIX on his home desktop.
>
> Neither are conducive to production, stable environments: it took many companies coming in and polishing up the linux kernel or LLVM before they became core components at many companies today. The same will have to be done for D.
>

Exactly, so what is the D Foundation waiting for? D is 18 years old.

>
> Why hasn't ruby/rails, Rust, or Nim gotten backing from big players yet? Most things don't get backing from big players, especially initially. What you hope is to create a superior tool that helps small companies grow into the big players someday.

D could be a superior tool. But D is drinking all its money.

>
> I agree that D has had perhaps too much of an emphasis on breaking new ground rather than the boring nuts-and-bolts of adding new platforms and bug-fixing. Now that multiple multi-million-valued and several small companies are built on D, let's hope they get together and make a push with the community in that direction, as Nicholas indicates.

It's 2018. The IT world has realized that you need to be compatible. And it has to be as easy and smooth as possible.

> In the meantime, you are a commercial user of D, one who has always been _extremely_ positive about the language over the years in these forums. What changed your mind recently?
>
> I'm asking for specifics: bugs not fixed or concrete incidents that indicate the wrong mindset. We can all wave our hands in the air over perceived generalities, but nothing can change without specifics.

Thanks for asking. It's little things and big things that happened over the years. I think what really made me go "Hm" was https://issues.dlang.org/show_bug.cgi?id=16739 and that it took so long to fix it. I was starting to write a new text parser and came across this stupid bug. Then there was the whole issue of string handling and autodecode and the way the leadership / big guys in the community dealt with it. I was of the opinion that such an essential issue had to be fixed immediately (of course with a proper path to fix it). I even offered to be the guinea pig and document the transition. But no.

Then there were the dreaded dmd updates. "Shit, what will break now?" this question would be my constant companion. Sometimes nothing, sometimes quite a few things. How would fixing it affect my code? Yes, I updated my code, but...Once my code broke and I was told to use the `-allinst` flag (Why? It had worked before!), then a few releases later my code broke completely again and on a whim I removed the -allinst flag and it compiled again. Just don't ask why! It's Ahhhrrrrrrrr! The thing is, in D normal features break, not the experimental ones. Ordinary idiomatic D code just breaks and then works again and breaks again. WT*?

And, being a vibe.d user, the compiler would spit out loads of warnings related to vibe.d or just break it. I would have to wait for poor Sönke to fix it, but in the meantime there would be a new dmd version and again...poor Sönke. You can put up with this for a while until you realize that it need not be this way.

Then there was the whole issue of ARM. Walter said he had no experience with it and kinda didn't care either, while everything was going in the direction of mobile (talking about priorities and signs of the time)! If it wasn't for you we'd have nothing, zero, nada. 5 years ago I raised the question. 5 years. D is 18 years old.

What makes my blood boil is when I see lengthy discussions about semi-demented constructors and how they are soooo useful and then they forgot the semi-demented deconstructor and it wouldn't work anyway, because it would break some sh*it and conflict with the PR for the new loco-allocator library...and the guys don't even have a new XML parser you can safely use...but who needs XML, it suck anyway...ah, no lads, it's just crazy.

And the advent of the D Foundation didn't help either. Quite the opposite.

All I know is that I got things working fast in other languages (even if they don't have semi-demented constructors), I'm more productive than in D,...and I don't need to be afraid of the compiler...afraid of the compiler!

On Thursday, 22 November 2018 at 22:04:36 UTC, Laeeth Isharc wrote:
> On Thursday, 22 November 2018 at 11:14:54 UTC, Chris wrote:
>> On Thursday, 22 November 2018 at 04:07:32 UTC, Laeeth Isharc wrote:
>>
>> [snip]
>>
>> By the way, you keep mentioning that you use D for your own internal stuff, and as far as I can see a lot of companies that use D do the same. They have their own in-house ecosystem, and that's fine. Of course, for this kind of usage D might be OK (apart from the facepalm flaws it still has) - or any language for that matter.
>>
>> However, a lot of IT companies (small, medium and big) also have to adapt to the market in terms of third party products like Android and iOS and other technologies (including those that do not yet exist). Once that's the case, D is one of the worst choices possible.
>
> D doesn't have the best GUI libraries, that's quite true.  JNI is not that bad so if you wanted everything but the front end in D would it be so tough?  You might be right about the situation on ios as I haven't heard of people doing much there in D - last I heard the hard work was done but the last stage - something relating to bitcode if I recall right.
>
>> Everything takes years
>
> True.  Why does it bother you? Did somebody suggest it would be otherwise? If one puts some energy behind making something happen it's not that bad, I think.  Eg autowrap for JNI shouldn't take more than a couple of months of work to be mostly useful I think.
>
>> anything that is not directly related to (some specific features of) the language is treated as lowest priority
>
> Who is treating, and what is this word priority I keep hearing.
>
> It's open source, ordered anarchy.  It's hard enough persuading a creative person that you pay to do something he doesn't want to do.  How do you suppose it is that Walter and Andrei can assign priorities more to your liking and make people work on what you would wish?   They cannot.

It's not what _I_ wish. It's common sense. Sound string handling and tooling.

> I think you're applying rules from your work domain to an environment where they don't apply.   That's simply not how volunteer open source works.

This is no longer true of D. 18+ years and a D Foundation. The "hobby project / open source community" argument is no longer valid. You cannot aspire to be a big player on the one hand and then, on the other hand, when it gets a bit rough, say "Ah, we're just a small community". It's either or.

If I were an investor I'd say "No!" after listening to you. You need to be realistic. While everything has a spiritual dimension, one has to be practical at too.