D

Too go fast

if you care about performance so much that a little gc is not ok for you, you probably want to write your own stdlib anyway.
-t someone who has never developed a kernel
i was not saying that it is something to be proud of
i did. how about you learn d before you try to shit talk it? why don't you tell me how much memory it will cost?

d is fast

Not fast enough.

and you know that how? where are your benchmarks?

Where are yours?

wiki.dlang.org/BenchMarks
togototo.wordpress.com/2013/08/23/benchmarks-round-two-parallel-go-rust-d-scala-and-nimrod/

I don't know, you don't know. That's the point. :^)

Hey that's cool and all but why don't you name one real world product D is used in.

k

dlang.org/orgs-using-d.html
sadly nobody gives a fuck about d :/

Array sizes alone are bloat. Fuck off now.

Seems like a nicer, faster, less verbose version of Java. I like the fact that the GC is mostly deterministic and that you can have fine control over it unlike Java's motherfucking "System.gc() is just a suggestion for the garbage collector to run, but it will ultimately run whenever it pleases. I wouldn't be surprised if System.gc()'s function body is just a return.

name one C compiler people actually use that does this for non-toy code.

Oh wait, you can't. Fuck off back to Yahoo Answers.

That explains a lot.

...

?

THIS
Rust is full of poo since the SJW fucktards have gotten their grubby greasy sausage fingers all over it. Anyways, D looks interesting.

The game is shit, but technically speaking, it is fairly impressive. It's true that from a theoretical standpoint no game should require such a big machine to run at ultra settings, but most other C++ AAA game engines require similar configurations, so I doubt you could blame D for it.

Because I'm learning Ada.

What do you think the compiler is doing? It's almost exactly 1:1 in C with optimization disabled, and optimization is far more limited in what it can do than you think. People also disable the optimization selectively where they need 1:1 like with non-volatile volatiles.

Now, why would I use D when I know C++? Personally, I like having a standard library that I can use without garbage collection.

Rust is a joke. Rust is a big fat mistake.

Because D is memory safe and C++ isn't.

Spoken like a true pajeet who's never even heard of reload.c.

A subset of it only, and at the cost of superfluous array bounds checks and garbage collection. If I need all this safety, why can't I simply use C++ STL algorithms and RAII/smart pointers instead?

Someone should tell Lennart about this.

because it is not memory safe

Let us know when you grow up and grasp the concept of "Right tool for the right job".

In the real world knowing of and knowing about a wide variety of languages is preferable.
No employer in the world will so much as look at you if you if all you do is sperg out and shove "Muh milliseconds" spreadsheets in their face the moment they so much dare hint that they're not interested in using your preferred language.

Nice meme.

p u r e s e x

Too many Turks

Worms Armageddon 4.0 is being rewritten in D :^)

D is a jack of all trades and master of none.
also, the main implementation switched from GCC to proprietary bullshit

It's literally the only fucking thing I know seriously. I didn't expect anyone else to bring it up.

So OP likes the D huh

gcc is shit

i tried, but there's no libraries of my interest and i'm literally retarded and barely understand programming

4.0 will never come out
worms armageddon will never be open source
team 17 will fold under bad sales of WMD
in 50 years we will be only able to emulate the PSX/Dreamcast version if it'll be still legal to do so

I'm a white guy with 20 years of writing C/C++ in industry.
So what tech blag are you copy pasting this whine from? It's not even relevant, it's historical baggage in gcc, not a problem with C.

D is for OP is a diversity hire who can't into real languages.

I'm looking at the compilers by language Wikipedia page and it says nothing about anything proprietary. In fact, I can't find any sources. Do you have any fact to back that up?

Oh, so you're talking about a perfectly spherical compiler that exists in complete vacuum

2/10 here's your (((You)))

...

Proprietary reference implementation
Schizophrenic/competing stdlibs
Does nothing to enable safe multicore programming

A lot of reasons. I do like D a lot, but:

* Garbage collection can be a bitch to work around. If you don't want GC, you have to research every function you might want to use to be sure it won't leak.
* The standard library is kind of messy, and not fully a uniform style (not as bad as the Python standard library, but still pretty bad)
* Compilation is still really fucking slow
* Trying to run without a runtime is a serious bitch, and requires a hell of a lot more pain than just using C or C++ (this isn't really an issue unless you want to do embedded development, though)
* The official implementation (DMD) is still mostly closed-source, with the two better implementations (GDC and LDC) consistently lagging in features and stability.
* Shared loading D code in native D is still a nightmare (thanks to mangling), so anybody using runtime-loaded D libs tends to just use C linkage
* D structs vs classes is stupid. I like structs being POD vs classes being more complex types, but having the struct vs class type also control their allocation and collection semantics is retarded.
* Immutable vs const is dumb
* Template invocation is ugly. I like the drive to make statically-computed code look the same as dynamic code, but template invocation is always static, so it shouldn't look anything like an ordinary argument list, and the use of the exclamation point there is gross.
* Arrays are awkward as fuck, and the semantics for whether an array is static or dynamic are stupid
* The design-by-committee development of D was a mistake.
* The module system is frequently bizarre at best, borrowing some of the weirder parts of Java and Python's packaging (though it's a minor gripe, and this point is still better than C++ and C's include-based system)
* Instance method-like scoping rules make everything bizarre (arrays have no methods, but a free function that takes an array as the first parameter can be invoked as if it is an instance method of an array)
* Property methods are stupid and shouldn't exist. You save two keystrokes (an empty set of parens) and make things far less obvious, in the name of making some of the code look minimally prettier

My biggest issues are basically summarized as

* D is supposed to be a better C++, but programming without GC in D is basically uglier and worse than just using C++ in the first place (which is basically anywhere where you'd have any real-time application, like physics simulations or video games)
* D does way too much to hide some of the underlying details from you, especially where memory allocation is concerned. Not good for a language that's supposed to be a "sytems programming language"
* D is supposed to a better C++, but most of the reasons you'd use C++ in the first place are still better in C++ than they are in D

I do like D a lot though. It's basically a better, native Java with some of the better parts of C++ borrowed. I'd rather just use C++ than D, and the only reason I'd be using Java anyway is for the JVM and the existing support and ecosystem, or because I'm working on a project that was already Java.

Note that I did only play with D for a few months, but I wasn't particularly impressed.

Words have meanings, please stop this nonsense.

But C is almost 1:1 to assembly, user. That's why everyone on Windows uses C++, because you can steal the original C code with a simple reverse engineering program! :^)

until they use template heavy code

guess which 3 you know nothing about?

If you're under the impression Rust used to be good before the SJWs arrived, consider looking into its creator, Graydon Hoare.

Get out of here.

...

en.wikipedia.org/wiki/LSE_(programming_language)