Dlang

Why do shit-cunt languages like Rust and Go get all the attention when D is actually decent?

Other urls found in this thread:

github.com/gecko0307/atrium
dlang.org/dmd-linux.html
twitter.com/SFWRedditVideos

D is like a drug, once you get used to it you can't live without it. But alas, It's not backed by rich corporations.

Coming from C++, D seems too good to be true. I think that once D's toolkit improves, D could become mainstream.

Poor Linux and BSD support. They were focused on Windows, but couldn't compete with the VB, C++ and Delphi tooling. Then .NET came out so no one bothered with D.

>Poor Linux support
What do you mean?

Poor BSD support - for OpenBSD and NetBSD - Yes. FreeBSD has good support and as for Linux, D has great support.

Rust has memory safety, no GC (can be used as system lang) and fast compiler.
Go isn't OO, good concurrency, good GC and fast compiler as well.
D is just C++ with easier syntax, shitty (though optional) GC and slow compiler.

>D first released 2000
>Go and Rust ca 2010
>both Go/Rust toolkit function better than D's
There is nothing to be done. D lost.

Go got Google (it'd be largely forgotten otherwise), Rust got Mozilla

because I can use Java when I want GC and Rust when I don't

s/D/LISP/

>D lost
>Yet it's still growing
>It has no backing
>People are genuinely getting pissed that backed languages like Rust are infecting everything

Rust sacrifices everything for the lifetime analyzer, and actual production code is almost write-only. Actual production D code is more readable than fucking Python. Try reading the Phobos library versus C++'s standard lib.

D wins, if it takes 10 or 20 years. For most applications, the GC doesn't matter, and for those where it does there are options. It's incredibly well-positioned; moneyed backing is distorting how horribly positioned Rust is.

take your meds, Walter

D will never be popular. That's extremely obvious to anyone that isn't a Walter Bright dick rider.

>easier syntax
Cleaner* syntax

And there's NOTHING good about Go's GC

>Rust
>Fast compiler

>Go
>Good GC

>D
>Slow compiler

0/3

D went full retard when it added a GC. D shills will tell you that it's optional - they forget to say that 90% of standard library calls will leak memory if you turn it off.
If D was simply C++ with more consistent syntax, cleaner templates, modules, UFCS and easy C/C++ linkage it would have been perfect.

It's low-latency. That's literally the only good thing.

>It's low-latency.
Nice buzzword. D's GC latency is fully customizable, it's nothing new. All it does is cater snake-oil to uneducated retards (the target audience of Go). D's GC is bad but Go's GC is not better either.

For an example of good GC, look up Nim

We're in agreement.

I mixed Rust and D on that one. As for Go I talked relatively to D.

CHAPEL YOU FOOL

They had
- two language versions
- two competing standard libraries
- a compiler frontend that was owned by Symantec because not-so-Bright worked on it on his work time
- just recently the idea that a garbage collector in the standard libraries might be a bad thing for a system programming language

In modern development, with software based on other peoples libraries trust is the most important thing for people to have in a development environment.
And dlang really worked hard to lose that trust.
I might give it another chance for personal projects because the language itself is comfy once GCC 8 is in reach. But I'm fairly surprised there even are non-trivial D projects at this point, like some IDEs, GUI-libraries and this github.com/gecko0307/atrium game.

also

>For an example of good GC, look up Nim

LMAO. Is this satire?

>They had
I almost forgot how they introduced better metaprogramming NOW, but then again, so does C++.

this, to be sincere

>two competing standard libraries
No, not competing. The previous one is depracated.

>satire
No, what makes you say so?

What are you talking about?

>No, not competing. The previous one is depracated.
Pretty sure at some point of D1 Phobos and Tango were battling.

The new version of compile time function evaluation. I'm not even sure if it can do what Jai can do, now.

It's a lot faster, I don't think it was ever meant to do as much as the Jai one does. I remember Stephan mentioning why somewhere, let me see if I can find it.

I made my own programming language and it's better than D

Show it to us, please!

No

>and it's better than D
We'll be the judge of that.

All of them are shit though.

because d official website looks like shit?

D is a bloated mess and smells to much like Java.

I'd rather have a language that does "a better C" than a language that does "a better C++".

This. These new languages need to stop taking inspiration from these disgusting OO monstrosities. Nobody is falling for the "OO is useful" bullshit anymore. Look at C and the ML family of languages for inspiration.

>I'd rather have a language that does "a better C"
Go then?

> Go
> better than anything

Got you covered
dlang.org/dmd-linux.html

dmd -betterC

>GC
>no macros
>better C
Rob Pike should just kill himself at this point.

>macros
>good

Go is definitely the direction I would go into. But it's not systems programming language and no replacement for C.

>no metaprogramming facilities at all
>good

is right

> D
> Slow compiler