 Ja, wir kommen zurück zur Veranstaltung Programmierparadigmen im Sommersemester 2020 an der Uni Stuttgart. Das hier ist das dritte Themenmodul innerhalb dieser Veranstaltung, in dem es um Namen, Scopes und Bindings in Programmiersprachen geht. Speziell ist das der erste Teil des Moduls, in dem ich einen kleinen Überblick darüber gebe, um was es hier eigentlich gehen soll. Schauen wir uns vielleicht erstmal an, was überhaupt Namen in Programmiersprachen sind. Alles, was man benennen kann, hat den großen Vorteil, dass man es nicht jedes Mal im Detail beschreiben muss, sondern man kann einfach den Namen verwenden. Also Namen sind sowohl in Programmiersprachen als auch in der normalen natürlichen Sprache eine Form von Abstraktion, die uns helfen, bestimmte Details einfach nicht jedes Mal wieder aufzuzählen. In Programmiersprachen passiert diese Abstraktion insbesondere auf zwei Arten und Weisen. Zum einen abstrahieren wir mithilfe von Namen von der Hardware, auf dem das Programm schlussendlich ausgeführt wird. Also zum Beispiel abstrahieren variablen Namen weg, wie genau Werte im Speicher eigentlich abgelegt werden und welche Art von Speicher auf dem Hardware-Level dafür vielleicht verwendet wird. Wenn ich das Programm schreibe, interessiert mich das zumindest nicht unbedingt und ich kann einfach den Namen dafür verwenden, ohne dass ich mich jetzt darum hören muss, wie das auf die Hardware abgebildet wird. Die zweite Art und Weise, wo Abstraktion mithilfe von Namen ständig stattfindet, ist, dass bestimmte Funktionalität und wie genau die implementiert ist, durch Namen abstrahiert wird, nämlich in der Regel in der Form von Funktionsnamen. Also was so eine Funktion im Prinzip macht, ist, da ist ein Stück Code, was beschreibt, was passiert, wenn diese Funktion ausgeführt wird. Also das ist die Beschreibung einer bestimmten Funktionalität, beziehungsweise deren Implementierung. Und ich kann diese ganze Implementierung einfach referenzieren, indem ich den Namen der Funktion verwende und dann gar nicht genau wissen muss, was dahinter steckt, sondern alles, was ich brauche, um so eine Funktion aufzurufen, ist eben der Name. Der zweite Begriff, der im Titel dieses Moduls auftaucht, ist Binding und weil es vielleicht auch etwas ist, was nicht jedem so geläufig ist, sage ich erst mal kurz, was damit gemeint ist. Also ein Binding ist diese Assoziation zwischen einer Entität, einem Ding und dem Namen, den wir diese Entität zuordnen. Also zum Beispiel gibt es ein Binding zwischen einer Variable oder dem Variable im Namen und dem Speicherobjekt, was dahinter steht. Oder es gibt auch ein Binding zwischen einer Funktion beziehungsweise dem Funktionsnamen und dem Code, der diese Funktion implementiert. Und dieses Zusammenstecken von Namen und Ding, was benannt ist, das nennt man Binding. Wie genau die Bindings funktionieren, das variiert wie so oft von Programmiersprache zu Programmiersprache. Und wir werden im Laufe dieses Moduls verschiedene Arten und Weisen ansehen, wie diese Bindings funktionieren. Vielleicht als kleinen Vorgeschmack, zwei Arten von Bindings, die es in verschiedenen Programmiersprachen gibt, Aesthetic Binding und Dynamic Binding, wo jeweils zur Laufzeit oder eben statisch festgelegt wird, welchen Namen genau an welche Dinge gebunden sind. Der dritte Begriff im Titel des Moduls ist Scope und auch hier wieder eine kurze Erklärung, was das eigentlich ist. Also zum einen gibt es den Scope eines Bindings und das ist einfach nur die Region im Programmtext, in der ein Binding aktiv ist. Also wenn ich einen Namen an ein bestimmtes Ding, zum Beispiel eine bestimmte Stelle im Speicher binde, dann ist das nicht immer und überall so, sondern das gilt nur an einem bestimmten Teil des Programms und üblicherweise ist dieser Teil des Programms eine Textregion innerhalb des Source-Codes. Das ist das Scope von einem bestimmten Binding und dann gibt es auch noch den Begriff Scope allgemein und was der in der Regel beschreibt, ist eine Region im Text oder eine Stelle im Text, in der sich keine Bindings ändern. Also innerhalb dieses Scopes bleiben die Bindings immer dieselben und sobald wir diesen Scope verlassen, können die Bindings natürlich wieder anders sein. Hier unten auf der Folie sehen wir ein kleines Beispiel und zwar Python Code, in der wir drei Variablen x und y haben und eine Funktion f und entsprechend der Scoping-Regeln von Python, die wir auch noch ein bisschen genauer anschauen werden, gibt es hier zwei Scopes, nämlich zum einen den äußeren Scope, der außerhalb dieser Funktion f definiert ist und in der gibt es genau nur einen Binding, nämlich das x diese Variable benennt, in der erstmal eins gespeichert ist. Außerdem gibt es noch den Scope dieser Funktion f, also innerhalb dieser Funktion gibt es einen eigenen Scope und hier gibt es jetzt auch wieder eine Variable x, allerdings ist das nicht das selbe Stück Speicher, wie das andere x aus dem äußeren Scope, weil das eben eine andere Variable ist, die hier nur lokal in dieser Funktion f definiert ist und außerdem gibt es in diesem inneren Scope, in diesem Scope der Funktion f auch noch eine Variable y und wenn wir jetzt die Zuordnung in der letzten Code-Seile haben, wo x nach y geschrieben wird, meint das eben diese beiden Variablen, die innerhalb von f definiert sind, also y zeigt schlussendlich auch auf ein Stück Speicher, in dem der wer 2 gespeichert ist. So, jetzt haben Sie eine ungefähre Idee darüber, was diese drei Begriffe im Titel dieses Modules überhaupt bedeuten. Hier ist jetzt ein kleiner Überblick, worum es im Rest des Modules noch gehen soll und zwar sind das vier Teile, die dann jeweils ein Video wieder sind. Also im ersten Teil bzw. im zweiten nach diesem allerersten geht es um Object Lifetime, d.h. also die Lebenszeit von Objekten, d.h. wie lange existieren Dinge überhaupt im Speicher und wie wirkt sich das auf die Namen auf, mit denen ich auf diese Dinge im Speicher zugreifen kann und wie wird das ganze Speichertechnisch überhaupt gemanagt und inwiefern hilft die Programmiersprache dabei. Der nächste Themenblock ist dann zum Thema Scopes, wo wir uns genauer anschauen, wie diese Scopes überhaupt in verschiedenen Programmiersprachen definiert sind und auf was man achten muss, wenn man diese eine oder diese andere Sprache benutzt, weil da nämlich die Scopes anders funktionieren. Dann schauen wir uns Early Async and Overloading an. Das sind so zwei Spezialfälle von dieser Assoziation zwischen Namen und Dingen, die benannt werden, wo wir nämlich entweder zwei Namen haben, die auf dasselbe Ding zeigen oder eben einen Namen haben, der auf zwei verschiedene Dinge zeigen kann, je nachdem in welchem Zusammenhang der Name verwendet wird. Und dann schlussendlich schauen wir uns noch die sogenannten Referencing Environments an oder Referenzumgebung, wo es darum geht, dass sich all die Bindings, die an einem bestimmten Zeitpunkt während der Ausführung existieren, abspeichern kann, um sie dann an irgendeiner Stelle wieder zu benutzen und wenn das gut ist, sehen sie dann in dem entsprechenden Teil. Ja, und das soll es dann auch schon wieder gewesen sein für diesen allerersten Teil dieses Moduls. Und ja, damit danke fürs Zuschauen und bis zum nächsten Mal.