imported>Invisigoth67: typo, form

2025-10-28T12:47:53Z

typo, form

Neue Seite

{{Infobox Programmiersprache
| Name = Dylan
| Paradigma = [[Objektorientierte Programmierung|objektorientiert]]
| Erscheinungsjahr = 1992
| AktuelleVersion = 2023.1.0
| AktuelleVersionFreigabeDatum = 15. Juni 2023
| Typisierung = stark, dynamisch
| Implementierung = Gwydion Dylan, Open Dylan
| Beeinflusst_von = [[Common Lisp Object System|CLOS]], [[LISP]], [[EuLisp]], [[ALGOL]], [[Scheme]]
| Beeinflusste = [[Goo (Programmiersprache)|Goo]], [[Lasso (Programmiersprache)|Lasso]], [[Python (Programmiersprache)|Python]], [[Ruby (Programmiersprache)|Ruby]]
| Betriebssystem = [[plattformübergreifend]]
| Website = [https://opendylan.org/ opendylan.org]
}}

'''Dylan''' ('''''Dy'''namic '''Lan'''guage'') ist eine [[Programmiersprache]], die Anfang der 1990er Jahre von einer Gruppe unter der Führung von [[Apple]] initiiert und spezifiziert wurde.

Ziel war es,
* die besten Aspekte von [[Lisp]] und [[Smalltalk (Programmiersprache)|Smalltalk]] zu kombinieren
* den Benutzern statischer Programmiersprachen eine attraktive dynamische Alternative zu bieten
* auf kleinen Maschinen nutzbar zu sein
* hohe Dynamik während des [[Prototyping (Softwareentwicklung)|Prototypings]] und bei der Entwicklung zu bieten
* Werkzeuge anzubieten, die kommerzielle [[Performance (Informatik)|Performance]] in Produktionscode bieten.

Dylan war ursprünglich zum Einsatz auf Apples [[Newton (PDA)|Newton]] PDAs vorgesehen, wurde dort aber aus Termin- und vermutlich auch Prestigegründen durch [[NewtonScript]] ersetzt, eine auf der Programmiersprache [[Self (Programmiersprache)|Self]] basierende Eigenentwicklung Apples.

== Abgrenzung von anderen Programmiersprachen ==
Dylans objektorientiertes Paradigma steht in der Tradition von [[Common Lisp]] und unterscheidet sich von den meisten objektorientierten Programmiersprachen (wie C++, Java, Python, Ruby) im Abstraktionsprinzip des [[Polymorphismus]], das in beiden Fällen unterschiedlich umgesetzt wird.

Programmiersprachen wie Java kapseln Daten in Objekte, etwa eine Klasse Bruch, die Zähler und Nenner enthält. Operationen die mit diesen Objekten arbeiten, etwa die Addition, werden ebenfalls als Eigenschaft des Objekts/der Klasse gesehen und in der Klasse selbst verwaltet.

Wie der Folgende Pseudocode-Abschnitt zeigt, sind sowohl Daten als auch Methoden (Operationen) Teil des Objekts.
<syntaxhighlight lang="java">
Bruch a;
a.nenner = 10;
a.zaehler = 1;
Bruch b;
b.nenner = 1;
b.zaehler = 5;
a.addiere(b);
</syntaxhighlight>

Mit virtuellen Methoden ermöglicht dieser Ansatz [[Polymorphismus]]. Das bedeutet, dass ein Objekt seine Operationen "selbst mitbringt" und der Programmierer zur Laufzeit nicht festlegen muss, wie z. B. eine Addition für verschiedene Objekte ausgeführt werden soll.

Hat man zum Beispiel zwei Klassen <code>Bruch</code> und <code>KomplexeZahl</code>, welche beide die Elternklasse <code>Zahl</code> haben, die eine Methode <code>betrag()</code> definiert, so kann der Betrag einer komplexen Zahl oder eines Bruches mit <code>a.betrag()</code> berechnet werden, ohne im [[Quelltext]] unterscheiden zu müssen, ob es sich bei <code>a</code> um einen Bruch oder eine [[komplexe Zahl]] handelt.

Dieser Ansatz verspricht einen Abstraktionsgrad, weil eine gut implementierte Klasse dem Programmierer wesentlich Arbeit abnimmt. Ein Objekt "weiß" selbst am besten wie man seinen Betrag berechnet.

Der Nachteil dieses Ansatzes ist, dass man Operationen, welche man nicht genau einem Objekt zuordnen kann, nun in eine Klasse stecken muss. Die Addition zweier Zahlen <code>A</code> und <code>B</code> ist so ein Fall. Entspricht <code>A+B</code> nun <code>A.addiere(B)</code> oder <code>B.addiere(A)</code>.

=== Multiple Dispatch ===
Dylan setzt den Polymorphismus auf eine andere Weise um. Operationen und Methoden werden außerhalb der Klasse definiert, an die Stelle von <code>A.addiere(B)</code> tritt nun <code>addiere(A,B)</code>. Innerhalb der Klasse werden lediglich Datenfelder beschrieben und Zugriffsrechte verteilt.

Mit geringen Abweichungen in der Berechnung der [[Class Precedence List]] ist Dylans Multiple Dispatch eine exakte Übernahme der [[Multimethode#Multimethoden in Common Lisp|Multimethoden]] von [[Common Lisp]].

<syntaxhighlight lang="scheme">
define class <Bruch> (<object>)
slot nenner;
slot zaehler;
end;

define method addiere(a :: <Bruch>, b :: <Bruch>) => (ergebnis)
// Implementierung
end;</syntaxhighlight>

Wird eine Klasse für komplexe Zahlen implementiert, so lässt sich die Methode <code>addiere</code> einfach für weitere Datentypen erweitern.

<syntaxhighlight lang="scheme">
define method addiere(a :: <KomplexeZahl>, b :: <KomplexeZahl>) => (ergebnis)
// Implementierung
end;
define method addiere(a :: <Bruch>, b :: <KomplexeZahl>) => (ergebnis)
// Implementierung
end;
define method addiere(a :: <KomplexeZahl>, b :: <Bruch>) => (ergebnis)
// Implementierung
end;
</syntaxhighlight>

Eine weitere Methode kann nun unabhängig von Klassen mit Zahlen arbeiten und rechnen:

<syntaxhighlight lang="scheme">
define method rechteck_umfang(laenge, breite) => (umfang)
2*(addiere(laenge, breite))
end;
</syntaxhighlight>

Anzumerken ist, dass die Klassen für die Parameter <code>laenge,breite</code> nicht festgelegt sind. Bei Ausführung der Berechnung wird automatisch die richtige Implementierung von <code>addiere</code> herausgesucht. Dies nennt sich [[Multiple Dispatch]] und entspricht der Tradition objektorientierter Programmierung in Sprachen der Lisp-Familie, wie etwa in Common Lisp mit dem Common Lisp Object System [[CLOS]].

== Implementierungen ==

=== Apple Dylan / Harlequin Dylan / Functional Developer / Open Dylan ===

Nachdem Apple 1998 die Entwicklung von Dylan endgültig einstellte, ging der Quellcode an die englische Firma Harlequin über. Harlequin wurde kurz darauf von Global Graphics übernommen und die Entwicklung von Harlequin Dylan in eine eigenständige Firma, Functional Objects (auch „FunO“), ausgegliedert. Die Dylan-Implementierung mit [[Integrierte Entwicklungsumgebung|IDE]] wurde fortan unter dem Namen „Functional Developer“ verkauft. 2004 wurde Functional Developer schließlich an die Gwydion Dylan Maintainer als Open-Source-Projekt übergeben (FunO stellte seine Geschäftstätigkeit Anfang 2006 vollständig ein). Die Software heißt seitdem Open Dylan.

Neben einer interaktiven Shell (ähnlich [[Ruby (Programmiersprache)|Rubys]] IRB oder [[BeanShell]]), bietet die IDE einen [[Klassenbrowser|Object-Browser]], mit dem sich der Zustand laufender Programme analysieren lässt. Beide Tools können sowohl auf lokale als auch auf anderen Rechnern laufende Dylan-Programme angewendet werden.

Die IDE ist momentan nur unter [[Windows]] verfügbar, der [[Compiler]] läuft mittlerweile jedoch auch unter [[Mac OS X]] und [[Linux]].

=== Gwydion Dylan ===

Gwydion Dylan, benannt nach einem Zauberer aus einer walisischen Sage, wurde ursprünglich an der [[Carnegie Mellon University]] entwickelt.
Es handelt sich dabei um einen Compiler, der C-Code erzeugt. Dieser Code muss mittels eines C-Compilers in Maschinencode übersetzt werden. Dadurch können Gwydion-Dylan-Programme auf vielen Plattformen laufen. Die Implementierung ist jedoch weniger vollständig als Open Dylan.

=== Mindy ===

Mindy ist ein Dylan-Interpreter, dessen Entwicklung mittlerweile eingestellt wurde. Er wurde benutzt, um die [[Bootstrapping (Programmierung)|erste Version des Gwydion-Compilers zu kompilieren]]. Die Bezeichnung ist ein [[rekursives Akronym]] von MINDY Is Not Dylan Yet.

== Weblinks ==
* ''[https://opendylan.org/ Open-Dylan-Website]'' (englisch)
* [[CRE (Podcast)|CRE]]: ''[https://cre.fm/cre031-programmiersprachen-und-dylan Programmiersprachen und Dylan]''

[[Kategorie:Objektorientierte Programmiersprache]]

Dylan (Programmiersprache) - Versionsgeschichte

imported>Invisigoth67: typo, form