Ja, sehr schön. Dann willkommen zurück. Ich hoffe,
ihr hattet schöne Pfingstferien. Nicht erschrecken. Ich mache jetzt
den ersten Teil der Vorlesung und nicht den zweiten.
Hat terminliche Gründe. Okay, ich gehe mal davon aus,
dass nicht alle von euch über Pfingsten sich mit Java beschäftigt haben und den SE2-Entwurfsregeln.
Deswegen dachte ich, machen wir noch mal ganz kurz einen Überblick,
wo wir überhaupt letztes Mal stehen geblieben sind.
Also wir hatten uns diese Entwurfsregeln angeschaut und wir waren darüber eingekommen,
dass wir über Werkzeuge ja noch nicht so wahnsinnig viel wissen.
Das kommt so ein bisschen später. Wie baut man grafische Oberflächen,
dass wir über Fachwerte noch nicht so wahnsinnig viel wissen und
dass wir uns hier auf diesen inneren Kern hier mal konzentrieren
Wir hatten also ein System gebaut oder ein System umgebaut,
wo es um Wetterdaten ging.
Man will sich irgendwie Wetterdaten aus dem Internet saugen und so
wahnsinnig viel konnte man bis jetzt gar nicht damit machen.
Das Interessante war also, dass wir uns einmal dieses Material angelegt hatten,
bis jetzt noch ein ziemlich blödes Material,
einfach nur so eine Aggregation von so ein paar Strings.
Vielleicht schauen wir uns noch mal ganz kurz die XML-Datei dazu an.
Genau, also das war ja das XML,
was wir uns gesogen hatten und wir hatten irgendwie gemerkt,
Es gibt immer so interessante Zeitabschnitte, die wir irgendwie festhalten wollen.
Und jeder dieser Zeitabschnitte kriegt so ein, wird in so ein Material gesteckt.
Also das From ist quasi, von wann dieser Forecast ist,
bis wann ist das True? Dann hatten wir uns noch überlegt,
dass diese Temperatur wie ganz spannend ist in Celsios.
Und ich glaube, diesen String wollten wir noch haben.
Hatte ich damit alles abgefrühstückt? Ah, Unit Celsios,
okay, falls nochmal ein anderes Unit ist.
Okay. Und wie haben wir diese Materialien jetzt verwaltet gehabt?
Wir haben einfach in unserem Service so eine Map angelegt.
Wer von euch kann sich denn noch daran erinnern,
warum diese Map diese Struktur hat oder warum es nicht einfach nur eine Liste ist?
Weiß jemand doch einfach nur mal so als Stimmungsmilieu,
ich nehme euch nicht daran, ihr müsst keine Angst haben.
Einfach, wer erinnert sich, warum wir so eine Map genommen haben?
War das irgendwie, ja, nicht so wahnsinnig viele Leute. Also wir hatten gemerkt,
wenn wir einfach nur eine Liste nehmen, dann werden alle Forecasts,
die ich mir übers Internet abrufe von Hamburg, Berlin,
Bremen, Düsseldorf, Hannover,
die werden dann alle in einer Liste landen und das ist einfach nicht so wahnsinnig sinnvoll strukturiert,
wenn ihr jetzt jemand sagt,
gib mir doch mal die Forecasts von Hamburg,
dann würde ich die gerne direkt haben,
diese Liste und nicht erst durch alles durchhüllen und
davon Hand filtern müssen
Also in dieser Map wird für jede Stadt eine eigene Liste gespeichert.
Oder soll zumindest irgendwann mal gespeichert werden. Okay, gut. Genau,
ich denke mal, wir gehen den Code einfach nochmal durch,
um das nochmal so ein bisschen aufzufrischen.
Ich habe ihn mir heute angeguckt, ihr ja wahrscheinlich nicht.
Okay, also das Erste, was wir tun,
in dieser einzigen öffentlichen Operation dieses Services ist zu sagen,
wenn mir der Benutzer eine Stadt reingibt,
dann will ich eben so eine Forecast-Liste zurückgeben.
Eine, die halt in dieser Map drin ist,
passend zu der Stadt. Aber das Erste,
was wir machen, ist,
wir holen uns erstmal das XML über das Internet für die
entsprechende Stadt
Dann ist das ja so eine kleine D-Bug-Ausgabe, das ist eigentlich Quatsch,
dass die da steht, die kommentiert einmal ganz kurz aus.
Und wenn wir dann das XML haben, dann wird es gepasst.
Dadurch wird jetzt eine Liste gefüllt, das werden wir uns gleich
auch nochmal angucken. Okay, und diese Zeile sorgt dafür,
dass dann aus der Map zu der entsprechenden Stadt der richtige Forkers zurückgegeben wird.
Dann kann noch irgendwas schiefgehen, vielleicht habe ich kein Internet
oder ich habe illegale Daten bekommen von dem Weathermap-Service,
dann muss ich das irgendwie abfangen.
Okay, dann sehen wir hier nochmal,
wie die Kommunikation mit dem Web-Service funktioniert,
wir müssen uns hier so ein Request zusammenkleben,
wo einmal die Stadt drin kodiert ist und einmal dieser Schlüssel
Wer von euch hat sich denn mal so einen Schlüssel besorgt
und hat zu Hause damit rumgespielt? Ich habe ja so
ein paar Anfragen bekommen, dass das Leute machen wollen.
Ja, ja, weniger als zehn Leute für die Kamera.
Gut. Genau, was machen wir dann? Dann machen
wir so ein URL-Objekt, dann öffnen wir eine Verbindung und
dann holen wir uns die ganzen Daten aus diesem Strom raus.
Das mit der Acception ist da jetzt nicht so spannend.
Hier bin ich letztes Mal auch rübergegangen. Das ist schade,
dass man in Java so viel Code dafür braucht.
Ich will einfach nur alle Daten aus diesem Strom raus haben.
Genau, dann war das noch so halbwegs spannend
Hier wird also dieses ganze XML-Zeugs gemacht. Und das besonders Spannende war,
dieser Weather XML-Händler, weil ich den selber geschrieben habe.
Und diese Zeile sagt halt, ich stoße jetzt den Passvorgang an.
Und jedes Mal, wenn der Parsa einen Tech sieht,
und ich habe das letztes Mal gar nicht so eindeutig gesagt,
also ein Tech ist immer sowas, was in spitzen Klammern steht,
immer wenn so ein Tech gefunden wird,
dann wird in unsere Klasse quasi reingesprungen.
Gehen wir da mal ganz kurz rein in unseren Händler.
Dann wird in diese Methode reingesprungen. Das heißt hier Element.
Also Techs heißen hier Elemente, fragt mich bitte nicht,
warum. Gut. Was würden wir denn jetzt konkret
zum Beispiel machen, wenn wir dieses Metatech finden?
Da werden wir
nichts mitmachen
Weil wir hier so wunderschön switchen über den Namen des Texts.
Und ihr seht, für das Meta interessieren wir uns gar nicht.
Wir interessieren uns nur für Time, für Simble und für Tempriture.
Die schauen wir uns noch mal ganz kurz an in dem XML.
Wir interessieren uns also dafür, wenn dieses Check aufgemacht wird,
weil da eben die zeitlichen Informationen drinstehen, hierfür,
weil ich dieses Clears Guy mir rausholen will.
Und für Tempriture, weil mich da eben die Einheit und der Wert interessiert.
Und dann haben wir noch gesagt, wenn jetzt dieses Timetech
wieder zugeht, da wollen wir bitte auch benachrichtigt werden.
Also diese Methode wird immer aufgehoben, wenn so ein Tech
zugemacht wird. Und wenn es das Time-Ding ist,
dann erstellen wir uns hier so ein Material,
das ist eine Frage
Ihr kennt mich genau, das ist der Gegner. Ja,
also deine Frage war, woran erkennt er,
dass er diese spitzen Klammern sozusagen ja nicht mitliefert in dem String,
also dass er mir nicht so einen String liefert,
sondern einfach so einen.
Das ist einfach die Spezifikation von XML und der Parser,
der in Java eingebaut ist, ist einfach so gebaut,
dass er dir nur das in den Spitzenklammern liefert.
Darum müssen wir uns nicht kümmern, ja.
Du hast einfach eine Syntagsfrage. Okay, was hatten wir
gemacht? Als wir die einzelnen Text gesehen haben,
wir haben uns erstmal nur diese Informationen gemerkt,
in eigenen Exemplarvariaplen,
die seht ihr hier oben
Ja. Weil wir die ja so Stück für Stück reinkriegen. Also einmal,
wenn Time gefunden wird, merken wir uns zwei Variablen,
wenn ein Symbol geöffnet wird,
merken wir uns diese Variable und wenn ein Temperature geöffnet wird,
merken wir uns diese beiden Variablen.
Ja, und erst, wenn das Timetech zugemacht wird,
erst dann können wir was Sinnvolles mit diesen gemerkten Variablen machen,
nämlich reinstoffen in dieses Material namens Forecast.
Ja, das war so der Stand von letzter Woche.
Und dann war auf einmal die Zeit vorbei. So,
jetzt gucke ich noch mal ganz kurz auf unseren Plan.
Nicht wahr, ich hatte euch das erzählt,
wir haben das System verstanden, wir haben uns die Entwurfsregeln angeschaut,
wir haben das System entzerrt und dann war irgendwie Schluss.
Ja, also diese beiden Punkte hatte ich euch versprochen,
die wollte ich heute noch mit euch
zusammen erledigen
So, dann habe ich mal mit unserem Kunden gesprochen,
der dieses System kaufen will, wenn es denn mal fertig ist.
Und er hat sich vorgestellt, dass es irgendwie so aussehen soll.
Also man startet das System und dann erscheint ja so ein kleiner Prompt.
Den gibt der Benutzer nicht ein, das ist einfach
nur damit klar ist, er soll jetzt was eingeben.
Und wenn man dann einen Stadtnamen eingibt, dann soll eben,
ja, vielleicht ganz kurz für uns interessanterweise auf der Konsole erscheinen,
hey, ich muss mir das jetzt aus dem Internet laden,
ich weiß noch nichts über Hamburg.
Und dann sollen die Daten irgendwie auf der Konsole erscheinen.
So wie es jetzt gerade für uns passend ist.
Ich habe das jetzt hier nicht spezifiziert
Und das Programm läuft dann weiter. Und wenn ich dann
nochmal Hamburg eingebe, dann sollte irgendwie klar werden,
ich muss es mir nicht nochmal aus dem Internet holen.
Ich werde dieses Programm ja nicht tagelang laufen lassen.
Ich muss nicht ständig die neuesten Forecasts mir holen.
Ich will sie mir zwischendurch speichern in dieser Map.
Und dann soll dasselbe, bla bla bla, hier stehen.
Okay, aber wenn ich dann eine andere Stadt eingebe,
zum Beispiel Berlin, dann muss er das natürlich wieder remote holen.
Klar. Gut, jetzt will ich nicht zu viel verraten.
Das programmieren wir erstmal. Wenn das funktioniert, haben wir noch weitere Anforderungen.
Mal schauen, ob wir da noch Zeit für haben.
Okay. Gut, jetzt gibt es auch noch gar keine Möglichkeit,
überhaupt irgendwas einzugeben. Das ist sogar noch schlimmer,
man kann das System überhaupt nicht starten.
Also ich weiß gar nicht, was passiert,
was passiert eigentlich, wenn ich hier raufklicke und sage,
Run as Java Application ist das
überhaupt möglich
Weil wir haben ja gar keine Main-Methode. Was passiert jetzt
? Ja, selection does not contain a main type.
Ich hatte ja diese Main-Methode so schön rausgenommen, weil wir gesagt haben,
es soll nicht in einem Service eine Main-Methode geben.
Okay. Wir wollen jetzt also ein Werkzeug bauen,
wo diese Main-Methode drin ist.
Das ist jetzt auch so ein bisschen künstlich.
Ich gehe nochmal ganz kurz hier in diese Entwurfsregeln.
Wenn hier steht, Werkzeug ist damit immer implizit gemeint, eine grafische Oberfläche.
Damit ist nicht gemeint, wo man was in der Konsole eingibt.
Das ist jetzt leider so ein bisschen künstlich,
aber das ist, glaube ich, nicht schlimm.
Das hat jetzt einfach pädagogische Gründe. Wenn wir uns um
Guiz kümmern, wird das System vielleicht ein bisschen ansehnlicher.
Okay, das heißt,
ich mache mal eine neue Klasse für dieses Werkzeug
Das nenne ich jetzt einfach mal, da wir jetzt hier
alles Englisch machen, nenne ich das einfach mal Weather-Tool.
Ich wollte es nicht Weather-Werkzeug nennen. So. Und dann ist natürlich sofort die Frage,
dieses Weather-Tool muss ja irgendwie kommunizieren mit diesem Service.
Ich weiß, soll sich jetzt das Weather-Tool den Service
selber erzeugen oder soll es den irgendwie reingesteckt bekommen?
Und man kann sich tatsächlich mal die Zeit nehmen,
sich diese Entwurfsregeln durchzulesen und irgendwo ist das tatsächlich definiert.
Wo ist hier das Werkzeug hier? Es gibt hier irgendwo
einen Absatz
Ah, guck mal hier, da steht jetzt der dritte Absatz.
Der Werkzeugklasse werden benötigte Services als Konstruktorparameter übergeben.
Die meisten anderen Punkte können wir jetzt erst mal ignorieren,
die sind eigentlich nur für tatsächlich Googles relevant.
Aber das ist spannend. Also das Werkzeug, er stellt sich
den Service nicht selber, sondern kriegt den irgendwie reingereicht.
Gut. Das heißt, wir merken uns den vielleicht dann
mal in der Exemplarvariable. Weather Service unterstrich Service.
Und da will ich jetzt einen Konstruktor schreiben.
Das ging doch immer so schön an Eclipse,
dass ich sagen kann, schreib mir den bitte von alleine.
Saws, Generate, Constructor, Using Fields.
Ich sage einfach immer, okay, bis ich
diesen Dialog verstanden habe.
Genau,
und das super brauchen wir nicht
Ja. Das nennt man auch ganz hochgestochen Dependency Injection. Ja,
also dieses Weather-Tool braucht Zugriff auf auf ein anderes Objekt und
anstatt es sich selber zu erzeugen,
wird dieses Objekt im Konstruktor reingesteckt und ich merke es mir dann einfach.
Das ist so eine händische Version von Dependency Injection.
Es gibt auch noch Bibliotheken und Frameworks für,
wo das alles so ein bisschen impliziter passiert.
Aber das ist Zukunftsbrei, den ich gerade erzähle.
Gut. Ja, das heißt, ab jetzt können wir
also irgendwie damit was machen.
So, was machen wir denn noch? Vielleicht haben wir
irgendwie so eine Hauptschleife oder sowas drin. Vielleicht irgendwie,
ich nenne das mal ganz gerne Rapple,
kennt jemand
dieses Wort
So Konsolenanwendungen, Rappel, sagt das jemandem irgendwas?
Ich kann das vielleicht mal da drüber schreiben. Rappel,
das gleiche Reed, ever you add print loop.
Das sind also Programme, die warten darauf,
dass der Benutzer was eingibt, sonst passiert überhaupt nichts.
Und wenn er was eingibt, dann wird irgendwas damit gemacht,
was er eingegeben hat.
Ja, ihr seht das hier in unserem Anwendungsfall.
Und ich war, das soll ich ja eingeben,
solange ich das nicht eingebe, passiert nichts.
Und wenn ich es dann eingegeben habe, macht das Programm irgendwas.
Und nachdem es das dann gemacht hat, wartet es auf die nächste Eingabe.
Das ist so eine Schleife. Ja, gibt was ein,
wird verarbeitet, dann darfst du wieder was eingeben.
Das ist schon so eine klassische Konsolenanwendung. Das heißt also,
solange das System läuft,
werde ich aus dieser Methode
nie wieder rauskommen
Sollten uns vielleicht noch überlegen. Ich nehme das gleich mal,
ich habe gerade eine SMS von unserem Kunden bekommen.
Es soll also auch möglich sein, vielleicht sowas einzugeben,
wie Quit. Und dann System wird beendet oder so.
Weil das wäre ja schon irgendwie blöd, wenn man das
nicht beenden kann. Okay. Gut. Jetzt müssen wir
was tun, was ihr wahrscheinlich noch nie gemacht habt.
Wir müssen jetzt was von der Konsole einlesen.
Also ihr wisst ja wahrscheinlich, dass man was auf
die Konsole schreiben kann mit diesem System Outprintplan.
Das kennt ihr doch. System Outprintline. Hallo? Oder
machen wir ohne, dass L. Ähnlich will er keinen Seinruch haben.
Das ist jetzt quasi die Aufforderung, lieber Benutzer,
bitte gib mal was ein.
Aber wie lese ich denn jetzt das ein,
was er mir eingibt
Tja. Dafür gibt es eine Klasse,
das habe ich mir extra mal vorhin wieder rausgeholt.
Es gibt ja immer so viele Klassen in Java.
Da kommt man ja mal ein bisschen durcheinander, was es
da alles gibt. Also es gibt eine Klasse Scanner.
Und man kann diesen Scanner instanzieren, das seht ihr hier,
kann man das lesen? Ja. Ich kann nur sagen,
ich brauche einen neuen Scanner, der dieses System innen scannt.
System innen ist das Gegenteil zu System Out sozusagen.
Über System Out kann ich was schreiben auf die Konsole.
Out System innen kann ich was lesen von der Konsole.
Und mit diesem Scanner ist das einigermaßen angenehm,
weil der hat eine Methode,
die heißt Next Line
Sonst versucht mal mit Google rauszufinden,
wie man eine Zeile von der Konsole in Java einliest.
Das ist nicht ganz so trivial wie in anderen Programmiersprachen.
Das ist das Leichteste, was ich gefunden habe. Okay,
das heißt, wir legen uns hier mal so einen Scanner an.
Und initialisieren den mal, also ich muss importieren, ach,
da gibt es mehrere, wir nehmen mal Java Your Trill Scanner.
Und dann sage ich doch einfach mal,
ich brauche einen neuen Scanner, der System in verarbeitet.
Ob der für eine Klammeration, der System in verarbeitet,
ja? Gut. Ja, dann kann ich doch jetzt
hier eigentlich direkt mal anfangen, einzulesen.
Also, Laien ist gleich Scanner, Nextline.
Gut. Viel mehr müssen wir eigentlich vielleicht noch gar nicht machen.
Wirklich schwer können wir mal einen kleinen Test machen.
Ich sage jetzt einfach mal Benutzer, hat eingegeben,
dass euch einfach klar ist, dass es wirklich funktioniert.
Und dann diese Line. Und wir machen auch noch gar keine Schleife.
Das ist erstmal alles, was wir machen, okay?
Nur für den ersten kleinen Test. So. Jetzt haben wir aber
immer noch keine Main-Methode. Also wenn ich jetzt versuche,
das zu starten, wird natürlich nichts passieren.
Java ist ja nicht schlau genug zu verstehen, ach,
das ist ein Werkzeug, dann wäre es ja wahrscheinlich sinnvoll,
da mal anzufangen.
Wir haben keine Main-Methode. Gut. Wie machen wir das
denn in der Mediathek? Wisst ihr noch, ja
Genau, es gibt eine Startup-Klasse. Wir können da ja
mal ganz kurz reingucken, dass ihr seht,
dass wir uns da in unsere eigenen Konventionen halten.
Hier ist sie. Das heißt, man würde jetzt ja auch erwarten,
dass hier wahrscheinlich irgendwelche Services erzeugt werden und dann in irgendwelche Werkzeuge reingesteckt werden.
Ich gucke mal, ob das irgendwie, guck mal,
hier ist die Main-Methode. Schaut mal hier, wenn die
Services erstellt. Wunderbar. Dann wird hier ein Werkzeug erstellt
und das Werkzeug bekommt hier unter anderem den Service mit reingesteckt.
Genauso, wie wir es auch gemacht haben,
nur jetzt aus der Klientenseite. Das heißt,
wenn ihr jetzt hier zum Beispiel mal reingehen würdet,
würdet ihr erwarten, dass dieser Service an eine Exemplarvaria dazugewiesen wird.
Schauen wir das einmal
ganz kurz
Hier. Da passiert exakt dasselbe. Service wird reingesteckt von außen.
Ich merke mir, da kann ich später darauf zugreifen.
Gut, dann mache ich das mal wieder zu.
Das ist hier alles schon wieder Google-Kram, das könnt ihr noch nicht verstehen.
So. Okay, das heißt, wir bauen eine Starter-Klasse.
Jetzt muss ich das wieder zumachen, das verwirrt mich sonst.
So. New Class, Starter-Startup. So. Da will ich jetzt
eine Main-Methode haben, soll ich einfach Main starten gelernt hast.
Ja, dann fangen wir doch mal an mit dem Service erstellen.
Also ich will einen neuen Weather-Service haben.
Da ist er. Das spielt er in eine lokale Variable
. Da haben wir sie. Name ist okay.
So. Und dann will ich mir so ein Weather-Tool erzeugen.
Hallo? Und... Ach, guck mal, das ist
ja interessant. Also E-Clips ist schlau genug zu verstehen,
dass hier ein Weather-Service erwartet wird.
Und er schaut direkt, habe ich denn hier irgendeinen Weather-Service?
Ja, ich habe hier eine lokale Variable namens Weather-Service.
Oder ich könnte in alle Referenzen übergeben.
Dann nehme ich doch mal hier diese Variable zack und schon
hat das für mich eingetragen.
Nicht schlecht
Dann nennen wir das mal ein Weather Tool.
Okay. Fehlt noch irgendwas? Wir müssen diese Startmethode ausführen.
Sonst wäre es ja sinnlos, dass wir das Weather Tool erzeugt haben.
Wo ist es? Die Startreppe, da ist es.
Ja. Ich weiß nicht, warum hier immer so komische Zeilen genommen sind.
Und die verschwinden auch, wenn ich was tippe.
Und dann sind sie wieder da. Wenn du so irgendwelche Linux-Experten gibt,
die wissen, warum es liegt bitte nach der Vorlesung,
wenn eine Mail schreiben.
Okay, das wollten wir jetzt ja einmal ausprobieren.
Ob man tatsächlich in der Konsole was starten kann.
Ich zeige euch einmal ganz kurz oder schreibe es hin.
Alt, Shift, X, wenn mich nicht alles täuscht,
Shift X und dann
Passiert irgendwas? Achso, jetzt ist die Konsole unten offen,
das seht ihr gar nicht, ne?
So. Also, ihr seht, dass das Programm läuft,
sonst wäre ja nicht dieser Stopp-Button, man kann nur stoppen,
was läuft. Und jetzt ist hier diese Ausgabe erschienen,
gehen wir nochmal ganz kurz in unser Weller-Tool.
Warum ist die erschienen? Nur ja, System-Out-Print. Das
ist jetzt nicht erstaunlich, also, dass diese Zeile wurde ausgeführt.
Und jetzt hängt das System sozusagen gerade in dieser Zeile.
Der Kontrollfluss ist irgendwo innerhalb dieser Methode, und solange wir
da nichts eingegeben haben, wird jetzt nichts passieren.
Geben wir doch mal ein.
Ihr seht, ich kann jetzt hier was einglücken.
Es wird grün, wenn ich jetzt Enter drücke, zack.
Dann landet der Kontrollfluss wieder bei mir, die Methode wird verlassen.
Und dann steht in der Variable Line tatsächlich das drin,
was ich eingegeben habe. Ja, so schreibt man Konsolenanwendung.
Müsst ihr wahrscheinlich nie wieder machen. Okay. Ja,
wunderbar. Und dann kommen wir noch jetzt als nächstes vielleicht.
Eine Schleife da drumherum bauen, ja. Also,
vielleicht sagen wir mal, ah, ich mache mal einen beliebten Anfängerfehler.
Ich sage, solange der Benutzer nicht eingegeben hat,
Quit.
Das könnte fast eine Klausurfrage sein. Hier sind mehrere Probleme in dem Text.
Sieht jemand ein Problem? Also ich kann hier was eingeben
und wenn es nicht Quitt ist, sage ich dem Benutzer,
was er eingegeben hat und dann wird ja wieder die Schlafbedingung geprüft.
Gibt es da irgendein Problem? Ja. Richtig,
das will ich einmal demonstrieren, das wird dauernd ausgegeben.
Also ich starte das System. Wenn ich jetzt sage toll,
ja toll ist ja nicht Quitt,
also wird das jetzt immer wieder auf die Konsole geschrieben,
nicht so wahnsinnig sinnvoll.
Also was sollte der Benutzer denn machen können,
nachdem er, nachdem einmal seine Eingabe verarbeitet wurde?
Was wäre jetzt sinnvoll?
Genau, er soll eine neue Eingabe machen.
Ich mache mal was, was auch gerne falsch gemacht wird.
Ich kopiere mir das jetzt einfach hier rein.
Warum geht das nicht? Der Herr? Wir haben schon
die Variable Line. Also ich würde hier,
wenn das gehen würde in Java, würde ich eine neue Variable deklarieren,
da die neue Zeile reinschreiben und anschließend würde es diese Variable nicht mehr geben.
Wir wollen ja tatsächlich in die Variable reinschreiben,
die schon da ist. Das ist SE1-Wissen. Ich hoffe,
das ist euch
noch halbwegs klar
Jetzt müsste das eigentlich gut sein, dass ich immer
was Neues angeben kann. Also toll, super gut.
Ach so, jetzt erscheint dieser blöde Pomp nicht mehr.
Das ist vielleicht auch nicht so hübsch.
Das muss ich jetzt auch noch mal kurz hier reinkopieren.
Hier? Okay, vielleicht findet ihr eine saubere Lösung,
dass ich das nicht zweimal im Quelltext stehen haben muss.
Also neue Versuche, toll, super.
Okay, jetzt gebe ich Quitt an. Was wird passieren
? Was wird passieren, wenn ich jetzt Enter drücke?
Sehr schön, das hast du sehr ausführlich gesagt. Also,
dieser String, wo die fünf Zeichen,
Klammer auf Aquit drinstehen und der String,
der generiert wurde,
als ich diese fünf Zeichen auf der Tastatur eingegeben habe,
liegen an verschiedenen Stellen im Speicher
Und dieser Vergleich ist in Java bei Referenztypen immer ein Referenzvergleich.
Es wird also geguckt, ist das ein String-Objekt,
also so? Oder sind es zwei String-Objekte? Und es
sind zwei String-Objekte. Was ich ja eigentlich machen will,
ich will ja die Zeichen überprüfen, ich will überprüfen,
auch der Benutzer Klammer auf der QU-I-T eingegeben hat.
Wie kann ich denn Strings in Java auf inhaltliche Gleichheit überprüfen?
Weiß das noch jemand? Nur einer, zwei Leute nur
drei, vier. Mit Equels, genau, ne?
Punkt Equels, Klammer auf,
So, ist das jetzt korrekt? Logiker an die Front?
Ja. Da muss ein Ausrufezeichnen. Ich will ja nicht sagen,
solange der Benutzer Quit eingibt, soll es weitergehen.
So, jetzt müssten wir alle Bugs behoben haben.
Schauen wir nochmal ganz kurz. Also, A,
B, C. Und jetzt könnt ihr es überhaupt sehen,
was ich da unten eingebe, ja so gerade eben.
Quit. Gut. Ihr seht, es wurde tatsächlich beendet
. Hier ist nichts mehr und ich kann hier,
glaube ich, auch nichts mehr eingeben, oder?
Nee. Okay, ja, gar nicht so einfach.
Text in der Konsole in Java einzulesen.
Okay, die Hürde haben wir
jetzt genommen
Was wir jetzt aber eigentlich machen wollen, wir wollen nicht
einfach nur auf die Konsole schreiben, was der Benutzer eingegeben hat.
Sondern was wollen wir tatsächlich machen? Wenn ich da zum Beispiel Hamburg
eingebe oder Berlin oder so, was soll jetzt passieren?
Ja. Genau, wir wollen ihn nach den Wetterdaten in der Stadt fragen.
Sehr schön also, lieber Service, da ist er.
Und es gab hier nur eine Public-Methode, wo ist sie hier?
Get Weather, falcoast for String City. Und unsere City ist
die Line, ja, so, ne? Gut,
jetzt Ist das wahrscheinlich ein bisschen enttäuschend, weil dieses Gate Weather,
Forecast for line, liefert mir jetzt eine Liste zurück,
aber ich mache ja gar nichts mit der Liste.
Wollen wir irgendwas mit der Liste machen?
Ich speichere sie mir einmal in eine Variable.
Zack. Ja, nennen wir es mal Forecast, Mira.
Es muss nicht so ein langer Name sein. Also ich
habe jetzt diesen schönen Forecast. Was sollen wir denn jetzt
laut Spezifikation damit machen? Ja, bla bla bla.
Also wir sollen es irgendwie auf die Konsole schreiben.
Was passiert eigentlich, wenn man in Java eine Liste auf die Konsole schreibt?
Passiert da irgendwas Sinnvolles? Ich fürchte, das wird nicht
besonders hübsch aussehen. Wir können ja mal gucken,
was da passiert. Und unser Kunde wird es uns wahrscheinlich
um die Ohren hauen.
Also ich gebe mal Hamburg an
Okay. Das bedeuten dann diese ganzen Striche.
Ich hoffe nicht, dass der Service gerade offline ist.
Also ich habe den Eindruck, dass das hier die leere
Liste sein könnte. Aber mir ist nicht hundertprozentig klar,
wo diese Striche herkommen, ehrlich gesagt.
Wir können ja vielleicht Folgendes machen. Ich gebe hier Amacrit
an. Das wäre doch mal ein toller Zeitpunkt,
um zu debacken. Also wo ist mein Service?
Hier ist mein Service
Wo lese ich denn das XML ein? Hier,
Get XML-Fonds, wo rufe ich diese Methode auf?
References, Project. Okay. Wollen wir vielleicht mal hier
ein Breakpoint hinsetzen? Und mal schauen, was in der Variable XML
dann drinsteht, ob da irgendwas Sinnvolles drinsteht oder nicht.
Wenn da jetzt nichts Sinnvolles drinsteht, dann haben wir ein Riesenproblem.
Da kann ich dann aber nichts dafür. Gut,
das heißt, ich sage jetzt mal auf der Start-up-Klasse,
nicht Run ist,
sondern die Buckass-Java-Application
Damit wir auch bei diesem Breakpoint ankommen und sagen Hamburg,
jetzt bin ich mal sehr gespannt. So,
ihr seht, hier ist jetzt die, ah nee,
guck mal, hier, das sieht doch alles gut aus.
Weather Data, Location, Name Hamburg.
Ja. Nee, damit bin ich eigentlich zufrieden.
Warum ist denn dann so ein Unsinn passiert?
Ich hatte jetzt eigentlich gehofft, dass hier das Problem ist.
Wenn ich das jetzt einmal überspringe, wie hat sich jetzt
unser Map geändert?
Wir haben jetzt hier
die Forecasts
Da scheint noch nichts drin zu sein. Haben wir letzte Woche
irgendwas auskommentiert, was uns das jetzt hier kaputt gemacht hat?
Da müssen wir noch mal ganz kurz unsere geschulten Java-Augen raufschauen lassen.
Ob hier in Pass XML irgendein offensichtliches Problem ist.
Also wir haben hier diese Liste. Und hier sollte sie
eigentlich befüllt. Hier sollte sie eigentlich befüllt werden.
Gehen wir noch mal hier rein. Ach,
schau mal, hier kommen diese ganzen Ausrufezeichen,
die ganzen Minuszeichen,
das nehmen wir mal weg
Aber das wird doch tatsächlich in diese Liste reingetan, oder?
Das passiert doch hier. Ich starte das System einmal neu,
ob das immer noch so komisch ist.
Rainer Trull. Und ich mache jetzt vielleicht mal Freundes,
dass ich hier tatsächlich mit einer Vorschleife durchgehe. Nee,
muss man einfach, was haben wir denn da gemacht?
For each wollte ich haben. For each. Ja,
das nennen wir mal, das ist hier eigentlich plural.
Dann nennen wir das mal Forecasts und das nennen wir mal so
So, mal gucken, ob jetzt irgendwas Sinnvolles passiert.
Ich hoffe doch. Nee, die Liste scheint leer zu sein.
Das ist ja interessant. Okay, dann quitten wir das
mal. Dann haben wir da irgendein interessantes Problem.
Dann gehen wir mal wieder zurück in den Händler.
Und ich mache jetzt mal das sogenannte Debugging für Arme.
Ich werde jetzt jedes Mal, wenn wir hier ankommen,
werde ich einfach mal auf die Konsole schreiben,
dass das der Fall ist.
Ed forecast tour
Forecasts. Ich will einfach sicher gehen, dass diese Zeile
ausgeführt wurde. Das geht einfach ein bisschen schneller,
als das jetzt mit dem Breakpoint zu machen.
Okay, neuer Test. Okay, diese Zeile wird nie
ausgeführt. Das werden wir nicht so schön. Okay,
dann schauen wir doch mal, ob die Zeilen da drüber
ausgeführt werden. Da mache ich jetzt mal hier Folgendes.
Interstatt, Element
Und getonen. Und das mache ich hier unten auch mal.
Ihr seht manchmal in den Vorlesungen interessante Wendungen. Es passiert
auch in der Praxis manchmal, dass Programme nicht funktionieren.
Und ich finde, es ist auch eine ganz nette,
was habe ich hier gemacht. Eine ganz nette Fähigkeit,
spontan mal zu gucken, wo ist denn jetzt eigentlich das Problem?
Das führt euch ja in der Praxis auch passieren.
Die Realität ist ja nicht so geskriptet, dass immer alles funktioniert.
Also schauen wir mal. Aha, also in das Startelement
wird offenbar reingegangen. Ihr seht, wir kriegen massig Daten
. Okay, aber in das Entelement wird irgendwie nicht reingegangen
Das erkennst du an dem Slash.
Das erkennst du hier an diesem Slash. Ich glaube,
wir haben uns tatsächlich letzte Woche in der Vorlesung gar nicht
davon überzeugen können, dass das tatsächlich passiert.
Wir können ja mal Folgendes machen. Wir gehen mal
in die Superklasse. Mir ist es, glaube ich,
schon beim Schauen, dass ich das Vorlesungsvideos aufgefallen habe,
dass es da mehrere End-Element-Methoden gibt.
Und möglicherweise haben wir nicht die richtige genommen.
Nee, ist End-Element. Ihr seht also,
ihr erwartet drei Strings und wie ist es bei meiner End-Element-Methode
Guck mal, die nimmt noch solche Attribute entgegen.
Also ich könnte mir vorstellen, dass ich hier einfach die
falsche Methode überschrieben habe. Versuchen wir das doch mal.
Ihr seht, das ist jetzt ein reines Glück,
dass mir das zu Hause aufgefallen ist.
So einen Fehler findet man normalerweise nicht so schnell.
Mal gucken. Ara. Okay, das ist doch schon
deutlich besser. Also wir gucken mal ganz kurz.
Seht ihr, Startelement ist irgendwo, hier ist das Endelement.
Könnt ihr das sehen? Ja. Glück gehabt. Wir
hätten jetzt auch zwei Stunden nach diesem Fehler suchen können.
Okay, wir haben einfach die falsche Methode überschrieben.
Gut, dann kann ich jetzt meinen ganzen System-Out-Printlines wieder rausnehmen
Also, weg damit, weg damit. Ach so,
wenn ihr eine Zeile löschen wollt,
das geht in der Clips and Steuerung.de.
Hatten wir noch mehr? Ich glaube, das war's.
Aber irgendwas war noch komisch, oder?
Was ist das denn hier für ein merkwürdiges Zeug?
Wetter.forcast at 29 at 3DA1. Wo kommt das denn her?
Hat da jemand eine Ahnung, wo diese Merkwürdige, ja.
Ja, also hier wird quasi die To-String-Methode von Forcas aufgerufen
und die liefern auch überhaupt nichts Sinnvolles zurück.
Wollen wir die vielleicht mal überschreiben,
dass irgendwas Sinnvolles zurückkommt
Also, wie mache ich das?
Ich sage to string, wo haben wir sie da?
Overright Method and Object, das will ich machen.
Und ich würde euch einmal ganz kurz zeigen,
was das to string macht, wenn man es nicht überschreibt.
Ihr wisst ja, dieser Superaufruf, kleine Wiederholung,
in einer überschreibenden Methode kann ich die überschriebene Methode aufrufen,
eben mit diesem Superaufruf und ihr werdet es sehen.
Jetzt lande ich also in Java-Bibliothekscode, wenn ihr to string nicht überschreibt,
dann wird der Name der Klasse als String irgendwie generiert,
dann dieser Klammeraffe und dann der Hashcode.
Das ist ja genau das, was wir gerade gesehen haben.
Ist also nicht weiter verwunderlich. Eingebaute Java-Magie sozusagen.
Gut, dann überschreiben wir das doch mal halbwegs hübsch.
Jetzt kommen hier wieder die String-Formatier-Experten. Wie machen wir das?
Ich mache das jetzt völlig blöd. Ich schreibe einfach vielleicht
... Punkt, Punkt, Punkt. Das sieht so aus
wie ein Intervall. So. Dann vielleicht ein Zeilen. Um auch,
ihr erinnert euch vielleicht gerade, dass wir sowas ähnliches
auch mal bei den CDs und DVDs und so gemacht haben.
Was nehmen wir mal als nächstes? Nehmen wir mal Value,
dann nehmen wir mal das Unit und dann vielleicht noch,
vielleicht in Klammern, den Simple Name,
das war dieses Rainy oder irgendwie so ein Wort,
das beschreibt, wie das gerade aussieht.
Soll ich ein Wechsellash-N machen? Ja, ich mache es
mal. So, okay. Neu starten, schauen,
dass das True String jetzt was Sinnvolles macht, hups.
So, das sieht doch schon besser aus, oder?
Wollen wir uns einmal angucken, dass das irgendwie halbwegs sinnvoll ist,
was der mir rausgespuckt hat. 12 Uhr bis 15 Uhr,
da sind wir ja quasi gerade, 17,5 Grad Celsius.
Ja, ich komme das ungefähr hin,
ich bin nicht so ein Temperaturmensch,
hat jemand irgendwie Vergleichswerter auf seinem Handy oder so,
angeblich und es soll ein bisschen regnen,
das habe ich
gar nicht gemerkt
Na gut, ist ja auch nur eine Vorhersage. Okay,
das wurde jetzt also übers Internet geholt und jetzt können wir langsam zu der ersten Anforderung kommen,
wenn ich jetzt also nochmal Hamburg eingebe,
dann soll das nicht nochmal übers Internet geholt werden.
Die Daten werden jetzt ja exakt gleich sein wahrscheinlich.
Das ist irgendwie Verschwendung, da immer übers Internet zu gehen.
Gut, wollen wir uns darum mal zuerst kümmern.
Diese Excession ist nur aufgedreht, weil ich das Programm gekillt habe.
Ja, ich war zu faul, Quit einzugeben.
Das ist also kein Fehler an unserem Programm. Gut. Genau,
also ich habe also Hamburg zweimal eingegeben,
ich habe jedes Mal diese Methode aufgerufen und was haben wir
in dieser Methode gemacht
Genau, wir haben als allererstes erstmal gesagt, hol dir doch mal das XML übers Internet.
Das wollen wir jetzt aber nicht. Wir wollen ja irgendwie unterscheiden,
ist in dieser Map schon ein Eintracht drin für die Stadt oder nicht?
Machen wir das denn? An welcher Stelle wäre das sinnvoll,
das zu tun, irgendwie so ganz unten oder im Catchblock oder bevor,
nachdem irgendwas Spannendes passiert ist, wann sollte man diese Überprüfung machen,
ob wir die Daten schon haben?
Ja. Genau, würde ich auch sagen. Jetzt ist eine spannende Frage,
ob wir das über das Trial schreiben sollen oder eher hierhin,
ich würde mal sagen, Wenn wir in der Map die Daten haben,
müssen wir ja überhaupt nichts machen mit,
was irgendwie eine Acception auslösen könnte.
Mein Forscher ist zu sagen, wir machen das hier.
Also ich will wissen, Forecasts,
ob es da schon einen Eintrag gibt zu der Stadt.
Ja, es ist gleich die erste Methode.
Also manchmal bin ich total erstaunt, wie Schlau-Eclipse ist.
Also es gibt eine Methode Contains Key.
Und dann kann ich diese City übergeben. Und das wird
eben True sein, wenn wir schon einen Eintrag haben.
Okay, dann will ich was machen. Und im anderen Fall,
oh Gott, das wird ganz schön lang,
das müssen wir gleich mal refactoren.
Im anderen Fall will ich dieses Remote-Ding machen. So,
also ich habe festgestellt, ich habe diesen Schlüssel in
der Map zu der City.
Was will ich jetzt zurückgeben
Wie komme ich denn jetzt an diese Liste ran?
Ich will ja an diese Liste jetzt quasi rankommen.
Ja. Genau. Genau, noch das Ganze returnen wir dann einfach.
Okay, das Witzige ist, sehe ich gerade,
dass diese Zeile ja genauso ist wie diese Zeile.
Vielleicht könnt ihr euch mal überlegen, ob das irgendwie einfacher geht.
Aber was mich total beunruhigt, ist, dass die Methode
ist irgendwie zu kompliziert. Ich habe ein ewiger MLs,
okay, dann habe ich in dem Elser mal einen
Try Catch und irgendwie finde ich das nicht so hübsch.
Ich würde eigentlich ganz gerne diese Methoden, oder ne,
Entschuldigung, diesen Code-Blog in eine eigene Methode auslagern
Das haben wir schon mal gemacht, wir haben das schon mal von Hand gemacht,
irgendwann habe ich das Eclipse automatisch machen lassen.
Als kleine Erinnerung, was drückt man nochmal, wenn ich,
wenn ich da so eine eigene Methode machen will?
Weiß das noch jemand? War das nicht AltshiftM? Genau,
das könnt ihr nicht sehen, aber ich kann da oben jetzt
einen Methodennamen eingeben. Ich ziehe das mal so runter,
dass ihr das sehen könnt, weil das total wichtig ist.
Genau. Wie wollen wir die nennen,
sagen wir mal, also ich will den Weatherforecast haben,
ja, ich nenne das jetzt einfach mal Talk,
Show, Open, Weathermap.
Mir fällt gerade nichts Besseres ein. Aber es sollte irgendwie
daraus klar werden, dass jetzt was ist,
was man im Internet zu tun hat.
Jetzt drücke ich einfach Enter. Und ihr seht jetzt,
Jetzt ist der Code, finde ich, irgendwie leichter verständlich.
Ich habe hier eine Fallunterscheidung, entweder mache ich es lokal oder ich mache es remote.
Gut. Und wer mich interessiert, wie dieses Remote genau funktioniert,
dann schaue ich eben in der Methode darunter.
Das ist jetzt im Prinzip so, wie die Methode vorher war.
Ich habe eigentlich, dass IFLs jetzt nur darum rumgebaut,
ich habe es nur auf einem anderen Weg erreicht.
Okay. Ja, vielleicht machen wir dann jetzt auch noch
diese D-Bug-Ausgabe hier rein. Also, wie wollte der Klient
das haben? Fatching Remote-Data, Fatching Local Data.
Also dann sage ich hier Setching,
Local Data
Zack. Und dann sage ich hier Fetching, Remote Data.
Okay. Und ich werde jetzt mal gleichzeitig etwas machen.
Ich werde jetzt mal in dieses Weather-Tool reingehen und ich werde
mal sagen, ich will nicht alles sehen.
Ja, das bewirbt mich immer so, wenn da jetzt
so eine riesige Fünf-Tages-Ausgabe kommt. Mir reicht es eigentlich,
dass das Erste zu sehen, was da drin steht.
Ja, ich nehme jetzt mal hier diese Schleife weg.
Ich will ja einfach nur mal sehen, dass es überhaupt funktioniert.
Gibt es sowas wie First oder so? Kann ich da
irgendwie sagen, so was will er jetzt schon mehr?
Achso, ich habe jetzt ja
gar nicht mehr
Wie kriege ich jetzt das erste Element? Get null,
Get null. Ja, in manchen Programmiersprachen geht das noch
ein bisschen expliziter. Okay, da muss ich nicht mal
so viel hoch und runter scrollen.
Schauen wir noch mal, ob das jetzt entsprechend funktioniert.
Also ich würde jetzt erwarten, dass sie jetzt,
was würden wir jetzt erwarten? Soll da jetzt stehen,
Fatch Local Data oder Fatch Remote Data?
Vielleicht mal eine Abstimmung. Wer sagt lokal? Okay,
und wer sagt remote? Die meisten. Gut. Denn
jetzt ist es ja zum ersten Mal in die Map reingekommen.
Ja, wir haben ja keine Langzeitpersistenz in dem System.
Immer wenn ich es neu starte, ist die Map ja leer.
Gut, genau, das war das, was wir gerade gesehen hatten.
Und jetzt gebe ich nochmal ein, was sollte jetzt passieren?
Wer sagt, dass jetzt Local kommt
Okay, und wer sagt das jetzt, immer noch remote ist?
Keine Ahnung. Gut, funktioniert. Das ist doch schön
. Ja, dann schaue ich doch mal ganz kurz,
was wir noch machen sollen oder wollen.
Das funktioniert, genau. Ja, das ist jetzt,
glaube ich, ein ziemlich großer Brocken.
Also ich hatte mir überlegt, vielleicht will man auch mal wissen,
was ist denn so die Durchschnittstemperatur morgen? Ja,
da müsste man dann also irgendwie über diese Liste rübergehen, gucken,
welches Datum ist es, dann müsste man das aggregieren,
dann müsste man den Durchschnitt bilden.
Und wir haben jetzt noch sechs Minuten,
ich kann ja mal
Matthias fragen
Ich soll weitermachen, okay, gut. Ich habe also den Segen,
da muss ich kein schlechtes Gewissen haben. Ja, okay,
das heißt, wir haben jetzt einmal in der Konsole,
haben wir jetzt die Herausforderung,
wir müssen das irgendwie auseinanderziehen, wir müssen erstmal gucken,
dass das hier tatsächlich dieses Average Tomorrow am Anfang steht und
dahinter dann um welche Stadt es gehen soll.
Vielleicht machen wir das System erstmal einfacher, man gibt nur
Average Tomorrow ein und es funktioniert nur für Hamburg.
Das System ist noch nicht so toll,
dass wir es außerhalb von Hamburg jemals einsetzen werden wahrscheinlich.
Wir beschränken uns mal auf Hamburg, das heißt,
ich nehme das jetzt hier mal weg,
ich vereinfache jetzt mal
die Anfrage.
Das könnte man wunderbar aufteilen. Ja,
wenn ihr jetzt in einem Team wert, könnte man sagen,
hey, die einen können sich doch schon mal darum kümmern,
dass man das eingeben kann, dass es erkannt wird.
Also ihr schreibt in der Werkzeugklasse,
das andere Team kann schon mal in einem Service anfangen rumzuhühnern.
Also wenn ich jetzt irgendwie so gut wäre,
dass ich auf zwei Tastaturen gleichzeitig tippen könnte,
dann würde ich das jetzt vorführen.
Gut. Also dann gehen wir doch mal in das Tool,
irgendwie scheint mir das, da sind wir ja schon drin.
Genau, also momentan gehen wir davon aus,
dass in der Line die Stadt drin steht.
Und wir könnten jetzt erstmal die Unterscheidung machen,
ist das sowas Spezielles, wie dieses Ed,
wie hieß es,
Everage Tomorrow,
dann muss ich damit
was Spezielles machen
Wenn es at ever, wisst ihr was,
ich nenne es mal nur Tomorrow, weil sonst werde ich
mich später ständig vertippen bei so einem längeren String.
Also wenn es das ist, dann will ich was Besonderes machen.
Ansonsten will ich eben das machen, was ich vorher auch schon gemacht habe.
So, das würde man jetzt auch eigentlich wieder in Methoden auslagern.
Das könnt ihr ja als kleine Hausaufgabe machen.
So, was machen wir jetzt? Jetzt haben wir im Prinzip
zwei Möglichkeiten. Die erste Möglichkeit ist zu sagen, ja,
wir holen uns jetzt einfach den Weather of Hawcast von Hamburg
und dann machen wir eine Schleife und gucken,
was sind denn die Einträge,
die für morgen gelten und dann mache ich diese ganze Logik hier in diesem Werkzeug.
Ich finde es eigentlich ganz gut,
dass ich hierfür noch die Zeit habe
Ihr müsst ja in eurem eigenen Projekt diese Vormark-Funktionalität einbauen.
Und ihr müsst dann einfach mal schauen,
in diesen Entwurfsregeln, in dieser Grafik, ja, wo bauen
wir denn diese Logik rein? Also zum Beispiel in unserem
Fall eben diese Schleife, wo soll die reingebaut werden?
Soll ich diese Schleife in das Werkzeug bauen?
Soll ich sie in einen Service bauen? Soll ich
sie ins Material reinbauen? Ich sage euch mal,
warum ich diese Logik nicht in das Werkzeug reinbaue.
Das liegt daran, dass man Fachlogik wie Durchschnittstemperatur von morgen
, würde man ja auch gerne mal testen
Das ist der eine Punkt, ja.
Und Werkzeuge testet man fast nie. Kann ich euch versprechen,
das lohnt sich in den meisten Fällen einfach nicht.
Es gibt ja Leute, die das tun, aber gut.
Man kann sich auch vorstellen, es soll mehrere Werkzeuge geben.
Ja, vielleicht soll es eine Konsolenanwendung geben,
dann soll es eine grafische Oberfläche geben für einen Desktop,
dann soll es das nochmal mobil geben.
Und ich will diese Logik, wie berechnet sich eigentlich die Durchschnittstemperatur?
Will ich nicht auf jedem Gerät neu programmieren müssen?
Ja, ich will in dem Werkzeug keine Fachlogik drin haben.
Während dieser Service, der ist ja eigentlich relativ geräteunabhängig,
ja, ob jetzt hier irgendwie ein iPhone mit mir redet oder ein normaler,
normaler Computer, ja.
Oder eine Konsoleneingebaut, so. Das ist dem Service
ja im Prinzip
völlig egal
Ja, also jegliche Fachlogik, bitte in den Service und wenn es geht,
kann man es auch in die Materialien reintun.
Ich glaube, das wäre in unserem Fall nicht so möglich,
weil ein Material kennt ja immer nur einen Wert und kann jetzt nicht irgendwie großartig aggregieren über mehrere Werte.
Ja, ich entscheide mich also dafür, das in den Service zu tun.
Das heißt, ich kann mir jetzt hier einfach mal vorstellen,
es würde eine Operation geben, ich sage jetzt mal,
Service, Punkt, ja, Average, Tempridge,
ja,
was muss ich denn da jetzt alles übergeben
Ich muss ein Datum übergeben und in welcher Stadt das sein soll.
Also sagen wir mal als Datum, jetzt muss ich einmal,
das ist jetzt so ein bisschen technisch,
ich muss einmal die XML-Datei reingucken, wie die hier genau aussehen.
Guck mal, die sind so formatiert.
Das ist so ein bisschen krude. Eigentlich sollte man das
nicht so technikabhängig machen, dass das Format genauso aussieht.
So was haben wir denn morgen? Das ist jetzt auch
sehr cool. Ich gucke gar nicht, was tatsächlich.
Das Datum ist, ich hardcode das jetzt hier, hups
, 05526. Das würde man natürlich normalerweise alles dynamisch machen.
Ich würde das Java-System fragen, welcher Tag ist heute,
welcher Tag ist morgen.
Okay, und dann werde ich
es von Hamburg wissen
Okay, ich wünsche mir einfach so einfach, dass es das gibt.
Und dann schreibe ich das auf die Konsole.
Ja, also in Hamburg wird es morgen durchschnitt durch.
Oh Gott, das ist ein schweres Wort. Durchschnittlich.
Ich habe das nicht gespeichert hier oben, sehe ich gerade.
Double Champ. Grad sein. Ja. So,
da können jetzt irgendwelche Benutzerfreundlichkeitsexperten sich streiten,
um das
eine tolle Meldung ist.
Diese Methode gibt es natürlich noch gar nicht. Jetzt könnte
ich in den Service reingehen und sie bauen und so,
aber es geht ja alles viel einfacher.
Ich sage einfach Steuerung 1 und sage, liebes Equipse,
erzeug mir doch mal bitte diese Methode.
Dann kann ich mich da zumindest nicht vertonen.
Create Method. So, jetzt haben wir sie hier.
Okay. Gut. Jetzt hier diese beiden Strings,
das ist nicht so wahnsinnig sinnvoll.
Also sagen wir hier mal Day und hier sagen wir mal City.
Okay. Ich strolle das mal ein bisschen hoch.
Jetzt habe ich natürlich überhaupt keine Ahnung,
ob wir überhaupt schon Daten zu dieser Stadt haben.
Ich könnte jetzt einfach direkt auf die Map zugreifen,
wenn ich Pech habe, ist da gar nichts drin.
Wie komme ich denn jetzt am sinnvollsten erst mal an diese ganzen Forecasts überhaupt daran?
Gibt es im Service irgendwie eine Möglichkeit zu sagen,
ich will zu dieser City, die Forecasts haben?
Haben wir das schon programmiert? Soll ich mal Steuern O drücken?
Von dir sagt mir jetzt, welche Methode es ist.
Keiner. Ja. Die hier, ne? Sehr schön
. Die wollen haben. Achso, ich habe ja noch
gar nichts geschrieben. Ja, die wollen wir haben.
Also ich rufe sie auf
Genau, die City ist schon richtig. Natürlich, das ist eine Variable rein.
Ja, ich nenne es einfach nur Forecast oder Forecasts.
Guck mal, das ist nicht so schön konsistent.
Manchmal mache ich Singo oder manchmal plural, das müsste man
in echt auch mal überarbeiten, dass es überall konsistent ist.
Okay. Jetzt müssen wir diese Liste durchgehen,
dafür geht doch die VEG-Schleife. Nein. So,
und ihr seht auch, ihr Clips ist unglaublich schlau,
der merkt, mit einer VEG-Schleife geht man ja über Collections.
Welche Collections gibt es denn hier so? Oh,
es gibt ja nur diese eine Collection,
dann will der Benutzer wahrscheinlich über die iterieren.
Na, den Element-Typ kenne ich ja von der Collection,
der steht ja ja. Naja,
und wenn eine Collection mit S endet,
dann ist das wahrscheinlich der Plural,
dann nehme ich mal für den Element,
für das einzelne Element,
dass er ist einfach weg
Toll, oder? Muss ich nichts von Hand schreiben.
Gut. Jetzt muss ich mal gucken,
ob das ein Forecast ist, der für mich relevant ist.
Ach, ich habe noch gar keine Ghetter.
Das ist ja blöd. Also ich würde gerne irgendwie an
das Datum rankommen, wie Get Date. Und wenn das,
ich muss das jetzt mal hier ein bisschen abkürzen,
wenn das mit dem Tag anfängt.
Das ist ja das, was als erstes drinsteht.
Ich beschleunige das jetzt mal so ein ganz kleines bisschen.
Das Get Date erzeuge ich mir, aber hier unten,
wie heißt das tatsächlich? Ach guck mal, das heißt ja
From From und True. Ich gehe mal davon aus,
dass die, oh, was machen wir denn jetzt?
Nee, ich mache es anders. Ich nenne es
Get Day und mache hier schon diese Beschneidung.
Ich kann ja hier einfach sagen, Pass auf,
ich gebe dir einfach das From zurück und zwar die ersten vier Zeichen.
Ja, das ist doch, nee, das ist ja nur das Jahr.
Die ersten, wie viele Zeichen sind das? Das Jahr,
ich muss einmal die XML-Dateien angucken, dass ich mich nicht vertue.
Wie viele Zeichen habe ich ja markiert? Eins, zwei,
drei, vier, fünf, sechs, plus wir sind zehn.
Machen wir es wieder zu. Also zehn Zeichen.
Das sollte den Tag also als String irgendwie charakterisieren.
Okay. Und dann kann ich ja auch direkt Equiels nehmen.
Was habe ich denn da für einen Unsinn eingegeben? Equiels,
der equiels day und dann hieß die Methodik auch day.
Ist das halbwegs sinnvoll, was ich gerade gemacht habe?
Ich glaube ja
Okay, und dann kann ich mir doch mal angucken,
was die Temperatur hier tatsächlich ist. Das gibt es auch
noch nicht. Das muss ich mir also auch wieder generieren lassen.
So, da sind wir, da sollte ein Double zurückkommen.
So, dann gehen wir mal hier zurück, die Tempridge Show.
Und das ist, glaube ich, ein String.
Das ist natürlich jetzt nicht so schön. Da muss ich
jetzt mal on the fly einfach sagen, Double Value of Champager.
Man wurde wahrscheinlich in Wirklichkeit die Temperatur von vornherein schon als
Double in dem Material erpflegen und nicht als String.
Wie heißt das, habe ich mich vertan?
Value heißt das. Value. Okay, du musst alles
noch nicht so wahnsinnig sauber, unser Datenmodell.
Das können wir beim nächsten Mal vielleicht ein bisschen bereinigen.
Jetzt haben wir leider gar nicht so viel Zeit.
Das ist also die Temperatur. Hallo, das reicht,
wenn es kurz ist. So. Und jedes Mal,
wenn ich diese Temperatur habe,
muss ich sie immer irgendwie auf so einen Akkumulator drauf addieren.
Ich sage jetzt einfach mal, Summe plus gleich Temp,
die gibt es noch gar nicht.
Das legen wir uns einmal ganz kurz an. So,
und ich muss mir merken, wie viele Summen ich gesehen habe.
Sonst kann ich ja schlechten Durchschnitt berechnen. Also jedes Mal,
wenn ich eine sinnvolle Temperatur gesehen habe, wird das hochgezählt.
Und was muss ich jetzt am Ende nur noch zurückgeben?
Ich habe also aufsummiert und ich weiß, wie oft,
wie viele Summen da drin sind.
Jetzt will ich den Durchschnitt haben. Vielleicht mal irgendjemand anders
. Ich habe ja so ein bisschen mathematische Begeisterung aussprüht,
der Durchschnitt
Ja. Genau. Some getimt durch N. Gut.
Jetzt gibt es hier keine Warnung mehr. Jetzt gehe ich
ganz kurz in meine Tools, machen wir den letzten Test.
Das Tolle ist, da kann jetzt irgendeine Zahl stehen.
Wir werden, glaube ich, nicht wirklich sehen können,
ob das sinnvoll ist. Mal gucken. Also ich würde
ja erwarten, wir hatten ja heute 17,5 Grad,
dass es morgen so ähnlich sein wird, oder?
Mal gucken. Ah, wir haben diese Logik,
hätte nicht in einem L sein dürfen.
15 Grad, guck mal, es wird morgen
ein bisschen kälter
Das beheben wir noch ganz kurz.
Also ich muss ja diese beiden Zahlen immer machen.
Das ist, glaube ich, hoffentlich eben klar.
Das heißt, ich ziehe diese geschweifte Klammer nach hier,
mache einmal Autoformat, mache noch einmal einen Test.
Das soll ja wirklich schön laufen, das System, also neuer Test.
Gut. Wo ist unsere schöne Meldung? Musst du da
jetzt nicht hin in Hamburg, wo du das morgen vorauslich...
Achso, weil ich Hamburg angegeben habe, ich Horst.
Ich hätte ja Tomorrow eingeben müssen.
Mann. Tomorrow
Genau. 15,6,11,25. Also das sieht nach einem berechneten Wert aus,
der steht nicht in den Originaldaten drin. Und jetzt gebe ich
das exakt nochmal ein und ich will es mal sehen,
dass hier jetzt nicht mehr remote steht, sondern Local, okay.
Gut. Ich denke mal, das reicht, glaube ich,
erstmal, heute als ganz kleine Zusammenfassung, was haben wir heute gemacht?
Was haben wir heute erreicht? Also, nachdem wir nochmal verstanden hatten,
wie diese Map aufgebaut ist, haben wir gesagt,
wir wollen nicht jedes Mal die Daten neu übers Internet holen,
sondern wir gucken einmal, haben wir die Daten schon?
Wenn ja, können wir sie zurückgeben? Ansonsten müssen wir
sie uns holen. Dann haben wir ganz viel Bugfixing betrieben.
Dann haben wir dieses Tool eingebaut, das Werkzeug,
wo der Benutzer tatsächlich interagiert mit dem Programm.
Das ist eine eigene Klasse. Und dieses Tool kommuniziert mit
einem Service, der als Konstrukteparameter reingesteckt wurde
Und die Sache mit dem Scanner ist relativ technisch.
Und hier ist dann diese Haupteingabeschleife,
die ihr wahrscheinlich in eurem eigenen Leben nie wieder schreiben müsst,
weil ihr demnächst wisst, wie man grafische Oberflächen baut.
Vielen Dank,
bis nächste Woche
Ja, dann wollen wir gar nicht so lange erwarten.
Hallo, auch von mir. Wir wollen gleich mal weiterschauen,
wo waren wir da krank gelblieben bei den Sachen,
die uns Fried gezeigt hat.
Und ich nehme deswegen noch mal eine Folie vom letzten Mal,
weil das war ja die Erläuterung vom letzten Mal.
Und zwar hatten wir da den Begriff des Services.
Das war gerade das, was uns Fried so schön anschaulich gezeigt hat.
Irgendwann kommt das bei mir hier auch. Wir hatten hier ein Bild,
wo die Fachwerte und die Werkzeuge zusammen waren mit dem Service.
Ja, also das, was uns Fried gerade gezeigt hat,
wo ist meine Maus
Ja, er hat einen Service gebaut, der uns Werte lieferte.
Fachwerte spielen jetzt hier nicht so eine starke Rolle,
weil wir keine Datenverarbeitung hatten. Wir haben eingegeben,
was wir brauchen, aber das ist ein Beispiel für einen Service,
der uns Daten liefert und dann Bestandteil eines Materials wird.
Das Ganze ordnete sich ein, auch vom letzten Mal,
in diese Grundmethodik, ein Werkzeug, ein Service,
ein Material,
ein Fachwert
Das, worüber ich beim letzten Mal gesprochen habe,
klang ja gar nicht danach, als ob man das direkt mit Java macht.
Umso schöner war das, dass Fried uns das gleich zeigen kann,
wie das mit Java denn aussieht. Tatsächlich ist es so,
wenn wir hier davon sprechen, ein interaktives System zu bauen,
dann gestalten wir erst mal etwas und das passiert noch vor der Programmierung.
Wir sprechen vom Entwurf, das ist auch das Thema,
was wir heute fortsetzen wollen mit Entwurfsmethodik, ein bisschen ein Ausflug.
Beim letzten Mal ging es ja um diese Methode Wamm,
die wir bei SE2 einsetzen, wann als Werkzeugmaterialeinsatz, die Abkürzung A,
das A da drin ist nicht Werkzeug und nicht Material,
das ist Automat, Werkzeugautomatmaterial,
so war das damals bezeichnet worden von den Erfindern,
dieser Methodik.
Und diese Vorgehensweise dient dazu, die Anwendung zu strukturieren,
um etwas einzuteilen, zu analysieren, was mache ich denn?
Eben nicht nur runterprogrammieren, sondern vorher strukturieren,
was ist ein Service, was ist ein Material,
was brauchen wir als das interaktive Werkzeug?
Dazu möchte ich nochmal, das drauf wollte ich nochmal kommen,
diese Begriffe. Wir hatten ja beim letzten Mal,
dass ein paar Folien weiter erläutert, was ist ein Material, was ist ein Fachwert
Und dann kamen diese fachlichen Services und die Werkzeuge.
Das sind die Sachen, die sollten sie sich unbedingt angucken,
die sollten sie unbedingt können.
Die kommen in der Prüfung sehr sicher davor. So,
wir machen weiter mit dem Stoff der Vorlesung 7. Ich habe
leider ein bisschen spät mit Hochladen. Tut mir leid,
das war nicht rechtzeitig fertig, aber wenigstens können sie jetzt darauf zugreifen.
Diese Vorlesung bezieht sich, hat den Titel objektorientierte Programmierung und Modellierung.
Und wir liefern, wollen, wollen heute darüber sprechen,
was sind denn die Dinge, auf denen die so eine Methode aufbaut.
Was machen wir, wenn wir eine Anwendung strukturieren?
Der Begriff modellieren klingt so ein bisschen, da steckt das Modell drin,
ein Modell, ja, ist erstmal so ein,
so ein Ding. Ach ja, vielleicht für die,
falls es jemanden gibt, der hier noch nicht war,
ich bin der Erste in dieser Reihe der Namen,
ich habe mich ja einfach mal davor gesetzt,
weil ich noch ein bisschen bearbeitet habe,
sonst sehen sie häufig Guido Kritzern hier und mein Name ist Matthias Riebisch.
Wir sind heute vom Thema her dabei, diese Entwurfsmethode,
Werkzeugmaterialansatz zu einzuordnen in das, was Andere Entwicklungsmethoden, Softwareentwicklungsmethoden machen.
Und damit wollen wir über Modellierung sprechen. Das wäre ein
Punkt, wo ich gern mal ihre Meinung einholen möchte.
Was ist ein Modell? Modellierung steckt ja das Modell drin
. Was ist ein Modell? Bitteschön. Super,
eine Vereinfachung einer realen Situation, eines realen,
etwas aus der realen Welt.
In welche Richtung könnten wir denn, könnte das
eine Vereinfachung sein
Was könnten wir, Vereinfachung bedeutet ja,
ich lasse etwas weg, Sie haben das Wort Abstraktionen genannt,
abstrakt, etwas Abstraktes, lässt Details weg.
Was lassen wir denn weg bei einem Modell? Oder vielleicht,
vielleicht fragen wir doch einmal, vielleicht gibt es auch
noch Beispiele für ein Modell, bitter, eine Antwort.
Das klingt schon sehr nach Informatik. Modelle gibt es
auch außerhalb der Informatik. Natürlich können wir,
das wäre ein Beispiel, man könnte so etwas weglassen.
Wo gibt es denn noch Modelle? Wenn wir davon sprechen,
Systeme zu modellieren, jetzt hatten wir etwas,
ein Service, ein Werkzeug,
das passiert auch,
bevor wir wirklich etwas mit Informatik machen
Modelleisenbahnen sind ein bisschen aus der Mode gekommen,
auch wenn das Miniatur-Wunderland wahre Erfolge feiert. Der Merklin-Konzern hat
wohl damit zu kämpfen, dass zu wenig Umsatz gemacht wird,
weil die jüngeren Generationen sich nicht so viel Modelleisenbahn interessieren.
Das wäre zum Beispiel ein Modell, da habe ich
eine kleine Eisenbahn, die sieht aus wie der Eisenbahn,
die fährt auch tatsächlich, aber ein paar Sachen Stimmen nicht.
Da ist nicht wirklich ein Lokführer drin, das Ding fährt
nicht wirklich mit Diesel, die bremst nicht wirklich mit Druckluft.
Also ein paar Sachen sind vereinfacht,
auch die Kupplung ist ein bisschen anders als bei der Realität,
aber sie fährt.
Ein paar Sachen sind drin
Ich hatte neulich das Vergnügen, einen Ersthelfer-Lehrgang zu machen.
Bei ihnen liegt das vielleicht nicht so lange zurück,
wie bei mir, der zurück lag.
Das war für mich mal wieder sehr erhellend,
aber da hatten wir auch ein Modell.
Nämlich so für diese Wiederbelebungsdruckmassage. Da musste sich keiner von
den Teilnehmern hinlegen und sich da den Brustkorb zerquetschen lassen.
Nein, da hatten wir so ein Teillegen. Hat auch
etwas von der Realität weggelassen. Hat nämlich das weggelassen,
das darf kein Fleisch und Blut drin war. Ja,
aber es gab sowas wie einen Rachenraum, es gab einen Lungenraum,
es gab auch etwas, wo man den Kopf da zurückstrecken muss.
Ich hoffe, sie erinnern sich alle noch,
dass der Atemkanal frei war.
Also ein paar Sachen waren aus der Realität da und
ein paar Sachen waren nicht da
Wonach entscheiden wir denn, was wir lassen und was wir weglassen?
Was fällt der Abstraktion zum Opfer? Und was bleibt dem
Modell enthalten? Wonach würden Sie denken und scheiden wir das
? Eine Meinung. Ja, eine praktische Entscheidung,
das ist, wovon würden Sie das abhängig machen?
Praktisch bedeutet ja, ich kann es irgendwie anfassen.
Ich sehe eine Meinung, was denken Sie
Super, also ich wiederhole es mal lauter. Sachen,
die man braucht, ja, haben sie gesagt.
Das ist genau der Punkt, in ein Modell,
nehme ich das auf, was ich brauche,
um den Zweck zu erfüllen, was ich damit möchte.
Tatsächlich gibt es sogar so etwas wie Modellierungstheorie.
In der Wissenschaft gibt es für fast alles irgendeine Theorie.
Also für Modellierung gibt es auch eine Theorie,
da spielt dieser Zweck eine große Rolle. In einem Modell,
nämlich das auf, was ich für den Zweck brauche.
Und wenn wir jetzt ein interaktives System gestalten wollen,
dabei geht es ja bei dir unserer Entwurfsmethode bei unserem Softwareentwurf,
den wir bei SE2 machen wollen, Da geht es darum,
wie gestalte ich die Interaktion zwischen den Menschen und dem Benutzer?
Und da brauchen wir genau diese Sachen,
die wir jetzt eben in dem Bildchen gesehen haben, wir brauchen etwas,
worum es geht, was bearbeitet wird, das nennen wir Material.
Wir brauchen etwas, das die Bearbeitung durchführt und gleichzeitig das ist,
womit der Mensch arbeitet, das bezeichnen wir als Werkzeug.
Und ein Modell ist damit das,
eine Abstraktion des Realen, eines realen Vorgehens,
zum Beispiel eines Systems für die Ausleihe von irgendetwas,
was wir ja hier als Beispiel haben,
Ausleihe von digitalen Medien zum Beispiel.
Damit lassen wir ein paar Sachen weg.
Wir lassen vielleicht weg, wie die CD genauso genau aussieht.
Wir sagen mal einfach, es gibt ein digitales Medium.
Wir lassen weg, wie der Mensch genau heißt, der das ausleiht.
Wir lassen weg, welche Farbe der Tisch hat,
über den die Bedienung erfolgt. Das sind alles Sachen,
die wir nicht brauchen, aber wir brauchen ein paar essenzielle Übergänge,
Handlungen, Dinge, die dabei besprochen werden.
Und das geht darum, geht es bei Modellen.
Jetzt aber zu unserem Punkten hier, Objektorientierung, Objektorientierung wurde entwickelt,
genau mit dem Ziel, solche Modelle zu schaffen.
Anfangs der Informatik der Programmierung hat man sehr kleine Systeme entwickelt.
Da braucht man keine Abstraktionen. Es ist nicht so viel,
dass ich etwas weglassen muss, sondern eigentlich kann der Entwickler alles im Kopf behalten.
Bei kleinen Systemen sind sie selbst der Auftraggeber.
Sie sind selbst in der Lage, alles im Kopf
zu behalten und da brauche ich nicht groß ein Modell.
Aber so wie ich mit mehreren Leuten spreche,
die alle arbeitsteilig zusammenarbeiten wollen, brauchen wir ein Modell,
um Dinge besser verständlich zu machen.
Und dazu braucht man gute Begriffe. Die Jahreszahlen,
die Sie jetzt auf den folgenden Folien sehen, slingen alle irgendwie nach Steinzeit.
Also wir waren Angefangen hat das mit der Objektorientierung,
dass man versucht hat, Software anders zu gliedern, als das früher übrig war.
Erst gab es nämlich nur Daten und Funktionen.
Und diese Daten und die Funktionen waren an unterschiedlichen Plätzen.
Die Daten waren die Variablen, die standen irgendwo im Speicher.
Die wurden am Anfang des Programms deklariert und zwischendurch musste man die einfach kennen.
Und man konnte von überall her darauf zugreifen. Bei kleinem Programm ist das super,
bequem und ich brauche nicht viele Aufstände zu machen,
aber dass die Bugging mit globalen Variablen,
wer von ihnen schon größere Programme bearbeitet hat, weiß,
das ist ganz schwierig.
Also kann man auf eine andere Idee,
nämlich Dinge als Objekte
zu betrachten
Ja, das Erste, was Objekte hatte, war die Sprache Simular rechts im Bild.
Das ist eine Programmiersprache, die man für Simulationssysteme empfunden hat.
Simulation ist ja etwas, ich möchte die Realität nachbilden.
Das ist auch was mit Modellen zu tun.
Modelle wollen auch die Realität nachbilden. Man hat hier versucht,
das Verhalten und den Zustand von Dingen der realen Welt
nachzubilden und hat das benutzt, zum Beispiel für Verkehrssysteme.
Dazu braucht man das, um zu testen. Ja,
also sie wissen, bei der Eisenbahn ist,
das ist immer das Risiko des von Unfällen.
Wir hatten ja kürzlich erst einen schweren Eisenbahnunfall in Bayern.
So etwas darf möglichst nicht passieren. Man möchte irgendwie Systeme entwickeln,
mit denen man das ausschließen kann, im Steuerungssystem,
mit dem man Unfälle ausschließen kann.
Da muss man vorher viel simulieren, viel testen.
Dafür für solche Systeme ist es entwickelt worden. Später ist Smalltalk entwickelt worden,
links im Bild oder links erwähnt, ist die erste objektorientierte Sprache,
vieles von dem, was Ideen in Smalltalk war,
ist das, was wir heute in Java haben.
Insofern ist das, die Jahreszahlen liegen zwar Jetzt wäre es
sehr lange her, aber es ist doch relativ präsent noch.
In Java war es so, dass selbst in Smalltalk,
dass selbst eine Zahl ein Objekt ist, man hatte immer alles als Objekt betrachtet.
Und diese Objekte erlauben eine gute Zusammenfassung von den Dingen,
die da relevant sind. Ich kann mich auf eine Sache
konzentrieren und das war die brechende Idee hinter Objekten.
Diese Objekte ontierten mit Methoden, Simular, betrachten,
brachten erstmalig die Begriffe Analyse und Entwurf auf, wo es darum geht,
eine Aufgabenstellung zu verstehen, bevor ich anfange mit Programmieren.
Und das ist genau der Punkt, mit dem wir uns hier auch beschäftigen wollen.
Man wollte, es gibt ja hier eine Reihe von wichtigen Autoren.
Das geht so in die 90er Jahre rein.
Und jeder von diesen Autoren hat versucht,
eine Methodik unter die Leute zu bringen,
mit denen man in der Praxis gut komplizierte Programme entwickeln kann.
Mit denen man gut Arbeitsteilungen realisieren kann, mit denen man gut modellieren kann.
Modellieren im Sinne von, ich male ein Bild,
Sie kennen alle diesen Spruch, ein Bild sagt mehr als tausend Worte.
Ja, ich melde eine Struktur, zum Beispiel eine Struktur,
wie die Daten in dem Wetterdienst, den Fried uns skizziert hat,
wie die denn vorliegen.
Weil das einfach besser zu überschauen ist als eine komplizierte XML-Datei
und man hat versucht, Modellierungssprachen zu entwickeln. Diese Modellierungssprachen,
davon gab es eine Zeit lang sehr viele,
Anfang der 90er Jahre, das ist so ein Zeitpunkt,
wo als ich selbst in die Informatik gekommen bin,
das war so ein Zeit der Methodenkampf des Methodenkampfes,
also die verschiedenen Methoden haben versucht, Anhänger zu gewinnen.
Da gab es tatsächlich Leute,
die durch die Landschaft gefahren sind und für ihre Methoden geworben haben,
ja, weil sie natürlich hinter den Methoden auch etwas,
eine Dienstleistung anbieten wollten,
sie wollten sich selbst als die kompetenten Leute präsentieren
Wichtig war, sind vielleicht die Namen, die wir hier sehen,
Creddy Booth, James Rambo und Iva Jacobson,
da steht er in der zweiten Teile,
das sind drei von den Leuten gewesen, die verschiedene Methoden hatten.
Und die haben dann irgendwann mal gesagt, lasst uns zusammenschließen.
Es gab damals ein großes Dilemma, nämlich das Dilemma,
das ist keine Tools für diese Methoden gab.
Ein Tool, damit ist gemeint nicht ein Programmierwerkzeug, sondern ein Zeichenwerkzeug.
Ein Werkzeug, wo ich vorgefertigte Elemente habe,
wo ich daraus möglichst gleich irgendwie Quellcode-Klassen generieren kann.
Und das Problem war für die Toolhersteller war unklar, welches dieser,
sage ich mal, circa 20 Methoden sich dann unterstützen sollen,
weil jede war anders.
Und jeder hatte nur einen kleinen Marktanteil.
Und den Toolhersteller müssen natürlich sehen, dass er Kundschaft kriegt.
Und diese drei Leute, Booth, Rambo, Jakobsen,
haben die brennende Idee gehabt. Wir haben gesagt,
wenn wir drei uns zusammenschließen und unsere Anhängerschaft vereinigen und wir
eine gemeinsame Methode haben, sind wir Marktführer.
Und tatsächlich, das hat geklappt. Sie haben ihre Sprache UML genannt,
Unified, Modelling Language, eine Modellierungssprache mit Kästchen Linien verschiedenen Symbolen,
die wir,
von denen wir schon einige Bilder kennengelernt haben und diese Modellierungssprache kann man dann ganz gut verwenden,
um etwas zu strukturieren.
Und das ist das, was wir in Zukunft auch machen werden.
Auch wenn die Jahreszahlen, die hier auf der Folie stehen,
schon ein bisschen jünger sind, so ist das alles doch eine Weile her.
Auch 1997 UML 1.0 ist schon eine Weile her,
dann später gab es Anfang der 2000er-Jahre die UML 2,
die nochmal einen deutlichen Wechsel gemacht hat.
Und seitdem ist UML eigentlich der Marktführer,
wenn es darum geht,
objektorientierte Softwaresysteme zu beschreiben
Es gibt noch weitere Arbeiten,
es geht heute weiter und beispielsweise werden serviceorientiertes System entwickelt,
die ganz viel benötigt werden, um Webservices zu machen.
Da kommt der Begriff Service her, den wir bei dem Wetterpeispiel schon hatten.
Doch da wollen wir jetzt gar nicht weitergehen.
Wir wollen uns jetzt anschauen,
was aus diesen Methoden wir denn verwenden können für unser Vorgehen
gut zu strukturieren,
damit wir
in größeren Teams arbeiten können
Zunächst müssen wir zwei Sachen unterscheiden. Die wollen wir
als grundlegende Herangehensweisen separat betrachten. Das eine,
wir wollen, das ist der erste Punkt, anwendungsorientiert.
Wir wollen aus der Sicht des Anwenders eines Systems dieses Systems betrachten.
Anwender ist jetzt zum Beispiel jemand, der vor einem Fahrkartenautomat steht,
der auf einer App einen Wetterbericht haben möchte,
der eine Veranstaltung strukturiert oder der etwas kaufen möchte.
Das ist der Anwender, der Bediener eines Softwaresystems.
Und aus diesem, aus dem Blick dieses Anwenders können wir das betrachten.
Hier steht das Wort von der fachlichen Dynamik. Damit ist gemeint,
Es gibt einen gewissen Ablauf, aber das ist rein die Aufgabensicht.
Das ist die Sicht desjenigen, der bearbeitet. Da ist
nichts von Technik die Rede und deswegen passiert das auch,
können wir das auch durchaus machen, ohne mit Java gleich zu programmieren.
Es gibt da ganz nette Entwicklungssysteme, wo ich sowas wie
eine Bildschirmmaske gestalten kann. Ich kann da sogar draufklicken.
Da wird es simulativ etwas abgearbeitet, ohne dass ich programmieren muss.
Und dann kann ich mit den Leuten diskutieren,
die Beispiele für meine späteren Benutzer sind, um zu ermitteln,
verstehen die das?
Ist das so für die folgerichtig? Habe ich das
überhaupt richtig verstanden
Und erst wenn ich das richtig verstanden habe,
der Entwurf akzeptiert wird, auch für Leute verständlich ist,
die weniger IT-Know-how haben, als wir Informatiker,
erst dann wird das System in die Realität umgesetzt.
Das ist der erste Punkt. Dabei orientieren wir uns sehr
stark an diesen fachlichen Dingen, fachliche Gegenstände, Arbeitsprozesse.
Wir hatten beim letzten Mal schon über Materialien gesprochen,
Fachwerte, Werkzeuge, das orientiert sich an diesen Prozessen.
Der zweite Punkt, Da geht es um die technische Seite.
Wir wollen ja am Ende eine technische Realisierung haben. Und diese technische Realisierung,
da betrachten wir das, wie können wir das Fachliche auf das IT-System abbilden?
Was von den Dingen brauchen wir? Und da kommen wieder diese Begriffe,
die wir jetzt hier eingeführt haben beim letzten Mal,
nämlich wir wollen erkunden, was ist denn das Material,
was wir am Ende übers benutzen wollen? Der Werkzeugmaterialansatz,
von dem wir jetzt sprechen in dieser Veranstaltung,
beruht darauf, dass man die Anwendungen analysiert,
dass man versucht zu verstehen, was ist,
was passiert hier, was machen die Menschen hier,
wie arbeiten sie im Kern, was ist das,
was sie immer wieder brauchen, um nur dafür Werkzeuge zu entwickeln.
Dieses Vorgehen ist hier von Kollegen Zülikoven und anderen
in einem Buch zusammengestellt worden. Das ist auch schon,
ich glaube, das dritte Buch in dieser Reihe.
Vorher hat er noch ein Buch in Deutsch gehabt und
dann gab es noch einen Vorläufer mit einem bisschen anderen Titel
Dabei greift er viele Ideen auf, die auch andere schon,
und die man auch in anderen Bereichen auch von anderen Autoren gemacht wird,
die sich also als erfolgreich erwiesen haben.
Ich will ein Beispiel aus einem anderen Bereich bringen. Wir wollen ja,
wenn wir betrachten, wir wollen zum Beispiel ein Auto montieren.
Sie alle haben schon mal die Bilder gesehen, wie so ein Fließband aussieht,
heutzutage stehen da vor allen Dingen Roboter, früher standen da Menschen,
aber auf jeden Fall habe ich verschiedene Fertigungsstationen nacheinander.
Da habe ich was, da wird die Karosserie zusammengeschraubt,
geschweißt, da habe ich etwas,
da werden die Türen eingesetzt, da wird das Fahrwerk eingebaut,
da wird die Innenausrichtung gebaut, da werden die Kabel reingelegt,
verschiedene Stationen nacheinander.
Und das ist auch wunderbar, solange ich immer wieder
das Gleiche produziere
So könnten Software-Systeme auch sein, wenn sie immer gleich sein sollen.
Also wenn ich immer in der gleichen Weise eine Steuererklärung bearbeite,
dann kann das tatsächlich auch so sein, erster Klick,
dann sehe ich die Kundendaten, nächster Klick,
dann sehe ich was, weiß ich, die Bankverbindung.
Nächster Klick, da sehe ich die Lohnsteuerkarte und so weiter,
bis ich dann die Steuererklärung fertig habe.
Aber wer, der Ablauf ist mal ein kleines bisschen anders.
Dann würde dieses Schema nicht mehr passen. Als wenn sie
jetzt auf dieser Fertigungslinie für die Autos dann plötzlich mal etwas machen wollen,
wo eine große Batterie reinkommt,
weil wir wollen jetzt ein Elektromotivmobil bauen,
dann müssen wir das irgendwie umbauen,
dann funktioniert das nicht
Oder wenn morgen jemand was möchte,
wo ein Auto ein Stück mit aus Holz oder Papasché gemacht wird,
damit dieses Fahrzeug ein bisschen ökologischer ist,
dann geht das mit dem Schweißen nicht.
Also wir müssen irgendwie das anders gestalten und eine
fest montierte Reihe ist da nicht das Richtige.
Deswegen gibt es zum Beispiel für die Fertigungstechnik die Idee,
man analysiert das und versucht es zu zerlegen, in die elementaren Fertigungsschritte.
Und dann macht man eben eine Insel mit Schweißen,
eine Insel mit Fertigungstechnik, mit Kleben, eine Insel,
wo etwa Kabel gelegt werden, eine Insel und so weiter.
Und dann hat man
die verschiedenen Arbeitsvorgänge entkoppelt
Aber die kehren immer wieder. Es wird immer etwas geben,
wo man etwas mit Schweißen verbindet. Es wird immer etwas geben,
wo man etwas mit Träten verbindet. Und auf diese Weise,
indem man elementare Arbeitsvorgänge erkennt,
kann man dann auch eine Lösung schaffen, eine technische Lösung,
im Fall dieser Autoherstellung, ist das jetzt eine Fertigungs-,
eine Fabrik, die das herstellt, die die Arbeitsvorgänge realisiert,
im Fall der Software ist es ein Stück Programmcode.
Und wenn dieser Programmcode so gestaltet ist,
dass die einzelnen Werkzeuge für sich gestaltet sind,
Dann können wir damit auch flexibler arbeiten.
Dann könnte ich, ist es nicht nur die Steuererklärung von
oben, erster Klick bis zum letzten Klick.
Nein, wir können zwischendurch auch mal woanders hinspringen.
Einen Teil können wir weglassen, wir können etwas Neues hinzufügen.
Voraussetzung, dass wir so etwas können, ist,
dass wir erkennen, was sind die fachlichen Gegenstände.
Dass wir erkennen, was ist der,
ich mache es mal hier auf der Maus,
damit man das im Bildschirm dann auch erkennt für den Instream auch erkennt.
Ja, also dass wir hier erkennen,
was ist denn das,
was Strukturen in diesem Anwendungsbereich sind
Anwendungsorientiert bedeutet also, wir müssen versuchen zu verstehen,
wie die Menschen arbeiten. Was sind die elementaren Tätigkeiten,
so wie bei meiner Autoproduktion mit dem Beispiel?
Und dann diese fachlichen Aufgaben identifizieren, zu überlegen,
wie laufen die in ihrer Reihenfolge?
Das werden die Prozesse. Womit wird gearbeitet? Das sind
die Gegenstände. Und wie arbeiten die Leute zusammen?
Das wären Kooperationen zwischen verschiedenen einzelnen Leuten.
Und da kommen wir in dieser Methode, wann immer näher?
Bei wann versucht man auch zu analysieren,
was sind die fachlichen Gegenstände
Hier sind jetzt ein paar bunte Bildchen dargestellt, also so was wie ein Kalender oder so etwas wie Papier,
Stifte, ein Rechner, ein Kopierer, die Ablage von Informationen in Büchern.
Das sind Gegenstände mit den Menschen arbeiten. Und was wir jetzt,
jetzt kommen wir zurück zu der Modellierung,
was wir erreichen wollen, ist,
dass wir diese Gegenstände durch etwas repräsentieren, was wir dann,
mit dem wir erstmal mit Leuten reden können, sagen,
so etwas wie ein Notizblock, so etwas wie ein Rechner,
so etwas wie ein Kurzzeitspeicher für Informationen oder wie ein Kalender,
das sind Gegenstände, mit denen ihr arbeitet,
in welcher Form arbeitet ihr denn damit?
Wir versuchen damit zu modellieren, indem wir sagen,
was sind denn gleichartige Gegenstände? Meine Maus geht gerade hier
nicht in diesem Bild, also die sind ganz oben dargestellt.
Und was sind fachliche Werte? Was sind Sachen, die
wir zum Arbeiten benutzen und Behälter? Ich möchte das gleich,
das ist ein bisschen zu abstrakt, lassen Sie uns,
lassen Sie uns das etwas konkreter anschauen.
Wir wollen ein Bibliotheksystem betrachten Und in diesem Bibliotheksystem geht es ja,
jeder von uns kennt das, darum,
dass dort Informationen bereitgestellt werden, die man sich mitnehmen kann,
die man dort aber gesammelt vorfindet.
Also bei der Bibliothek geht es um das Sammeln von Literatur
und um das Benutzen. So,
und wenn wir hier diese Bibliothek in irgendeiner Form durch Software unterstützen wollen,
zum Beispiel zur Rationalisierung, dass da Verwaltungsaufwand nicht so groß ist,
müssen wir erstmal verstehen,
wie arbeitet so
eine Bibliothek
Meistens hat man selbst schon einen gewissen Bezug dazu.
Zum Beispiel, sie haben die Bibliothek schon benutzt. Sie wissen,
wenn sie das Buch zu spät zurückbringen oder das Buch verlieren,
dann müssen sie entweder das Buch bezahlen oder sie müssen eine Strafe bezahlen,
so etwas.
Also sie haben schon irgendwie Kontakt gehabt,
aber das ist ja noch nicht alles,
was so in so einer Art Bibliothek zum Ablauf notwendig ist.
Wir versuchen deswegen zu verstehen,
welche Aufgaben hat so eine Bibliothek und welche der Aufgaben sollen
durch Software unterstützt werden im Sinne von Vereinfachen von Verwaltungsgegenständen.
Das wäre jetzt
unser Beispiel
Man kann dazu ein Bild malen und damit sind wir
auch gleich bei dem ersten Modell, was diese UML,
diese Unified Modelling Language, an grafischen Ausdrucksmitteln mitbringt.
Das, was wir hier sehen, gehört zu einem Use-Case-Diagramm.
Das ist ein Bild, ein Modell, was darstellt,
welche Use-Cases wir in der Anwendung haben.
Use-Case heißt Anwendungsfall auf Deutsch übersetzt, das sind Szenarien,
die immer wiederkehren, die als solches vom Anwender wahrgenommen werden können,
als Beispiel.
Und hier haben wir etwas zur Ausleihe und etwas
zur Beschaffung identifiziert
Wenn man die Bibliothek anschaut, hat man als Benutzer eigentlich
nur mit der Ausleihe zu tun. Aber man weiß,
es gibt noch mehr Leute. Also diese Strichmännchen hier,
das sind Benutzer, die, nein,
das sind Verzeihung, das war der falsche Begriff,
das sind Akteure in so einem System, der Kasten hier,
das ist die Systemgrenze.
Also alles, was in dem Kasten ist, gehört zum System.
Wenn wir jetzt hier so eine Ellipse hätten,
die ja außerhalb, wer würde die nicht zum System gehören?
Und jeder von diesem Ellipsen steht für einen Use-Case.
Hier steht immer der Name des Use-Cases drin.
Also wir haben hier etwas zur Ausleihe und das wird von
den Akteuren Benutzer der Bibliothek und von dem Akteur Bibliothekar,
also Mitarbeiterdibliothek benutzt
Und dann gibt es noch einen weiteren Ablauf,
von dem sieht man als Benutzer nichts.
Das ist die Beschaffung von neuen Büchern oder von Büchern,
die man als Ersatz braucht, für verlorene gegangene oder zerstörte Bücher.
Mit denen hat der Bibliothekar zu tun,
aber noch jemand anders, nämlich jemand, der Bücher liefert.
So, dieses Bildchen zeigt uns schon die Struktur von
grundlegenden Vorgängen und wer hat damit zu tun?
Das ist natürlich noch relativ wenig. Das ist das
erste Diagramm der UML, das wir jetzt hier sehen.
Wir müssten es noch ein bisschen verfeinern. Zum Beispiel das
nächste Bild zeigt uns etwas genauer, Welche Teilaufgaben gehören denn
zu diesem System Ausleiher, was vorher das Obere war?
Die Ausleihe sehen wir hier wieder,
aber ich müsste auch etwas zurückgeben und ich möchte Bücher vorbestellen
können oder ich möchte die Bibliothek möchte und mich mahnen,
wenn ich das vergessen habe, weil andere vielleicht darauf warten.
Und wir versuchen also, damit man dieses Bild erstellt,
muss man mit den Leuten der Bibliothek sprechen.
Man muss verstehen, was tun sie? Man muss sie
bei der Arbeit beobachten und muss sich erklären lassen,
welche Arbeitsschritte gehören dazu.
Wir sehen hier in diesem Bild noch nicht wirklich
weitere Details.
Viele Details fehlen noch
Mir fehlt noch, in welcher Reihenfolge wird denn etwas gemacht?
Oder es fehlt noch, was passiert denn bei der Rückgabe
genau? Wie wird denn eine Mahnung abgewickelt?
All diese Details fehlen. Wir wissen auch nicht,
hier steht auch gar nirgendwo was drin zu den Dingen,
Dingen, die wirklich ausgeliehen werden, zu den Büchern.
Und deswegen müssen wir das weiter verfeinern und dazu weitere Begriffe erfragen.
Wenn wir weitergehen, würden wir im Entwurf ein Modell malen,
in dem wir sagen, was gehört denn dort alles dazu?
Zum Beispiel gehören zu einem, zu einer Bibliothek
der Begriff des Buches
Ja, das ist das, was die meisten Bibliotheken verleihen.
Aber vielleicht gibt es auch noch Bücher.
Neben den Büchern gibt es vielleicht auch noch Zeitschriften.
Und wenn das eine Bibliothek einer Firma ist,
dann hat die vielleicht auch noch so etwas wie Technical Report,
also irgendwelche fachlichen Berichte, die über Produkte hergestellt werden.
Die sind dort auch noch in der Bibliothek zusammengefasst.
Und was wir auch noch haben,
ist als fachlicher Gegenstand, hier sehen wir den Benutzer,
dass wir dem für den Benutzer
eine Ausleihkarte ausstellen
Bibliotheken, die nicht mit Computer arbeiten, hat man immer solche Pappkarten gehabt.
Ich weiß nicht, ob jemand von Ihnen das Vergnügen hatte,
so eine Dorfbibliothek oder so eine Farbbibliothek zu kennen,
die haben eigentlich die Sachen immer auf Karteikarten.
Ich kenne solche Bibliotheken auch noch,
die sind mittlerweile fast verschwunden, aber das war natürlich,
lebt das alles davon, dass man immer diese Karteikarten hat.
Und wenn die Karteikarte nicht da ist, dann ist das Buch irgendwie verschwunden.
Wenn wir diese Karteikarten gehören aber mit dazu. Hier sehen
wir, auf diesem Bild sehen wir andere grafische Elemente.
Keine Elipsen, sondern hier sehen wir Kästen. Ich bin
sicher, Sie haben das von SE1 schon mal gesehen.
Das ist das UML-Klassendiagramm. Jeder dieser Kästen steht für
eine Klasse
Wir haben also hier die Klasse Buch,
die Klasse Technical Report, die Klasse Zeitschrift.
Und oben die Klasse Benutzer. Eine Klasse ist jetzt eine Zusammenfassung von
fachlichen Gegenständen, über die wir ein paar Informationen haben.
Damit haben wir mehr Dinge, die wir schon da zusammenfassen können.
Aber wir sind bitte immer noch, Sie kennen den Begriff Klasse, natürlich von Java.
Aber ich rede nicht von Java. Ich rede davon,
dass wir eine fachliche Klasse ermitteln, ein fachliches Objekt ermitteln.
Und diese fachliche Klasse kann auch Daten haben,
sie kann Zustände haben, sie kann Operationen haben,
aber die wird nicht eins zu eins in Java abgebildet.
Normalerweise nicht
Diese fachlichen Klassen leiten wir aus den Use Cases
ab und wir sammeln dann ein paar mehr Informationen.
Ach ein, was habe ich noch weggelassen?
Diese Pfeile hier. Diese Pfeile kennen Sie vermutlich auch schon.
Das ist die Generalisierung Spezialisierungspfeile. Wir versuchen von diesen drei Dingen,
die vor drei unterschiedlichen Sachen, die in der Bibliothek gespeichert werden,
da versuchen wir zu abstrahieren.
Wir versuchen, die Gemeinsamkeiten zusammenzufassen, um etwas Wiederkehrendes zu haben,
damit wir das später mal erweitern können, diese Bibliothek.
Und zwar haben wir gesagt, okay,
alle drei ist gemeinsam, sie werden gesammelt.
Wir haben also einen Namen dafür gefunden für die
nächst allgemeinere Zusammenfassung davon und die Verallgemeinerung heißt bei uns Sammelgut
Tatsächlich, wenn sie vielleicht ein bisschen weiterspinnen und wissen,
was in Bibliotheken manchmal noch verfügbar ist.
So könnte es ja auch sein, dass dort
Gemälde auszuleihen sind oder dass dort elektronische Medien auszuleihen sind.
Auch die würden unter dieser Überschrift, unter dieser Zusammenfassung sammelgut ganz gut passen. So,
wenn wir für diese Klassen uns genauer erfragen,
was dazugehört, wenn wir es ein bisschen genauer anschauen,
da sehen wir wieder dieses Symbol der Klasse und jetzt mit ein paar mehr Informationen,
nämlich welche Informationen, welche Daten dazugehören und welche Operationen dazugehören.
Wo ist meine Maus? Die kriegen ich vielleicht auch wieder hier drauf.
Nein, die will nicht. Doch hier ist sie. Also,
wir haben zum Beispiel für die Gemeinsamkeiten von hier unten zusammengefasst,
und zwar bei dem Buch gibt es Autoren,
ein Titel, ein Ja.
Bei dem technischen Report gibt es eine Autorenliste,
aber Titel und Ja gibt es auch. Bei dem Zeitschriftenartikel,
da gibt oder bei der Zeitschrift gibt es nicht den einen Autor.
Nur das Ja kommt hier wieder vor. Aber was ich alle drei gemeinsam haben,
in der Bibliothek werden sie verwaltet über eine Signatur,
über eine Nummer,
mit der man
das Buch identifizieren kann
Wir haben hier das Klassensymbol mit drei Teilen und im zweiten Teil sind die Daten,
wir kennen vielleicht das Klassensymbol schon für Java,
da wäre das das Attribut.
Hier sind das also die Daten, auch als Attribut bezeichnet und
darunter sind die Operationen, die ich damit machen kann.
Ich kann etwas ausleihen, zurückgeben, mahnen, verlängern,
vorbestellen und über diesen Pfeil hier unten drücken wir aus,
dass das die Verallgemeinerung ist von denen hier unten.
Also die hier unten können auch alle drei jeweils ausgeliehen,
zurückgegeben, gemahnt, verlängert und vorbestellt werden.
Wenn Sie den Begriff nur unter Vererbung kennen,
so können Sie sich den durchaus in Erinnerung behalten,
aber bitte nehmen Sie jetzt zusätzlich auf,
das heißt auch Verallgemeinerung
Wir haben nach oben zusammengefasst, was für die Unteren zutrifft. Natürlich,
das können wir das dann am Ende mit Java so machen,
dass wir es nur einmal schreiben und die Unteren erben das dann. Damit ermöglicht uns das,
nämlich auch das, was ich schön angekündigt habe,
man kann das gut erweitern, um etwas Neues,
was hier dazukommt, zum Beispiel ein elektronischer Datenträger,
für den kann ich auch ausleihen, zurückgeben, Mann verlängern,
vorbestellen und ich würde hier ein paar zusätzliche Dinge dazu hinzufügen.
Wenn wir Hiermit, davon sprechen, wir wollen ein Modell bilden.
Wir wollen fachliche Gegenstände bilden, dann ist es für uns wichtig,
verstanden zu werden. Verstanden wird man am besten,
zum Beispiel, wenn man über Prinzipien spricht,
über sprachliche Bilder benutzt und da helfen uns Metaphern.
Metaphern sind Stellvertreter, sind Platzhalter für Dinge,
die ich in irgendeiner Weise woanders wiederkenne, wiedererkenne.
Zum Beispiel, ein Papierkorb für etwas, was ich wegwerfe,
ein Ordner für etwas, was ich zusammenfasse oder ein Briefkurver,
eine Nachricht für etwas,
was ich versende
Das muss gar nicht wirklich eine Nachricht sein,
die ich jemandem mitgebe. Und er trägt sie dorthin,
das kann auch etwas Elektronisches dann am Ende werden.
Aber die Metapher können wir dafür verwenden, um diese Metaphern
spielen eine wichtige Rolle, dass wir etwas darstellen können.
Und wenn wir von Interaktiven Systemen sprechen, dann müssen wir den Dingen,
die ja eigentlich nicht gegenständlich sind, wir bearbeiten irgendwelche Daten,
da müssen wir den Dingen einen guten Namen geben.
Und da helfen uns Metaphern, solche Namen zu geben.
Im Wammberg, in dem Wammansatz,
den wir hier besprechen wollten, spielen die Metaphern Werkzeug,
Material,
Automat und Behälter
Auch Container genannt, eine wichtige Rolle. Ja,
das sind die Metaphern,
mit denen wir hier arbeiten wollen und wir vernutzen Werkzeug als Begriff,
um etwas weiterzuentwickeln, was man abstrakt zusammenfassen kann.
Werkzeug, all diese Bilder zeigen irgendwelche Handwerkswerkzeuge,
das ist natürlich jedem klar, es ist irgendeine Säge,
ein Hammer, das gehört zu Werkzeugen.
Diese Werkzeuge beschreiben aber eigentlich Dinge, die ich brauche,
in einem Arbeitsvorgang. Gut, wir sind jetzt nicht mehr
im Mittelalter und diese Bildchen zeigen uns das schön.
Wir arbeiten heute bei Informationsverarbeitung, wir wollen ja am Ende
wieder zu unserer Bibliothek zurück, auch mit Werkzeugen.
Es gibt hier Werkzeuge zur Holzbearbeitung. Hier baut jemand ein Musikinstrument,
aber auch Werkzeuge zur Informationsbearbeitung. Hier arbeitet jemand mit Stift und Papier.
Und diese Arbeit bedeutet, dass wir damit etwas machen.
Also wir betrachten jetzt auch, es wird jetzt ein bisschen philosophisch,
Arbeit als den Vorgang. Und die Materialien sind damit die Dinge,
die wir dabei bearbeiten, also die Gegenstände, die Arbeitsergebnisse werden.
Und Werkzeuge sind dann das, womit wir diese Arbeiten ausführen.
Und das möchte ich an einem Beispiel darstellen,
was tatsächlich mit diesem Werkzeugmaterialansatz entwickelt worden ist.
Es gibt im Hamburger Hafen eine nautische Zentrale,
die ist da bei Finkenwerder in der Nähe, bei der Lutzenstation, der alten Lutzenstation untergebracht.
Und dort wird zum Beispiel die gesamte Lageplan des Hafens koordiniert. Und das wurde vorher gemacht mit einem System,
wo man mit verschiedenen Karten, verschiedenen Monitoren,
sie wissen, es gibt eine Station,
es gibt so eine ganze Reihe von Radarstationen bis zur Mündung der Elbe,
wo man die Schiffe dann verfolgt und die verschiedenen Lotsen haben dann gesagt,
da kann das Schiff hin, dort muss es noch eine Weile warten,
wegen wegen der Zeiten,
dass du bist nach Wasserstand entsprechend hochkommt.
Die brauchen also Karten der Tiefen. Sie brauchen Informationen über freie Liegeplätze
und diese ganzen vielen Arbeitsvorgänge wurden zum Beispiel mit der Methode Werkzeugmaterialiansatz analysiert.
Daraus wurde analysiert, welche Arbeitsgegenstände brauchen denn diese Lotsen?
Welche Arbeitsmaterialien haben diese Lotsen? Und daraufhin wurde ein Software-System entwickelt,
was tatsächlich dort im Einsatz ist. Dieser kleine Kartenausschnitt zeigt jetzt hier,
vielleicht erkennt es der ein oder andere wieder.
Das ist also hier trüben Landungsbrücken und hier ist das,
wo die Musicals laufen
Hier drüben unsere beliebte Elbphilharmonie. Ja,
also hier ist zwischendurch eine Baustelle eingezeichnet und das Werkzeug,
was wir jetzt hier sehen, ist ein Pott,
wird als Pottmonitor bezeichnet und es liefert verschiedene Werkzeuge,
um Bearbeitungsvorgänge zu machen, Bearbeitungsvorgänge,
zum Beispiel eine Baustelle für Gesperr zu erklären, tiefen Veränderungen einzutragen,
in die Karten, da gibt es verschiedene Materialien,
wie zum Beispiel Kartenbelegungspläne und so weiter.
Das soll ein Beispiel, es soll Ihnen ein bisschen eine Vorschau geben,
wozu wird diese abstrakten Sachen, über die ich heute gesprochen habe, brauchen.
Wir müssen verstehen, wie die Menschen arbeiten,
um am Ende, Flagzeuge zur Verfügung zu stellen,
mit denen die Leute insgesamt ihre Gesamtarbeit machen können.
Und dieses Werkzeug, was wir hier jetzt gerade sehen,
ist also dazu gedacht,
dass diese Hafenverwaltung, Port Outsority in Hamburg genannt,
dass diese alle Werkzeuge zur Verfügung haben in einem System und trotzdem flexibel arbeiten können.
Nicht so fest hintereinander montiert, wie das bei einer Fließstraße ist.
Ich muss erst das machen, bevor ich das machen kann,
sondern sie haben so eine Art von Elementarwerkzeugen zur Verfügung.
Und die müssen wir erst per Analyse erkennen.
Das ist das, worum es uns bei fachlicher Modellierung geht.
Und an dieser Stelle setzen wir beim nächsten Mal weiter.
Machen wir beim nächsten Mal weiter. Vielen Dank für Ihre Aufmerksamkeit
und ich freue mich, Sie nächste Woche wieder zu sehen.
Vielen Dank