Does D have any political goals?

[Karmello]

On Monday, 14 November 2022 at 22:35:50 UTC, Walter Bright wrote:
> On 11/14/2022 12:01 PM, Karmello wrote:
>> [...]
>
> Language - D has been moving forward pretty fast. For example, 
> the dip1000 initiative has made great progress, and the ImportC 
> initiative is a big step forward in usability. D now has a 
> prototype borrow checker - the same thing Rust has. Memory 
> safety is the future of D.
>
> D hasn't moved as fast with concurrency, but Sebastiaan Koppe 
> has pointed the way with structured concurrency, which he's 
> already implemented:
>
> https://dconf.org/2022/#sebastiaank
>
> I'd like to get his work into Phobos. I like it a lot better 
> than async/await.
>
> People talk about sumtypes and pattern matching, which are good 
> features, but not game changers.
>
> People also talk a lot about not adding new features for D, as 
> it already has plenty :-)
>
>
> IDE - I am not remotely opposed to IDEs. Rainer Schuetze has 
> integrated D with Visual Studio. I'm sure he would welcome help 
> from anyone who wants to improve it. I'm all for it. As to why 
> I don't do that myself, I'm a poor person to do it as IDEs (as 
> you mentioned) are not my personal style.


I'm not denying that D has done a lot. I am talking about the 
ecosystem that surrounds D that will give it life to grow far 
past your existence.

The problem is quite simple though:  exp(at).

If a > 1 then it grows, if a < 1 then it dies. a will encode the 
entire D evolution.

a < 1 for D, it will D. a actually depends on time so maybe 
something will happen in the future but a is not large enough to 
sustain the organism too distance in the future. Just like how 
99.99% of all things in the past have died out, D will be one. It 
doesn't have to be but your approach is a sort of "let's plant it 
and see what happens" rather than "Let's do everything we 
possibly can to make sure it grows in to the best thing possible".

I use Visual D all the time... it's the only reason I use D at 
all. It's a bare minimum IDE. What happens when Rainer goes? Then 
what?

I'm looking 10-20-30 years in the future, you are looking at next 
month. That is, I look at D more from a "visionary" perspective 
and you look at D more as a "maintainer"'s perspective. Neither 
one is good. "It takes a village". Both approaches are bad in 
isolation. The problem is that D does not have a proper 
organization structure around it that drives it forward so that 
it can withstand the downswings. It's almost in a constant 
holding pattern with little forward drive. This is better than a 
nose dive in to oblivion but it means that it will have to land 
relatively soon.

I like D, I wanted to see it be a major competitor. Most of the 
work is done on the language. While the language isn't perfect, 
it's type system is probably one of the best simply due to it's 
power(it's not necessarily the best design but it is almost 
complete and integrated well in to the underlying language).

For me, tooling is everything. I want my time programming to be 
enjoyable and efficient. I do a lot of stuff so I hate wasting 
time. The way I see it is that you have an old school conception 
of how things work and should be done and that's that. D will 
never get past that unless someone comes along and wants to 
revamp D to modernize it. The amount of work required to do so is 
so much that the person will likely just want to write their own 
language, compiler, etc. Then the question is why go through all 
that trouble when there are already good languages out there that 
have a lot going for them?

What would be great is if you could get MS to take up D and 
create a D.net(or you guys could do it since it would just be 
compiling to IR). This way D could be integrated in to all things 
.NET. I hate .NET because of it's IR but other than that it's 
probably the best out there by far. I still wish programming was 
an order of magnitude better but it is what it is and I'll die 
before it changes to something I'd like to see(such as AI helpers 
for code generation, code maps that allow for visual programming 
in an integrated way sorta like, say, altium designer for 
code(but not like the hacky visual programmers), better 
organization for complex designs, etc).