Sehr schön. Ja, herzlich willkommen zur letzten Vorlesung SE1.
Es tut mir ganz schrecklich leid,
aber nächste Woche werdet ihr mich hier nicht treffen.
Das heißt, wir müssen uns jetzt erstmal vorläufig verabschieden.
Heute werde ich zwei Teile haben.
Mal wieder bis zur Pause. Ein bisschen nochmal Stoff,
so Einführung eigentlich in die Programmierung von und mit Grafen.
Es geht gar nicht so sehr um Grafen,
Grafen ist wieder sozusagen die Fachlichkeit.
Und wir versuchen dann diese Fachlichkeit mal abzubilden in Software
und wie
man damit programmieren kann
Das steht im Vordergrund, das ist so die erste Hälfte.
Und in der zweiten Hälfte werde ich dann auf ein paar Preise zu sprechen kommen.
Ich muss Preise verteilen. Es sind also Studierende hier,
die noch von mir Preise bekommen. Warum werdet ihr da noch
sehen? Und dann werden wir auf die Lehrerevolution gucken.
Die ist ja durch. Ich habe die Ergebnisse vorliegen und
wir können dir hier nochmal besprechen. Ich freue mich,
dass überhaupt noch so viele von euch da sind.
Ich meine, es ist ja immer die letzte Vorlesung.
Das ist sehr, sehr erfreulich und ich danke euch,
dass ihr mir noch hier so ein bisschen Aufmerksamkeit schenkt.
Okay, Grafen. Haha, Grafen. Also wenn ich
das richtig mitbekommen habe, ich habe jetzt den Hinweis bekommen,
dass in diskreter Mathematik natürlich auch das Thema Grafen behandelt wird.
Ihr werdet das da natürlich sehr viel ausführlicher tun.
Hier ist es jetzt so, sagen wir nur mal,
am Rande gestriffen. Aber ich habe jetzt auch das Skript bekommen,
freundlicherweise, sodass ich auch mal abgleichen konnte,
ob unsere Terminologie nun fürchterlich von der abweicht in DM,
weil das wäre ja doof, wenn ihr jetzt hier irgendwie andere Begriffe bekommt von uns.
Also das ist schon eigentlich weitgehend DM-konform.
Sollte also keine großen Schwierigkeiten machen
Ja, warum beschäftigt man sich überhaupt mit Grafen? Ja,
es ist halt so, dass man, wenn man ein bisschen drüber nachdenkt,
man in fast allen Kontexten irgendwie mit Grafen zu tun hat.
Das heißt, wenn ihr euch Streckennetze öffentlicher Verkehrsmittel anseht,
dann ist das letztendlich ein Graf, in dem die Stationen
Knoten sind und die Bahnverbindungen oder Busverbindungen sind dann die Kanten oder Verbindungen.
Vernetzte Rechner, welcher Rechner kann welchen erreichen? Logistik,
ein etwas konkreteres Beispiel hier. Eine Fluggesellschaft soll prüfen können,
ob zwischen zwei Flughäfen irgendwie Verbindung hergestellt werden kann, mit der eigenen Gesellschaft,
also ob man da tatsächlich innerhalb des eigenen Netzes fliegen kann.
Die Flughäfen sind dann Knoten und die Flugverbindungen sind Kanten in einem Grafen.
Ein weiteres Beispiel ist jetzt in der Übungsleiterrunde angesprochen worden.
Facebook. Es gibt ja so dieses komische Facebook. Ich meine,
ich bin da auch und habe aber nur meine Güte,
man muss da halt irgendwie sein und er ist nicht sehr aufregend, finde ich.
Aber es gibt halt Leute, die sind da sehr interaktiv und
sehr aktiv. Und da ist es natürlich auch so,
dass man ja eigentlich sagen kann, also wenn man das abstrahiert,
die müssen ja auch Software haben bei Facebook, irgendwie alle Leute,
die bei Facebook sind, sind Knoten, Ja, das ist lustig.
Und die Leute haben dann irgendwie ja Verbindungen zueinander, sind zum Beispiel befreundet.
Man kann ja auf Facebook mit verschiedenen Leuten befreundet sein.
Und üblicherweise ist das so eine beidseitige Geschichte.
Also wenn ich jetzt irgendwie sage, ich will mit jemandem
befreundet sein, dann kann ja mit meiner Freundschaftsanfrage annehmen.
Und in dem Moment sind wir sozusagen wechselseitig befreundet.
Es gibt nicht so was wie einseitige Freundschaften.
Also es ist dann nicht mehr so richtig eine Freundschaft.
Und dann ist es natürlich auch wieder spannend, naja,
wie viele Freunde hat denn jemand? Das seht ihr,
wenn ihr euch einloggt bei Facebook, dann seht ihr als erstes,
du hast 64 Freunde oder 128 oder 512,
wie auch immer
Das sind alles letztendlich Algorithmen auf Grafen, die da rattern,
um das zu ermitteln. So ganz banal, weil einfach,
dass ein Riesengraf ist, der bei Facebook verwaltet wird.
Ich weiß nicht, mit mehreren hundert Millionen Teilnehmern und entsprechend vielen Verbindungen zwischen diesen Knoten.
Ich würde euch bitten, nicht mehr zu reden.
Es ist sehr laut. Es sind also irgendwie,
ich höre immer von da so einen Redeschwall hier rüber und ich fürchte,
dass die Leute, die drumherum sitzen,
das nicht so angenehm finden, wenn laut gesprochen wird.
Vielen Dank. Okay, also wenn wir jetzt einfach mal sagen
, Es lohnt sich, man kann sofort Anwendung sehen,
es lohnt sich, sich mal mit Grafen zu beschäftigen.
Und insbesondere jetzt hier, SE1, eher Programmierveranstaltung,
wie kann man denn so Grafen programmieren? Um erst mal
so ein bisschen gucken, was Grafen eigentlich sind. Und ja,
wenn man jetzt so ein bisschen die mathematischen Definitionen hernimmt,
also das ist eine Menge von Objekten mit einer Relation auf diesen Objekten.
Also formal ist ein gerichteter Graf üblicherweise,
sagen wir jetzt mal hier, gerichteter Graf ein Graf,
ist ein Paar von zwei Mengen, nämlich einer Knotenmenge und einer Kantenmenge.
Die Knoten werden gerne mit V,
die Knotenmenge wird gerne mit V bezeichnet,
Vertex,
Und die Kanten sind die Edges also eh.
Und formal ist eh dann eine zweistellige Relation auf diesen,
auf dem Kreuzprodukt dieser beiden, dieser Knotenmengen.
Also das E ist dann das Kreuzprodukt der Knotenmengen.
Bildliche Darstellung eines Knotens durch einen kleinen Kreis.
Klar, so hier und gerichtete Kante durch einen Pfeil.
Das ist ein Beispiel für einen gerichteten Graf. Und das
ist auch sehr anschaulich. Man sieht sofort, ja,
der hat drei Knoten und da sind irgendwie gerichtete Kanten irgendwie so.
Man kann da irgendwie, irgendwie ist seine Verbindung, was immer das bedeutet.
Das ist ja hier schon sehr abstrakt. Wir haben jetzt
hier nicht irgendwie Facebook oder sonst irgendwas als Fachlichkeit,
irgendwelche allgemeinen Grafen? Ja, und dann gibt es natürlich
eine ganze Reihe, ein ganzes Panoptikum von Grafen.
Ich habe hier noch mal eine kleine Auswahl,
weil man kann da durchaus noch das ein oder andere mehr dazunehmen an Begriffen.
Das zum Beispiel ist ein gerichteter Graf,
wenn die Kanten also irgendwie so Pfeile haben,
dann kann man sagen, der Graf ist gerichtet.
Das hier ist ein ungerechneter Graf,
also ohne irgendwelche Pfeilspitzen an den Verbindungen, mit symmetrischen Beziehungen.
Dann hat man hier sowas auch so etwas ungerechtet und dann auch vollständig.
Also wenn in einem Knoten, in einem Grafen jeder Knoten,
in einem anderen Knoten eine Verbindung hat, dann heißt der Graf vollständig.
Im Skript steht er noch irgendwie vollständig zusammenhängend,
das ist so eine der Punkte,
wo ich dann mal die Terminologien mal angepasst habe an DM.
Dann gibt es diesen Begriff von Zusammenhangskomponenten,
also so ein Graf, wie dieser hier oben rechts,
der besteht hier aus sieben Knoten und einigen Kanten.
Und man sieht dann, dass eben halt nicht alle Knoten
irgendwie über mit anderen Knoten verbunden sind.
Das heißt, man sieht hier, das ist eine Zusammenhangskomponente,
das ist eine andere Zusammenhangskomponente.
Ja, also dann gibt es sowas wie gewichtete Grafen
Das heißt, da werden die Kanten dann irgendwie bewertet,
üblicherweise mit irgendeiner Aufwandsfunktion, dass man sagt,
es kostet so und so viel von dem Knoten,
zu dem Knoten zu kommen.
Jedes Navigationssystem funktioniert genau so. Also man hat irgendwie Knoten und kann dann berechnen,
wie viel Strecke man braucht und möglicherweise auch noch andere Aufwandsfunktionen.
Es muss ja nicht nur Strecke sein, es kann ja auch teilweise sein,
wie schnell ist das, wie teuer ist das,
wenn da noch Maut bezahlt werden muss und ähnliches.
Also da gibt es verschiedene fachliche Möglichkeiten,
wie man so eine Bewertung von den Kanten vornehmen kann.
Und die ganzen Grafen, die hier so auf der Folie aufgeführt sind, zyklisch.
Das heißt, es gibt mindestens einen Pfad, auf dem
ein Knoten zweimal vorkommt. Der Begriff des Pfades ist unscharf,
also in DM wird da eigentlich etwas genauer differenziert.
Da gibt es dann irgendwie Kantenfolgen. Also einfach nur,
wenn ich mehrere Kanten hintereinander mir angucke, dann ist das eine Kantenfolge.
Dann gibt es sowas wie Kantenzüge, wenn bestimmte,
wenn keine Kante doppelt vorkommt in so einer Kantenfolge
und wenn dann noch nicht mal mehr Knoten doppelt vorkommen,
dann spricht man eigentlich von einem Weg.
Da kommen wir nochmal drauf auf Wege in Grafen
Ja, wie gesagt, ich glaube,
das ist so für so die Fachlichkeit, dass ihr wisst,
worüber wir hier reden, ist das ausreichend.
Wir müssen da jetzt nicht in die Theorie der Graphen einsteigen.
Spannender ist jetzt eigentlich, wie implementiert man denn sowas?
Also wenn man jetzt irgendwie Graphen braucht in einer bestimmten Anwendung,
wie macht man das denn dann? Wie geht man denn
da ran? Und da gibt es natürlich mehrere Möglichkeiten,
wie immer. Könnt ihr euch schon besser überlegen,
weil wir ja schon gelernt haben, mit dieser Veranstaltung,
es gibt sowas wie die Schnittstelle,
das war jetzt gerade was so Graphen so an Eigenschaften haben.
Und dann kann man das unterschiedlich implementieren. Habt ihr schon gesehen.
Man kann fast alles auf mindestens zwei Weisen implementieren, meistens mehr.
Und auch bei Dafür gibt es zwei beliebte Methoden, nämlich Adliatenz Matrizen.
Und hat ja Zenslisten. Zwei Knoten, U und V sind Adliatent,
benachbart, wenn sie durch eine Kante verbunden sind.
So. Ja, erstmal wieder nur Begriffe. Jetzt gucken wir
es mal an, so eine Art Jazz-Matrix. Nehmen wir
mal einen ungewichteten Grafen. Da soll das so sein,
dass falls es eine Kante von I nach J gibt,
dann soll in dieser Matrix dieser Eintrag für diese Kantenverbindung True
Da haben wir hier mal so einen Beispielgraphen.
Man sieht hier, er ist gerichtet, aber auch ungewichtet.
Und man möchte jetzt irgendwie das modellieren und dann kann man
das eben tun über eine Abjazzenz-Matrix. Man sieht hier
zum Beispiel Knoten 1 hat eine Verbindung zu Knoten 2,
also sieht man hier irgendwie, da ist eine 1,
wenn eine Verbindung existiert von Knoten 1 zu Knoten
2. Und von Knoten 1 zu Knoten 4 ist offensichtlich
auch eine, man sieht das hier.
Von 2 ist eine zu 4 und so weiter.
Also da ist immer eine 1 eingetragen,
wenn da eine Verbindung besteht oder eine Kante existiert und eine Null,
wenn das nicht der Fall ist
Ja, für gewichtete Grafen, also wenn es darum geht,
jetzt irgendwie diese Aufwandsfunktion damit reinzubeziehen, dann können diese Kosten damit eingetragen werden.
Da hat man nicht nur die Unterscheidung. Und wie näher ist da
eine Verbindung oder nicht, sondern man kann da die Kosten eintragen.
Wenn wir jetzt mal hier einen gewichteten Grafen haben und ich erzähle diese Kanten,
Gewichte mal eintragen, also irgendwelche Beispiele hernehmen,
wie hier in der Zeichnung, dann sieht das halt vielleicht so aus,
dass man dann eben halt sowas einträgt, irgendeinen Merker,
irgendeinen Eintrag, irgendwas, was eben halt deutlich macht,
da ist keine Verbindung,
hier ist jetzt mal irgendwie sowas
wie unendlich eingetragen
Und hier ist zum Beispiel dann von 1 nach 2,
ist dann das Kantengewicht 6. Also hier sieht man
die 6 und von 2 nach 1 ist dann 5,
also das ist genau von 2 nach 1. Also ja,
man kann das hier sehr schön ablesen.
Ja, jetzt könnt ihr euch überlegen,
dass es natürlich relativ groß werden kann, so eine Matrix,
wenn man irgendwie mehrere hunderte oder mehrere hundert mehrere tausend Knoten hat,
dann kann das schon sehr, sehr groß werden.
Deswegen gibt es eine andere Möglichkeit, das sind die Abjazzenzlisten.
Da verfügt jeder Knoten über eine Liste seiner Nachfolgeknoten,
Und zusätzlich ist es möglich, dass alle Knoten irgendwie direkt zugreifbar sind.
Also auch hier wieder ein Graf, der gleiche wie auf der vorigen Folie.
Und ich mache das so, dass ich sage,
ich habe irgendwie ein Array. Das ist jetzt erst mal so,
sagen wir, was in vielen Lehrbüchern so drinsteht,
wo es noch nicht unbedingt so objektorientiert modelliert ist.
Wir gucken es jetzt gleich mal so ein bisschen objektorientiert an.
Aber hier sagen wir mal, das ist ein Array von Knoten.
Also für jeden Knoten gibt es einen Eintrag in dem Array.
Das ist so ein bisschen wie in der Hash-Tabelle,
die ihr kennt. So, jetzt habe ich hier irgendwie
Darin irgendwie verkettet die Knoten, die Nachfolger sind.
Also eins hat eine Kante zu zwei und zu vier.
Oder zwei hat eine Kante zu eins und zu vier und so weiter.
Also die sind dann hier sozusagen eingetragen. Das heißt,
man hat eigentlich zu jedem Knoten eine Liste seiner Nachbarn.
Okay, das ist ganz günstig, weil man weniger Platzbedarf hat.
Eine Matrix ist halt schnell groß. Und man kann eigentlich
auf alle seine Nachfolgeknoten so in Linealzeit zugreifen.
Das kennt ihr noch aus der Hash-Tabelle. Also wenn ich jetzt irgendwie erstmal weiß,
von welchem Knoten ich die Nachbarn will,
Ich kann also schnell zugreifen hier auf einen bestimmten Knoten und kann dann sagen,
gib mir mal die Nachbarn, dann kann man uns hier nicht hier einfach linear durchgehen und alle Nachbarn abarbeiten.
Wenn immer man das braucht. Bei Bedarf kann man natürlich
auch inverse Adjazenzlisten machen, also wo man nicht Nachfolger vermerkt, sondern Vorgänge.
Wenn es gerichtet ist. Ja, das ist ja ganz
schön. Wie gesagt, das ist so die Standard-Sprechweise,
die man auch oft so in Algorithmen-Büchern findet.
Und man kann das jetzt ein bisschen mal so objektorientiert versuchen zu modellieren.
Und wir haben ja jetzt hier in der Veranstaltung schon gelernt,
Listen und Mengen und so weiter.
Also wenn wir jetzt mal überlegen, Wenn wir jetzt Grafen haben,
in denen es nicht mehrere Kanten geben kann, zwischen zwei Knoten.
Also immer nur genau eine Kante gibt, wie in diesen Beispielen hier,
dann ist es eigentlich so, dass wir sagen können,
dass jeder Knoten über eine Menge von seinen Nachbarknoten verfügt.
Also einfach jeder Knoten hat eine Menge von Nachbarknoten.
Weil entweder ist ein Knotennachbar oder nicht. Das heißt also,
da kann man eigentlich von einer Menge sprechen, ist ein bisschen passender.
Und dass alle Knoten über einen Array zugreifen,
da sträuben sich natürlich und schon die Nackenhaare,
weil wir ja wissen, Arrays sind ein Low-Level-Konzept.
Da sollte man vielleicht einmal überlegen, das ist eigentlich auch eine Menge.
Ich habe also ein Graf ist eine Menge von Knoten und ja
, dann kann man das hier mal so rauskicken.
Und dann sagt man, wir machen das mal anders,
machen eine objektorientierte Modellierung und sagen einfach mal,
wie bauen wir das denn jetzt in OO in Java zum Beispiel?
Und eine mögliche objektorientierte Modellierung, das ist nicht die einzige.
Es ist auch ganz wichtig, dass es eben halt bei
der Modellierung immer ganz viele Möglichkeiten gibt. Und eine Modellierung,
die wir jetzt hier mal ein bisschen genauer ins Ansehen werden,
weil wir auch ein Projekt dazu haben in den Übungen,
ist, dass es eine Klasse gibt, die die Knoten modelliert.
Das ist, glaube ich, ganz gut nachvollziehbar,
nachdem wir jetzt so ein Semester lang mit Java umgegangen sei,
sollte das euch nicht mehr so erstaunen, dass man sagen kann,
naja, halt eine klasse Knoten und jedes Exemplare von ist dann ein Knoten.
Und dann gibt es üblicherweise schon mal mehrere Möglichkeiten für die Kanten.
Man kann es so machen, dass man sagt,
ein Knoten hält Referenzen. In Java geht das ja
sehr gut. An Knoten hält Referenzen auf seine Nachbarknoten.
Dann ist sozusagen die Kanten implizit da. Dann hat man
also keine eigene Klasse dafür geschrieben. Oder man modelliert tatsächlich
erst als eigene Klasse. Da hat man eine Klasse.
Knoten und eine knasse Kante und dann muss man irgendwie
dafür sorgen, dass dann irgendwie die beieinander eingetragen werden.
Das ist also irgendwie zum Beispiel ein Knoten dann eine Menge von Kanten hat.
Und dass es bei einer Kante dann irgendwie eingetragen ist,
Anfangsknoten und Endknoten, zum Beispiel. Das ist relativ aufwendig und in der Modellierung,
die wir uns gleich genauer ansehen werden, ist es eben so,
dass es etwas einfacher gemacht ist, nämlich einfach,
dass ein Knoten Referenzen hält auf andere Knoten.
Naja, und dann haben wir eben halt eine Klasse,
die dann den ganzen Grafen modelliert und die hält einfach eine Menge von Knoten.
Das heißt also, so ein Graf wie diesen hier,
der nur aus einer Zusammenhangskomponente besteht oder auch Grafen auf den vorigen Folien,
wo dann tatsächlich ein Graf durchaus aus mehreren Zusammenhangskomponenten bestehen kann,
da wird einfach gesagt, eine Klasse modelliert den Graphen insgesamt und hält einfach eine Menge von Knoten.
Ja, da habe ich doch mal wieder ein Blue-Jay-Projekt.
Und das ist auch das Projekt, was ihr in den
Übungen benutzen werdet. Die Übungen habt ihr ja wahrscheinlich mitbekommen,
dieses Aufgabenblatt 14, das ist natürlich total freiwillig,
also eher für die Leute von euch,
die noch Spaß an der Programmierung haben,
obwohl sie jetzt ein Semester lang gequält wurden damit.
Das ist eigentlich ein ganz schönes Projekt und ich will auch
das jetzt mal so ein bisschen vorstellen,
wenn man daran eben so ein paar Dinge zeigen kann.
Also, wir haben tatsächlich diese Modellierung, die wir hier
gerade schon besprochen haben, mehr wenn ihr so umgesetzt gebt.
Also eine Klasse für Knoten. Es gibt eine Klasse für den Grafen.
Die Kanten sind implizit über Referenzen abgelegt. Was wir auch gebaut haben,
also das sind sozusagen die beiden Klassen, in denen irgendwie was passiert,
üblicherweise sogar nur in der Klasse Graf, müssen irgendwelche Aufgaben bearbeitet werden.
Und dann gibt es aber hier noch so drei andere Klassen,
die eigentlich nur dazu da sind, so ein Grafen mal zu visualisieren.
Ich habe also hier so ein bisschen was gebaut damals,
schon ein paar Jahre her.
Und dann wird eben halt tatsächlich hier so ein Graf angezeigt.
Das ist jetzt tatsächlich ein Graf, der schon vorher abgelegt ist,
der dann auch sehr realisiert ist, also auch gespeichert wird.
Und wenn man das beendet und wieder startet, Sieht ja wieder genauso aus.
So, und dann sieht man hier jetzt einfach mal so einen Grafen.
Und was ihr seht, erstens ist er irgendwie ungerichtet.
Es gibt also keine Pfeilspitzen. Und die Knoten können ja
so ein bisschen durch die Gegend bewegt werden.
Das ist so ein bisschen nett gemacht. Und die Kanten
sollen aber auch gewichtet sein. Das heißt,
das soll irgendwie hier die Möglichkeit geben, so was wie kürzeste Wege zu berechnen.
Ja, und was man hier eben sieht, ist,
dass eigentlich der Graf hier insgesamt, also ein Graf,
wie er da so ist,
visualisiert wird und dass man dann jetzt zum Beispiel auch ein bisschen manipulieren kann.
Also ich kann jetzt hier zum Beispiel sagen,
ich möchte einen neuen Knoten haben, zack, neuen Knoten,
da habe ich ihn.
Und wenn ich jetzt irgendwie zwei Knoten irgendwie verbinden will,
dann kann ich tatsächlich sagen, hier eine neue Verbindung.
Und dann sagt er hier, bitte erst ein Gewicht von 1 bis 999 angeben.
Es gibt also keine Gewichte, kleiner Null.
Das ist auch wieder ein fachlicher, fachlicher Einschränkung.
Gibt wieder andere Grafen, wo das wieder anders ist.
Bei diesem Grafen ist es eben halt so.
Es ist auch ganz angenehm, dass man das weiß,
dass hier die Gewichte mindestens eins sind. Ja,
wenn ich jetzt eine Verbindung angeben will, also sage ich mal hier zehn,
jetzt kann ich sagen, neue Verbindung, dann sagt er,
ich will mal den Start knoten, ich nehme mal den hier.
Und das ist mein Zielknoten
Und dann habe ich hier eine Verbindung. Und dann kann
ich hier sozusagen mir so einen Graf zusammenklicken, interaktiv.
Das ist ganz hübsch visualisiert, ist auch farblich,
sagen wir, interessant in dem Sinne,
dass ihr raten könnt, warum das Ding hier Mongraf heißt.
Die Kunstbeflüssen unter euch können da vielleicht irgendwie was,
genau, wer die Lösung hat, kann sie mir einschicken.
Ich gebe aber keine Snickers mehr raus. Ist klar. Gut,
auf jeden Fall, das hier ist nur die Visualisierung.
Und was wir hier tatsächlich dann auch visualisieren,
wenn also jetzt tatsächlich ich diese Main-Methode gestartet habe und das Ding hier läuft,
dann kann ich hier auch interaktiv jetzt an dieser Klasse Hauptfenster sagen,
gib mir mal den visualisierten Graf
Und den kann ich mir jetzt hier auf die Objektleiste legen.
Und dann habe ich den gleichen Graf,
den ich hier sozusagen interaktiv manipulieren kann,
habe ich den auch hier so als Blue-Jay-Referenz jetzt liegen.
Und die Idee ist, dass man das so macht,
damit man auch mal so ein paar Sachen testen kann.
Wir werden gleich mal was implementieren hier auf dem Graf.
Und da wäre es natürlich schön, wenn man da jetzt aufpasst,
dass man, wenn man den hier manipuliert, ihn nicht verändert.
Also idealerweise sollte man hier nur sondierende Methoden aufrufen.
Also zum Beispiel sowas wie Anzahl Knoten. Wenn wir jetzt
zum Beispiel hier drauf gucken, wie viele Knoten sind das?
Zwei, vier, sechs, acht, zehn, zwölf.
Das heißt, wenn ich jetzt hier aufrufe,
gib mir mal die Anzahl Knoten,
sollte da zwölf rauskommen und siehe da, es kommen zwölf raus.
Das ist auch jetzt nicht überraschend. Dann sind hier aber auch
noch so ein paar andere Operationen implementiert, zum Beispiel Anzahl der Zusammenhangskomponenten.
Das wären in dem Fall hier jetzt zum Beispiel vier.
Ich sehe hier irgendwie eine große Zusammenhangskomponente und drei einzelne Knoten.
Das sind also vier Zusammenhangskomponenten. Und wenn wir das jetzt aufrufen,
dann kommt da natürlich nichts raus, weil es noch nicht implementiert ist.
Das Projekt, was ihr bekommt, da müsst ihr eben halt
genau sowas implementieren. Ja, und dann ist hier auch
sowas drin wie kürzester Weg von einem Knoten zu einem anderen.
Das ist ganz spannend. Wie gesagt, wenn man so
diese Fragen beantworten will, wie komme ich denn jetzt am besten von hier nach da?
Das wird bei großen Grafen sehr schnell interessant,
bei so Grafen wie diesem hier ist das noch sehr leicht.
Da ist jetzt die Möglichkeit, also meinetwegen von da nach da zu kommen,
da kann über die 23er-Kante genommen werden oder die 12 plus 15,
27er kannte, das ist dann irgendwie offensichtlich,
wie man da irgendwie gehen sollte.
Aber sobald der Graf etwas komplexer wird und größer,
wird man da sicherlich Computerunterstützung benötigen und jedes Navigationssystem arbeitet
genau so
Genau. Und ich kann also, wie gesagt,
hier dann auch diese Sachen iterativ interaktiv aufrufen. Gut,
das ist jetzt erstmal nur, wie das Ding sich benutzen lässt.
Und jetzt gucken wir uns das mal an, wie es implementiert ist.
Also ich habe ja schon gesagt, eine Klasse für den Knoten.
Also erste Idee war, Knoten halten, eine Menge von Nachbarn.
Also jeder Knoten hat eine Menge seiner Nachbarknoten.
Und dann ist es sozusagen implizit durch die Referenzen ist da
ein gerichteter Graf realisiert. Die Kanten werden also durch Java-Referenzen
realisiert. Das sieht hier mal so aus. Ach,
hier steht noch Public, auch unschön,
also eigentlich nur Glas Knoten
Und hält intern ein Set auf Knoten.
Eine Menge von Knoten und das sind die Nachbarn des Knoten.
Kann man sich ganz gut vorstellen. Dann wird hier
ein Hashtag angelegt. Dann kann man irgendwie fragen,
ob eine Verbindung zu einem anderen Knoten da ist.
Dann muss man einfach nur sagen, ja,
wenn mein Nachbar, meine Nachbarmenge diesen Knoten enthält,
dann habe ich eine direkte Verbindung.
Ich kann auch direkt verbinden, dann wird das hier entsprechend eingetragen
in diese Menge. Und ich kann die Verbindung auch trennen.
Okay, das ist schon fast so implementiert.
Dann, wir gehen da gleich nochmal genau drauf ein.
Und dann haben wir ein Grafheld eine Menge von Knoten
Für einen ungerichteten Graf muss garantiert sein, das für eine
Verbindung Zweierknoten, beide Knoten wechselseitig als Nachbarn eingetragen sind.
Okay, das ist dann auch wieder hier ganz einfach gelöst.
Wir haben also eine Klasse Graf und die hält eine Menge von Knoten.
Das sind die Knoten des Grafen, das ist sozusagen die Knotenmenge.
Auch da machen wir hier irgendwie eine Initalisierung und dann kann man hier neue Knoten hinzufügen.
Das wird dann von dieser grafischen Oberfläche auch einfach mal aufgerufen,
wenn ein neuer Knoten hinzugefügt wird.
Und hier sieht man jetzt dieses Verbinde direkt. Ich möchte also
zwei Knoten miteinander verbinden im Grafen und weil es ein ungerichteter Graf ist,
muss man in beide Richtungen navigieren können.
Deswegen müssen beide Knoten gegenseitig als Nachbarn eingetragen werden.
Also sage ich K1, verbinde mit K2 und K2 verbinde mit K1.
Das dann dazu führt, dass man eigentlich hier sozusagen überall
diese wechselseitigen Referenzen einträgt. Ja, und dann,
wenn eben halt, wenn man fragen will,
ob ein Knoten überhaupt im Grafen enthalten ist.
Denn ich kann ja hier auch einfach mir jetzt
ein Exemplar von dieser Klasse erzeugen. Knoten hier,
neuer Knoten, irgendwie muss man eine Nummer angeben.
Na, machen wir mal 42, damit wir hier irgendwas Richtiges machen.
So, jetzt haben wir hier einen Knoten und der
ist natürlich jetzt nicht Teil des Grafen.
Der wird auch nicht visualisiert, dieser Knoten. Klar,
also man muss ihn erst in den Grafen eintragen,
dann passiert da was.
Und das sollte man, wie gesagt,
nicht tun auf dieser Ebene
Weil diese Visualisierung das nicht mitbekommt. Also diese Visualisierung geht davon aus,
dass alles, was verändert an dem Grafen, passiert,
über diese GUI passiert. Das ermöglicht uns,
dass wir hier diese Klassen Graf und Knoten einfach komplett freihalten können von irgendwelchen Sachen wie,
oh, ich habe mich geändert, wer immer mich visualisiert,
muss jetzt mal eben das mitkriegen.
Das ist da alles nicht drin. Also das ist
wirklich pure Fachlichkeit. Hier haben wir wirklich pur die Idee
von Knoten und einem Grafen implementiert.
So, ja. Und jetzt, wie gesagt,
haben wir hier diese Grafmenge. Wir können ja mal
den Graf von uns angucken,
die Klasse Graf
Diese Klasse modelliert, gewichtete, ungerichtete Grafen,
über die Schnittstelle können Knoten und gewichtete Kanten in einen Grafen eingeführt werden.
Ah ja, dann kommt dann was mit dem Interface Interrible,
das gucken wir uns gleich mal an.
Aber man sieht jetzt hier diese verschiedenen Operationen,
also ein neuer Knoten wird hier eingetragen, entferne Knoten.
Und man sieht tatsächlich, hier haben wir eine Menge von Knoten als Knotenmenge.
Ja, so. Jetzt ist es so,
wir wollen ja, ihr seht das hier in der Darstellung,
dass das ein gewichteter Graf ist.
Das heißt, die Kanten sollen ein Gewicht bekommen.
Die Frage ist jetzt, wo speichern wir jetzt dieses Gewicht ab?
Wir haben ja keine Klasse kannte, in der wir das
jetzt ablegen können. Dann wäre das ja ganz einfach,
da macht man einfach eine Exemplarvariable in einer Kante,
die das hält und dann kann man die irgendwie bei einer Kante abfragen, das Gewicht.
Haben wir nicht. Da ist natürlich jetzt eine andere Möglichkeit
und das ist auch genau hier implementiert,
dass ein Knoten nicht einfach nur eine Menge seiner Nachbarn hält,
sondern eine Map von Nachbarn.
Das heißt, er hält eine Abbildung von seinen ganzen Nachbarn.
Eine Map wisst ihr, das ist das,
was hier auf der Folie drauf ist.
Eine Map ist eine Abbildung von einem Schlüssel auf einen Wert
Und die haben wir irgendwie in der Vorlesung sieben oder was mal schon mal gesehen.
Und die gibt es tatsächlich auch im Collections Framework, solche Maps.
Und was man hier benutzen kann in diesem Grafenbeispiel ist,
dass wir sagen, ja,
wir machen einfach eine Map von dem Nachbarknoten auf den Wert der Kante.
Also hier Map statt Z in den Knoten. Also eben
haben wir gesagt, ein Knoten hält eine Menge seiner Nachbarn.
Hier sagen wir jetzt, ein Knoten hält eine Map seiner Nachbarn.
Und in einer Map, in einer Abbildung sind halt,
das erste ist der Schlüssel, der muss eindeutig sein.
In einem Grafen ist ein Knoten entweder drin oder nicht
Das heißt also, ups, das ist wieder das Bewegungsproblem mit meiner Maus. Also eine Map,
das heißt also auch hier wird eine Hashmap angelegt und dann hat man hier tatsächlich,
wenn ein neuer, wenn ein Knoten gefragt wird,
ob er einen Nachbarn hat,
dann wird eben halt in dem Keyset der Map nachgeguckt.
Also das sind sozusagen zwei Mengen, die eine Map hält,
nämlich eine Menge von Schlüsselwerten, eine Menge von Werten.
Und man kann in dieser Keyset, also in der Schlüsselmenge,
also in den Knoten direkt fragen dann, ob da das K enthalten ist.
Naja, und dann ist es natürlich auch so,
wenn ich jetzt verbinde mitsage,
dann gebe ich ja ein Gewicht mit an,
Wenn ich einen Knoten mit einem anderen verbinde.
Und dann trage ich halt diesen in meine Nachbar-Map diesen Knoten ein,
mit zusammen einem Gewicht. Also hier einem Integer mit dem entsprechenden Gewicht.
Und somit können wir jetzt sozusagen in einem Knoten halten,
wie weit der Weg ist zu seinen Nachbarn.
Also erstmal hat er eine Menge von seinen Nachbarn und
immer noch mit in dieser Map mit drin,
wie weit es denn ist, mal anschaulich gesprochen.
Und dann kann man sich eben halt hier genau das Verbindungsgewicht geben lassen von einem Knoten,
wenn jetzt ich zum Beispiel einen Knoten frage, hey,
wie weit bist du denn weg von dem Knoten?
Dann ist der Knoten hier der Ah. Ist das K
, das ich übergebe? Und dann prüft er erst
mal nach, ob der überhaupt drin enthalten ist.
Also er lässt sich aus dieser Menge das K geben.
Und wenn es ungleich nall ist, dann ist es wohl drin.
Und dann kann man tatsächlich hier von dem entsprechenden Gewicht sich den In-Value geben lassen.
Ja, das ist einfach nur erst mal die Modellierung.
Und das ist auch tatsächlich hier im Quelltext genauso vorzufinden.
Also hier der Graf. Gucken wir uns noch mal eben
den Knoten genauer an, damit ihr jetzt nicht das Gefühl habt,
dass ich euch hier überrumpel.
Also diese Klasse modelliert Knoten einem Graf und ein Knoten
kennt alle seine Nachbarknoten,
mit denen
ihr direkt verbunden ist
Für jeden Nachbarn ist eine ganze Zahl gespeichert, die das Gewicht der Verbindung modelliert.
Auch diese Klasse implementiert das Interface Iterrible, das werden wir uns gleich ansehen,
was das für uns bedeutet, wie praktisch das ist.
So ein Knoten hat auch irgendwie eine Nummer,
das ist noch so ein bisschen Relikt aus alten Zeiten,
das braucht man eigentlich gar nicht, so eine Art Identifikation,
dass man einen Knoten irgendwie, dass jeder Knoten eine Nummer hat,
braucht man nicht für die Aufgaben, die er bearbeiten sollt.
Zeuge einen neuen Knoten mit einer Nummer und so weiter.
Und dann hat man hier,
die kann man die Nummer abfragen und dann ist aber hier
das mit dem Iterator und hier hat jetzt zum Beispiel,
hat Verbindung zu, Keysaid Contains, verbinde mit,
damit das einfach in diese Map eingetragen
Und man kann sich das Verbindungsgewicht geben lassen. Also das ist alles genauso,
wie es eigentlich auf den Folien eben erklärt war. Ja,
so und dann haben wir sozusagen hier unseren Knoten erklärt und
jetzt haben wir halt in unserem Grafen verschiedene Operationen, die ihr implementieren sollt.
Also das verbindet direkt ist schon da,
ob ein Knoten enthalten ist, ist ja auch schon implementiert.
Die Anzahl der Knoten ist implementiert, nicht schwindelig werden,
ich rolle hier so ein bisschen. Und dann haben wir
jetzt hier zum Beispiel verbunden. Wenn ich mir mal das hier angucke,
wenn ich euch fragen würde, durch Draufschauen,
ist dieser Knoten hier, aber ich kann auch mit Steuerung,
kann ich zwei Knoten selektieren, so diese beiden Knoten hier.
Sind die miteinander verbunden? Da sagt ihr natürlich sofort durch Draufschauen,
nee, die sind nicht verbunden, da sehen wir sofort.
Für den Computer ist das nicht ganz so leicht,
also wenn die das programmieren wollt, wenn ihr diese Frage programmatisch beantworten wollt,
dann ist das nicht ganz so einfach.
Dann zum Beispiel, ob dieser Knoten jetzt mit diesem Knoten hier verbunden ist. Klar,
naja, da muss man halt irgendwie jetzt sich überlegen,
wie man da irgendwie ja alle Nachbarn durchgeht und das dann irgendwie,
das ist also eine klassische Aufgabenstellung in einem Grafen,
sind zwei Knoten miteinander verbunden und das lässt sich
wunderbar rekursiv lösen
Das ist ein klassisches Beispiel für einen rekursiven Algorithmus. Und
wenn ihr das selbst mal baut, und das würde ich euch empfehlen,
wenn ihr Spaß daran habt, dann werdet ihr merkt,
dass es durchaus nicht ganz so einfach ist.
Ich würde gleich nochmal so ein bisschen was dazu sagen,
wie man da vorgehen kann.
Was ich mal eben zeigen wollte, ist eine Aufgabe,
die ihr auch auf dem Aufgabenblatt drauf ist.
Ihr sollt für den Grafen den maximalen Grad ermitteln.
Bei einem Grafen ist der maximale Grad seiner Knoten,
der Gerade eines Knotens ist die Menge seiner Nacht, die Anzahl seiner Nachbarn.
Also zum Beispiel dieser Knoten hier hat eins, zwei,
drei, vier, fünf, sechs Nachbarn.
Dieser hat einen, dieser hat zwei und so weiter.
Dieser hat null. Und man soll jetzt für einen Grafen
ermitteln, was der maximale Grat ist.
Also in diesem Fall wäre das tatsächlich sechs. Also der
Knoten mit den meisten Nachbarn, der hat sechs Nachbarn.
Ja, und das ist auch relativ leicht zu bauen.
Ich kann das hier erstmal beenden vielleicht.
Dann gucken wir uns jetzt mal den Graf an.
Ich baue jetzt hier einfach mal,
und das will ich einfach nur mal zu zeigen,
wie nett man jetzt diese Knoten und Grafen
hier benutzen kann
Ich nehme mal eine, ich baue hier jetzt mal rein,
Public, Int, Max Grat. So,
und da soll jetzt sozusagen dieser Graf die Frage beantworten,
was ist der maximale Grat? So, wer hat jetzt
mal eine Idee, wie man das implementieren kann?
Also wie finde ich jetzt raus bei diesem Grafen,
was der maximale Grat ist?
Wie ist ein Lösungsvorschlag her? Wir gehen alle dumm durch,
berechnen lieber zu dem Grat. Ich weiß nicht,
ob es schon implementiert ist,
vielleicht sonst nicht
Noch miteinander zu schleifen. Und dann heißt der neue Grad
größer ist als Debatte, der vorher von Netzskropen hat,
dann übernehmen wir das in einer Variante.
So ist das. Okay, er sagt, wir gehen einfach
durch alle Knoten durch. Wir haben also hier die Knotenmenge,
das ist ja, das sind die ganzen Knoten des Grafen.
Also machen wir das mal und der sagt,
man soll sich irgendwie eine Variable anlegen, die den maximalen Grad berechnet.
Also nehmen wir mal hier irgendwie in Max Grad,
ist mal anfangs anfänglich null,
weil wir nehmen einfach mal an, es kann ja sein,
dass in einem Grafen alle Knoten nicht verbunden sind.
So, und jetzt gehen wir durch alle Knoten durch
In der Knotenmenge. Und das ist wieder so
ein Beispiel für die wunderbare Anwendung der erweiterten Vorschleife.
Ich kann jetzt einfach sagen, vor Knoten K in dieser Knotenmenge.
Für jeden Knoten K in der Knotenmenge mache irgendwas.
Und schwupps kann ich jetzt hier irgendwas machen.
Und am Ende schreibe ich dann irgendwie Return, Max Grad
und in dieser Schleife ermittle ich jetzt den maximalen Grad.
Und er hat auch schon eben richtig gesagt,
was ich machen muss, ist,
ich muss jetzt bei jedem Knoten eigentlich ermitteln,
was sein Grad ist.
Kann man jetzt gucken,
ist es beim Knoten implementiert
Der Grad ist nicht implementiert, deswegen müssen wir es selber machen.
Deswegen eine weitere Vorschleife. Also sage ich jetzt hier einfach vor,
ich kann jetzt wieder über alle Knoten,
über alle Nachbarn eines Knoten iterieren, auch mit der erweiterten Vorschleife.
Ich kann wieder schreiben vor Knoten, Nachbarn von diesem Knoten K,
den ich jetzt gerade betrachte, allen Knoten.
Da sage ich jetzt einfach mal, was mache ich dann?
Ich zähle sozusagen die Nachbarn. Ja,
da sage ich hier jetzt irgendwie, ich muss jetzt wahrscheinlich
hier eine lokale Variable haben, irgendwie in Grad.
Das ist der Grad, ist einen Knotens, eines Knotens.
Dann sage ich hier irgendwie Grad
Plus Plus. Und schon bin ich eigentlich durch. Das heißt,
ich habe jetzt bei einem einzelnen Knoten zähle ich seine Nachbarn
und erhöht dann diesen Grad. Und dann habe ich hier,
wenn jetzt if Grad ist größer als Max Grad,
dann muss ich natürlich, wir kennen das,
Max Grad ist dann der neue Wert ist dann,
der gerade ermittelte Grad
Und der Grad sollte natürlich sinnvoll initialisiert werden.
Richtig. Also ist das hier null. Vielen Dank für
den Hinweis. So, nachvollziehbar, was da passiert.
Denke schon, oder? Also wir gehen einfach für den Grafen
durch alle Knoten durch. Bei jedem Knoten sagen wir,
gehen wir durch alle Nachbarn durch und in jeder Schleifendurchlauf,
wo wir durch die Nachbarn durchgehen, erhöhen wir einfach diesen Zähler.
Das heißt, hinterher wissen wir, was der Grad des einzelnen Knoten ist.
Wenn dieser Grad höher ist, als der bisher gemerkte maximale Grad,
dann habe ich den Max gerade erhöht.
Das heißt, das müsste jetzt übersetzbar sein? Wunderbar. Und
jetzt habe ich tatsächlich hier meinen Hauptfenster nach wie vor,
kann also jetzt das Ding wieder starten.
Und der Graf ist immer noch derselbe. Und jetzt kann
ich hier mal sagen, was ist der maximale Grat?
Das kann ich jetzt leider nicht hier über diese Googy machen,
das haben wir nicht gebaut.
Also muss ich jetzt hier so ein bisschen wieder diesen kleinen Umweg gehen,
muss hier mal eben mit den Grafen geben lassen.
Lassen wir den wieder unten hinlegen und kann jetzt aber hier aufrufen,
Max Grat, habe ich gerade implementiert, kann ich jetzt auch aufrufen.
Da sollte ich jetzt Sex rauskommen, toll.
Also es hat tatsächlich geklappt. Wir haben also mal eben
on the fly hier Max Grat implementiert und das war Überhaupt nicht schlimm.
Ging eigentlich ganz einfach. Ja, gut, gut.
Das einfach mal zu dieser Implementation und da gibt es
eben halt noch so ein paar mehr Aufgaben wie,
ob zwei Knoten verbunden sind und der kürzeste Weg.
Das ist jetzt zum Beispiel was, da geht es jetzt
darum, man muss dann irgendwie durch den Knoten durchlaufen.
Und dabei soll oft jeder Knoten nur einmal bearbeitet werden.
Das heißt, wir haben,
wenn wir durch so einen Grafdurchlauf natürlich mehrere Möglichkeiten da durchzulaufen,
könnt ihr euch überlegen, gerade beim ungerichteten Graf,
gibt es da durchaus mehrere Pfade und es können Zyklen auftreten
So, und was man dann üblicherweise macht,
wenn man so irgendwie durch so einen Graf durchläuft,
ihn traversiert, man macht eine Buchführung.
Hat jemand mal irgendwie einen Fisherman oder sowas? Ich habe gerade
so ganz akute Probleme irgendwie hier. Hat jemand sowas dabei
, so einen Fisherman oder irgendwas zum Lutschen oder was?
Nee. Nichts. Okay, ich werde es schon schaffen.
Ich muss es wahrscheinlich ein bisschen Kaffee trinken.
Schade. Da ist er. Ah, toll.
Vielen, vielen Dank
Ein Vival, das hilft mir viel. Oh. Nicht
verlieren. Großartig. Vielen, vielen Dank. So,
also wenn wir durch so einen Grafen durchlaufen,
das müssen wir zum Beispiel machen, wenn wir wissen wollen,
ob zwei Knoten verbunden sind oder wenn wir den kürzesten Weg ermitteln wollen.
Das heißt, wir müssen irgendwie Buchführung machen.
Und wenn man durch so einen Grafen durchläuft,
macht man halt, haben wir bei Bäumen schon gesehen,
man kann so einen breiten Durchlauf machen oder
einen tiefen Durchlauf auf die erreichbaren Knoten
Und dabei kann man dann die Knoten, die man schon
besucht hat, markieren. Und dann dadurch, dass man
bereits markierte Knoten nicht nochmal besucht, mehrfach Besucher vermeiden kann.
So einen tiefen Durchlauf lässt sich sehr schön rekursiv implementieren.
Und diese Markierung schon besucht, muss man natürlich dann zurücksetzen,
wenn man wieder sozusagen frisch eine Anfrage an den Grafen stellt.
Das mit den Markierungen von den Knoten ist eine Möglichkeit.
Eine andere Möglichkeit ist einfach, dass ich als derjenige,
der gerade den Durchlauf macht durch den Grafen,
Dass ich eine Buchführung habe und mir merke,
welche Knoten ich schon besucht habe.
Ich kann zum Beispiel mir eine Menge definieren und diese Menge
packe ich immer die Knoten rein, wo ich schon war.
Man kann sich relativ schnell feststellen,
wenn ich einen neuen Knaut-Knoten aufnehme in meine Traversion,
ob ich da schon war oder nicht,
muss nur meine Menge fragen.
Das ist also alles möglich? Und als besonderes Bonbon kommen wir
jetzt nochmal zur Fragestellung, wie man den kürzesten Pfad in einem Grafen ermittelt.
Das ist nicht ganz trivial. Also wenn ihr erstmal versuchen solltet,
werdet ihr merken, dass das durchaus nicht so einfach
ist.
Was heißt kürzeste Pfad
Oder auch kürzester Weg. In einem gewichteten Grafen haben wir
also hier diese Kantengewichte und kann irgendwie Kosten modellieren,
wie auch immer, haben wir schon drüber gesprochen.
Und jetzt stellt sich die Frage zum Beispiel hier,
was ist der kürzeste Weg zwischen S und Z?
Also hier haben wir den Knoten S und hier haben wir den Knoten Z.
Und was ist der kürzeste Weg? Und da sehen wir
jetzt schon durch Draufschauen, ist das nicht so ganz einfach zu beantworten.
Da kann jeder mal so ein bisschen gucken und ein bisschen knobeln,
aber das ist nicht so, sagen wir sofort einsichtig.
Und das ist natürlich auch eine Aufgabe,
da ist ein Computer wieder super für geeignet.
Das ist einfach Man muss mal einmal programmieren,
da hat man die Abfrage immer so schnell wie möglich beantwortet.
Also, das braucht man natürlich an verschiedenen Stellen,
brauche ich übrigens nicht erläutern, dass man sowas braucht wie kürzeste Wege.
Man hört zum Brouting im Internet,
dass man da die Pakete nicht zu weit schickt oder im Netz
von Versorgungsleitungen oder einfach nur kürzeste Wege in einem öffentlichen Verkehrsnetz.
Also suchen wir jetzt diesen... Mann, Mann, Mann.
Kürzesten Pfad. Und die meisten Algorithmen oder viele Algorithmen basieren auf diesem Optimalitätsprinzip.
Das heißt, wenn ich einen bestimmten Pfad habe,
Von U0 nach UZ über U1 und so weiter.
Und das ist, ich weiß, dass es der kürzeste Pfad ist,
dann weiß ich auch, dass jeder Teilpfad davon,
von diesem Pfad auch ein kürzester Pfad sein muss.
Ganz einfache Grundannahme. Und was heißt, wenn ich in
kürzesten Pfad finden will, dann muss ich von kürzesten Teilpfaden ausgehen.
Das heißt, ich konstruiere mir aus kurzen,
kürzesten Faden immer längere kürzeste Pfade.
Das ist auch die Idee des Deixtra-Algorithmus,
der heißt tatsächlich so,
Deixtras-Algorithmus oder der Wellenalgorithmus
Und dann hat er schon 1959 formuliert.
Das ist irgendwie ganz cool. Der gute Herr Darkstar ist
ja inzwischen auch gestorben. Aber 1959, ich meine,
da waren Computer, die mit solchen Visualisierungen noch weit weg.
Und da hat er aber schon eigentlich diesen Grafen-Algorithmus entworfen.
Gut, klar, ist ja auch mathematisch formulierbar. Und die Idee,
die er hatte, war von einem Startknoten,
von dem ich ermitteln will, aber mit dem Zielknoten,
was der kürzeste Weg ist, sind nicht eine equitistante Welle aus.
Die sukzessive weitere Knoten erfasst, bis man sozusagen den Zielknoten
erreicht hat. Und da hat man drei Knotenmengen.
Einmal die Menge der gewählten Knoten
Das ist die Menge der Knoten, wo man den kürzesten Weg schon weiß.
Also von dem Startknoten S. Da war sie einfach, bei denen weiß ich,
wie sicher, das ist der kürzeste Weg bisher bekannt.
Dass es diese Menge hier gehe, dann gibt es
eine weitere Menge R. Da sind uns einzelne Wege bekannt,
aber wir wissen noch nicht, ob das wirklich die kürzesten sind.
Also da können durchaus einige Knoten drin sein in dieser Randmenge.
Dann gibt es noch den ganzen Rest. Das ist dann
sozusagen Terrain Kognita, das sind die ganzen anderen Knoten,
die wir noch nicht betrachtet haben.
Und dieser Algorithmus breitet sozusagen diese R-Menge immer weiter aus
Und holt dann immer aus der R-Menge Knoten in die Geh-Menge hier,
sodass man im G dann immer mehr kürzeste Wege aufsammelt.
Ja, und hier ist der Algorithmus mal beschrieben.
Und den kann man tatsächlich so runter implementieren. Ist nicht
so, sagen wir, ganz trivial. Ich habe das
gestern Abend mal gemacht. Das ist, glaube ich,
das erste Mal, dass ich ihn selbst implementiert habe.
Bisher haben das immer Vimis gemacht bei mir. Ich dachte,
ich will es mal machen. Und man braucht so ein,
zwei, drei Stündchen, Musik Musik Musik Musik
Musik Das ist so ein Motto, passiert, das ist sicher.
Also wir können natürlich noch sehen, aus 13,
und wir haben von der Arztstadt, und wir fahren von der Arztstadt.
Jetzt gehen wir weiter, wir hören wieder,
was wir dazu, um hier noch mal weitere Nachbarn zu.
Und am Ende haben wir dann wieder über die Zielgruppen, wo ihr hinwollt, und dann sind wir drinnen, haben wir da, setzen das. Das ist der kürzeste Weg,
vom Z, abblende, nach 6, 40,
von der Link, Überhaben, mit Konzepte und der Form,
wie immer diese Paare kontrollen haben, indem man den Vorgänger,
also wir, das ist das Z überhaben,
wo muss man hier das höhere Paar heilen sein,
wenn das hier weiter, ja, und von Haaren,
jetzt haben wir eh nie weiter, und von eh bis unserer Erdfalter,
was man jetzt hier bei denen hatte,
wo sieht man dann sozusagen dann auch diese Kantenfunk hier,
dass er dann ermittelt werden kann,
oft wieder gelegen werden.
So, und so haben wir auch im meisten Gesicht nicht was hier uns sondiert.
Diese Politik ist, wie gesagt, die Beine.
Aber irgendwo, ein Angehöriger, da haben wir wirklich Spaß an.
Und ich würde es euch sehr empfehlen, das auszuprobieren.
Danke, dass es dir noch ganz kurz, meine Höfung,
unseren Arm, die Woche nicht. Man hört,
dass ich so eine, eine Gravel-Windel, drei Faktoren,
weil wir auch, das würden sie dir ja neulich jetzt so huschen,
sie bitten, die zwei, die Woche noch in der Namen.
Und die habe ich heute in der Kimologie, war in einem Plastatum,
denn der lieber in unseren drei Einkämpfen in die Floten in der Namenskamine ran.
Und uns war uns im Konfersum die Größe der Schule permittiert. Ja,
da haben wir tatsächlich den anderen Muster kriminell hilft,
wenn es uns auch etwas erzeugen müsse,
dass es hier Grog in Seite einmögliche auf die Boje,
so über die wir haben in die Hand,
wir haben Fließer, über den Besorgnisset,
weil diese Gang eine Zelle der Verfügung,
um uns kurz zu brauchen.
Und dann mache ich das irgendwie entscheidende Vater. Das ist
ein Intro-Schlag, wenn ich noch nie mal ableite oder sowas.
Ich bin also mehr, wenn genau drauf. War,
wie gesagt, mit ganzem Anlagen, die ich noch hatte,
weil er aus schüttlichen Erlebungen, wie diese Gründe auch alle,
wir haben hier auch eine Besonderung, das fand ich diese Menge.
Klar, das dreimal, was für unsere Fragen es
gebaut wird.
Man gab jeden Tag
Keine Fragen, keine Fragen. Okay, dann ist das,
ich sage es ungern, das Ende von SE1. Aber nur fast.
Also erstens habe ich jetzt noch Preise zu vergeben.
Und zwar habe ich zwei Preise. Zum einen habe ich
hier einen Snickers. Ich habe hier einmal Snickers versprochen.
Für diejenigen, die Fehler finden irgendwie oder vor allem
die Testfälle finden können in diesem Listenprojekt
SR1-Tunes, man hatte irgendwie 20 Testfälle für die beiden Implementationen.
Und der gute Malte, wo ist er?
Malte, Malte ist da, da ist Malte.
Malte kommt kurz nach vorne. Malte hat einen Fehler gemacht
mit seiner Gruppe, in der Implementation.
Und hat mir auch einen Testfall geschickt.
Also unsere Tests haben diesen Fehler nicht aufgelegt.
Dann hat er mir einen Testfall geschickt, der ist aufdeckt.
Und deswegen haben wir unsere Testfälle jetzt um einen erweitert.
Und deswegen herzlichen Glückwunsch. Dafür gibt es einen Snickers.
Ja, ey. So, und dann haben wir noch
einen Sonderpreis
Die gute Tabea sitzt direkt daneben, Tabea kann nach vorne kommen,
Tabea hat mindestens drei fette Fehler in unserem Skript gefunden,
hat die hier auch uns kundgetan.
Und ich habe ihr angeboten, dass sie Snickers dafür kriegen kann,
aber sie mag nicht so gerne Nüsse.
Und deswegen habe ich ihr eine nestle, weiße, herzlichen Glückwunsch.
Vielen Dank. Also ihr seht, das lohnt sich total,
hier mitzuarbeiten und irgendwie Fehler zu finden.
Aber jetzt so langsam sind die viel auch aus.
Also ich glaube, viel mehr Fehler haben wir nicht im Skript.
Das ist eigentlich schon ziemlich fehlerlos. Das ist ja auch was,
was ich in der Lehre-Evolution bewertet habt und auch,
glaube ich, ganz gut bewertet habt.
Und das gucken wir uns nach der Pause an,
oder wollen wir heute durchmachen? Wollen wir lieber durchmachen? Ja,
wir machen das durch, dann sind wir schneller fertig, ne?
Gut. Also, nochmal so kurz Rückschau, ja?
Wir haben jetzt ein Semesterprogrammierung hinter uns.
Wir haben euch so Grundlagen der Programmierung vorgestellt und wir haben
das Ganze so ein bisschen strukturiert in so vier Stufen,
haben also versucht, systematisch zu behandeln,
was man so mit Objekten machen kann,
dann wie Objekte sich gegenseitig benutzen über Referenzen.
Dann haben wir eingeführt, sowas wie Schnittstellen und Implementationen,
Interfaces, Blackbox-Tests und dann auch unter anderem Sammlungen.
Und haben euch gezeigt, Implections Framework gibt es so Schnittstellen,
Interfaces, mit denen so Sammlungstypen beschrieben sind.
Und dann gibt es Implementationen dazu. Und in den letzten
Wochen haben wir uns jetzt eigentlich ausschließlich nur noch angesehen,
wie man denn solche Sammlungen bauen kann.
Mit Arrays, mit verketteten Listen, mit Hash-Verfahren und ähnliches.
Das ist einfach nochmal so der Überblick über die ganze Veranstaltung.
Und ja, da hat sich auch in den letzten Jahren eigentlich nicht viel geändert.
Das ist nochmal so ein kurzer Blick auf die ganzen Aufgabenblätter.
Ihr habt also jetzt durch 13 Aufgabenbetter gequält. Ich darf sagen,
es waren früher 14 und das 14. Blatt ist ja immer
noch da, aber es führt ein sehr stiefmütterliches Dasein.
Also es wird nur noch sehr wenig bearbeitet. Früher war das
noch im Pflichtkanon, da hatten wir aber auch noch mehr Zeit.
Da hatten wir am Montag, hatten wir die Vorlesung,
da konnten wir immer gleich schon in der ersten Woche Übungen machen.
Jetzt ist ja erstmal so, dass wir irgendwie eine halbe Woche verlieren.
Am Anfang war die Vorlesung in der Mitte ist der Woche.
Dadurch können wir nur 13 Übungsblätter machen. Also es ist also,
ja, durch diese Verschiebung habt ihr den Vorteil,
dass ihr einen Übungsblatt weniger machen müsst.
Und das senkt ja auch den Arbeitsaufwand.
Und das werden wir auch gleich in der Lehrrevolution sehen,
dass ihr das auch sozusagen nicht nur ihr,
sondern auch die Vorgänger von euch, das entsprechend honoriert haben.
Das heißt also, wir schauen jetzt mal auf die Lehre-Evolution.
Das heißt, ich habe jetzt von irgendwie 280,
290 ausgewerteten Fragebögen ein PDF bekommen, wo die ganze Auswertung drinsteht.
Das PDF hat, glaube ich, weiß nicht,
180 Seiten oder so, ist relativ lang.
Die ganzen Freitexte sind da mit drin. Und es gibt so
ein paar Skalen. Und diese ganzen Skalen werden auch veröffentlicht auf einer Webseite,
die allerdings nur für Informatiker im Informatikenetz zugreifbar ist.
Also wenn ihr über VPN ins Informatikenetz kommt,
dann könnt ihr diese Webseite euch ansehen mit diesen Evolutionsergebnissen,
Die werden von der Fachschaft, auf der Fachschaftsseite veröffentlicht.
Und da werden dann auch so ein bisschen diese Fieberkurven,
die da rauskommen, von verschiedenen Veranstaltungen verglichen.
Wir gucken uns das jetzt mal an. Ich habe so
ein paar Sachen mir mal rausgegriffen. Also zum Beispiel das hier.
Das, finde ich, ist mal so ein lustiges Thema.
Könnt ihr euch vorstellen, warum ich das Thema lustig finde?
War das für die Veranstaltung vorausgesetzte Vorwissen bei dir vorhanden?
Das sind eure Antworten. Also da haben irgendwie 271 Leute
darauf geantwortet, auf diese Frage. Und da kommen also
rund 50 Prozent, 20, naja, 40 Prozent,
haben irgendwie gesagt, Überhaupt nicht.
Ich habe das ganze Vorwissen nicht gehabt. Ich habe
nur mit großen Lücken das Vorwissen gehabt und mit einigen.
Warum finde ich das wohl möglicherweise witzig? Was für eine
Vorwissen? Ja, genau. Also wir haben kein Vorwissen
vorausgesetzt. Aber viele haben irgendwo dieses subjektive Gefühl von,
oh, alles, was von mir vorher erwartet wurde,
konnte ich alles nicht mitbringen.
Ist eigentlich nicht richtig, weil wir erwarten ja nichts.
Also von daher ist das immer so interessant, da zu sagen,
da sind Lücken oder das ist nicht da gewesen.
Also es ist natürlich subjektiv bei vielen der Eindruck,
dass es helfen würde, wenn man vorher programmieren könnte.
Aber das setzen wir nicht voraus
Das ist hier immerhin eine relativ niedrige Zahl.
In meiner anderen Veranstaltung ist das tatsächlich mehr.
Das sind das irgendwie, ich glaube, 50 Prozent,
die irgendwie glauben, sie hätten irgendwie das Vorwissen nicht.
Obwohl wir da auch nichts voraussetzen. Lustig. Gut.
Dann der Zeitaufwand für SE1. Das ist auch mal was,
was ganz spannend ist. Ich habe ja irgendwie am Anfang mal gesagt,
wir haben hier einen Sechs-Leistungspunkte-Modul und wir haben uns irgendwie mit
der Fachschaft mal irgendwie darauf geeinigt,
dass solche Veranstaltungen in der Vorlesungszeit ungefähr acht Zeit schon beanspruchen dürfen.
Also minimal. So, das heißt also,
wir können sagen, acht Zeitstunden solltet ihr
in SE1 verbringen pro Woche
Und da haben wir auch gefragt, wie viele Stunden pro Woche
investierst du insgesamt? Präsenz, Zeit, Heimarbeit und so weiter
in diese Lehrveranstaltung. Und das ist jetzt der Wert,
der vor eins, zwei, vor drei Jahren war,
vor drei Jahren in SE1. Das waren die Antworten.
Das ist der Wert vor zwei Jahren. Das ist der
Wert im letzten Jahr. Nee, gar nicht wahr.
Das ist der Wert, sorry, das ist der Wert vor zwei Jahren.
Das ist der Wert letztes Jahr und das ist der Wert aktuell.
Das ist ganz interessant zu sehen. Also erstmal habe ich
die Farbkodierung jetzt immer ein wenig einheitlich,
was vom letzten Jahr sind immer diese blau unterliegten,
dann diese etwas anders blau eingefärbten sind vor zwei Jahren.
Und dann gibt es noch so,
Folien habe ich auch noch so,
die vor drei Jahren mit drauf,
das ist dann
so Sepia-Farben
Was man hier sieht, ist, dass das irgendwie,
ja, ups, dass das irgendwie so sich im Bereich
eher so um vier bis sechs Stunden bewegt.
Es gibt auch Leute,
die investieren mehr als 22 Stunden pro Woche in SE1. Ja,
das sind nur 2,4 Prozent, also von 288 sind das also ungefähr,
naja, immerhin acht Leute, ja, irgendwie sowas.
Und dann sieht man aber hier, dass das sozusagen eigentlich
relativ stabil ist. Also es ist so, ja,
also Es liegt natürlich auch daran, dass ein Leute Vorwissen haben,
möglicherweise nicht so viel Zeit investieren, aber sagen wir,
der Großteil bewegt sich hier schon auf dem vernünftigen Weg.
Man sieht das hier, dass das aber durchaus auch
schon mal mehr war mit den sechs bis acht Stunden.
Damit geht einher natürlich dann häufig auch so ein bisschen Stoffumfang.
Interessant ist dann immer, wie das auseinander läuft,
wenn dann der Stoffumfang als zu groß empfunden wird,
aber die Leute nicht, die acht Stunden investieren.
Also das geht dann so ein bisschen auseinander. Aber das
ist ja hier jetzt relativ stabil inzwischen und relativ gut.
Das ist vor drei Jahren die Antwort gewesen,
wie die Studierenden den Stoffumfang empfunden haben.
Und da seht ihr, da war der Mittelwert bei 3,4.
Also der Mittelwert bei drei wäre sozusagen sagen, genau richtig,
so und nicht zu groß, nicht zu klein.
Und natürlich will man als Lehrveranstalter immer, dass die Studenten sagen,
oh, das ist zu viel. Das wäre natürlich eine Schande,
wenn ich jetzt hier irgendwie stehen würde und ihr würdet hinterher sagen,
oh, das war eigentlich zu wenig Stoff,
die es sonst gegeben hast.
Das will man nicht hören. Also man möchte schon
immer so ein bisschen rechts der Mitte sein.
Von daher ist das durchaus in Ordnung. Aber wir haben
tatsächlich dann jetzt über die Jahre uns da stetig verbessert.
Man sieht hier zum Beispiel, ja,
hier waren es noch 10 Prozent, die sagten,
das wäre viel zu groß und haben irgendwie im nächsten Jahr
nur noch 6 Prozent gesagt, wir haben viel Suche.
Ich hätte noch niemand gesagt, das wäre viel zu gering.
Hier haben die ersten schon gemeckert, haben gesagt,
oh,
das ist zu wenig
Ja, hier ist es jetzt schon 1 Kommentar.
Letztes Jahr waren es 1,1 Prozent, die E-Mail Journalism ist zu wenig,
aber nur noch 4,3 fanden, das ist viel zu groß.
Da war der Mittelwert 3,2. Und jetzt bei euch kommt irgendwie
auch so was raus, Mittelwert 3,2. Und naja,
also es hält sich so die Waage viel zu groß und viel zu gering.
Wir haben natürlich das Problem in dieser Veranstaltung, es gibt Leute,
die können programmieren, für die ist vieles langweilig.
Auf der anderen Seite gibt es diejenigen,
die nicht programmieren können und das Tempo ziemlich hoch finden.
Ja, und zwischen diesen beiden Extremen bewegt sich das alles.
Und so in der Masse kann man aber sagen,
dass wir eigentlich einen ziemlich perfekten Wert haben mit 3,2.
Also finde ich, ich finde das gut.
Also das ist gutes Feedback und wie ihr seht,
haben wir auch über die Jahre immer so ein bisschen
dran geschraubt
Aufgaben sind ja auch mal wieder so ein bisschen entschärft worden und so weiter,
dass wir jetzt also anscheinend einen ganz guten Wert haben,
dass alle so ein Gefühl von Last haben.
Also wir müssen das tun, aber man kann das schaffen.
Und das soll ja auch der Eindruck sein, der hier entsteht.
Stoffumfang. Gut, Niveau der Veranstaltung. Auch lustig.
Wie fandest du das Niveau der Veranstaltung? Da wollen wir natürlich,
also das will man natürlich erst recht nicht hören als Veranstalter,
dass da irgendwie kommt, das Niveau ist viel zu niedrig.
Also auch da bitte rechts der Mitte. Ja,
und da sieht man jetzt auch so über die Jahre so eine gewisse Entwicklung.
Also 3,2, das ist also auch ein guter Wert.
Auch dieses Jahr wieder, es gibt also Leute,
denen ist das viel zu niedrig.
Es gibt aber auch Leute, denen ist es
viel zu hoch
Klar, die gibt es immer. Das ist ja Statistik hier.
Aber so im Mittel sind wir eigentlich ziemlich prächtig unterwegs.
Also auch das ist in Ordnung. Dann so allgemeines zur
Veranstaltung. Die Veranstaltung ist sehr klar und strukturiert aufgebaut.
Die Veranstaltung ist inhaltlich sehr interessant und die Veranstaltung ist inhaltlich
für dein Studium sehr wichtig. Das sind dann hier so Werte,
kann man wahrscheinlich kaum lesen, aber so 2,5,
2,4, 2,5. Ja, das war vor drei Jahren.
Dann haben wir schon im Jahr drauf,
haben wir es verbessert, auf 2,1, 2,2,
2,3. Also es ist in jedem Punkt eine Verbesserung,
sehr zufriedenstellend.
Dann im letzten Jahr nochmal eine Verbesserung,
irgendwie 1,8,
2,0, also nochmal eine Verbesserung. Da habe ich schon,
im letzten habe ich schon gesagt, das ist der absolute Wahnsinn.
Die Umfragewerte waren schon eigentlich die Jahre vorher gut,
aber das war dann so, das kann man nicht mehr steigern,
aber dann ist es im letzten Jahr nochmal gesteigert worden.
Aber tatsächlich haben wir jetzt das Niveau gehalten.
Also wir haben jetzt nicht weiter steigern können,
die Werte hier sind, also 1,9, 2,2,
2,2, also eher wieder so ein bisschen.
Also ihr seid möglicherweise etwas kritischer. Aber das ist natürlich,
das sind gute Werte. Also wenn man sich jetzt andere
Veranstaltungen anguckt, dann ist das also eine ganz gute Bewertung.
Gut, der Vortragende, Das bin ich. Der Dozent,
die Dozentin gestaltet die Veranstaltung interessant und lebendig, wirkt gut vorbereitet,
ermutigt und macht nicht interaktiv, bemüht sich eine gute Veranstaltung.
Er hat sich stets bemüht, eine gute Veranstaltung zu halten.
Es ist immer so, dass man, ja,
ja, er hat sich stets bemüht.
Und der Dozent kann auch schwierige Sachverhalte verständlich erläutern.
Da sieht man hier, das ist nicht unbedingt meine beste Note offensichtlich.
Ich bin anscheinend jemand, der nicht so gut verständlich erklären kann.
Das ist also zumindest relativ zu den anderen Werten.
Aber hier so vor drei Jahren 1,6, 1,6,
1,9, 1,6. Sehr schön.
Schon im Jahr drauf war das etwas besser.
1,6, 1,3,
1,5,
Und dann im Jahr drauf, glaube ich,
noch mal ein bisschen besser. So, und die Werte
sind aber auch wieder relativ stabil geblieben. Ich glaube,
hier ist nichts, was wirklich, na doch,
hier zum Beispiel, bemüht sich eine gute Veranstaltung zu halten.
Das ist also 1,2, das ist der absolute Hammerwert,
den habe ich noch nie erreicht.
Und ich danke euch für dieses Feedback.
Ich bemühe mich wirklich, eine gute Veranstaltung zu halten.
Das sind schon gute Werte. Also man muss ja mal
dazu sagen, so leere Evolution ist ja was sehr Zwiespältiges.
Ich bin ja nun zufällig auch in dieser Fragebogen-AG und in
dieser Arbeitsgruppe Qualitätsmanagement und weiß einfach.
Ja, ich habe da nichts mit zu tun mit der Auswertung.
Also ich habe nur was mit dem Entwurf der Fragebögen und
der Überwachung, dass alles richtig läuft und so.
Damit habe ich was zu tun. Und wir werten das auch
aus und so weiter. Aber ich habe jetzt im Höheswillen,
ich habe da meine Finger nicht drin. Aber was eben halt bemerkenswert ist,
dass bei einer Pflichtveranstaltung diese Werte so gut sind,
weil im späteren Verlauf des Stürmens werdet ihr Veranstaltungen besuchen,
weil ihr sie interessant findet.
Und dann werdet ihr automatisch das Thema interessant finden,
der Zünd wird euch sympathisch sein und so weiter.
Aber in einer Pflichtveranstaltung, wo Leute gezwungen werden,
ihr werdet ja alle gezwungen, hier zu sitzen,
ihr armen Schweine,
da ist das dann schon irgendwie ein sehr,
sehr toller Wert
Vielen Dank dafür für das Feedback. Hier nochmal vortragender.
Auch nochmal, hat eine gut verständliche Aussprache. Das ist klassisch
auch meine Master-Disziplin, weil ich ja nie nuschel und ähnliches.
Nimmt Fragen ernst und waren uns die Klaren verständlich.
Dann hier Tafelfolien, Modelle, Video, Software, gezielter Medieneinsatz,
hilft mir der Veranstaltung zu folgen, Tafelbild gut lesbar.
Da sind die Wette halt auch so 1,5, 1,5,
1,5, 1,5, 1,5, 1,5, 1,9,
1,7. Haben sich dann auch stetig über die Jahre verbessert.
Und das ist jetzt der aktuelle Wert. Also auch das sieht natürlich,
das sieht richtig gut aus. Das ist toll. Gut,
aber das eine ist natürlich meine Show hier vorne, die ich abziehe,
aber ist ja auch für euch hier in der Veranstaltung die Übung,
weil das ist eine Programmierveranstaltung.
Wir glauben, dass es extrem wichtig ist, programmieren zu machen.
Und deswegen sind die Übungen auch sehr wichtig.
Und da ist es auch wieder interessant zu sehen,
wie sie das über die Jahre entwickelt hat, wie ihr das einschätzt.
Also Zeitaufwand für die Übungen, der war früher noch bei 3,4
der Mittelwert. Schwierigkeitsgrad sogar bei 3,5. Die Aufgaben des standen
jeweils rechtzeitig zur Verfügung. 1,8 noch vor drei Jahren.
Und dann hier Übungen passen inhaltlich sehr gut zur Vorlesung
2,2. Und die Übungen passen zeitlich sehr gut 2,6.
Und da sieht man dann auch schon eine kleine Verbesserung.
Im nächsten Jahr war es dann schon ein bisschen, naja,
das war nicht viel besser, das war auch nicht viel besser.
Hier wird es aber deutlich besser. Also
sie haben anscheinend Aufgaben wird dann immer rechtzeitig bereit gehabt.
Das ist hier besser geworden. Dann ist es hier wieder noch
ein bisschen besser geworden und aber letztendlich haben wir das jetzt der aktuelle Wert.
Das heißt, auch hier sagt ihr, Zeitaufwand ist eigentlich okay.
Also das ist ein bisschen zu viel, wieder ganz gut ist.
Also ganz im Ernst, Studenten sagen immer,
es ist zu viel. Wenn wir weniger machen würden,
würden trotzdem alle sagen, es ist zu viel.
Das ist klar. Hätte ich früher auch so gesagt als
Student. Das ist alles zu viel. Schwierigkeitsgrad 3,4,
wow, also das ist okay. Aufgabenwetter Rechtzeit zur Verfügung
ist es gut. Wir haben da also anscheinend
kein technisches Problem
Übungen passen da inhaltlich ganz gut dazu. Und was natürlich auch nochmal wichtig ist,
sind die Übungsleiter, das ist ja was,
ein Kern ist unseres Konzeptes, diese direkte Betreuung in den Übungen.
Ihr habt das auch in dem Feedback, in den Freitexten viel gesagt,
dass ihr sehr zufrieden wart mit den Betreuern,
dass die euch viel geholfen haben, überwiegend,
dass sie sehr hilfsbereit waren, freundlich waren, kompetent waren.
Und natürlich wollen wir das auch wissen. Und da sieht
man auch hier, das ist der Wert vor drei Jahren
gewesen, glaube ich. Das ist der Wert vor,
nee, das ist der Wert vor zwei Jahren gewesen,
also hier noch 2,1, 2,3.
Dann sieht man schon eine Verbesserung 1,7, 2,0.
Und hier haben wir jetzt irgendwie
Aber das heißt einfach,
dass wir auch in der Hinsicht inzwischen ganz guten Nachwuchs haben,
dass wir also auch dafür sorgen, dass sind die Leute,
die wirklich Spaß dran haben und auch Interesse daran haben,
hier zu betreuen,
die versuchen wir dann immer im nächsten Jahr abzugreifen als Betreuer.
Und das scheint uns inzwischen auch ganz gut zu gelingen.
Da sieht man also auch eine gewisse Entwicklung ins linke Spektrum.
Das ist also auch sehr erfreulich und das freut sicherlich auch unsere Übungsleiter,
dass ihre Arbeit hier entsprechend gut von euch angenommen wurde.
Gut, dann habe ich jetzt noch so als letzten Punkt
so ein paar negativ aufgefallene Punkte,
also in den Freitexten, diese Evolution, das PDF,
den gesamten Freitexten stelle ich auch noch ins Komsi rein.
Könnt ihr also auch noch mal in Ruhe angucken.
Wenn ihr wollt, da stehen ganz lustige Sachen drin,
so ein paar, zum Beispiel sowas hier.
Was ist euch negativ an SE1 aufgefallen? Ycon 1 und
Ycon 2. Ich kann nichts dafür. Ich weiß,
ich finde das sehr unpassend, dass jetzt in dieser Veranstaltung irgendwie zu kritisieren.
Da war aber auch nur eine Einzelmeinung. Gut. Lärmpegel
in der Vorlesung kriegen wir jedes Jahr als Feedback.
Das ist in diesem Jahr meiner Meinung nach besser als im letzten Jahr,
weil der gut Kollege hier das mal mit einem Tontechniker hat, überprüfen lassen.
Das heißt also, das Mikrofon ist deutlich besser geworden.
Es gab die letzten Jahre mal einen fürchterlichen Hall. Ich habe hier mal gestanden,
musste immer irgendwie regeln und das war dann,
wenn ich runtergeregelt habe, was zu leise,
wenn ich höher geregelt habe,
gab es irgendwie so einen fürchterlichen Hall.
Das ist deutlich besser. Das heißt, ich kann jetzt hier auch
noch richtig laut stellen und dann hört ihr mich auch richtig laut.
Und dann ist immer noch kein Hall da. Und das
ist dann wahrscheinlich die Lautstärke, die euch irgendwie wachhalten würde.
Aber ich finde es dann doch ein bisschen besser,
vielleicht so, naja, also der Lernpegel wird immer wieder kritisiert.
Es gibt immer wieder Studierende, die halt irgendwie laut quatschen.
Das ist ein bisschen schade. Stressige Übungen, Zeitdruck. Gut,
jetzt Das ist auch hier dann Aufgaben, teilweise zu wenig verständlich.
Das ist tatsächlich rausgeflogen. Also in den Jahren
früher war man noch so irgendwie, ja,
die Aufgaben sind so unklar und da haben wir anscheinend wirklich dazugelernt.
Jedes Jahr machen wir ja, überarbeiten wir das.
Das kam gar nicht mehr als Feedback. Das ist
sehr erfreulich. Aber Tempo zu schnell für totale Anfänger,
zu viel Stoff für Anfänger, Übungen zu umfangreich und zu anspruchsvoll für Unerfahrene.
So, klar, dazu muss ich erst mal sagen,
das ist was, was wir immer wieder hören.
Und das ist ja auch was, wo wir auch,
sagen wir, sagen wir, einigermaßen gut mitleben können,
weil das eben halt ja nicht durchgängig die Meinung ist.
Das seht ihr ja auch an der Bewertung des Stoffumfanges.
Und an der Bewertung des Niveaus
Aber man muss auch dazu sagen,
diese Veranstaltung ist mal konzipiert worden für den Informatikstudiengang.
Also für Bachelor-Informatik und Bachelor-Wirtschaftsinformatik. Und dann kamen die anderen Studiengänge
dazu und dann hieß es so, die müssen jetzt auch,
weil SE1 ist ja so toll und deswegen sollen die da auch alle rein.
Und für viele, die das eben halt eher so als Nebenfach betreiben,
ist dann möglicherweise, dass hier zu sehr Hardcore programmieren und
Hardcore-Informatik und das Tempo zu hoch.
Keine Ahnung. Da kann ich dann natürlich auch sagen,
da können wir nichts dafür.
Wir haben halt diese Veranstaltung so konzipiert, die passt,
glaube ich, ganz gut in das Schema hier rein.
Und für einige,
die es halt eher so im Nebenfach machen,
ist es möglicherweise
ein bisschen stressig
Also das ist halt kaum zu ändern. Überschneidung mit Analysis 1,
ein fürchterliches scheiß Problem, Entschuldigung. Können wir nichts dran machen,
dass es halt die ganzen Vorlesungspläne sind ja bei uns aufgedrückt.
Wir müssen ja mit SE1 am Mittwochnachmittag hier stattfinden,
obwohl wir es lieber am Montag wären zum Beispiel.
Vormittags wären wir auch viel lieber, da wären alle
noch viel wacher. Aber das geht halt nicht.
BlueJ ist einigen Leuten negativ aufgefallen, fand ich interessant.
Ich hoffe, das waren auch nur Einzelmeinungen,
es waren auch, glaube ich,
nur ein,
zwei Leute
Ich habe den Eindruck, früher habe ich noch eine Umfrage dazu gemacht.
Tatsächlich meine eigene Privatumfrage in meiner Veranstaltung hier nur,
um herauszufinden, wie denn Blue Jay bewertet wird.
Und da einfach, die Jahre war immer klar,
für die Anfänger ist Blue Jay einfach super gut geeignet,
um genau diese Kernkonzepte zu visualisieren.
Und ich glaube, die meisten von euch wissen das auch
zu schätzen und deswegen werden wir auch Blue Jay weiter einsetzen.
Ich glaube, das sind halt also Leute,
die möglicherweise schon programmieren können,
wie man mit Eclipse arbeiten würden,
für die ist dann Blue Jay vielleicht ein bisschen langweilig.
Schummeln bei Tic-Tac-Tone, ich weiß nicht wo.
Keine Ahnung,
wovon die Rede ist
Verschulung der Übung. Gut, ja, wir machen das eben halt noch sehr.
Wir gucken euch sehr über die Schulter. Ich glaube,
das ist ganz gut, wenn man so Programmieranfänger ist,
dass man noch so einen Übergang kriegt von der Schule an die Uni,
weil wir einfach immer wieder merken oder auch gemerkt haben,
die Jahre davor studieren ist was anderes als in die Schule gehen.
Klar. Studieren heißt selbstverantwortlich irgendwie, sich Stoff aneignen,
sich klarmachen, dass man vielleicht hinterherhängt.
Und wir machen das halt hier sehr explizit.
Ihr kriegt bei uns sehr deutlich zu spüren,
wenn ihr inhaltlich hinterherhängt und wir treten euch auf die Füße.
Das ist ein Service, den wir euch gerne anbieten
Aber ich glaube, es hilft auch. Ich glaube,
es hilft auch noch so ein bisschen getreten zu werden,
dass man einfach mitkriegt, dass man möglicherweise zu wenig tut.
Das ist letztendlich das, was passiert. Ich bin ja
der festen Überzeugung, dass niemand zu dumm ist zum Programmieren,
sodass es höchstens ist, dass die Leute,
die nicht hinterherkommen, zu wenig Zeit investieren.
Das ist meiner Meinung nach das Hauptproblem.
So, früher stärker und zwischen weitgehend abgestellt.
Das sind so Sachen wie manchmal zu wenige Betreuer.
Das kommt nur noch sehr, sehr wenig vor.
Ich glaube, am Mittwoch ist es meistens noch ein Problem.
Unfreundlichkeit, weniger Betreuer, nicht motivierte Betreuer,
schlecht gelaunte Betreuer, haben wir auch inzwischen relativ wenige.
Wir suchen die also nach ihrem sonnigen Gemüt
aus inzwischen
Oh, das ist mir auch sehr schön.
Ich habe dann auch noch mal so geguckt,
ganz oft steht tatsächlich, was ist euch negativ aufgefallen?
Da steht dann tatsächlich nichts. Hat jemand
explizit sich gedacht, mir ist nichts Negatives aufgefallen.
Das ist in dem Sinne bemerkenswert. Ich war,
glaube ich, zehnmal oder was, in den freien Texten drin,
dass andersrum im positiven Teil nie irgendjemand geschrieben hat.
Nichts. Also da hat niemand gesagt,
mir ist nichts Positives an dieser Veranstaltung aufgefallen.
Also das ist auch so ein Hinweis,
dass das eigentlich hier alles ganz gut funktioniert. Ja,
gibt es jetzt noch irgendwie spontan Feedback zu dieser Veranstaltung?
Wollt ihr noch irgendwas loswerden? Wollt ihr noch irgendwas sagen?
Irgendwas Verbesserungsvorschläge mäßig noch? Gibt es irgendwie noch Dinge,
ja, sieht sich aus. Lecture to go auch als
Podcast, oha. Da weiß ich nicht so genau,
da weißt du vielleicht ein bisschen mehr,
was von der Lecture-to-Go-Plattform aus da noch geplant ist.
Ich weiß, dass die Vorlesung inzwischen auch herunterladbar sind.
Also wir haben sie euch herunterladbar gemacht.
Im Komsi ist ein Link zu finden. Das heißt,
ihr könnt die auch offline runterladen und dann beliebig oft noch angucken.
Als Klausurvorbereitung ist es natürlich ganz hilfreich, sich die Videos nochmal anzugucken.
Ansonsten ist ist das, glaube ich, der Stand der Dinge.
Wir wollen diese Videos ungern der Welt zum Download überlassen sozusagen.
Ja, das ist, ja, das ist momentan
noch so ein bisschen die Haltung hier.
Sonst noch Hinweise, Fragen, irgendwelche Verbesserungsvorschläge, Kritik.
Ja, dann gibt es hier noch mal so ein paar Hinweise zur Modulprüfung.
Ihr wisst ja, dass ihr jetzt noch eine Klausur schreiben müsst.
Die müssen wir auch durchführen, weil wir euch irgendwie Noten geben müssen.
Eigentlich sind wir der Meinung, wenn ihr den Übungsbetrieb überstanden
habt,
dann ist alles gut
Aber ihr braucht halt Noten für euer Bachelorstudium. Und deswegen vergeben wir
auch welche. Und das machen wir an halt einer Klausur.
Und die erste Klausur ist am 6.2. um 10 Uhr im Audi Max.
Und die zweite ist am 19.3. auch um 10 Uhr um Audi Max.
Alle Informationen zur Anmeldung stehen auch im Kommen sie.
Die Übungsscheine werden wir, ich glaube, diesen Freitag bekannt geben.
Also wenn, es war früher so, dass der Übungsschein
die Voraussetzung für die Klausurteilnahme war, das ist nicht mehr so.
Ihr könnt einfach an der Klausur teilnehmen, auch wenn ihr keinen Übungsschein habt.
Ich würde das jetzt nicht so unbedingt empfehlen,
weil das ein ziemlich Zusammenhang ist zwischen Übungen,
gut bestanden und dann auch die Klausur gut bestehen können.
Aber es kann auch nicht schaden, die Klausur mitzuschreiben,
weil ihr könnt dann ja nur durchfallen und dann könnt ihr
sie beim zweiten Termin dann wiederholen.
Aber eigentlich war es die letzten Jahre immer so,
dass die Leute den Schein nicht haben, auch nicht zur Klausur gegangen sind.
So mein Eindruck. Wer den Schein bekommt, das werden wir jetzt,
glaube ich, am Freitag dann im Komsi bekannt geben.
Da wird einfach eine Matrikonummerliste im Komsi stehen,
dann könnt ihr schwarz auf weiß lesen, ob ihr einen Schein-Account oder nicht.
Bei der Klausur ist es halt wichtig,
dass ihr rechtzeitig da seid, was sehr unangenehm ist,
ist, wenn ihr zu spät kommt.
Wir haben dann auch teilweise schon Leuten einfach nicht mehr reingelassen.
Das ist ein bisschen uncool. Wir müssen halt so
ein paar Ansagen machen vorher zum formalen Ablauf und wenn dann
die Leute das nicht gehört haben, ist es nicht so ganz in Ordnung.
Und also das ist ein bisschen doof. Also gebt euch
Mühe, da mal 15 Minuten vorher da zu sein.
Das sollte möglich sein. Keine Hilfsmittel aus einem Stift,
überwiegend mal tiple choice. Da gibt es dann schon auch mal Kritik,
dass das irgendwie Multiple choice ist, weil das ja gar nicht richtig abbildet,
was man so an Programmierfähigkeiten hier bekommen hat.
Ist Geschmackssache. Wir haben das Gefühl,
dass diese Klausuren recht gut widerspiegeln, wie gut die Dinge
verstanden wurden
Und dass wir nicht nur irgendwelches Lernwissen abfragen,
sondern schon auch einfach Verständnis. Das werdet ihr auch in
der Klausur sehen. Gibt es noch Fragen zur Klausur?
Ja. Ich habe noch eine ganz große Frage.
Damals mal, wenn ich mir Notizen machen will,
dann kann ich mich daran auch auf der Firma vorfragen.
Weil es steht ja auch kein, der Strategobiner war ja
kein eigenes Papier. Ja, also er fragt,
ob man auf der Klausur irgendwie Notizen machen kann.
Ihr dürft auf der Klausur mehr oder weniger malen, so viel ihr wollt.
Wir bewerten nur den Bereich, wo die Kreuze gesetzt werden.
Da gucken wir hin und da gucken wir sehr genau hin.
Hat Fred ja auch nochmal Hinweise dazu geschrieben.
Also wenn was nicht angekreuzt sein soll,
wo ihr aus Versehen ein Kreuz gesetzt habt,
ihres Kästchen daneben und so, das ist klar.
Ansonsten könnt ihr darauf malen, auch die Rückseiten,
das ist einseitig bedruckt die Klausur,
auf den Rückseiten könnt ihr beliebig irgendwelche Proberechnungen machen und ähnliches.
Da war noch eine Frage. Das ist aufgewandt.
Ob die heutige Vorlesung über Grafen auch relevant ist,
ja, ich finde, die ist auch relevant.
Genau. Wissen Sie das, was ich meine?
Ja. Muss man ein Personalbekreis belegen. Ja,
die Frage ist aber noch ein Personalausweis mitbringen soll. Richtig,
also ihr solltet dabei haben, Personalausweis und studierenden Ausweis.
Das ist gut, weil dann müssen wir irgendwie die Kloregelung,
wenn ihr rausgehen wollt, auf Klo,
dann sollten wir mal kurz schreiben wir uns das auf,
wir müssen uns das alles, wir haben ja Protokollvorschriften, ganz schrecklich.
So, das heißt, wir wissen dann hinterher genau,
wer wann, wie lange aufs Klo gegangen ist.
Und können das zurückverfolgen und so. Und genau,
also es sollte auf alle Fälle, ihr solltet euch ausweisen können.
Es ist ja ein offizieller Prüfungstermin, da wäre es schon gut,
wenn ihr sagen könnt, ich bin tatsächlich der,
der da gebraucht wird.
Sonst noch Fragen. Sonst noch Fragen zur Klausur.
Keine weiteren Fragen. Toll. Dann sind wir fertig.
Vielen Dank für eure Teilnahme