dlang.org
D is a System Programming language developed by Walter Bright. Its focus is on combining the power and high performance of Cee Language and Cee Plus Plus with the programmer productivity of modern languages like Ruby Language and Python Language. Special attention is given to the needs of concurrency, reliability, documentation, quality assurance, management and portability.
The D language uses Static Typing and compiles directly to machine code. It supports many programming styles: imperative, object oriented, and metaprogramming. It's a member of the C syntax family, and its appearance is very similar to that of C++.
A book, The Dee Programming Language by Andrei Alexandrescu, was recently released and has been seen as an important step forward for D. (Chapter 13 "Concurrency in the D Programming Language" is available as free read online: www.informit.com 
)
There are two versions of D in use. D1 achieved stable status in 2007 and D2, a non-backwards compatible successor is nearly feature complete and is currently in the final stages of development.
Latest versions are D1.075 and D2.060 (Aug 2012)
Useful pages:
dlang.org D2 Home
digitalmars.com D1 Home
forum.dlang.org D Forums (The forum web app itself is written in D)
d.puremagic.com Bug tracker
prowiki.org Wiki
dsource.org D-related open source projects
github.com Source code
(Not to be confused with Tutorial Dee.)
Hello World in D
import std.stdio; void main() { writeln("Hello World!"); }
Community
Discussion of the D language and its development is on news://news.digitalmars.com in a number of groups:
digitalmars.D
digitalmars.D.dtl
digitalmars.D.bugs
D.gnu
The news groups can also be read in a web browser at forum.dlang.org
The IRC channel #d at freenode.net is frequented by the D core dev team
I looked at it and I think it is a great language. It is small and simple, OO like Java but native executables (60 KB+), GC, interfaces, templates, closures, enums, dynamic arrays, hashes, switch(string) and a lot more. I have installed a wiki to support Walter's creation: www.prowiki.org (350+ pages in Aug04). -- Helmut Leitner
According to Bjarne Stroustrup, there have been at least a dozen languages called D. www.research.att.com
Interesting, I was just yesterday thinking that it would be nice to be able to declare functions inside functions to support the simplification of complex if/then/else statements using Extract Method refactoring. The idea here is to simplify/clarify the situation where you need to use a large number of local variables in a complex logical comparison and want to keep the expression(s) in the if/then/else statement(s) as short/simple/clear as possible. Without something that allows you to extract a method but still allow access to the local variables of the enclosing function scope, you are left with either passing everything you need into the extracted method (which often confuses things as much as just leaving the messy logical expression in-place), or making all the variables needed in the extracted method(s) instance variables of the enclosing class (confusing, too). Reading the D Language "Quick Comparison" table, I noticed that it supports the notion of "Nested Functions" which allow exactly the behavior desired. Serendipity is an interesting thing...
See Nested Scopes.
Being able to nest function definitions is nice for all kinds of reasons (with full-strength Lexical Scoping, please), but in the scenario you describe, isn't the code trying to tell you that you're missing one or more classes with responsibility for the logic in the expression? Depending on what the result of the expression is for, maybe Strategy or State would be good patterns to use here. And anyway, isn't the better solution to "the situation where you need to use a large number of local variables in a complex logical comparison" to factor the code so that you only have a small number of local variables involved in a simple logical comparison?
See also Symantec Cpp Digital Mars
As a Cee Plus Plus programmer, the thing I like most about D is that it has both Garbage Collection and automatic("stack") objects, which you can use to manage resources.
Indeed, the main emphasis of it is, I believe, to take the good bits of C++ and remove the crud, i.e., compatibility with Cee Language, platform dependent type sizes and preprocessor. While adding in various c++ features that exist at the library level into the core language, i.e., garbage collection, strings, collections.
D looks like a fantastic language, but it's not enough of an improvement over C++ to get me to learn it. If I want speed, I can be fairly productive in C++ using Boost Libraries et al. If I don't care much about speed, there are much more productive and high-level languages I can use like Ruby Language or Python Language. D seems to be in an uncomfortable middle area: equivalent or slightly slower performance than Cee Cee Plus Plus but not substantially more productive.
If D had better standard libraries including a well-designed portable GUI frontend, I'd consider it for desktop app development. I think it could see some success there or in games, but only with more library work.
Andrei Alexandrescu has written a book, The Dee Programming Language.
See original on c2.com