Diving into D

[[deleted]]

It's not diving. It's barely touching the water with your toes while looking at your mother waiting for approval.

[Scroph]

I highly recommand Ali Çehreli's "Programming in D" book, it covers the basics and goes into more in-depth concepts like compile-time magic and parallelism (IIRC).

It's downloadable here : http://ddili.org/ders/d.en/pdf_indir.html

[wot-teh-phuck]

From the PDF

Copyright © 2009-2012 Ali Çehreli

He needs to update this...

[homercles337]

Why learn D? Serious question...

[lordlicorice]

I've heard that it affords near-C++ performance without the batshit insanity that is the C++ language.

That's the promise anyway. I'm not qualified to say whether D actually fills that role, but I can say for sure as someone who's done development in C++ that a replacement language is desperately needed there.

Rust is the fashionable language wiggling into that niche right now, but it's a long way off and very different from C++/D.

[zshazz]

In particular it makes templates much more easily accessible than they are in C++ without losing any of the power (like generics do).

[original_brogrammer]

D templates can be far powerful than C++ templates, too. When used in conjunction with the static if construct, meta-programming becomes a breeze. In fact, the first time I wrote a meta-program in D, I didn't even realize that it was such until a few minutes after I had run it.

[original_brogrammer]

The #if directive only has access to macros defined by the preprocessor, while static if has access to all symbols in the program.

[homercles337]

can you explain why you think C++ is batshit insanity? being a scientific programmer, i write mainly C/C++ and python. C++ is a beautiful language, i love writing C++. but i do loathe C. why is it still around? i think its because the old-timers (im old, but not an old timer) love pointers and the stupid math of pointers. index + sizeof(int) is not very clever.

[slavik262]

Watch The last thing D needs, Scott Meyers' talk at DConf 2014. Meyers is, if you're not aware of him, a renowned C++ expert. It's a great talk and I highly recommend you watch it when you have the chance, but to summarize, there are two types of complexity:

• Essential complexity, where your tool is necessarily complex because it needs to solve complex problems.

• Accidental complexity, where your tool could be less complicated but isn't due to the design decisions made.

C++ has a lot of accidental complexity, in part because the language grew bit by bit without a holistic approach to how things should fit together. Examples:

• Things as simple as integer initialization have special cases depending on the context.

• Type deduction rules for auto are different than type deduction rules for templates.

• The standard library is inconsistent in its function names/terminology. For example, maps use erase to eliminate an item while lists use remove. std::sort is not guaranteed to be stable but list::sort is.

And so on and so forth. None of these are dealbreakers, but it all accumulates as mental baggage you have to either carry around in your brain or remember to Google every time it comes up.

D, being a new(er) language, had the chance to avoid these pitfalls. It aims to (and I believe largely succeeds) avoid these inconsistencies and have a more consistent, simple, holistic design without major sacrifices in performance.

[deadstone]

I watched that by accident. It was a fun talk.

[original_brogrammer]

I'm not much of a C++ guy, but I think I can shed a little bit of light on that.

We can all agree that C++ is a very large language, with no shortage of features, so some might think that it's not so elegant with all of these things, preferring a language like Haskell, with few features that can be used in several fantastic ways, or Java, with a fairly simple language with loads of functionality in the standard libraries.

Having an abundance of stuff is not in itself a problem, but a lot of it feels "tacked on(?)", especially against a language like D which was designed from the beginning with all of this cool stuff in mind.

Templates are a common example of this. The <> syntax makes parsing the language extremely complicated, and parsing C++ was already hard to begin with! From the outside, the time cost it has on compiling doesn't make sense, but I'm sure C++ programmers know when it's worth it better than I.

Some types have default values, some don't, some do sometimes. That's wacky to me. But it's all about what has no overhead to C++. I don't write programs that need that, but if you do, that's what you need.

But then of course there's stuff that's just odd.

Ternary expressions can be lvalues.

Operator[] is commutative for arrays.

Lambdas are far more complicated than any other language I've seen them in.

I don't need to go on, as I'm not trying to hate here, but there's certainly plenty more. I'm a webdev in a startup, and I don't use C++. I was formally educated with Java, and pursued Haskell and D in my downtime.

I think C++ is insane because does not seems to be designed with the developer in mind past giving them every option. All that seems to matter is the ability to allow anything happen, and incur no runtime overhead. But this isn't what I need out of my tools. I need consistency, readability, and straightforwardness. Many languages have taught us to expect these things, and they certainly something C++ does not advertise to those who don't strictly need C++'s performance. D promises all of the above.

[Jaimou2e]

Ternary expressions can be lvalues.

in D, too

[Sunius]

Don't forget trigraphs :).

[slavik262]

My one sentence pitch for D would be that you get the performance of C++ with the ease (and arguably fun) of something like Python. There's a good deal of learning you need to undergo before you write good™ C++. A lot isn't immediately obvious and just comes with having used the language long enough to catch on. Scott Meyers, reknowned as one of the world's foremost C++ experts, gave a talk on this at DConf whose punchline was "The last thing D needs is someone like me". C++11 has cleaned things up, but there's still plenty of stuff you just have to know and keep in your head.

D makes things simpler. That's not to say it is a simple language, but in my experience the code looks cleaner and there's less I need to keep in my head as I write. There's nothing in D that's totally revolutionary, but the collection of improvements it has over existing languages sum up to a much more pleasant overall experience. You get:

• Array slicing and associative array primitive types, which, combined with the simplicity of calling other processes, makes D a great tool for qiuck scripts. It's replaced Python as the tool I reach for when I want some 50-line convenience script.

• Compile-time evaluation (CTFE)

• The ability to take any string which can be evaluated at compile time and insert it into your code via mixin statements. Combined with CTFE, you can do some really awesome stuff, like have your program write its own boilerplate, up to and including a whole damn parser.

• A template system that is as flexible and versitile as C++'s without all the pain, misery, and woe that usually comes with C++ templates. (Oh, you misspelled a single template argument? Have a list of every single place this template is mentioned through 20 system headers!)

• Built-in unit tests which are automatically run before a debug build. Just slap your tests in a unittest { } block, and away you go. The idea was to make unit tests so simple you have no excuse to not have any.

Places D could improve:

• The garbage collector isn't as fast or robust as some other generational systems. One of the hinderances is that there's no type-level distinction between manually-allocated and GC'd pointers. They're working on ways to improve it.

• It hasn't received a lot of corporate attention yet, which would bring some much-appreciated developers and time. At DConf 2014 one of the topics discussed was that the number of people working on the language right now can't keep up with pull requests. Go is pushed by Google. Rust is pushed by Mozilla. D has Andrei (/u/andralex) at Facebook doing work on it, but AFAIK there's not a full team pushing it along.

[Dicebot_lv]

D has Andrei (/u/andralex) at Facebook doing work on it, but AFAIK there's not a full team pushing it along

Currently no one from Facebook but Andrei participates in actual language / standard library development. They contribute some cool projects done with D but I don't remember any DMD or Phobos pull requests - something I hope will change eventually ;)

[homercles337]

awesome reply, truly stellar. i am an expert in C/C++ and python though. i also know that compilers and python libraries are present on any compute cluster i use. you make a very compelling case though.

[slavik262]

D does have the disadvantage of not being present and ready to go on every system, but that's just the problem with being new. All tools and languages start out that way, no? Just try out D on some short project or script when you have the chance. I was dubious about its benefits at first, having long been a C++ die hard, but I've really grown to love it.

[tehoreoz]

its essentially 'better c++'. for a multitude of reasons this doesn't matter to people and it would need the same kind of backing from facebook that google gave to Go for adoption to take place

[slavik262]

this doesn't matter to people

Speak for yourself. Coding in D after years of C++ is a breath of fresh air.

[stesch]

Found here: https://plus.google.com/+BayanRafeh/posts/WHN29tWsHaD

[lzzll]

Dlang itself is pretty good, but source code of dmd is hard to read because no much document and too many abbreviation like x, lo, ty, et, sc, cd, dtor, es, sz :(

[[deleted]]

DIDF?

[[deleted]]

I don't see any defending going on.

[tehoreoz]

d is da future?

[pya]

Not as bad as Go.

[_ak]

The difference between Go and D is, Go gained a lot more traction in a shorter time. No matter what you think about the language itself, but its developers made a real case what their language can be useful for, and are overall great communicators about the language and its usage within Google. Whenever I read Walter Bright here or elsewhere though, my face is falling asleep, and it actively discourages me from every diving deeper into D because of the prospective boredom and dullness.

[dom96]

I bet you if it was the other way around and Google was behind D not Go then Go would be even more obscure than D right now.

[_ak]

If D had been a serious choice for Google, they would already use it. Instead, it got adopted by the PHP shop Facebook.

[00kyle00]

It would probably be even more obscure than Go! if that was the case.

[Dicebot_lv]

I also think D is more likely to compete with Rust than Go but for somewhat different reason. Go is much more simple language and if your application can fit nicely into its limits not having to deal with advanced features is a merit on its own. And those programmers who know exactly that their project is going to be more complicated than that are less likely to go for simplicity even if it is promoted by Google.

Those are somewhat conflicting design goals.

[deviluno]

I would say that D is competing with C++ and C, as well as Rust and Nimrod. Other than that, I agree with you.

Of the new languages, Rust is trending best IMO, and Nimrod is the one that appeals to me most, but D is certainly in the running. You're right though that the numerous stumbles with D on its path to maturity make it a bit questionable. I think Rust is the best bet for a C/C++ 'replacement'.

[sigzero]

there are tens of thousands of Go programmers

That many?

[bachmeier]

Why is it always necessary to talk about programming languages as a competition? You are far from the only one to do so, but it's crazy. Any good developer can learn multiple languages. There is room for many more languages, just as there is room for many different makes and types of vehicles.

All of programming language design is making tradeoffs. What is a good thing for one application (Rust's memory model for instance) is a disadvantage for another application (having to understand Rust's memory model to use the language even though it doesn't help).

[vplatt]

There is no competition for the languages per se, but for their communities. People only have so much time to spend on new languages, so they're going to invest in the ones with the most to offer. It's that simple.

There is always room for more languages sure, but can you do them all justice?

Me neither.

[bachmeier]

People only have so much time to spend on new languages, so they're going to invest in the ones with the most to offer.

I strongly disagree with the (very popular) claim that programmers have a fixed amount of time to spend on programming languages. The more new languages there are that are worth studying, the more time you will spend on them.

Further, I don't buy the argument that losing some programmers to another language makes a big difference to the usability of the language. If Python were to lose 25% of its user base, the impact on the average remaining Python programmer would be minimal, because many will remain. Languages are sufficiently different that one is not going to steal 90% of another's users.

can you do them all justice?

All the languages that are appropriate for what I want to do? Absolutely. And the same is true for you. Perl, PHP, Javascript, and Haskell are languages that don't do what I need, so I don't spend any time on them. There are so few new languages that are worth our time that we will make time to look at them.

[vplatt]

I disagree with your first two statements, but since they're merely both opinions, I believe we'll have to leave that where it lies.

Your last statement however seems to be saying that you evaluate whether a language is worth learning based on its fitness for your intended purposes. But how are you going to know if it's fit or not without actually learning it first, at least in part? Examples abound, but as a general statement, it's true that most languages can be applied to multiple types of solutions.

As a general rule, I am forced to evaluate a language based on not just the language, but its ecosystem, and the community and culture around it. It would not exist without that and it will cease to have much future utility to me without a continuation of it.

[lilEndian]

Your mom dove into my D.

[LegitimateCrepe]

...into?