D

The programming language D is a successor to C and C++. It can be viewed as a more practical, modern, and safe C, retaining the compactness and especially the performance of the latter. It is also an improvement on C++, redesigning many of its useful features, replacing or removing those of questionable value, and adding some that C++ lacks. D combines its C and C++ heritage with features from modern languages like Ruby, Java and C#.

Conceived in 1999, D was initially a creation of Walter Bright, who was the main developer of the first native C++ compiler, Zortech C++, which later became Symantec C++ and is now Digital Mars C++ (Digital Mars is Walter Bright's own company). The language is partly open source and still under development, currently (2010) with a stable version called D1 and one evolving in several new directions, named D2. The evolution of D is actively supported by suggestions and critique from its user community. D managed to attract a number of renowned and productive persons who actively colaborate with D's principal developer.

Although D's syntax is very much like C's, D does not aim at full backward compatibility with C. While this means that a C program is not necessarily a correct D program, the innovations of the latter language are well justified and make it more consistent and easy to use.

A notable difference of D from C and C++ is the absence of a preprocessor. A number of features are introduced in its place to provide the needed functionality in safer, more flexible and reliable ways.

Another difference is that D programs tend to make much less use of explicit pointers. The reasons for which pointers are needed in C, and partly in C++, are mostly eliminated by introducing more useful arrays, automatic memory management, output and input-output parameters and other features.

Also distinctive for D with respect to C/C++ is that it uses exceptions to signal errors in function evaluation, instead of passing error codes.

It is a design policy of D to provide certain useful datatypes, data structures, and operations directly into the language, instead of relegating them to library modules. This contributes to the practical expressiveness of the language.

Here are, in more detail, some of the important features that characterize D.

• Modular structure. A module has its own namespace, from which symbols can be imported. Modules can be grouped together in hierarchical packages.
• Module initializers. This is code executed for a module before the main program receives control.
• Templates as means for generic programming. D's templates are simultaneously more powerful and have more convenient syntax than in C++. For example, function templatizing can take place in groups (while in C++ it is one function at a time). Template parameters of more kinds (in fact, any non-local symbol, including templates, modules, functions, typedefs, etc.) than in C++ are acceptable.
• Template mixins, used as ‘parametrized-code injectors’. A mixin refers to a template or a part of it, but, unlike template instantiation, the mixin is evaluated within the scope where it appears, not where the template is defined. Also, a name in the surrounding scope overrides the same name imported from a mixin.
• Class-based object-oriented programming with one root class, single inheritance and interfaces. Objects are instantiated by reference only, and assignment always means copying a reference, not a value.
• Conditional compilation through static if statements executed at compile time. Also versioning based on debug conditions or different OSs.
• static assert statements, executed at compile time, can be used to set conditions for statically correct composition of code. Violating a static assert aborts compilation.
• Function declaration order is insignificant. No forward declarations are needed.
• Function parameters can have in, out, or inout attributes, to designate how a parameter links to a corresponding actual argument, as in Ada or in C#.
• Delegates. A delegate is a pointer to a function or a method combined with a context pointer – a stack frame pointer or a this-pointer, respectively.
• Nested functions, anonymous functions and anonymous delegates.
• Exception handling, similar to the one in C++, but also with an optional finally clause as in Java.
• Scope guards. These allow code to be executed on exiting a scope, depending on whether the exit is normal or exceptional, or either way.
• A large set of numeric types. Each type is named by a single mnemonic word, such as byte, int, short and long for signed integers, and ubyte, uint etc. for their unsigned counterparts. Notably, the set of basic types includes complex numbers (instead of merely imitating such numbers through library functions). For example, since double is a floating-point type, cdouble is a complex type with real and imaginary parts each representable as a double. Complex constants are written as in mathematics, e.g. 2+3i.
• Unicode is supported both as data and as program source.
• Except ‘static’, there are also ‘dynamic’ arrays, i.e. ones with dynamically changeable sizes. These are functionally very close to C++'s vectors, but since they are built into the language, they appear to be syntactically and otherwise more convenient. Subscripts are checked against the respective array bounds at runtime.
• Array slices are a handy way to refer to subarrays for value setting and sharing purposes.
• There are also associative arrays, where any datatype can be selected for the ‘index’ (i.e. key) type of a particular array. Again, there is similarity to C++'s maps, but associative arrays are built into D, not a library feature, and thus more convenient in use.
• String manipulation facilities, including regular expressions. As strings are arrays of type char, string handling in D is a direct consequence of improved array handling.
• foreach loop statement for traversing collections: ordinary or associative arrays or user-defined class collections.
• Both basic and derived types (including classes) have properties that can be queried, and some of them set. Examples are size in bytes, maximum and minimum values, initializer. Arrays have length, a pointer to contents, and some procedural properties: for copying, sorting and reversing. Class properties are member functions syntactically treated as if they were fields.
• Uniform, right-to-left declaration syntax, ensuring readable declarations. For example, char * p, q means (unlike C/C++) that both p and q are pointers to char, and int [3]*[5] a declares a as an array of five pointers to arrays of three ints each. Other forms of declaration are also supported, though.
• typedef is ‘strong’: the name it defines designates a new type. By contrast, the alias declaration only introduces a new name for a type (and is thus equivalent to C's typedef). alias is also used for symbol aliasing.
• Default initializers. For each datatype (typedefs and classes included) there is an initializing value that is used if a local variable is not initialized explicitly. The default values are changeable.
• The typeof operator is used in declaration and type casting expressions to specify a type as derived for an expression, and thus to relate the type of one program object to that of another. For example, typeof(a+b)[typeof(*c)] d declares d as an associative array of type that of a+b and key type that of *c. The expression that is the argument of typeof may be templated.
• D's primary memory management scheme makes use of garbage collection, but stack allocation and explicit heap allocation through new or malloc (and reclamation through delete or free) are also possible. Garbage collecting can be switched off for all or some of the program objects.
• Operator overloading is based on the assumption that on new types the operator definitions should retain the properties they have on the built-in types. For example, + is commutative and, once defined on types A and B, there is no need to define it on B and A, since b+a is treated the same as a+b; also, == is commutative and consistent with !=, < is consistent with >= etc.
• Support for design-by-contract programming.
• Support for unit tests.
• Message passing (no shared mutable data), as well as thread synchronization based concurrency, the first being the default.
• In-line assembler.
• Nested comments. Documentation comments: from these, the compiler can generate documentation files.

D programs can call compiled C code directly and thus the wealth of existing C libraries is readily available to D. Moreover, D's standard runtime library Phobos implements, among all else, the C runtime library functions and OS API functions.

Links of Relevance:

The home page of D.
    • D language specification;
    • Phobos runtime library specification;
    • An overview of D;
    • Programming in D for C Programmers;
    • Programming in D for C++ Programmers;
    • D vs Other Languages – a comparison table.

A wiki page for documenting D, Phobos and other libraries

Wiki4D: a wiki page for D

Programming in D : a book on programming with D

Online-accessible compiler

boykobbatgmaildotcom