Kyuu
26.09.2009, 19:52
Was ist D?
D ist eine neue Programmiersprache, die seit 1999 von Walter Bright (Digital Mars) entwickelt wird und erstmals 2007 in einer stabilen 1.0 Version erschien. In der vorerst experimentellen 2.0 Version, wird D weiter ausgebaut und erweitert.
Die Sprache lehnt sich syntaktisch stark an C/C++ an und weist Ähnlichkeiten mit weiteren Sprachen wie zum Beispiel Java auf. Außerdem ist sie performant wie C - eignet sich also hervorragend als Systemsprache - und gleichzeitig komfortabel und produktiv wie Ruby und Python.
Was bietet D?
D versucht in erster Linie dem Programmierer so viel (fehleranfällige) Arbeit abzunehmen wie es möglich ist, durch Features wie dem automatischen Garbage Collector, als Systemsprache verbietet sie aber nicht und erlaubt sowohl Low-Level Programmierung mit Zeigern, Inline Assembly, etc, als auch den Lebenszyklus von Objekten komplett selbst zu steuern durch Support von Konstruktoren und Destruktoren (essentiell für RAII (http://en.wikipedia.org/wiki/RAII)), falls Determinismus gewünscht wird.
D bietet eine Reihe mächtiger DbC-Konstrukte (Design by Contract (http://de.wikipedia.org/wiki/Design_by_contract)) an, die zur Qualitätsverbesserung der Software verwendet verden können.
D ist C-linkfähig, es ist also möglich C-Funktionen aus D aufzurufen. Damit stehen D-Entwicklern alle Bibliotheken zur Verfügung, die in C geschrieben wurden.
Um auf C++-Bibliotheken zugreifen zu können, ist eine C-Abstraktionsschicht erforderlich.
D erlaubt Programmierparadigmen wie imperative, objektorientierte und Metaprogrammierung.
D automatisiert Unit Testing, Documentation Generation, Profiling und Debugging.
Ds Standardbibliothek Phobos, sowie die Community-gewartete Bibliothek Tango bieten eine riesige Palette an Funktionalität, wie Higher-Order Programming, I/O, Multithreading (Synchronisation ist bereits in der Sprache integriert), Networking, Internationalization Support, Compressing/Decompressing Algorithmen, etc.
Ich könnte so weitermachen, aber stattdessen verweise ich auf die offizielle Webseite, die bereits einen ausführlichen Überblick über Ds Umfang gibt.
Beispiele?
import std.stdio;
void main {
writeln("Hello MMX!");
}
Das obligatorische "Hello World", nur mit "MMX" statt "World".
D kennt echte Packages und Module! Header Files fallen in D weg und damit auch Undinge wie Include Guards, Forward Declarations und redundanter Code.
Ein Package in D ist ein Verzeichnis und ein Modul ist eine *.d Datei. In diesem Fall ist also std das Package und stdio das zu importierende Modul. Module können übrigens eigene Konstruktoren und Destruktoren haben und werden garantiert immer in der richtigen Reihenfolge initialisiert und zerstört, falls es Abhängigkeiten zwischen Modulen gibt.
import std.stdio;
void main {
int var;
writefln("%d", var);
}
In D werden alle Variablen automatisch mit den Standardwerten ihrer Datentypen initialisiert. var wird also mit 0 initialisiert und entsprechend sieht dann die Ausgabe aus. Das hat den entscheidenden Vorteil, dass subtile Bugs, ausgelöst durch nicht initialisierte Variablen, erst gar nicht entstehen können.
Variablen besitzen übrigens statische Attribute, unterschiedlich je nach Datentyp. Man könnte zum Beispiel vor einer Zuweisung mit wert >= var.min && wert <= var.max prüfen, ob wert überhaupt in var dargestellt werden kann.
import std.stdio;
interface Eatable {
void eat();
}
interface Flyable {
void fly();
}
class Creature {
}
class Bird : Creature, Eatable, Flyable {
this() {
writeln("Bird created...");
}
~this() {
writeln("Bird destroyed...");
}
void eat() {
writeln("Bird is being eaten!");
}
void fly() {
writeln("Bird flies!");
}
}
void main() {
Flyable flyable_bird = new Bird;
flyable_bird.fly();
Eatable eatable_bird = new Bird;
eatable_bird.eat();
}
D kennt neben Klassen auch Interfaces (in C++ vergleichbar mit abstrakten Basisklassen). Während von Klassen nur einfach geerbt werden kann, gibt es bei Interfaces keine Grenzen. Mehrfaches Erben von Klassen ist schwierig zu implementieren, weswegen viele Sprachen klugerweise nur einfaches Erben erlauben und darüber hinaus Interfaces anbieten.
Methoden sind in D standardmäßig virtuell und der Compiler entscheidet darüber, ob es Sinn macht, eine Methode nicht-virtuell zu machen. Wieder eine nervige Fehlerquelle beseitigt.
import std.stdio;
class Number {
void value(int val) {
value_ = val;
}
int value() {
return value_;
}
private int value_;
}
void main() {
Number num = new Number;
num.value = 123;
writefln("num's value: %d", num.value);
}
D erlaubt Attribute auch als solche zu behandeln. Nie wieder stupide Getter und Setter!
Da dies kein Tutorial werden soll, denke ich, reicht es fürs Erste. Sollte noch jemand Fragen haben, werde ich darauf natürlich eingehen.
Welche Plattformen werden unterstützt?
Windows - DMD (http://www.digitalmars.com/d/2.0/dmd-windows.html) | GDC (http://dgcc.sourceforge.net/) (über MinGW oder Cygwin)
Mac OS X - DMD (http://www.digitalmars.com/d/2.0/dmd-osx.html) | GDC (http://dgcc.sourceforge.net/)
Linux - DMD (http://www.digitalmars.com/d/2.0/dmd-linux.html) | GDC (http://dgcc.sourceforge.net/)
FreeBSD - DMD (http://www.digitalmars.com/d/2.0/dmd-freebsd.html) | GDC (http://dgcc.sourceforge.net/)
AIX - GDC (http://dgcc.sourceforge.net/)
Unterstützung für weitere Plattformen folgt in der Zukunft.
Links:
Digital Mars D (http://www.digitalmars.com/d/) - Offizielle Webseite.
D 1.0 Language (http://www.digitalmars.com/d/1.0/lex.html) - Offizielle Sprachreferenz zu D1.
D 2.0 Language (http://www.digitalmars.com/d/2.0/lex.html) - Offizielle Sprachreferenz zu D2.
Tango (http://www.dsource.org/projects/tango) - Community-eigene Standardbibliothek, die Phobos in Sachen Umfang weit überbietet.
dsource (http://www.dsource.org/) - Zentrale Anlaufstelle für Source Code und Projekte. Enthält auch Tutorials.
The Case For D (http://www.ddj.com/hpc-high-performance-computing/217801225) - Ein Artikel geschrieben von Andrei Alexandrescu, der sich aktiv an Ds Entwicklung beteiligt und in dem er kurz einige der wichtigsten Aspekte der Programmiersprache D aus einer professionellen Perspektive erläutert.
Wiki4D (http://www.prowiki.org/wiki4d/wiki.cgi?FrontPage) - Verschiedene Tutorials.
IDEs/Editoren findet ihr hier (http://www.prowiki.org/wiki4d/wiki.cgi?EditorSupport).
Literatur:
Es gibt leider noch nicht viele Bücher zu D. Persönlich habe ich bereits zwei gelesen und kann sie dementsprechend empfehlen oder nicht empfehlen.
Programmieren in D (http://www.amazon.de/Programmieren-Einf%C3%BChrung-die-neue-Programmiersprache/dp/3939084697/ref=sr_1_1?ie=UTF8&s=books&qid=1253823120&sr=8-1) - Dieses Buch kratzt nur an der Oberfläche und ist, soweit ich mich erinnere, stellenweise fehlerhaft. Es ist allerdings in Deutsch geschrieben und wäre vielleicht angenehmer zu lesen. Wer ausreichende Englischkenntnisse besitzt, ist mit einem der folgenden Bücher besser bedient.
Learn To Tango With D (http://www.amazon.de/Learn-Tango-D-Kris-Bell/dp/1590599608/ref=sr_1_2?ie=UTF8&s=books-intl-de&qid=1253823494&sr=8-2-catcorr) - Ein ausführliches Buch, das sowohl die Sprache beschreibt - also auch für Einsteiger nützlich, die Phobos verwenden, als auch sich auf die Bibliothek Tango konzentriert. Sehr preiswert und empfehlenswert.
The D Programming Language (http://www.amazon.de/D-Programming-Language-Andrei-Alexandrescu/dp/0321635361/ref=sr_1_1?ie=UTF8&s=books-intl-de&qid=1253824060&sr=8-1) - Dieses Buch ist leider noch in Arbeit und wird von Andrei Alexandrescu verfasst, bekannt beispielsweise für sein Buch Modern C++ Design. Man kann bereits vorbestellen und da ich vom Autor Qualität gewohnt bin, kann ich es nur jedem empfehlen. Es wird übrigens das erste Buch sein, das auch die D 2.0-Spezifikation behandelt.
D ist eine neue Programmiersprache, die seit 1999 von Walter Bright (Digital Mars) entwickelt wird und erstmals 2007 in einer stabilen 1.0 Version erschien. In der vorerst experimentellen 2.0 Version, wird D weiter ausgebaut und erweitert.
Die Sprache lehnt sich syntaktisch stark an C/C++ an und weist Ähnlichkeiten mit weiteren Sprachen wie zum Beispiel Java auf. Außerdem ist sie performant wie C - eignet sich also hervorragend als Systemsprache - und gleichzeitig komfortabel und produktiv wie Ruby und Python.
Was bietet D?
D versucht in erster Linie dem Programmierer so viel (fehleranfällige) Arbeit abzunehmen wie es möglich ist, durch Features wie dem automatischen Garbage Collector, als Systemsprache verbietet sie aber nicht und erlaubt sowohl Low-Level Programmierung mit Zeigern, Inline Assembly, etc, als auch den Lebenszyklus von Objekten komplett selbst zu steuern durch Support von Konstruktoren und Destruktoren (essentiell für RAII (http://en.wikipedia.org/wiki/RAII)), falls Determinismus gewünscht wird.
D bietet eine Reihe mächtiger DbC-Konstrukte (Design by Contract (http://de.wikipedia.org/wiki/Design_by_contract)) an, die zur Qualitätsverbesserung der Software verwendet verden können.
D ist C-linkfähig, es ist also möglich C-Funktionen aus D aufzurufen. Damit stehen D-Entwicklern alle Bibliotheken zur Verfügung, die in C geschrieben wurden.
Um auf C++-Bibliotheken zugreifen zu können, ist eine C-Abstraktionsschicht erforderlich.
D erlaubt Programmierparadigmen wie imperative, objektorientierte und Metaprogrammierung.
D automatisiert Unit Testing, Documentation Generation, Profiling und Debugging.
Ds Standardbibliothek Phobos, sowie die Community-gewartete Bibliothek Tango bieten eine riesige Palette an Funktionalität, wie Higher-Order Programming, I/O, Multithreading (Synchronisation ist bereits in der Sprache integriert), Networking, Internationalization Support, Compressing/Decompressing Algorithmen, etc.
Ich könnte so weitermachen, aber stattdessen verweise ich auf die offizielle Webseite, die bereits einen ausführlichen Überblick über Ds Umfang gibt.
Beispiele?
import std.stdio;
void main {
writeln("Hello MMX!");
}
Das obligatorische "Hello World", nur mit "MMX" statt "World".
D kennt echte Packages und Module! Header Files fallen in D weg und damit auch Undinge wie Include Guards, Forward Declarations und redundanter Code.
Ein Package in D ist ein Verzeichnis und ein Modul ist eine *.d Datei. In diesem Fall ist also std das Package und stdio das zu importierende Modul. Module können übrigens eigene Konstruktoren und Destruktoren haben und werden garantiert immer in der richtigen Reihenfolge initialisiert und zerstört, falls es Abhängigkeiten zwischen Modulen gibt.
import std.stdio;
void main {
int var;
writefln("%d", var);
}
In D werden alle Variablen automatisch mit den Standardwerten ihrer Datentypen initialisiert. var wird also mit 0 initialisiert und entsprechend sieht dann die Ausgabe aus. Das hat den entscheidenden Vorteil, dass subtile Bugs, ausgelöst durch nicht initialisierte Variablen, erst gar nicht entstehen können.
Variablen besitzen übrigens statische Attribute, unterschiedlich je nach Datentyp. Man könnte zum Beispiel vor einer Zuweisung mit wert >= var.min && wert <= var.max prüfen, ob wert überhaupt in var dargestellt werden kann.
import std.stdio;
interface Eatable {
void eat();
}
interface Flyable {
void fly();
}
class Creature {
}
class Bird : Creature, Eatable, Flyable {
this() {
writeln("Bird created...");
}
~this() {
writeln("Bird destroyed...");
}
void eat() {
writeln("Bird is being eaten!");
}
void fly() {
writeln("Bird flies!");
}
}
void main() {
Flyable flyable_bird = new Bird;
flyable_bird.fly();
Eatable eatable_bird = new Bird;
eatable_bird.eat();
}
D kennt neben Klassen auch Interfaces (in C++ vergleichbar mit abstrakten Basisklassen). Während von Klassen nur einfach geerbt werden kann, gibt es bei Interfaces keine Grenzen. Mehrfaches Erben von Klassen ist schwierig zu implementieren, weswegen viele Sprachen klugerweise nur einfaches Erben erlauben und darüber hinaus Interfaces anbieten.
Methoden sind in D standardmäßig virtuell und der Compiler entscheidet darüber, ob es Sinn macht, eine Methode nicht-virtuell zu machen. Wieder eine nervige Fehlerquelle beseitigt.
import std.stdio;
class Number {
void value(int val) {
value_ = val;
}
int value() {
return value_;
}
private int value_;
}
void main() {
Number num = new Number;
num.value = 123;
writefln("num's value: %d", num.value);
}
D erlaubt Attribute auch als solche zu behandeln. Nie wieder stupide Getter und Setter!
Da dies kein Tutorial werden soll, denke ich, reicht es fürs Erste. Sollte noch jemand Fragen haben, werde ich darauf natürlich eingehen.
Welche Plattformen werden unterstützt?
Windows - DMD (http://www.digitalmars.com/d/2.0/dmd-windows.html) | GDC (http://dgcc.sourceforge.net/) (über MinGW oder Cygwin)
Mac OS X - DMD (http://www.digitalmars.com/d/2.0/dmd-osx.html) | GDC (http://dgcc.sourceforge.net/)
Linux - DMD (http://www.digitalmars.com/d/2.0/dmd-linux.html) | GDC (http://dgcc.sourceforge.net/)
FreeBSD - DMD (http://www.digitalmars.com/d/2.0/dmd-freebsd.html) | GDC (http://dgcc.sourceforge.net/)
AIX - GDC (http://dgcc.sourceforge.net/)
Unterstützung für weitere Plattformen folgt in der Zukunft.
Links:
Digital Mars D (http://www.digitalmars.com/d/) - Offizielle Webseite.
D 1.0 Language (http://www.digitalmars.com/d/1.0/lex.html) - Offizielle Sprachreferenz zu D1.
D 2.0 Language (http://www.digitalmars.com/d/2.0/lex.html) - Offizielle Sprachreferenz zu D2.
Tango (http://www.dsource.org/projects/tango) - Community-eigene Standardbibliothek, die Phobos in Sachen Umfang weit überbietet.
dsource (http://www.dsource.org/) - Zentrale Anlaufstelle für Source Code und Projekte. Enthält auch Tutorials.
The Case For D (http://www.ddj.com/hpc-high-performance-computing/217801225) - Ein Artikel geschrieben von Andrei Alexandrescu, der sich aktiv an Ds Entwicklung beteiligt und in dem er kurz einige der wichtigsten Aspekte der Programmiersprache D aus einer professionellen Perspektive erläutert.
Wiki4D (http://www.prowiki.org/wiki4d/wiki.cgi?FrontPage) - Verschiedene Tutorials.
IDEs/Editoren findet ihr hier (http://www.prowiki.org/wiki4d/wiki.cgi?EditorSupport).
Literatur:
Es gibt leider noch nicht viele Bücher zu D. Persönlich habe ich bereits zwei gelesen und kann sie dementsprechend empfehlen oder nicht empfehlen.
Programmieren in D (http://www.amazon.de/Programmieren-Einf%C3%BChrung-die-neue-Programmiersprache/dp/3939084697/ref=sr_1_1?ie=UTF8&s=books&qid=1253823120&sr=8-1) - Dieses Buch kratzt nur an der Oberfläche und ist, soweit ich mich erinnere, stellenweise fehlerhaft. Es ist allerdings in Deutsch geschrieben und wäre vielleicht angenehmer zu lesen. Wer ausreichende Englischkenntnisse besitzt, ist mit einem der folgenden Bücher besser bedient.
Learn To Tango With D (http://www.amazon.de/Learn-Tango-D-Kris-Bell/dp/1590599608/ref=sr_1_2?ie=UTF8&s=books-intl-de&qid=1253823494&sr=8-2-catcorr) - Ein ausführliches Buch, das sowohl die Sprache beschreibt - also auch für Einsteiger nützlich, die Phobos verwenden, als auch sich auf die Bibliothek Tango konzentriert. Sehr preiswert und empfehlenswert.
The D Programming Language (http://www.amazon.de/D-Programming-Language-Andrei-Alexandrescu/dp/0321635361/ref=sr_1_1?ie=UTF8&s=books-intl-de&qid=1253824060&sr=8-1) - Dieses Buch ist leider noch in Arbeit und wird von Andrei Alexandrescu verfasst, bekannt beispielsweise für sein Buch Modern C++ Design. Man kann bereits vorbestellen und da ich vom Autor Qualität gewohnt bin, kann ich es nur jedem empfehlen. Es wird übrigens das erste Buch sein, das auch die D 2.0-Spezifikation behandelt.