BENCHMARKS:

recursive, n = 38:
  C: 3.89 s (with __builtin_expect)
  C: 3.99 s
  D: 4.95 s


hash, n = 500_000:
  D:     7.07 s (7.15 s with GC patched)
  D:     5.89 s (GC disabled)
  Psyco: 4.23 s

wordcount, on a txt file of 13_312_768 bytes:
  C: 0.73 s
  D: 5.77 s


gc1, with 6.3 MB of text:
        loading   splitting   total
         time        time     time
  D:       1.87 s     3.58 s   13.76 s
  Python:  0.28 s     1.98 s    3.52 s
  Python:  0.1 s      2.0 s     3.38 s (load with 'rb', same result)
With a Patch to the D GC, plus disabling the GC:
  D:       0.08 s     0.72 s    1.36 s (GC patched + GC disabled after load)


gc2, n=1_000, m=10_000:
               seconds  MB
  DMD class:   18.95    1.7
  GDC class:   17.91    1.8
  DMD struct:  11.77    1.7
  GDC struct:  12.31    1.8
  Python:      37.10    3.1
  Psyco:       15.68    3.5
  Java:         2.19    7.3


gc3 (binarytrees), n = 15:
  Java:   9.12 s
  D:     35.01 s


sort, const n = 1_000_000:
  Random distribution:
    sort: 2.934
    fastSort: 0.881
  Already sorted arrays:
    sort: 1.723
    fastSort: 0.41
 Inverted order arrays:
    sort: 1.853
    fastSort: 0.651

My timings of the "alignment" program:
  D3:        0.96 s    41 MB    66 lines
  C:         1.05 s    41 MB   146 lines
  C++:       1.22 s    41 MB    87 lines
  D2:        1.95 s    54 MB    60 lines
  D1:        2.73 s    57 MB    58 lines
  Java:      3.72 s    53 MB    79 lines
  Psyco:    11.22 s   168 MB    64 lines
  Python2: 115.3  s  ~160 MB    63 lines

        CTime  RTime   MB
Java6:  4.45   7.18   ~31
D DMD:  0.40   1.33   ~10.5 

Where:
  CTime is the compile time, seconds
  RTime is the running time, seconds
  MB is the peak memory used

Note:
  CTime  40 / 4.45 = 8.98
  RTime  7.18 / 1.33 = 5.4
  MB     31 / 10.5 = 2.95

Used:
  DMD v1.024
  javac 1.6.0_03

Compiled with:
  dmd death.d
  javac death.java

               seconds  MB
  DMD class:   18.95    1.7
  GDC class:   17.91    1.8
  DMD struct:  11.77    1.7
  GDC struct:  12.31    1.8
  Python:      37.10    3.1  (ShedSkin version)
  Psyco:       15.68    3.5
  ShedSkin      6.35    1.6
  Java (1):     2.19    7.3
  Java (2):     2.10    7.8

import std.gc;
class ObjectTest { ObjectTest next; }
void main() {
    for (uint k = 0; k < 50; k++) {
        std.gc.disable();
        for (uint i = 0; i < 20; i++) {
            auto root = new ObjectTest();
            for (uint j = 0; j < 10_000; j++) {
                root.next = new ObjectTest();
                root = root.next;
            }
        }
        std.gc.fullCollect();
    }
}

-------------------

-------------------

SOURCES:

// obj_test_class.d
class ObjectTest { ObjectTest next; }
void main() {
    for (uint i = 0; i < 1_000; i++) {
        auto root = new ObjectTest();
        for (uint j = 0; j < 10_000; j++) {
            root.next = new ObjectTest();
            root = root.next;
        }
    }
}

-------------------

// obj_test_struct.d
struct ObjectTest { ObjectTest* next; }
void main() {
    for (uint i = 0; i < 1_000; i++) {
        auto root = new ObjectTest();
        for (uint j = 0; j < 10_000; j++) {
            root.next = new ObjectTest();
            root = root.next;
        }
    }
}

-------------------

// ObjectTest.java
public class ObjectTest {
    public ObjectTest next;
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            ObjectTest root = new ObjectTest();
            for (int j = 0; j < 10000; j++) {
                root.next = new ObjectTest();
                root = root.next;
            }
        }
    }
}

-------------------

# obj_test.py
from psyco.classes import __metaclass__
class ObjectTest: pass
def main():
    for i in xrange(1000): # N
        root = ObjectTest()
        for j in xrange(10000): # M
            root.next = ObjectTest()
            root = root.next
import psyco; psyco.full()
main()

-------------------

# obj_test_ss.py
class ObjectTest: pass
def main():
    for i in xrange(1000): # N
        root = ObjectTest()
        for j in xrange(10000): # M
            root.next = ObjectTest()
            root = root.next
main()

- Create a model of the application.
- Write a miniapplication that implements the first instance of the repeated set of steps.
- Pull apart the miniapplication into template files replacing the named parts in the repeated set of steps with recognizable strings for substitution.
- Write code that can rebuild the miniapplication from the templates and the model.
- Generate all the code for the whole application.

private HashMap build<%TfmName%>Lookup() throws Exception {
    CustomTransform customTransform = new CustomTransform();
    <%DimName%>ManagerOlapFactory <%dimName%>MOFactory =
        new <%DimName%>ManagerOlapFactory();
    <%dimName%>MOFactory.setProperties(properties);
    <%DimName%>ManagerOlap <%dimName%>ManagerOlap = 
        <%dimName%>MOFactory.create<%DimName%>ManagerOlap();
    <%DimName%>Olap <%dimName%>Olap[] = 
        <%dimName%>ManagerOlap.loadAll();
    HashMap lookup = new HashMap();
    Class[] preformatArray = {Object.class};
    boolean preformatSet = false;
    Method preformat = null;
    try {
        preformat = customTransform.getClass().getDeclaredMethod(
            "pre<%TfmName%>", preformatArray); 
        preformatSet = true;
    } catch (NoSuchMethodException nsme) {
        preformatSet = false;
    }

>With a warehouse scenario he shows how different kind of code can be generated and he estimates that development time was reduced 30-50 percent. I consider this a very modest improvement and believe that one possible reason can be detected from the design model shown with the article (fig 1): The abstraction of the model is very low (code level) and seems to have some issues with low cohesion/high coupling. I haven't seen the whole model, or other models made. Anyway, industry experiences show that the speed will be fundamentally faster (500-1000%) if modeling language can lift the abstraction higher.<

>>> from string import Template
>>> s = Template('${who}likes$what')
>>> s.substitute(who='tim', what='kung pao')
'timlikeskung pao'

{{
from string import Template

# name initializations. The vars can be loaded from a dict,
# or from a file, etc.
TfmName = ...
DimName = ...
dimName = ...

print Template("""
private HashMap build${TfmName}Lookup() throws Exception {
    CustomTransform customTransform = new CustomTransform();
    ${DimName}ManagerOlapFactory ${dimName}MOFactory =
        new ${DimName}ManagerOlapFactory();
    ${dimName}MOFactory.setProperties(properties);
    ${DimName}ManagerOlap ${dimName}ManagerOlap =
        ${dimName}MOFactory.create${DimName}ManagerOlap();
    ${DimName}Olap ${dimName}Olap[] =
        ${dimName}ManagerOlap.loadAll();
    HashMap lookup = new HashMap();
    Class[] preformatArray = {Object.class};
    boolean preformatSet = false;
    Method preformat = null;
    try {
        preformat = customTransform.getClass().getDeclaredMethod(
            "pre${TfmName}", preformatArray);
        preformatSet = true;
    } catch (NoSuchMethodException nsme) {
        preformatSet = false;
    }
""").substitute(locals())
}}