On 7/21/2019 2:55 AM, Russel Winder wrote:
> I wonder of incremental change of programming language in a codebase is just a
> nice concept rather than a practiced reality?
> 
> One of Kotlin's massive advantages was that Java codebases could be
> incrementally transformed as needed from Java to Kotlin. Yet this is not how
> things have happened (as far as I know). Kotlin has taken Android development
> by storm, but this is nothing to do with incremental change of a code base.
> 
> It seems Java codebases are treated as Java, and part Java, part Kotlin is not
> seen as a way forward.

Both can be true. Having the option to do incremental change can be a major factor in selection, even if one decides later to not make use of it.

On 7/21/2019 11:46 AM, aliak wrote:
> A bug in Nullable cause of us to swear off working on the D version - but the same person got defeated by the Rust borrow checker but that for some reason did not make him swear it off.


I'm not surprised. I see this all the time. It's the "social proof" thing at work.

On Friday, 19 July 2019 at 22:00:41 UTC, bachmeier wrote:
> On Thursday, 18 July 2019 at 23:00:03 UTC, bauss wrote:
>> Microsoft has published article about needing a safer system programming language.
>>
>> https://msrc-blog.microsoft.com/2019/07/18/we-need-a-safer-systems-programming-language/
>>
>> Could D (Most likely as betterC) have fit into that domain OR is it not yet safe?
>
> Let's not go crazy over one post by a couple of guys that work in some division of Microsoft. They like Rust for a small sliver of programming tasks, but that doesn't mean anything one way or the other for D, and it doesn't mean MS is converting everything to Rust.

They might not rewrite everything, but they already:

- Have Azure IoT Edge using a mix of Rust and C#

- Are using a rigrep (grep implementation in Rust) as part  of VSCode

- Are helping porting Firefox to HoloLens and were hiring Rust devs for that purpose

- Created the Actix web framework, one of the best Rust web frameworks and are using it as part of Azure infrastructure.

On a sidenote, the new ChromeOS sandbox demoed at Google IO is written in a mix of Rust and Go.

On Monday, 22 July 2019 at 01:31:17 UTC, Walter Bright wrote:
> On 7/21/2019 11:46 AM, aliak wrote:
>> A bug in Nullable cause of us to swear off working on the D version - but the same person got defeated by the Rust borrow checker but that for some reason did not make him swear it off.
>
>
> I'm not surprised. I see this all the time. It's the "social proof" thing at work.

One is based on instability and the other is based on an assumed learning curve. So I can understand actually.

On Sunday, 21 July 2019 at 09:55:24 UTC, Russel Winder wrote:
> On Sat, 2019-07-20 at 17:22 -0700, Walter Bright via Digitalmars-d wrote:
>> 
> […]
>> D has some huge advantages over Rust.
>
> In certain cases, yes. For me D/GtkD/GStreamerD is better than Rust/gtk- rs/gstreamer-rs for writing GTK+ and GStreamer based applications exactly because inheritance, integral to the GObject mode, is part of D whereas is not in Rust and there has to be massive superstructure in gtk-rs and gstreamer-rs to handle this.
>
> In other cases, no. GStreamer folk have chosen Rust as the language for GStreamer so using Rust for applications gets support using D leaves you on your own.
>
>> For example, D has a familiar syntax and jargon. For another, you'll be able
>> to
>> move to memory safety incrementally with D, you won't have to rewrite your
>> app
>> from the start. D's metaprogramming abilities far exceed Rust's. Etc.
>
> I wonder of incremental change of programming language in a codebase is just a nice concept rather than a practiced reality?
>
> One of Kotlin's massive advantages was that Java codebases could be incrementally transformed as needed from Java to Kotlin. Yet this is not how things have happened (as far as I know). Kotlin has taken Android development by storm, but this is nothing to do with incremental change of a code base.
>
> It seems Java codebases are treated as Java, and part Java, part Kotlin is not seen as a way forward.
>
> Although Rust is now big in the GStreamer community, it is only for new or replacement plugins, there appears to be no replacement of C code with Rust code in the core libraries.

Kotlin will never win the hearts of all Java devs, because platform languages always win in the end, so it will just limp along just like any other JVM alternative language.

The KVM is Android, there Kotlin might reign now, specially since Google is only willing to partially update its support up to some Java 10 features, and they announced Kotlin First Everywhere at IO.

They just need to take care not to be overtaken by either the ChromeOS or Fuchsia teams.

On Monday, 22 July 2019 at 01:31:17 UTC, Walter Bright wrote:
> On 7/21/2019 11:46 AM, aliak wrote:
>> A bug in Nullable cause of us to swear off working on the D version - but the same person got defeated by the Rust borrow checker but that for some reason did not make him swear it off.
>
>
> I'm not surprised. I see this all the time. It's the "social proof" thing at work.

I think we can get some social proof, it requires continuing:
- emphasizing commercial success ($$$$$), big businesses over smaller ones.

- replacing (in volume) talk that excuse D for its choices(GC, supposedly "wrong" default that are actually the right ones...) with a discourse that talks about positives. This is a big one, you can see it all the time: if your release notes detail all the bug that were fixed, the overall impression is that "wow, there are many bugs".

- phasing out "D-man", or invest in making it more like a winning mascot

In literatture about "diffusion of innovations", it's pretty clear who brings the new technology matters quite a bit more than adequacy.

Social proof doesn't _have to_ work against us.

"D is ancient and has 'worked out' " => "D is stable and has a growing amount of companies using it for beating the expectations" (which is true btw)

In my view, people using unproductive languages (you know what they are) are "loosers", it shouldn't be us that pass as loosers.

On Monday, 22 July 2019 at 13:18:29 UTC, Guillaume Piolat wrote:
> "D is ancient and has 'worked out' " => "D is stable and has a growing amount of companies using it for beating the expectations" (which is true btw)
>
> In my view, people using unproductive languages (you know what they are) are "loosers", it shouldn't be us that pass as loosers.


I suggestion we should focus fix bugs and improve support/platform/quality.

Keep improve IDE,  dub package, language server.

Finish the LDC support for IOS/Android,  (I read from forum history,  people say it take a weekend work to made IOS branch upgrade to latest version,  but last commit for IOS is 2017).

I see in this forum,  people talk about D will catch web/mobile/WASM wave since 2015 or even earlier.   But compare other language today,   DLANg Github trending is  empty almost every time when I check.  Lack of user  population is hurting D as vicious circle.   No people use, resulting in hidden bugs,   and then lead to less people use.

On Sunday, 21 July 2019 at 00:22:11 UTC, Walter Bright wrote:
> D has some huge advantages over Rust.
>
> For example, D has a familiar syntax and jargon. For another, you'll be able to move to memory safety incrementally with D, you won't have to rewrite your app from the start. D's metaprogramming abilities far exceed Rust's. Etc.


But most developer in real life will refuse to use D,  and they think Rust has huge advantages over D,  which include community and developers, not just safety.

Compare to Rust  developer community,  D is a small village.  Rust is massive International Capital City.

Compare to Rust open source projects, D is Cottages, Rust is Skyscraper.

D has GUI/web/mobile support before Rust,   but the related real live Github projects quantity and quality is  approximately equal to none(except GTKD team, I guess ).

On 7/18/19 8:12 PM, Mike Franklin wrote:
> On Thursday, 18 July 2019 at 23:49:00 UTC, Mike Franklin wrote:
> 
>> I think D could meet Microsoft's needs, but only if they forked it and made some fundamental changes to remove the technical debt, remove some of the "weird sh**" (https://youtu.be/TkNep5zHWNw?t=1378), and a number of other things we all could list to make using D a more professional experience.
> 
> ... and D could complete better with Rust if it had @safe-by-default and statically-check ownership/borrowing mechanism as Walter recently proposed.
> 
> I think there is something that Microsoft is overlooking with D. In the last 2 paragraphs of the blog post they say that programmers should be using managed languages like C#|F# whenever possible, but use Rust when the prior don't scale.
> 
> D is unique from Rust and C# in that is scales both up and down.

For almost as long as I can remember now, it's always bugged me to no end that the vast majority of the programming world is completely, 100% convinced that a a good general-purpose high-AND-low language isn't even possible (or desirable).

It's always been obvious to me that it IS possible, and also that the popular false dichotomy only came about because more than a decade of language design took all low-level and threw it straight out the window (and they all did it because that was Java's approach, and Java was super hot Macarena-popular shit at the time). That left low-level to C, C++...umm...assembler...and really not much else. (And then, of course, JVM eventually would up proving that the whole VM-sandboxing thing doesn't really even save you from the security problems it was created to solve anyway.) I never understood why nobody else could see that's what was happening.

Maybe that's what D's slogan should be about, "high-level AND low-level" (instead of the "fast, fast, fast" horribleness).

On Monday, 22 July 2019 at 16:29:16 UTC, Newbie2019 wrote:
>
> Lack of user  population is hurting D as vicious circle.  No people use, resulting in hidden bugs,   and then lead to less people use.

I too think this is the biggest problem (I am repeating myself). So what can we do to encourage newcomers? Is D welcoming, and appealing? There are some good ideas posted above; are they listened to?

My two cents: these newsgroups/forums could benefit from some reorganization; many people have asked/proposed changes. As for Learn, the last community survey voted in favor of moving that to StackOverflow (where there is already D traffic); this is a more suitable, powerful and searchable platform, and would provide free exposure and immense search engine exposure compared to here.

Does D have or want a plan to promote itself, given that the results so far in this regard have not been good at all? Are we too busy putting out fires, and too stressed because we don't have enough firefighters, that we don't stop to realize that no one besides the firefighters care that fires are burning? Are other people not open to D, or is it that D neglects to promote itself properly at all?