D programming language

[+Xinok Subscriber²]

I'm curious if anybody else here has ever looked at or used the D programming language. Personally, it's my favorite programming language and I find it much more enjoyable to use than any other language. It was designed to be a successor of C and C++, although it's not backwards compatible and a very different language. It's a modern language in many aspects including garbage collection, exception handling, modules, dynamic arrays, associative arrays, functional programming (pure, immutable, shared, etc.), and much more. At the same time, it's a systems programming language - It compiles to machine code, supports pointers, inline assembly, and is fully linkable with C.

While the language itself is great, there are other problems. There isn't a huge number of libraries available for D, and many are out of date or not of the best quality. There are two standard libraries, the official Phobos and the unofficial Tango, which causes some fragmentation in the community. No IDE has full support for D yet, the best is perhaps DDT, a plugin for Eclipse. The best way to participate in the community is a newsgroup server with a buggy web client.

I'm hopeful for the future of D, but I simply don't find it reliable enough for serious development. I don't think it simply needs more time, it's been developed for over 10 years now. What it really needs is growth in the community and a serious effort to make D mainstream.

[Soulsiphon]

Looks just like C++ to me. :whistle:

[+Majesticmerc MVC]

D is on my list of languages to learn, but I'm wary of spending time on it for fear that it is going to fade into obscurity. I guess that makes me part of the problem, rather than the solution, but it does seem to have some good ideas going for it.

[Matthew S.]

I personally haven't really used D, but I continue to watch the progress. What the D community needs to do is find a way to allow Tango and Phobos to co-exist.

[Andre S. Veteran]

From what I've seen, it's what C++ should have been. Unfortunately, it's too late to dethrone C++ as the standard, best-supported way of doing native code for any platform. All the compilers, IDEs, tooling, libraries etc. Also, the big C++ libraries (boost, stl) are template libraries and thus unusable by any language other than C++.

[articuno1au]

Why would you choose this over other things?

C#/C++ seems fully matured and well supported.. What's the real advantage? O.o

[Andre S. Veteran]

Why would you choose this over other things?

C++ has many problems. Compilation takes ages, headers are a maintenance nightmare, and basically every feature of it is a pitfall*. Its popularity and level of support is what makes it essential; there are way better languages that achieve the same goals, like D or Go.

C# isn't meant to replace C++.

*see this and this.

[+Xinok Subscriber²]

The one thing that D possibly does better than any other language is metaprogramming.

1. Templates

Templates in D are a pleasure to work with. The syntax is clean, predictable, and very powerful. Unlike C++ in which templates are attached to a function or class, D can define templates independent of any other construct.

void main(string[] args){
	// D doesn't use angle brackets which causes many syntactic problems in C++
	foo!(string).value = "Hello!";
	foo!(int).value = 300;

	// In certain cases, the parenthesis are omissible
	writeln(foo!string.value);
	writeln(foo!int.value);

	// D programs are correct - Even though main has no return value, it will always return zero...
	// Unless an exception occurs, in which case, the program will return a non-zero value
}

// Things don't have to be declared in order; No need for prototyping.
template foo(T){
	T value;
}

D does have syntactic sugar for defining templates as part of a function or class.

void main(string[] args){
	// Largest floating point type supported by hardware, typically 80-bits
	real[] arr;

	// Template arguments can be implicitly derived from function arguments
	foo(arr);
}

void foo(T)(T[] arr){ }
class N(T){ }

Template Constraints consists of specialization and if statements.

template foo(int V : 300){ }
template foo(int V : 400){ }
template foo(int V) if(V > 1000){ }

2. Mixins

Mixins can be used to essentially paste a template or string into code at compile time.

void main(string[] args){
	int a = 35, b = 40;
	writeln(mixin("a + b"));
}

3. Static If

Static if allows you to define conditions at compile time which will include or exclude code. This is similar to using #if, #endif in C. Unlike C, static if is not a separate language. The condition can access constants or call functions at compile time.

void main(string[] args){
	foo();
}

const v = 30;
static if(v > 0){
	void foo(){
		writeln("What?");
	}
}

4. Compile Time Function Execution (CTFE)

All of the features above ultimately adds up to this - CTFE. CTFE means that D can interpret code at compile time to do all sorts of meaningful metaprogramming in a much less complex manner. The standard sort function allows you to define a custom condition for sorting:

void main(string[] args){
	struct ST{
		string name;
	}

	ST[] arr;
	sort!("a.name < b.name")(arr);
}

Just how powerful is it? scregexp is a statically compiled regular expression library for D. You provide a regular expression as a template argument, like in the example above, and CTFE is used to generate a static routine from that regular expression at compile time.

[Colin-uk Veteran]

that looks nice. never knew it existed.

maybe i'll learn it one time. :)

[+Xinok Subscriber²]

*bump* So there's been some positive developments in the D community recently.

The best news first, bugs are being fixed at a faster rate than ever. The community is very devoted to making D stable and production ready. The D compiler and standard library (Phobos) are hosted on Github, so anybody can contribute to its development.

http://www.dlang.org/bugstats.php

New simple domain: http://www.dlang.org/

There's a new web interface for the newsgroups to replace the old, horrid one. It mimics a forum, though it also has threaded views and is a pleasure to use. It uses Gravatar or identicons to generate unique avatars for everybody. It's also really snappy because, well, it's written in D. :p

http://forum.dlang.org/

D 1.x will be discontinued by the end of this year, leaving just the D 2.x branch.

There are fewer breaking changes, and they're clearly marked in the changelog now.

While there's an unofficial third-party standard library called Tango, it doesn't officially support D 2.x, only some unofficial branches. So this leaves Phobos as the official and only standard library for D 2.x.

While little work has been done on this, there's been lots of discussion about improving the garbage collector as well as revamping the standard library for manual memory management. At the moment, the GC isn't great and turning it off means you can't use the standard library.

The website is still a mess at the moment, with several broken links and out of date material. A better place to start would be the Wiki.

http://prowiki.org/wiki4d/

There's a free ebook available here which is still in the process of being translated to english:

http://ddili.org/ders/d.en/index.html

[spikey_richie]

What's next; VD?

[+Majesticmerc MVC]

What's next; VD?

Not if you practice safe hex.

[Andre S. Veteran]

Is there a way to use D in Visual Studio?

[Kami-]

Is there a way to use D in Visual Studio?

http://dblog.aldacron.net/2010/04/19/visual-d/

http://visualstudiomagazine.com/articles/2008/02/05/new-microsoft-programming-language-d.aspx [This isn't the same D ;)]

[KomaWei]

While I agree that C++ should of been like D, but I know D will never be useful. It was dead, before it even began.

[+Xinok Subscriber²]

Is there a way to use D in Visual Studio?

Wiki4D is the place to find this info (check the links on the left), but what you're looking for is Visual D.

While I agree that C++ should of been like D, but I know D will never be useful. It was dead, before it even began.

There's a small number of people using D in the real world. As D matures, its usage will grow, but it's hard to say if it can ever succeed C++.

[htcz]

C# is the future. It overtook D in a matter of months.

C# is the future. It overtook D in a matter of months.

**** that. It has actually taken over C++ . Wow.........thats a big step.

http://www.tiobe.com...tpci/index.html

[Soulsiphon]

There's a small number of people using D in the real world. As D matures, its usage will grow, but it's hard to say if it can ever succeed C++.

I'd probably be a bit more optimistic about it's success if you'd said that there's 'a small number of large-corporations using D in the real world.'

It's just not apparent to me where it could wedge itself in amongst the current mainstay languages of real-world enterprise development.

[Andre S. Veteran]

C# is the future. It overtook D in a matter of months.

They don't have the same purpose; C# is meant for application development, D (and C++) is for systems programming.

That said, I want to agree that C# pretty much pwns everything at the moment. It has been used to develop operating systems (1, 2), so it's demonstrated its viability for systems programming even though that's not its original vocation. D looks very well-designed, seemingly better than C# (at least the way it handles generics and compile-time evaluation of functions), but it's not a CLI language and as such it's isolated from the rich ecosystem of libraries and languages built around .NET.

A lot of platforms today don't support .NET, and by platforms I mean every piece of electronic equipment we use including computer hardware (device drivers), routers, cars, airplanes, gps, etc. Then again, they often only support C (not even C++!), so there's little hope for D there as well.

So, for D, the only avenue I see is for new performance-critical components for PC applications, which would currently require C++. Whenever performance is not an absolute, a .NET language will be better simply because of the interoperability with .NET libraries and other CLI languages.

[KomaWei]

There's a small number of people using D in the real world. As D matures, its usage will grow, but it's hard to say if it can ever succeed C++.

How many years has it been out, and no one really did accept accept it yet?

[+Xinok Subscriber²]

How many years has it been out, and no one really did accept accept it yet?

Between 2006-2009 (4 years), there were 2000 bug fixes. Between 2010-2011 (2 years), there were nearly 3000. As well, less work is being done the language design and much more on the standard library. So things are picking up and D is finally maturing. There's lots of work yet to be done, and it may be years to come, but they'll get there eventually. I'm just afraid it could be too little, too late.

[KomaWei]

Between 2006-2009 (4 years), there were 2000 bug fixes. Between 2010-2011 (2 years), there were nearly 3000. As well, less work is being done the language design and much more on the standard library. So things are picking up and D is finally maturing. There's lots of work yet to be done, and it may be years to come, but they'll get there eventually. I'm just afraid it could be too little, too late.

Yeah, I believe it is a little too late for D. It would be nice, if it had a market for it, but I rarely ever hear about the language to see a market.