Dynamische Programmiersprachen - Fachgebiet ...

Dynamische Programmiersprachen
Von Lisp und Smalltalk zu Perl, Python, Ruby, Groovy …
Seminar im WS 2008/2009
Prof. Dr.-Ing. Hans-Jürgen Hoffmann
TU Darmstadt, Fachbereich Informatik,
FG Programmiersprachen und Übersetzer
Seminarausarbeitung
von

INHALTSVERZEICHNIS 1
Inhaltsverzeichnis
1 Einleitung 2
2 Was versteht man unter Binden ? 3
2.1 Neu-Binden und Mutation . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Zeitpunkt des Bindens . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3 Dynamische Typisierung / Statische Typisierung 8
3.1 Duck-Typing und die halbdynamische Sprache Boo . . . . . . . . . . . 10
3.2 Vor- und Nachteile bei dynamischer / statischer Typisierung . . . . . . 12
4 Polymorphe Variablen 13
5 Dynamische- / Statische-Bindung 14
5.1 Unterschiede zwischen dynamischer und statischer Bindung . . . . . . 18
6 Fazit 19
INHALTSVERZEICHNIS

1 EINLEITUNG 2
1 Einleitung
Das Wort Binden“ (engl. binding) besitzt eine Vielzahl von Bedeutungen und wird in
”
unterschiedlichem Kontext verwendet. So bezeichnet es so unterschiedliche Vorgänge
wie beispielsweise das Zusammenfügen einzelner Seiten zu einem Buch, in der Chemie
das Eingehen einer chemischen Verbindung und vieles mehr. Allgemein bezeichnet Binden
das Herstellen einer Verbindung zwischen zwei oder mehreren Entitäten. In dieser
Seminararbeit geht es um den Begriff Binden im Kontext der Informatik, insbesondere
in Hinblick auf dessen Verwendung bei den Programmiersprachen.
Diese Seminararbeit ist wie folgt gegliedert:
Nach einer kurzen Einleitung im 1. Abschnitt wird in Abschnitt 2 versucht, eine kurze
Definition des Begriffs Binden im Kontext der Informatik zu geben und die unterschiedlichen
Bindungsarten vorzustellen.
Der darauffolgende Abschnitt 3 befaßt sich mit den Unterschieden zwischen dynamischerund
statischer Typisierung und dient als Grundlage für das Verständnis der unterschiedlichen
Realisierungsmöglichkeiten für spätes Binden.
Im 4. Abschnitt wird die Verwendung von polymorphen Variablen dargestellt und deren
Zusammenhang mit spätem Binden aufgezeigt.
Abschnitt 5 beschäftigt sich mit dem Zeitpunkt des Bindens und versucht den Unterschied
zwischen frühem und spätem Binden zu verdeutlichen.
Der sich anschließende letzte Abschnitt beinhaltet ein kurzes Fazit.
Grundsätzliche wurde versucht, in jedem dieser Abschnitte die zu vermittelnde und
notwendige Theorie durch möglichst viele Beispiele zu erläutern.

2 WAS VERSTEHT MAN UNTER BINDEN ? 3
2 Was versteht man unter Binden ?
Wie bereits in der Einleitung erklärt wurde, hat das Wort Binden je nach Zusammenhang
eine unterschiedliche Bedeutung. Auch in der Informatik gibt es je nach Kontext
unterschiedliche Definitionen was durch Begriffe wie beispielsweise Namensbindung,
Variablenbindung und Funktionsbindung ausgedrückt wird.
Eine allgemeine Definition für den Begriff Binden“ im Kontext der Informatik kann
”
man beispielsweise in der Wikipedia (siehe [1]) finden: In computer science, binding
”
is the creation of a simple reference to something that is larger and more complicated
and used frequently.“ (In der Informatik bezeichnet der Begriff Binden“ die Erzeugung
”
einer einfachen Referenz zu etwas das größer und komplizierter ist und häufiger benutzt
wird.)
Ein Beispiel hierfür ist das folgende Python-Programm:
Abbildung 1: Beispiel: Binden in Python
In der ersten Zeile des Programms wird eine Funktion mit dem Namen meineFunktion“
”
definiert, die aus 1 Millionen Zeilen Code bestehen soll. Die Python-Anweisung def
gefolgt von dem Namen der Funktion bewirkt, daß der nachfolgende Code (die 1
Millionen Zeilen) mit dem Funktionsnamen assoziert werden, d.h. an diesen gebunden
werden sollen. Der Funktionsname ist damit die einfache Referenz für diese 1 Millionen
Zeilen Code, die ungleich größer und komplizierter sind. Nachdem der Code an den
Funktionsnamen, d.h. an die Referenz dieser Funktion, gebunden wurde, reicht es aus,
wenn man im Hauptprogramm nur noch diesen Funktionsnamen schreibt. Durch das
Schreiben von einer Zeile Code werden 1 Millionen Zeilen Code ausgeführt.
Grundsätzlich bezeichnet der Begriff Binden das Assoziieren von symbolischen Datenreferenzen
mit physikalischen Maschinen-Adressen, d.h. ein symbolischer Bezeichner

2 WAS VERSTEHT MAN UNTER BINDEN ? 4
ist eine Referenz auf eine physikalische Speicheradresse. Binden bezeichnet also das
Verknüpfen eines Namens (Variablenname, Methodenname usw.) mit einer physikalischen
Speicheradresse, d.h. dem Ansprechen von Speicheradressen mit einem Namen.
Dies funktioniert daher auch nicht auf der Ebene der Maschinensprache, da dort keine
Bezeichner mehr vorhanden sind, sondern nur noch die einzelnen Daten in ihrer
Binärdarstellung im Speicher des Rechners vorliegen.
Da in einer Speicheradresse eines Rechners verschiedene Daten, wie beispielsweise Variablen
/ Attribute, Funktion / Methoden usw. abgelegt sein können, kann man auch
all diese an einen symbolischen Namen innerhalb der Programmiersprache, so fern diese
es zulässt, binden.
Ein Beispiel für Funktionsbindung, also das Binden der Speicheradresse an der sich
eine Funktion befindet an eine Variable, ist das untenstehende C-Programm:
Abbildung 2: Beispiel: Funktionsbindung in der Programmiersprache C
In dem obigen Programm werden in den ersten Zeilen zwei Funktionen f1 und f2
definiert, die jeweils den gleichen Rückgabetyp, nämlich int besitzen und die lokale
Integer-Variable x als Übergabeparameter erwarten. Anschließend wird im Hauptprogramm,
das mit der Definition der main-Funktion beginnt, zuerst zwei Integer-Variablen

2 WAS VERSTEHT MAN UNTER BINDEN ? 5
auswahl und x deklariert, wobei die erste die Auswahl des Benutzers im späteren Programmverlauf
speichern und die zweite als Zählervariable innerhalb einer Schleife, die
zur Ausgabe der berechneten Werte auf dem Bildschirm dient, benutzt werden soll.
Danach erfolgt die Deklaration einer besonderen Art von Variablen, eines sogenannten
Funktionszeigers (engl. function pointer).
Ein Funktionszeiger ist eine Variable, in der die Adresse einer Funktion, die sich im
Speicher eines Computers befindet, abgelegt werden kann. Über diese Zeiger-Variable
kann die von ihr referenzierte Funktion im weiteren Verlauf eines Programmes einfach
durch Schreiben des Funktionszeigernamens, d.h. äquivalent zu einem normalen
Funktionsaufruf, aufgerufen werden. Der Funktionszeiger ist also eine Referenz auf eine
Funktion, äquivalent zum Namen der Funktion, jedoch mit dem Unterschied, daß die
Bindung nicht statisch ist, sondern durch Veränderung des Wertes des Funktionszeigers
auf eine andere Speicheradresse während der Laufzeit geändert werden und damit
an eine andere Funktion gebunden werden kann. Funktionszeiger ermöglichen damit
dynamische Bindung an Funktionen.
Im weiteren nicht dargestellten Verlauf des Programms, was durch die drei Punkte
repräsentiert werden soll, wird der Benutzer in einem Menu dazu aufgefordert, entweder
die erste oder die zweite Funktion auszuwählen, von der anschließend eine Wertetablle
im Bereich von 0 bis 10 ausgegeben werden soll. Die Auswahl des Benutzers wird in
der Variable auswahl gespeichert und in der anschließenden if-Bedingung ausgewertet.
Je nachdem ob der Benutzer zuvor die erste oder die zweite Funktion ausgewählt hat,
also abhängig vom Wert der Variablen auswahl wird dem Funktionszeiger func die
Adresse der ersten Funktion f1 oder der zweiten Funktion f2 zugewiesen. Durch diese
Zuweisung wird der Funktionszeiger an die Funktion f1 oder f2 gebunden. Danach kann
durch einfaches Schreiben seines Namens, abhängig von dessen Inhalt, die Funktion
f1 oder f2 aufgerufen werden, was in der nachfolgenden Schleife erfolgt. Innerhalb
der Schleife wird zusätzlich die Schleifenzählvariable x als Parameter der durch den
Funktionszeiger referenzierten Funktion übergeben und anschließend der Rückgabewert
auf dem Bildschirm ausgegeben.
Der gleiche Mechanismus findet sich auch in objektorientierten Programmiersprachen,
beispielsweise in C#, als Methodenzeiger (engl. delegate) oder bei Objective-C in Form
von Selektoren wieder.

2 WAS VERSTEHT MAN UNTER BINDEN ? 6
2.1 Neu-Binden und Mutation
Zwei weitere Begriffe, die häufig im Zusammenhang mit dem Begriff Binden verwendet
werden, sind zum Einen das Neu-Binden“ und zum Anderen die Mutation“. Dabei
” ”
versteht man unter Neu-Binden die Änderung eines referenzierenden Bezeichners
währenddessen Mutation die Veränderung eines referenzierten Wertes bezeichnet.
Die Unterschiede zwischen den beiden Begriffen sollen anhand zweier Beispiele in der
Programmiersprache Java verdeutlicht werden:
Abbildung 3: Beispiel: Neu-Binden in der Programmiersprache Java
Im obigen Beispiel wird in der ersten Zeile eine Referenz mit dem Namen list die ein
Objekt vom Typ LinkedList referenzieren kann deklariert. Da in der Programmiersprache
Java Referenzen standardmäßig mit dem Wert null“ 1 . initialisiert werden, wird
”
die Referenz list an den symbolischen Wert null gebunden. In der zweiten Zeile wird
anschließend ein Objekt vom Typ LinkedList erzeugt und mittels des Gleichheitszeichen-
Operators an die Referenz list gebunden. Es hat also ein Neu-Binden stattgefunden. In
der darauf folgenden Zeile wird die Referenz explizit an den Wert null gebunden und
es findet erneut ein Neu-Binden, also eine Änderung des referenzierenden Bezeichners,
statt.
Abbildung 4: Beispiel: Mutation in der Programmiersprache Java
Das obige Beispiel für die Mutation ist bis auf die dritte Zeile mit dem vorhergehenden
Beispiel für das Neu-Binden identisch. In der dritten Zeile jedoch wird durch
1 In einigen Programmiersprachen existiert dieser spezielle Wert null oder auch NULL, der von der
Ziffer 0 zu unterscheiden ist. Er hat die Bedeutung leer, unbestimmt, ohne Wert
2.1 Neu-Binden und Mutation

2 WAS VERSTEHT MAN UNTER BINDEN ? 7
das Hinzufügen eines Strings-Objektes in das verkettete Listen-Objekt, das verkettete
Listen-Objekt geändert, d.h. der referenzierte Wert, also das Listen-Objekt LinkedList
ändert sich. Es hat hier also die Veränderung eines referenzierten Wertes stattgefunden,
eine Mutation.
2.2 Zeitpunkt des Bindens
Prinzipiell existieren zwei Zeitpunkte, an denen eine Referenz an ein Objekt gebunden
werden kann. Das ist zum Einen, während der Kompilierung eines Programms und
zum Anderen während der Laufzeit eines Programms. Die erste Möglichkeit, also Binden
während der Kompilierung, wird auch als statische Bindung oder auch als frühes
Binden (engl. static binding bzw. early binding), die zweite Möglichkeit, während der
Laufzeit, als dynamisches oder spätes Binden (engl. dynamic binding bzw. late binding)
bezeichnet.
Unterschiede liegen für den Programmierer vor allen Dingen in der höheren Flexibilität
und besseren Erweiterbarkeit bei Verwendung von dynamischen Binden, da während der
Ausführung eines Programms Veränderungen möglich sind. Teilweise muss jedoch bei
Lösungen die dynamisches Binden verwenden auch mit einer schlechteren Performanz
gerechnet werden, da da der Compiler während der Kompilierung aufgrund der dynamischeren
Natur des Programms weniger Annahmen treffen kann und damit weniger
Möglichkeiten zur Optimierung besitzt.
Um spätes Binden zu erreichen müssen verschiedene Sprachmittel eingesetzt werden.
Diese unterscheiden sich je nachdem ob man eine dynamische Programmiersprache, wie
beispielsweise Smalltalk oder Python, oder eine statische, wie beispielsweise Java oder
C++, verwendet. Bei der Verwendung von dynamischen Programmiersprachen lässt
sich spätes Binden durch die Anwendung der dynamischen Typisierung als Sprachmittel
erreichen, während man bei den statischen Programmiersprachen das späte Binden
mittels polymorphen Variablen bzw. Methoden ermöglicht werden kann.
In den nachfolgenden zwei Abschnitten soll daher zuerst die Verwendung von dynamischer
Typisierung und polymorpher Variablen gezeigt werden. In dem darauf folgenden
Abschnitt soll dann gezeigt werden, wie man mit Hilfe dieser Sprachmittel spätes Binden
in den unterschiedlichen Programmiersprachen ermöglichen kann.
2.2 Zeitpunkt des Bindens

3 DYNAMISCHE TYPISIERUNG / STATISCHE TYPISIERUNG 8
3 Dynamische Typisierung / Statische Typisierung
Grundsätzlich bedeutet der Begriff statisch“ in Hinsicht auf Programmiersprachen,
”
daß das Binden während des Kompilierens stattfindet und danach keine Veränderungen
mehr möglich sind (siehe [2]).
Im Gegensatz dazu bedeutet dynamisch“ daß während der Ausführung eines Programms
Veränderungen bezüglich des Bindens vorgenommen werden können.
”
In einer statisch typisierten Programmiersprache wie Java oder Pascal, findet Variablenbindung
während des Kompilierens statt. Das bedeutet beispielsweise, daß die
Variablen-Typen, also beispielsweise integer oder string zur Kompilierzeit festgelegt
sind und sich während der Ausführung nicht mehr ändern können. Während des Kompilierens
werden die Variablentypen an einer Stelle des Speichers gebunden. In einer
dynamisch typisierten Programmiersprache wie beispielsweise Smalltalk oder Python
dagegen, sind Variablen nur Bezeichner und deren Typen werden nur durch deren Werte
definiert und nicht durch eine etwaige vorangegangene Typdeklaration. Die Bindung der
verschiedenen Typen an einen Bezeichner erfolgt während der Programmausführung.
Dies soll an dem folgenden Beispiel in der Programmiersprache Python verdeutlicht
werden:
Abbildung 5: Beispiel: Dynamische Typisierung in der Programmiersprache Python
In diesem Beispiel ist der Bezeichner b nur ein Variablenname, der während der Laufzeit
immer wieder neu an eine neue Speicherstelle und an einen neuen Variablentypen, zuerst
an einen String und dann an einen Integer-Wert, gebunden wird. Dieses Verhalten ist
möglich, da Python die Fähigkeit zur dynamischen Typisierung als Sprachmittel besitzt.

3 DYNAMISCHE TYPISIERUNG / STATISCHE TYPISIERUNG 9
Es erfolgt im Gegensatz zu einer statischen Programmiersprache wie beispielsweise Java
im Quell-Code keine Typ-Deklaration der einzelnen Variablen.
In einer statisch typisierten Programmiersprache wie Java ist dies, wie das folgende
Beispiel zeigt, nicht möglich:
Abbildung 6: Beispiel: Statische Typisierung in der Programmiersprache Java
Da die Variable b bereits im Kopf des Programms statisch als integer-Variable deklariert
wurde, lässt sich ihr innerhalb der main-Methode kein String-Wert mehr zuweisen.
Es kommt daher zu einem Kompilierfehler. Dies lässt sich sowohl als Nachteil- aber
auch als Vorteil bezüglich des Beispiels mit dynamischer Typisierung betrachten. Ein
Nachteil besteht darin, daß sich der Bezeichner b nicht wiederverwerten lässt, der
Vorteil, daß durch die Typprüfung verhindert werden kann, daß nicht unbeabsichtigte
Wertzuweisungen auftreten können.
Ein weiteres Beispiel für dynamische Typisierung findet man in der Programmiersprache
Objective-C, einer hauptsächlich von Brad Cox in den 80er Jahren bei PPI, später Stepstone,
um die Fähigkeit der Objektorientierung entwickelten Erweiterung der Programmiersprache
C. Deren Syntax und Konzeption der objektorientierten Erweiterungen ist
an Smalltalk angelehnt. Bemerkenswerte Eigenschaften von Objective-C gegenüber der
Programmiersprache C++, die ebenfalls einen Ansatz einer objektorientierten Erweiterung
der Programmiersprache C darstellt (der jedoch auf Simula zurückgeht), sind
u.a. das späte Binden von Methoden und die Typlosigkeit, die beide auf Smalltalk
zurückgehen.
Im unteren Beispiel wird ein Ausschnitt einer Klasse gezeigt, die einen Knoten in einer
einfach verketteten Liste darstellen soll. Dabei ist das Attribut LinkedListNode*
next ein Zeiger auf das nächste Element der Liste und das Attribut id data der Inhalt

3 DYNAMISCHE TYPISIERUNG / STATISCHE TYPISIERUNG 10
den ein Listenelement speichern kann. Damit die Liste jeden beliebigen Typ aufnehmen
kann, ist die Variable data vom Typ id. Id ist in ObjectiveC ein Variablentyp der alle
Objekttypen aufnehmen kann, so daß die Liste alles speichern kann.
Abbildung 7: Beispiel: Dynamische Typisierung in der Programmiersprache Objective-C
3.1 Duck-Typing und die halbdynamische Sprache Boo
Ein Beispiel für eine Sprache die sowohl dynamische Typisierung als auch statische
Typisierung unterstützt ist die Programmiersprache Boo. Boo ist eine seit 2003 von
Rodrigo Barreto de Oliveira entwickelte OpenSource-Programmiersprache für das Microsoft
.NET Framework und die Java Virtual Machine (boojay). Die Syntax ist stark an
die von Python angelehnt, da es das ursprüngliche Entwicklungsziel war, eine pythonähnliche
Sprache zu entwickeln, die jedoch auch die Fähigkeit besitzt auf die .NET
und JVM-Bibliotheken zugreifen zu können. Boo ist statisch typisiert, wobei dem Programmierer
das explizite Binden von Variablen an Typen durch Typinferenz und Generische
Typen großteils erspart wird. Daneben wird auch das langsamere, von Ruby
übernommene Duck Typing 2 , also dynamische Typisierung geboten. Dadurch ist sie
2 Duck-Typing ist ein Konzept der Objektorientierung, das die Anwendbarkeit bestimmter Verfahren
nicht an die Ableitung der Klasse von einer bestimmten Superklasse oder der förmlichen Implementierung
einer Spezifikation knüpft, sondern an das Vorhandensein bestimmter Merkmale. Der Name
leitet sich aus einem Gedicht des amerikanischen Schriftsteller James Whitcomb Riley ab. Darin heißt
es: ”When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call
that bird a duck.”[6]
3.1 Duck-Typing und die halbdynamische Sprache Boo

3 DYNAMISCHE TYPISIERUNG / STATISCHE TYPISIERUNG 11
auf der explizit für statisch typisierte Sprachen ausgelegten CLR 3 recht schnell, ohne
auf die Flexibilität einer dynamischen Skriptsprache verzichten zu müssen.
Abbildung 8: Beispiel: Duck Typing in der Programmiersprache Boo[5]
Im obigen Beispiel wird in der ersten Zeile die Variable d als eine Variable vom Typ
duck deklariert. Eine Variable vom Typ duck kann in der Programmiersprache Boo
jeglichen Wert annehmen. In der zweiten Zeile wird der Variablen dann ein Integer-
Wert zugewiesen und in den nächsten Zeilen damit arithmetische Operationen und
eine Bildschirmausgabe durchgeführt. Anschließend wird der Variablen ein String zugewiesen
und anschließend eine String-Operation auf ihr ausgeführt. Wie man erkennen
kann, ist das Verhalten der Variablen nur abhängig davon welchen Wert sie besitzt.
Hier zeigt sich das Prinzip des Duck-Typings: ”
Wenn es geht wie eine Ente, schwimmt
wie eine Ente und quakt wie eine Ente, dann behandle ich es wie eine Ente“ .
3 CLR - die Common Language Runtime ist eine von Microsoft entwickelte Softwareplattform.
Diese umfasst eine Laufzeitumgebung, eine für Programmierer bestimmte Sammlung von Klassenbibliotheken
(API), und angeschlossene Dienstprogramme (Services).
3.1 Duck-Typing und die halbdynamische Sprache Boo

3 DYNAMISCHE TYPISIERUNG / STATISCHE TYPISIERUNG 12
3.2 Vor- und Nachteile bei dynamischer / statischer Typisierung
Grundsätzlich kann man feststellen, daß sich die Vor- und Nachteile bei dynamischer
und statischer Typisierung gegenseitig die Waage halten. Die Vorteile die man bei
statischer Typisierung besitzt sind gleichzeitig aber auch die Nachteile der statischen
Typisierung. Das gleiche gilt umgekehrt auch für die dynamische Typisierung.
Statische Typisierung
• Vorteile:
– bessere Fehlererkennung (während des Kompilierens)
– schnellere Ausführungsgeschwindigkeit der Programme
• Nachteile:
– geringere Flexibilität
– schlechtere Erweiterbarkeit / Wiederverwendbarkeit
Dynamische Typisierung
• Vorteile:
– höhere Flexibilität
– bessere Erweiterbarkeit / Wiederverwendbarkeit
• Nachteile:
– schlechtere Fehlererkennung
– langsamerere Ausführungsgeschwindigkeit der Programme
3.2 Vor- und Nachteile bei dynamischer / statischer Typisierung

4 POLYMORPHE VARIABLEN 13
4 Polymorphe Variablen
Statische Programmiersprachen, wie beispielsweise Java, können dynamisches Binden
im Gegensatz zu dynamischen Sprachen wie Python, nicht mit Hilfe von dynamischer
Typisierung erreichen, da ihnen dieses Sprachmittel fehlt. Um jedoch trotzdem dynamisches
Binden bei Methoden zu ermöglichen wird dies durch Verwendung von Polymorphie
4 und dabei insbesondere unter Verwendung von polymorphen Variablen und
Methoden erreicht.
Im nachfolgenden Beispiel wird gezeigt, wie ein Drucker-Objekt mittels Verwendung
polymorpher Variablen sowohl an die Variable drucker vom Typ Drucker gebunden
werden kann, als auch an die Variable ausgabegeraet (also an zwei unterschiedliche
Variablentypen und nicht nur an einen bestimmten Typ). Diese Eigenschaft ermöglicht
erst spätes Binden (late binding).
Abbildung 9: Beispiel: Verwendung polymorpher Variablen
Ausgabegeraet ausgabegeraet;
Monitor monitor;
Drucker drucker;
ausgabegeraet
ausgabegeraet
= monitor; // OK
= drucker; // OK
drucker = ausgabegeraet; // nicht OK !
4 Polymorphie (griechisch Vielgestaltigkeit) ist die Fähigkeit eines Bezeichners, der ein Literal oder
eine Variable repräsentieren kann, sich abhängig von seiner Verwendung unterschiedlich darzustellen.
Sie erlaubt es dem Bezeichner, je nach Kontext einen unterschiedlichen Datentyp anzunehmen.

5 DYNAMISCHE- / STATISCHE-BINDUNG 14
5 Dynamische- / Statische-Bindung
Statisches Methodenbinden bezeichnet das bereits im zweiten Abschnitt erwähnte statische
Binden eines Bezeichners an eine Methode und ist die Standard-Aufrufweise
bei statischen Programmiersprachen wie beispielsweise Java und C++ (zum Beispiel
myObject.myMethod()). Das heißt, es existiert ein direkter Verweis auf die zu verwendete
Methode bzw. Funktion während der Kompilierzeit.
Die Voraussetzungen für statisches Methodenbinden sind zum Einen, daß die aufgerufene
Methode zur Kompilierzeit existiert und deren Signatur dem Compiler bekannt
sein muß und zum zweiten, daß die Bindung an zur Kompilierzeit bekannte Typen,
Interfaces oder Oberklassen erfolgen muß.
Abbildung 10: Beispiel: UML-Diagramm Klassenhierarchie bei Polymorphie

5 DYNAMISCHE- / STATISCHE-BINDUNG 15
Ein Beispiel für dynamisches Binden in Java:
Abbildung 11: Beispiel: Dynamisches Binden in Java

5 DYNAMISCHE- / STATISCHE-BINDUNG 16
Bei dynamischer Bindung erfolgt die Bindung nicht durch den Aufruf einer Referenz der
Implementierung, sondern durch das Schicken von Nachrichten an ein Object (message
passing / dynamic dispatch). Das Object selbst schaut dabei zur Laufzeit nach, ob es
eine passende Implementierung (Methode) besitzt, die zur Nachricht passt. Falls es
diese nicht besitzen sollte, kann es entweder eine Fehlermeldung ausgeben oder die
Nachricht an ein anderes Objekt weiterschicken, was als forwarding bezeichnet wird.
Ein Beispiel in Objective-C: Nach dem Beginn der main-Funktion wird eine Variable
namens ausgabegeraet deklariert die vom Typ id ist. Der spezielle Variablen-Typ id
besitzt in Objective-C die Eigenschaft, daß er jedes Objekt binden kann. Durch diese
Art der Typisierung kann dann im weiteren Verlauf des Programmes der Variablen
ausgabegeraet sowohl ein Objekt vom Typ Monitor als auch vom Typ Drucker zugewiesen
werden, da die Variable ausgabegeraet ja vom Typ id ist. Anschließend kann
an die Variable ausgabegeraet dann die Nachricht ausgabe geschickt werden und das
dahinterstehende Objekt (also drucker bzw. monitor) führt die Methode ausgabe anschließend
aus. Es ist kein Polymorphismus nötig wie in Java, da Objective C eine
dynamische Sprache ist.
Abbildung 12: Beispiel: Dynamisches Binden in Objective-C

5 DYNAMISCHE- / STATISCHE-BINDUNG 17
Auch bei Python ist, ähnlich wie bei Objective-C, kein Polymorphysmus notwendig
um Late-Binding zu erreichen. In dem folgenden Beispiel werden die Klassen Monitor
und Drucker deklariert, die beide die Methode ausgabe() besitzen. Danach werden
im Hauptprogramm zwei Instanzen (Objekte) der beiden Klassen erzeugt. Anschließend
wird, was aufgrund der dynamischen Typsierung der Programmiersprache Python
möglich ist, einfach einer neu eingeführten Variablen namens ausgabegeraet entweder
das Monitor-Objekt oder das Drucker-Objekt zugewiesen. Daraufhin kann über die
Referenz ausgabegeraet die Methode ausgabe des entsprechenden Objekts aufgerufen
werden.
Abbildung 13: Beispiel: Dynamisches Binden in Python

5 DYNAMISCHE- / STATISCHE-BINDUNG 18
5.1 Unterschiede zwischen dynamischer und statischer Bindung
Statisches Methodenbinden ist schneller, da es zum einen keinen Overhead bezüglich
des Methodenaufrufs gibt und zum anderen Inlining 5 möglich ist. Daß kein Overhead
bei statischem Methodenbinden bezüglich des Methodenaufrufs vorhanden ist, ergibt
sich aus der Tatsache, daß der Computer nicht mehr während der Laufzeit des Programmes
suchen muß, wo (Methoden können beispielsweise in Objective-C per forwarding
in anderen Klassen aufgerufen werden) und welche Methode (Methoden können
sich in Ober- oder Unterklassen befinden) er erst aufrufen muss. Dies erfolgt beim
statischem Methodenbinden alles schon während der Kompilierzeit. Dadurch ist außerdem
auch Inlining möglich, was bedeutet, daß der Compiler während des Kompilierens
die komplette Methode an die Stelle des Methodenaufrufs setzt, so daß der Rechner
während der Laufzeit nicht mehr mit großem Aufwand zwischen den Methoden hinund
herspringen muß. Dies macht sich insbesondere innerhalb von Schleifen bemerkbar.
So kann man sich vorstellen, daß sich schon ein erheblicher Unterschied ergibt,
ob der Computer innerhalb einer Schleife, die 1 Million mal ausgeführt wird, zwischen
zwei Funktionen, mit entsprechender Parameterübergabe über den Stack, hin- und herspringen
muß, oder ob der Code der Funktion einfach innerhalb der Schleife eingesetzt
wurde. C++ besitzt das Schlüsselwort inline für Funktionen / Methoden mit dem man
dem Compiler anzeigen kann, daß man die damit markierte Methode / Funktion als
inline-Funktion haben will.
Bei dynamischer Bindung ergibt sich das Problem, daß der Compiler während des
Kompiliervorgangs noch nicht wissen kann, ob und wann eine Methode überhaupt aufgerufen
wird und er auch nicht sagen kann, ob die Übergabe- und Rückgabetypen
überhaupt zueinanderpassen. Das heißt, daß bei dynamischen Programmiersprachen
eventuell Fehler erst während der Laufzeit auftreten, die in statischen Programmiersprachen
schon während des Kompilierens auffallen und korrigiert werden können bevor
das Programm ausgeliefert wird.
5 Bei kleinen Unterprogrammen fällt der Aufwand zum Aufruf des Unterprogrammes verglichen
mit der vom Unterprogramm geleisteten Arbeit stärker ins Gewicht. Daher versuchen Compiler, den
Maschinencode kleinerer Unterprogramme direkt einzufügen. Diese Technik wird auch als Inlining
bezeichnet. In manchen Programmiersprachen ist es möglich, durch inline-Schlüsselwörter den Compiler
darauf hinzuweisen, dass das Einfügen von bestimmten Unterprogrammen gewünscht ist. Das
Einfügen von Unterprogrammen eröffnet oft, abhängig von den Parametern, weitere Möglichkeiten
für Optimierungen.
5.1 Unterschiede zwischen dynamischer und statischer Bindung

6 FAZIT 19
6 Fazit
In dieser Seminarbeit wurde versucht die Begriffe dynamisch“ und statisch“ im Kontext
von Programmiersprachen und des Zeitpunkt des Bindens darzulegen. Weiterhin
” ”
sollten die Vor- und Nachteile von dynamischer - und statischer Typisierung aufgezeigt
und deren Verwendung als Sprachmittel in Hinsicht auf die Realisierung von
frühem und spätem Binden gezeigt werden. Auch sollte gezeigt werden, daß man den
grundsätzlichen Widerspruch zwischen den Vor- und Nachteilen von dynamischer und
statischer Programmierung nicht auflösen kann und sich je nach Anwendung für die
für das Projekt passende Variante entschieden werden muss.
Grundsätzlich kann man festhalten, daß, wenn man auf die Performanz der Ausführung
und eine bessere Fehlererkennung der Programmen Wert legt, man statische Programmierung
bevorzugen sollte, falls höhere Flexibilität, Erweiterbarkeit und Produktivität
gewünscht wird, dynamische Programmierung.

LITERATUR 20
Literatur
[1] Binding (computer science) - Wikipedia
http://en.wikipedia.org/wiki/Binding (computer science)
Zugriffsdatum: 02.12.2008
[2] Dai, L.: Static and Dynamic Behavior
http://www.seattleu.edu/dingle/web/510/chapter11.ppt
acstaff, 2007
Zugriffsdatum: 02.12.2008
[3] Anonymous: Dynamic binding, binding evaluation contexts, and (delimited) control
effects
http://www.okmij.org/ftp/Computation/dynamic-binding.html
okmij.org, 2007
Zugriffsdatum: 02.12.2008
[4] H.-C. Stotts: Dynamic Method Binding, Inheritance
http://www.rockfish.cs.unc.edu/COMP144/lect24a.ppt
University of North Carolina, 2007
Zugriffsdatum: 02.12.2008
[5] Rodrigo Barreto de Oliveira: Boo Tutorial Part 18 - Duck Typing
http://boo.codehaus.org/Part+18+-+Duck+typing
Zugriffsdatum: 02.12.2008
[6] Duck-Typing - Wikipedia
http://de.wikipedia.org/wiki/Duck-Typing
Zugriffsdatum: 02.12.2008
LITERATUR

ABBILDUNGSVERZEICHNIS 21
Abbildungsverzeichnis
1 Beispiel: Binden in Python . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Beispiel: Funktionsbindung in der Programmiersprache C . . . . . . . . 4
3 Beispiel: Neu-Binden in der Programmiersprache Java . . . . . . . . . 6
4 Beispiel: Mutation in der Programmiersprache Java . . . . . . . . . . . 6
5 Beispiel: Dynamische Typisierung in der Programmiersprache Python . 8
6 Beispiel: Statische Typisierung in der Programmiersprache Java . . . . 9
7 Beispiel: Dynamische Typisierung in der Programmiersprache Objective-C 10
8 Beispiel: Duck Typing in der Programmiersprache Boo[5] . . . . . . . 11
9 Beispiel: Verwendung polymorpher Variablen . . . . . . . . . . . . . . 13
10 Beispiel: UML-Diagramm Klassenhierarchie bei Polymorphie . . . . . . 14
11 Beispiel: Dynamisches Binden in Java . . . . . . . . . . . . . . . . . . 15
12 Beispiel: Dynamisches Binden in Objective-C . . . . . . . . . . . . . . 16
13 Beispiel: Dynamisches Binden in Python . . . . . . . . . . . . . . . . 17
ABBILDUNGSVERZEICHNIS