The D pro­gram­ming lan­guage. Mod­ern con­ve­nience. Mod­el­ing power. Na­tive ef­fi­ciency.

DConf 2013 is sched­uled for May 1-3 in Menlo Park, Cal­i­for­nia. Visit the con­fer­ence web­site for more de­tails in­clud­ing how to pro­pose a ses­sion.

#!/usr/bin/env rdmd
// Computes average line length for standard input.
import std.stdio;

void main() {
    ulong lines = 0;
    double sumLength = 0;
    foreach (line; stdin.byLine()) {
        ++lines;
        sumLength += line.length;
    }
    writeln("Average line length: ",
        lines ? sumLength / lines : 0);
}

D is a lan­guage with C-like syn­tax and sta­tic typ­ing. It prag­mat­i­cally com­bines ef­fi­ciency, con­trol, and mod­el­ing power, with safety and pro­gram­mer pro­duc­tiv­ity.

Con­ve­nience

• D al­lows writ­ing large code frag­ments with­out re­dun­dantly spec­i­fy­ing types, like dy­namic lan­guages do. On the other hand, sta­tic in­fer­ence de­duces types and other code prop­er­ties, giv­ing the best of both the sta­tic and the dy­namic worlds.
  See ex­am­ple.

  void main() {
      // Define an array of numbers, double[]. Compiler recognizes the common
      // type of all initializers.
      auto arr = [ 1, 2, 3.14, 5.1, 6 ];
      // Dictionary that maps string to int, type is spelled int[string]
      auto dictionary = [ "one" : 1, "two" : 2, "three" : 3 ];
      // Calls the min function defined below
      auto x = min(arr[0], dictionary["two"]);
  }
  // Type deduction works for function results. This is important for generic
  // functions, such as min below, which works correctly for all comparable
  // types.
  auto min(T1, T2)(T1 lhs, T2 rhs) {
      return rhs < lhs ? rhs : lhs;
  }
  

• Au­to­matic mem­ory man­age­ment makes for safe, sim­ple, and ro­bust code. D also sup­ports scoped re­source man­age­ment (aka the RAII idiom) and scope state­ments for de­ter­min­is­tic trans­ac­tional code that is easy to write and read.
  See ex­am­ple.

  import std.stdio;
  
  class Widget { }
  
  void main() {
      // Automatically managed.
      auto w = new Widget;
      // Code is executed in any case upon scope exit.
      scope(exit) { writeln("Exiting main."); }
      // File is closed deterministically at scope's end.
      foreach (line; File("text.txt").byLine()) {
          writeln(line);
      }
      writeln();
  }
  

• Built-in lin­ear and as­so­cia­tive ar­rays, slices, and ranges make daily pro­gram­ming sim­ple and pleas­ant for tasks, both small and large.
  See ex­am­ple.

  #!/usr/bin/env rdmd
  import std.range, std.stdio;
  
  // Compute average line length for stdin
  void main() {
      ulong lines = 0, sumLength = 0;
      foreach (line; stdin.byLine()) {
          ++lines;
          sumLength += line.length;
      }
      writeln("Average line length: ",
          lines ? cast(double) sumLength / lines : 0.0);
  }
  

Power

• The best par­a­digm is to not im­pose some­thing at the ex­pense of oth­ers. D of­fers clas­sic poly­mor­phism, value se­man­tics, func­tional style, gener­ics, gen­er­a­tive pro­gram­ming, con­tract pro­gram­ming, and more—all har­mo­niously in­te­grated.
  See ex­am­ple.

  // Interfaces and classes
  interface Printable {
     void print(uint level)
     in { assert(level > 0); } // contract is part of the interface
  }
  
  // Interface implementation
  class Widget : Printable {
     void print(uint level)
     in{ }
     body{ }
  }
  
  // Single inheritance of state
  class ExtendedWidget : Widget {
     override void print(uint level)
     in { /* weakening precondition is okay */  }
     body {
         //... level may be 0 here ...
     }
  }
  
  // Immutable data shared across threads
  immutable string programName = "demo";
  // Mutable data is thread-local
  int perThread = 42;
  // Explicitly shared data
  shared int perApp = 5;
  
  // Structs have value semantics
  struct BigNum {
      // intercept copying
      this(this) { }
      // intercept destructor
      ~this() { }
  }
  
  void main()
  {
      // ...
  }
  

• D of­fers an in­no­v­a­tive ap­proach to con­cur­rency, fea­tur­ing true im­mutable data, mes­sage pass­ing, no shar­ing by de­fault, and con­trolled mu­ta­ble shar­ing across threads. Read more.
• From sim­ple scripts to large pro­jects, D has the breadth to scale with any ap­pli­ca­tion's needs: unit test­ing, in­for­ma­tion hid­ing, re­fined mod­u­lar­ity, fast com­pi­la­tion, pre­cise in­ter­faces. Read more.

Ef­fi­ciency

• D com­piles nat­u­rally to ef­fi­cient na­tive code.
• D is de­signed such that most "ob­vi­ous" code is fast and safe. On oc­ca­sion a func­tion might need to es­cape the con­fines of type safety for ul­ti­mate speed and con­trol. For such rare cases D of­fers na­tive point­ers, type casts, ac­cess to any C func­tion with­out any in­ter­ven­ing trans­la­tion, and even in­line as­sem­bly code.
  See ex­am­ple.

  import core.stdc.stdlib;
  
  void livingDangerously() {
      // Access to C's malloc and free primitives
      auto buf = malloc(1024 * 1024);
      scope(exit) free(buf); // free automatically upon scope exit
      // Interprets memory as an array of floats
      auto floats = cast(float[]) buf[0 .. 1024 * 1024];
      // Even stack allocation is possible
      auto moreBuf = alloca(4096 * 100);
      //...
  }
  
  // Using inline asm for extra speed on x86
  uint checked_multiply(uint x, uint y) {
      uint result;
      version (D_InlineAsm_X86) {
          // Inline assembler "sees" D variables.
          asm {
              mov     EAX,x        ;
              mul     EAX,y        ;
              mov     result,EAX   ;
              jc      Loverflow    ;
          }
          return result;
      } else {
          result = x * y;
          if (!y || x <= uint.max / y)
             return result;
     }
  Loverflow:
     throw new Exception("multiply overflow");
  }
  
  void main()
  {
      // ...
  }
  

• The @safe, @trusted, and @sys­tem mod­u­lar at­trib­utes allow the pro­gram­mer to best de­cide the safety-ef­fi­ciency trade­offs of an ap­pli­ca­tion, and have the com­piler check for con­sis­tency. Read more.