EvenThisAcronym

Hands down, it's D's shorthand array operations.

    int[] a = [1, 2, 3];
    int[] b = a[] * 3;
    assert(b == [3, 6, 9]);

    a[] += 2;
    assert(a == [3, 4, 5]);

    int[] c = a[] + b[];
    assert(c == [6, 10, 14]);

This of course works with D's slicing syntax so you can do stuff like a[0..1] *= 3.

D has also had them since the early 2000s.

I'm the author of the article, so feel free to ask me anything, or give me your thoughts on the article.

I'm really glad you mentioned the concurrency problem from day 18, because this was one of those personal "eureka!" moments I had while learning D. I had no idea that concurrency could be so simple, and this is not even having any special built-in support aside from thread-local data by default. This is all in _user_ code.

By that same token, std.parallelism.parallel was one of those things where I just looked at it and thought "man, you can actually _do_ something like that?"

>because it's slow

Where do people get this from? D compiles down to the same machine code that every other compiled language does and it has similar language semantics to C++. In some cases D is _faster_ because its richer type and effect systems allow for more opportunities for optimization.

>and till fairly recently it wasn't a community project, but a one-man work

All of D except the backend was open-sourced in 2011, I'm pretty sure. Even before that, Walter Bright accepted patch submissions.

D's syntax isn't quite as nice as, say, Haskell (which strongly depends on preference anyway), but it has all the necessary tools to write strongly pure, referentially-transparent functions. There's the `pure` and `immutable` keywords that let the compiler statically verify the above properties.

>Nothrow and Pure are not part of the type signature of functions

Actually they are. Take a look at this example:

void main() {

    int delegate(int) @safe nothrow @nogc pure f;
    //This looks like something bad is happening, but the delegate literal 
    //actually has the proper attributes inferred so it Just Works
    f = delegate(int) { return 0; };

    int delegate(int) g;
    f = g; //Fails, as it should
}

I find that kind of ironic. I know there's a lot of people that love Go and it's a solid language, but I personally see it as the ultimate blub language.

I saw this in theatre and instantly knew something was off with his face. It was such a disturbing feeling, made my brain question whether everyone else in the movie was CG as well and it took awhile before I was able to see the other actors as "real" again. The uncanny valley is deep and extremely disturbing.

I'm surprised the author didn't mention the connection between Kong (孔) and Confucius, as Confucius' family name was also 孔.

I am a Millennial and I think Millennials are terrible (and I am not excluding myself). With few exceptions, I have not met anyone from my demographic who is not spoiled by their parents, entitled and has not made poor financial and/or life decisions. Of course there are Millennials that exist outside this stereotype, but I think our reputation has mostly been earned, not fabricated.

Ah, I see. I'm assuming then that Rust generics are not generative templates like C++/D, but closer to Java/C#.

As I understand it gaming enthusiasts regard games as being intrinsically art, with no need to "prove" that they can be. Every game from Pong to Call of Duty is a work of art. This whole discussion around whether games are art or not seems to be coming from outside the gaming community, and should not really be attributed much importance.

> That's why we get so many complaints from C++ and D developers that you can't do certain things. But Rust sticks with its strongly-typed generics, because Rust has always tried hard to strike a balance between code expressivity and maintainability.

In what sense are Rust macros "strongly-typed"? D and C++ templates are also strongly typed, just like the rest of the language.

Chinese sentence structure is in many cases identical or very similar to English, and follows the same general word order, Subject-Verb-Object.

Perhaps you should do some research on the subject before making such an ignorant statement.

People often say this because D has many features that allow it to be almost as flexible as the various scripting languages while still being compiled and statically typed. I don't bother with bash/cmd nowadays as D can easily fill that role, with the bonus of my small little scripts having all the power and scalability that D offers.

Also check out https://github.com/Abscissa/scriptlike

D is what you get if C married Python and the resulting baby was adopted and raised by Lisp and C#.

I have not tried it myself but there seem to be ways to get a stack trace on Linux.

http://vibed.org/docs#handling-segmentation-faults

Yes, this page is quite dated. It dates from the time of D1 (though much of it is still correct).

Where did this myth that Option types are the "solution" to nullable references come from? That's got it perfectly backwards. The solution to nullable references is to remove them from the language; Option is just a means for languages that have already done this to encode nullability into the type of a value add necessary, as it should be. And people claiming that a language needs pattern matching or it doesn't solve the problem?! It makes me worry that those advocating these ideas are just part of the latest cargo cult and don't really understand the underlying principles or why these are good ideas in the first place.

The repo owner is accepting pull requests for the benchmarks so at least it's fixable.

I never use anything else anymore for personal projects, unless I absolutely have to due to missing a certain library. A well-known phenomenon in the D community is that it "spoils" you such that when you have to use another language all you can think about is how much easier it would be to do your task in D, and how you miss certain features from D (such as the phenomenally better template syntax compared to C++). I've experienced this many times, such as when writing a large-ish Python script, or when working on a mobile game in C# + Unity. I really wish I could use D at work.

"How to remove null checks and then add them back again as a library feature."

The difference being, of course, that having an Optional type forces you to check if it's null or not before getting at the underlying object.

You should know by now that all of HN is a parody of itself.

Compare this to https://news.ycombinator.com/item?id=10023413 or https://news.ycombinator.com/item?id=10187596 and tell me that HN doesn't have a severe Rust/Javascript bias.

I started learning D in 2012, coming from a Java/C++ background. One thing that I've learned over the past 3 years is that D is one of those languages that completely changes your perspective on some aspect of language design (for D, that's metaprogramming and range-based algorithms). D can proudly take its place among the Lisps, the Haskells, the Smalltalks, as one of those fundamental paradigm shifts that makes you think differently about everyday problems.

>...and in Canada, we do not claim to have free speech and defined in America. Hate speech is not tolerated here...

One of the worst aspects of our country IMO. I wish we had millions of people willing to defend the basic right to say what you want.

I highly recommend http://jsemu.github.io/gba/launcher.html#fire_emblem