The D programming language, also known simply as D, is an object-oriented, imperative, multiparadigm system programming language by Walter Bright of Digital Mars. It originated as a re-engineering of C++, but even though it is predominantly influenced by that language, it is not a variant of C++. D has redesigned some C++ features and has been influenced by concepts used in other programming languages, such as Java, C# and Eiffel. A stable version, 1.0, was released on January 2, 2007. An experimental version, 2.0, was released on June 17, 2007. Ð, Unicode codepoint 208, U+00D0 is: Ð, a letter used in Old English and present-day Icelandic and Faroese. ... A programming paradigm is a paradigmatic style of programming (compare with a methodology, which is a paradigmatic style of doing software engineering). ... This does not cite any references or sources. ... Walter Bright is a computer programmer known for the design of the D programming language. ... A software release refers to the creation and availability of a new version of a computer software product. ... is the 65th day of the year (66th in leap years) in the Gregorian calendar. ... 2008 (MMVIII) will be a leap year starting on Tuesday of the Anno Domini (common) era, in accordance with the Gregorian calendar. ... In computer science, a type system defines how a programming language classifies values and expressions into types, how it can manipulate those types and how they interact. ... Look up Implementation in Wiktionary, the free dictionary. ... C is a general-purpose, block structured, procedural, imperative computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. ... For a WikiBook on programming with C++, see Wikibooks: C++ Programming. ... The title given to this article is incorrect due to technical limitations. ... Java language redirects here. ... Eiffel is an ISO-standardized object-oriented programming language designed for extensibility, reusability, reliability and programmer productivity. ... Object-oriented programming (OOP) is a programming paradigm that uses objects and their interactions to design applications and computer programs. ... In computer science, imperative programming, as opposed to declarative programming, is a programming paradigm that describes computation in terms of a program state and statements that change the program state. ... This does not cite any references or sources. ... System programming languages (otherwise known as applications languages) are programming languages that are statically typed, allow arbitrarily complex data structures, compiled, and meant to operate largely independently of other programs. ... Walter Bright is a computer programmer known for the design of the D programming language. ... Digital Mars features C and C++ compilers for Win32, Win16 and DOS. And also D. External links Digital Mars ... C++ (pronounced see plus plus, IPA: ) is a general-purpose programming language with high-level and low-level capabilities. ... Java language redirects here. ... The title given to this article is incorrect due to technical limitations. ... Eiffel is an ISO-standardized object-oriented programming language designed for extensibility, reusability, reliability and programmer productivity. ... is the 2nd day of the year in the Gregorian calendar. ... Year 2007 (MMVII) is the current year, a common year starting on Monday of the Gregorian calendar and the AD/CE era in the 21st century. ... is the 168th day of the year (169th in leap years) in the Gregorian calendar. ... Year 2007 (MMVII) is the current year, a common year starting on Monday of the Gregorian calendar and the AD/CE era in the 21st century. ...

Features

D is being designed with lessons learned from practical C++ usage rather than from a theoretical perspective. Even though it uses many C/C++ concepts it also discards some, and as such is not strictly backward compatible with C/C++ source code. It adds to the functionality of C++ by also implementing design by contract, unit testing, true modules, automatic memory management (garbage collection), first class arrays, associative arrays, dynamic arrays, array slicing, nested functions, inner classes, closures [1], anonymous functions, compile time function execution, lazy evaluation and has a reengineered template syntax. D retains C++'s ability to do low-level coding, and adds to it with support for an integrated inline assembler. C++ multiple inheritance is replaced by Java style single inheritance with interfaces and mixins. D's declaration, statement and expression syntax closely matches that of C++. Design by contract, DBC or Programming by contract is a methodology for designing computer software. ... In computer programming, a unit test is a procedure used to validate that a particular module of source code is working properly. ... It has been suggested that this article or section be merged into Modularity (programming). ... In computer science, garbage collection (GC) is a form of automatic memory management. ... In computing, a first-class object (also value, entity, and citizen), in the context of a particular programming language, is an entity which can be used in programs without restriction (when compared to other kinds of objects in the same language). ... For the microarray in genetics, see SNP array. ... An associative array (also map, hash, dictionary, finite map, lookup table, and in query-processing an index or index file) is an abstract data type composed of a collection of keys and a collection of values, where each key is associated with one value. ... A dynamic array, growable array, resizable array, dynamic table, or array list is a data structure, an array which is automatically expanded to accommodate new objects if filled beyond its current size. ... In computer programming, array slicing is an operation that extracts certain elements from an array and packages them as another array, possibly with different number of indices (or dimensions) and different index ranges. ... A nested function is a function which can only be called from its parent function. ... In object-oriented programming, an inner class is a class defined entirely within another class. ... In computer science, a closure is a function that is evaluated in an environment containing one or more bound variables. ... Compile time function execution is the ability of a compiler, that would normally compile a function to machine code and execute it at run time, to execute the function at compile time. ... In computer programming, lazy evaluation is a technique that attempts to delay computation of expressions until the results of the computation are known to be needed. ... Generic programming is a style of computer programming where algorithms are written in an extended grammar and are made adaptable by specifying variable parts that are then somehow instantiated later by the compiler with respect to the base grammar. ... This article does not cite any references or sources. ... Inline assembler is a feature of programming languages, that enables very low level code written in assembler to be embedded in a high level language like C. This allows programmers to optimise a very performance-sensitive algorithm by sending individual commands to the computers CPU. This example of inline... See the terminology section, below, regarding inconsistent use of the terms assembly and assembler. ... Multiple inheritance refers to a feature of object-oriented programming languages in which a class can inherit behaviors and features from more than one superclass. ... Multiple inheritance refers to a feature of object-oriented programming languages in which a class can inherit behaviors and features from more than one superclass. ... An interface defines the communication boundary between two entities, such as a piece of software, a hardware device, or a user. ... In object-oriented programming languages, a mixin is an approach to implementing classes that differs from the most widely-used approach coming from the programming language Simula. ... For other uses, see Syntax (disambiguation). ...

The inline assembler typifies the differences between D and application languages like Java and C#. An inline assembler lets programmers enter machine-specific assembly code in with standard D code—a technique often used by system programmers to access the low-level features of the processor needed to run programs that interface directly with the underlying hardware, such as operating systems and device drivers. Java language redirects here. ... The title given to this article is incorrect due to technical limitations. ... See the terminology section, below, regarding inconsistent use of the terms assembly and assembler. ... CPU redirects here. ... For other uses, see Hardware (disambiguation). ... An operating system (OS) is the software that manages the sharing of the resources of a computer and provides programmers with an interface used to access those resources. ... A device driver, or software driver is a computer program allowing higher-level computer programs to interact with a computer hardware device. ...

D has built-in support for documentation comments, but so far only the compiler supplied by Digital Mars implements a documentation generator. Documentation generator is a programming tool that generates an API Documentation documentation from a set of specially commented source codes, and in some cases, binary files. ...

Programming paradigms

D supports three main programming paradigms—imperative, object-oriented, and metaprogramming.

Imperative

Imperative programming is almost identical to C. Functions, data, statements, declarations and expressions work just as C, and the C runtime library can be accessed directly.

Object Oriented

Object oriented programming in D is based on a single inheritance hierarchy, with all classes derived from class Object. Multiple inheritance is possible from interfaces (interfaces are a lot like C++ abstract classes).

Metaprogramming

Metaprogramming is supported by a combination of templates, compile time function execution, tuples, and string mixins. Metaprogramming is the writing of computer programs that write or manipulate other programs (or themselves) as their data or that do part of the work during compile time that is otherwise done at run time. ... In mathematics, a tuple is a finite sequence (also known as an ordered list) of objects, each of a specified type. ...

Memory management

Memory is usually managed with garbage collection, but specific objects can be finalized immediately when they go out of scope. Explicit memory management is possible using the overloaded operators new and delete, and by simply calling C's malloc and free directly. Garbage collection can be disabled for individual objects, or even for a full program, if more control over memory management is desired. The manual gives many examples of how to implement different highly optimized memory management schemes for when garbage collection is inadequate in a program. In computer science, garbage collection (GC) is a form of automatic memory management. ... In computer programming, operator overloading (less commonly known as operator ad-hoc polymorphism) is a specific case of polymorphism in which some or all of operators like +, = or == have different implementations depending on the types of their arguments. ... C is a general-purpose, block structured, procedural, imperative computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. ... In computing, malloc is a subroutine provided in the C programming languages and C++ programming languages standard library for performing dynamic memory allocation. ...

Interaction with other systems

C's application binary interface (ABI) is supported as well as all of C's fundamental and derived types, enabling direct access to existing C code and libraries. C's standard library is part of standard D. Unless you use very explicit namespaces it can be somewhat messy to access, as it is spread throughout the D modules that use it -- but the pure D standard library is usually sufficient unless interfacing with C code. C is a general-purpose, block structured, procedural, imperative computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. ... In computer software, an application binary interface (ABI) describes the low-level interface between an application program and the operating system, between an application and its libraries, or between component parts of the application. ... Illustration of an application which may use libvorbisfile. ...

C++'s ABI is not fully supported, although D can access C++ code that is written to the C ABI, and can access C++ COM (Component Object Model) code. The D parser understands an extern (C++) calling convention for linking to C++ objects, but it is only implemented in the currently experimental D 2.0. Component Object Model (COM) is a platform for software componentry introduced by Microsoft in 1993. ...

D 2.0

D 2.0, a branch version of D that includes experimental features, was released on June 17, 2007. Some of these features include support for enforcing const-correctness, limited support for linking with code written in C++, and support for "real" closures. is the 168th day of the year (169th in leap years) in the Gregorian calendar. ... Year 2007 (MMVII) is the current year, a common year starting on Monday of the Gregorian calendar and the AD/CE era in the 21st century. ... In computer science, const-correctness is the form of program correctness that deals with the proper declaration of objects as mutable or immutable. ... C++ (pronounced see plus plus, IPA: ) is a general-purpose programming language with high-level and low-level capabilities. ... In computer science, a closure is a function that is evaluated in an environment containing one or more bound variables. ...

Implementation

Current D implementations compile directly into native code for efficient execution. A diagram of the operation of a typical multi-language, multi-target compiler. ... A system of codes directly understandable by a computers CPU is termed this CPUs native or machine language. ...

Even though D is still under development, changes to the language are no longer made regularly since version 1.0 of January 2, 2007. The design is currently virtually frozen, and newer releases focus on resolving existing bugs. Version 1.0 is not completely compatible with older versions of the language and compiler. The official compiler by Walter Bright defines the language itself. Walter Bright is a computer programmer known for the design of the D programming language. ...

• DMD: the Digital Mars D compiler, the official D compiler by Walter Bright. The compiler front end is licensed under both the Artistic License and the GNU GPL; sources for the front end are distributed along with the compiler binaries. The compiler back end is proprietary.
• GDC: A front end for the GCC back end, built using the open DMD compiler sources. Development snapshots also support D version 2.0.
• LLVMDC: A new front end, also based on open DMD sources that uses LLVM as its compiler back end. It's in early development.

The Artistic License is a software license used for certain free software packages, most notably the standard Perl implementation, most of CPAN modules and Parrot, which are dual-licensed under the Artistic License and the GNU General Public License (GPL). ... GNU (pronounced ) is a computer operating system composed entirely of free software. ... GPL redirects here. ... The GNU Compiler Collection (usually shortened to GCC) is a set of programming language compilers produced by the GNU Project. ... Low Level Virtual Machine (LLVM) is a compiler infrastructure designed for compile-time, link-time, run-time, and idle-time optimization of programs from arbitrary programming languages. ...

Development tools

D is still lacking support in many IDEs, which is a potential stumbling block for some users. Editors used include Entice Designer, emacs, vim, SciTE and Smultron among others. Vim supports both syntax highlighting and code completion (through patched ctags). A bundle is available for TextMate, and the Code::Blocks IDE includes partial support for the language. However, standard IDE features such as code completion or refactoring are not yet available, though they do work partially in Code::Blocks (due to D's similarity to C). An integrated development environment (IDE), also known as integrated design environment and integrated debugging environment, is a programming environment that has been packaged as an application program,that assists computer programmers in developing software. ... This article is about the text editor. ... Look up vim in Wiktionary, the free dictionary. ... SciTE or SCIntilla based Text Editor is a cross-platform text editor written by Neil Hodgson using the Scintilla editing component. ... Smultron is an open source Mac OS X text editor. ... TextMate is a general-purpose GUI text editor for Mac OS X. It provides users with innovative abstractions to support declarative customizations which are at once transparent and flexible. ... Autocomplete is a feature provided by many source code text editors, word processors, and web browsers. ... Refactoring is the process of rewriting a computer program or other material to improve its structure or readability, while explicitly keeping its meaning or behavior. ...

There are at least two actively developed Eclipse plug-ins for D, Descent and Mmrnmhrm.

Additionally, there are open source D IDEs written in the D language itself such as Poseidon, which does feature code completion, syntax highlighting, and integrated debugging. Open source refers to projects that are open to the public and which draw on other projects that are freely available to the general public. ... Autocomplete is a feature provided by many source code text editors, word processors, and web browsers. ... HTML syntax highlighting Syntax highlighting is a feature of some text editors that displays text—especially source code—in different colors and fonts according to the category of terms. ... Debugging is a methodical process of finding and reducing the number of bugs, or defects, in a computer program or a piece of electronic hardware thus making it behave as expected. ...

D applications can be debugged using any C/C++ debugger, like GDB or WinDbg, although support for various fundamental language features is extremely limited. A debugger with explicit support for D is Ddbg for Windows. The commercial ZeroBUGS debugger for Linux has experimental support for the D language. Ddbg can be used with various IDEs or from the command line; ZeroBUGS has its own GUI. The GNU Debugger, usually called just GDB, is the standard debugger for the GNU software system. ... Windbg is a multipurpose debugger for Microsoft Windows, created and distributed on the web by Microsoft. ... GUI redirects here. ...

Problems and controversies

Operator overloading

D operator overloads are significantly less powerful than the C++ counterparts. A popular example is the opIndex, which does not allow returning references. This makes assignments like obj[i] = 5; impossible. The D solution is the opIndexAssign operator, which only fixes this very case, but not variations like obj[i] += 5;. In addition, the C++ way of returning a reference allows for the usage of the returned type's overloaded assignment operator. This is currently not possible in D. D 2.0 will fix this by introducing an opIndexLvalue - like operator overload, and deprecating opIndexAssign.

Division concerning the standard library

The standard library in D is called Phobos. Some members of the D community think Phobos is too simplistic and that it has numerous quirks and other issues, and a replacement of the library called Tango was written. However, Tango and Phobos are at the moment incompatible due to different run-time libraries (the garbage collector, threading support, etc). The existence of two libraries, both widely in use, could lead to significant problems where some packages use Phobos and others use Tango.

Unfinished support for shared/dynamic libraries

Unix's ELF shared libraries are supported to an extent using the GDC compiler. On Windows systems, DLLs are supported and allow D's garbage collector allocated objects to be safely passed to C functions, since the garbage collector scans the stack for pointers. However, there are still limitations with DLLs in D including the fact that run-time type information of classes defined in the DLL is incompatible with those defined in the executable, and that any object created from within the DLL must be finalized before the DLL is unloaded.[2] In programming, Runtime Type Information (RTTI, RunTime Type Identification) means keeping information about an objects datatype in memory at runtime. ...

Examples

Example 1

This example program prints its command line arguments. The main function is the entry point of a D program, and args is an array of strings representing the command line arguments. A string in D is an array of characters, represented by char[] in D 1.0, or invariant(char)[] in D 2.0 alpha. Newer versions of the language define string as an alias for char[] or invariant(char) [], however, an explicit alias definition is necessary for compatibility with older versions.

 import std.stdio: writefln; void main(string[] args) { foreach(i, a; args) writefln("args[%d] = '%s'", i, a); } 

The foreach statement can iterate over any collection, in this case it is producing a sequence of indexes (i) and values (a) from the array args. The index i and the value a have their types inferred from the type of the array args.

Example 2

This illustrates the use of associative arrays to build much more complex data structures.

 import std.stdio: writefln; void display_item_count(string person, string[] items) { writefln(person, " is carrying ", items.length, " items."); } void main(string[] args) { // Declare an associative array with string keys and // arrays of strings as data string[][string] people; // Add some people to the container and let them carry some items people["Anya"] ~= "scarf"; people["Dimitri"] ~= "tickets"; people["Anya"] ~= "puppy"; // Iterate over all the persons in the container foreach (person, items; people) display_item_count(person, items); } 

Example 3

This heavily annotated example highlights many of the differences from C++, while still retaining some C++ aspects.

 #!/usr/bin/dmd -run /* sh style script syntax is supported! */ /* Hello World in D * To compile: * dmd hello.d * or to optimize: * dmd -O -inline -release hello.d * or to get generated documentation: * dmd hello.d -D */ import std.stdio; // References to commonly used I/O routines. int main(string[] args) { // 'writefln' (Write-Formatted-Line) is the type-safe 'printf' writefln("Hello World, " // automatic concatenation of string literals "Reloaded"); // Strings are denoted as a dynamic array of chars 'char[]', aliased as 'string' // auto type inference and built-in foreach foreach(argc, argv; args) { auto cl = new CmdLin(argc, argv); // OOP is supported writefln(cl.argnum, cl.suffix, " arg: %s", cl.argv); // user-defined class properties. delete cl; // Garbage Collection or explicit memory management - your choice } // Nested structs, classes and functions struct specs { // all vars automatically initialized to 0 at runtime int count, allocated; // however you can choose to avoid array initialization int[10000] bigarray = void; } specs argspecs(string[] args) // Optional (built-in) function contracts. in { assert(args.length > 0); // assert built in } out(result) { assert(result.count == CmdLin.total); assert(result.allocated > 0); } body { specs* s = new specs; // no need for '->' s.count = args.length; // The 'length' property is number of elements. s.allocated = typeof(args).sizeof; // built-in properties for native types foreach(arg; args) s.allocated += arg.length * typeof(arg[0]).sizeof; return *s; } // built-in string and common string operations, eg. '~' is concatenate. string argcmsg = "argc = %d"; string allocmsg = "allocated = %d"; writefln(argcmsg ~ ", " ~ allocmsg, argspecs(args).count,argspecs(args).allocated); return 0; } /** * Stores a single command line argument. */ class CmdLin { private { int _argc; string _argv; static uint _totalc; } public: /** * Object constructor. * params: * argc = ordinal count of this argument. * argv = text of the parameter */ this(int argc, string argv) { _argc = argc + 1; _argv = argv; _totalc++; } ~this() // Object destructor { // Doesn't actually do anything for this example. } int argnum() // A property that returns arg number { return _argc; } string argv() // A property that returns arg text { return _argv; } wstring suffix() // A property that returns ordinal suffix { wstring suffix; // Built in Unicode strings (UTF-8, UTF-16, UTF-32) switch(_argc) { case 1: suffix = "st"; break; case 2: suffix = "nd"; break; case 3: suffix = "rd"; break; default: // 'default' is mandatory with "-w" compile switch. suffix = "th"; } return suffix; } /** * A static property, as in C++ or Java, * applying to the class object rather than instances. * returns: The total number of commandline args added. */ static typeof(_totalc) total() { return _totalc; } // Class invariant, things that must be true after any method is run. invariant () { assert(_argc > 0); assert(_totalc >= _argc); } } 

Example 4

This example demonstrates some of the power of D's compile-time features.

 /* * Templates in D are much more intuitive than those in C++. Here we can see * the use of static if, D's compile-time conditional construct, to easily * construct a factorial template with functional style. */ template Factorial(ulong n) { static if( n <= 1 ) const Factorial = 1; else const Factorial = n * Factorial!(n-1); } /* * Here is a regular function that performs the same calculation. Notice how * similar they are. */ ulong factorial(ulong n) { if( n <= 1 ) return 1; else return n * factorial(n-1); } /* * Finally, we can compute our factorials. Notice that we don't need to * specify the type of our constants explicitly: the compiler is smart enough * to fill in the blank for us, since it already knows the type of the * right-hand side of the assignment. */ const fact_7 = Factorial!(7); /* * This is an example of compile-time function evaluation: ordinary functions * may be used in constant, compile-time expressions provided they meet * certain criteria. */ const fact_9 = factorial(9); /* * Here we can see just how powerful D's templates are: we are using the * std.metastrings.Format template to perform printf-style data formatting, * and displaying the result using the message pragma. */ import std.metastrings; pragma(msg, Format!("7! = %s", fact_7)); pragma(msg, Format!("9! = %s", fact_9)); /* * Our task done, we can forcibly stop compilation. This program need never * actually be compiled into an executable! */ static assert(false, "My work here is done."); 

See also

• Comparison of programming languages
• Ddoc

Programming languages are used for controlling the behavior of a machine (often a computer). ... Ddoc is the embedded documentation generator for the D programming language. ...

References

1. ^ D Change Log, http://www.digitalmars.com/d/1.0/changelog.html

External links

• Digital Mars: D programming language
• D at the Open Directory Project
• DSource, an open source community for the D Programming Language.
• Dprogramming.com, home of the DFL windowing library.
• Wiki4D, "the wiki for the d programming language"
• gdc, D front-end for GCC
• The Computer Language Benchmarks Game
• D Documentation Wiki
• D Language Feature Table
• Video presentation of D by Walter Bright
• Ddbg - Win32 D debugger
• DWin - library for D Programming Language
• DLogo - logos, buttons, banners for D Programming Language
• SciTE4D - Text Editor for D Programming Language
• D Programming Language China
• Chinese support forum for D Programming Language