Moin und herzlich willkommen zur Folge 77 von einfach Komplex ist
Gerrit und. Burkhard Moin wieder in Hamburg.
Genau jetzt sind wir wieder zu zweit heute und wie wir es schon
ein paar Mal eigentlich gemacht haben, gucken wir uns ein
bisschen die Software und Softwareentwicklungshistorie an.
Was das genau für Themen sind, die wir da heute ja mal genau
unter die Lupe nehmen, das sagt Burkhard gleich, aber warum?
Ist immer gut, mal die Historie anzugucken.
Ich glaube, es ist total wichtig zu wissen, die Dinge auch
entstanden sind und Historie ist ja bei Software et cetera jetzt
auch noch nicht irgendwie so 200 Jahre her oder 500 wie das
Mittelalter oder so, sondern wir reden ja immer über Zeiträume
von 20 3040 Jahren und da ist ja der ganze entscheidende Kram
passiert und viele Ideen entstanden, die dann doch wieder
nach meinem Gefühl, irgendwie, manchmal Jahrzehnte brauchen,
bis die dann irgendwie in der Praxis eigentlich erstmal
ankommen, und deswegen ist es immer cool, aber so viel von
mir, Burkhard, was ist denn das Thema für heute?
Aber ich stimme noch mal kurz in dein Lied mit ein, aber ich
find, das ist ja so wahr was du sagst, es ist ja auch so, wenn
man mal n bisschen in die die Taschenlampe auf die
Vergangenheit hält, entdeckt man Dinge, die ja wieder in
Vergessenheit geraten sind, die aber manchmal von der Idee und
der Konzeption her schon hervorragend waren.
Ja, und man ertappt sich ja ganz oft, als gerade als junger
Softwareentwickler. Wobei man ja überflutet ist an
Möglichkeiten und und Architekturen und so weiter
dabei, dass man eigentlich n Art noch mal erfindet, was schon mal
längst erfunden war vor 30 Jahren oder Irgendsowas ja von
der Idee her, ja klar hat man andere andere Hardware um sich
rum gehabt und andere Softwarebedingungen, das wollen
wir auch mal angucken heute, aber brillante Ideen gab es
damals schon, ja und deswegen haben wir n bisschen was
rausgekramt, was eigentlich also was ne ganze Zeit lang
hochaktuell war und auch ja auf dem Planeten sag ich mal schwer
genutzt wurde. Und heute?
Kaum einer mehr kennt. Das würd ich vielleicht nicht so
sagen, also alle, die so mein Baujahr sind, so diese die 80er
Jahre Softwareentwickler, die kennen das alle sehr wohl noch,
ich geb mal den Fokus wo wir heute sind, ja also wir gehen
zurück in die 90er und zweitausender Jahre um euch mal
zu orientieren was da so los war, das ist nämlich auch immer
mein Problem ja 90er zweitausender was heißt denn das
ja für Architektur, für Software und so weiter wo sind wir denn
ja? Wir, wir sind jetzt erst mal bei
und, und das ist jetzt aktiv, in dieser Folge so, wir bleiben
heute mal bei Microsoft, wo ich mich eigentlich gar nicht so gut
auskenne, aber ich hab mich vorbereitet und wir sind
technisch bei einer Technologie, die nennt sich.com.com, da komm
ich später noch genau drauf, was das ist da, das wollen wir heute
mal n bisschen genauer angucken. Was was hatten wir so?
Wir hatten wir hatten Desktop Anwendung.
Ja und was jetzt die Leute irgendwie noch wissen vielleicht
an den Zuhörern ist. Wir hatten Windows 311 ja in den
Neunzigern gab es Windows 311 das ist das erste Windows was
wirklich ne Oberfläche hatte, ja mit dem wo man das erste Mal
irgendwie Fenster aufmachen konnte und klicken und n
Startmenü und so weiter ja das fing da an erfordert mit Durst
ja. Es gab aber schon vorher Windows
auch, also nur halt mit Konsole oder wie?
Richtig. Das ist das Windows hat mit
Windows 1 angefangen oder irgendwas geht noch n bisschen
weiter zurück so ne und dann das war am Anfang gab es DOS und
dann gab es halt Windows, war ja so ne Idee quasi an der
Visualisierung von dem dos System ja so und so stand das
Fang fing das ja an und dann ich glaub dass also diejenigen die
es die da quasi in dieser Zeit schon groß waren sag ich mal die
wissen es noch, dann gab es windows NT, windows 95, Windows
98, Windows 2000 ja dann kam das glaub ich.
Das Vista und das XP und ich weiß jetzt nicht mehr welche
Reihenfolge, aber ihr kennt das alles so.
Ja jetzt haben wir Windows 11 demnächst auf dem Schrank, ganz
viele haben noch Windows 10 und so weiter aber es gab halt diese
ganzen Windows Versionen und das ist alles so in dieser Zeit
zwischen Anfang 90er Ende zweitausender irgendwie passiert
um dann noch mal einzuordnen wo wir sind.
Wir hatten an Programmiersprachen im Prinzip
in dieser Zeit zwischen also in den 90er Jahren und auch Anfang
der Zweitausender noch hauptsächlich C und C plus Plus
und sowas wie Basic. Basic gab es schon damals auf
dem Commodore. Ja, das war meine erste
Programmiersprache, die ich gelernt hab, also ganz mit wo
man noch die Zeilen nummerieren musste im Quelltext und so
weiter ja und go to konntest du hinspringen und so weiter ja,
also da, da sind wir jetzt und um das noch weiter genauer zu
einzuteilen, damit man versteht, wovon ich heute spreche ist, was
ist auch ganz gut anzuschauen, was gab es damals halt noch
nicht, ja was wir heute als selbstverständlich nehmen, es
gab zum Beispiel nicht Docker, ja Docker, die uns die
Microservices und die ganze moderne Softwarearchitektur
ermöglichen, gab es nicht, ja. 64 Bit gab es auch noch nicht.
Ja, es gab einfach nur 32 bit. Ja man musste, es gab auch
überhaupt noch nicht fette Hardware, es gab ganz wenig
Hauptspeicher, RAM und so weiter man musste sich also Gedanken
machen darum, dass man auch Anwendungen, die man die hatte
relativ schmal programmierte, damit die überhaupt liefen.
Ne, also ich konnte nicht einfach irgendwelche großen
Datentypen nehmen, so wie heute und musste nicht drüber
nachdenken, sondern ich musste über vieles nachdenken.
Und Programmiersprachentechnisch, um
das auch mal einzuordnen. Es kam halt so, erst Ende dann
der der 90er kam so die richtig die Programmiersprachen raus die
wir so kennen. Also klar Python kam dann 91
raus aber kam halt raus heißt war halt noch nicht in
Benutzung, war also Hallo hier ist Python so ja und PHP erst 97
erschienen ne javascript 95 erschienen Java 95 auch so also
das sind ne so also. In diese Mitte Ende 90er kamen
überhaupt diese Hochsprachen, indem wir heute viel machen,
überhaupt erst auf die Welt. Ja, das heißt, die Technologie
der 90er, die dann am Start war, die hat halt noch ganz andere
Voraussetzungen gehabt, als die wir heute haben.
Wir befinden uns in den Neunzigern.
Technologiestike war n anderer als als er es heute ist.
Wobei der, der heute genutzt wird, auch tatsächlich ja, so
wie es gerade klingt in den Neunzigern dann schon zumindest
mal sein Hallo gegeben hat und und irgendwie die Oberfläche.
Gesehen hat das erste Mal, aber warum sollte man jetzt weiter
die Folge hören? Burkhard, also warum ist das
Kram überhaupt noch relevant, abgesehen davon, dass man sich
vielleicht einfach für Geschichte von Computern und
Software interessiert? Also abgesehen find ich ja mal n
bisschen Allgemeinbildung gehört ja dazu, das kann man schon mal
wissen dürfen ne was da los ist find ich und auch spannend ist
umhin aber nein, also es ist auch deswegen relevant und
deswegen bin ich auch so tief in dem Thema drin, wir haben es
tatsächlich auf dem Zettel gerade, denn es ist einfach.
Noch nicht so alt die Software, dass sie komplett weg ist.
Ja, also heute zeichnet man sie als Legacy, als veraltet und es
gibt alternative Technologien. Es ist aber so, dass wir ja in
der Industrie auch Maschinen haben, die gern mal 10 oder 20
Jahre funktionieren, ja, und die viel Geld kosten und wo es im
Prinzip keinen Grund gibt die zu ersetzen, aber die Maschinen
mussten ja damals auch anprogrammiert werden, hatten n
Interface und so weiter ja und dann hat es halt das Interface
von vor 1020 Jahren. Und da sind wir auf einmal in
dieser Technologie. Und wenn du heute die diese
Maschinen nicht einfach wegschmeißen willst samt der
Software, dann ist es ganz gut zu wissen, was war da eigentlich
los und wie Krieg ich das in die heutige moderne
Softwarearchitektur integriert, ja.
Ich glaub du musst deinen Scope noch n bisschen vergrößern.
Also 1020 reicht bald nicht mehr.
Ja also wir reden dann über über 2030 Jahre und ich glaub auch
nicht, nur nicht nur Industrie und Maschinenwelt, sondern also
da kennen wir uns jetzt nicht so aus, weil das jetzt nicht so
unsere Branchen sind, aber. Ich glaube, auch in vielen
anderen Branchenindustrien läuft noch ganz, ganz, ganz viel alte
Software. Das stimmt.
Und vor allen Dingen diese Technologie ist also, die genau,
wir kennen es nicht so aus, aber ich fürchte, dass in der
Finanzwelt da auch noch was, also die, die waren, diejenigen,
die, die das ganz viel benutzt haben, ja Mhm, auch diese
Technologie, ja genau, nee, und eben es gibt noch n Grund, es
hat mich privat einfach, also wenn man, wenn man in der
Softwarearchitektur arbeitet und wenn man das dann liest und sich
mal drauf einlässt, was da war. Dann merkt man, wie genial diese
ganzen Ideen und wie hoch aktuell das eigentlich alles
noch ist. Ja, weil die Probleme waren auch
damals schon ziemlich ähnlich zu den heutigen.
Also die Softwarelösungsprobleme die ich hatte und es was Cooles
entstanden ja was man einfach mal an angucken kann, ja.
Also gleichen Ideen oder oder grundlegende Ideen und andere
Zeiten. Ne andere Betrachtungsweise,
aber vielleicht die gleichen Herausforderungen, Themen.
Es ist noch Software im Feld, die so funktioniert, die
sogenannte Legacy ja. Genau so n Grund oder sollen wir
rein starten? Wir können rein starten.
Gut, dann hatten wir ne lange Einleitung.
Du hattest vorhin schonmal.com erwähnt, das hat jetzt erst mal
nichts mit Punkt com zu tun, nehm ich an oder bei Double Han
hab ich zuerst gedacht. Ja, und wenn man es Google, dann
hast du auch n Problem mit com. Ja genau, nee, hat es nicht,
also es hat nichts mit dieser Top Level Domain zu tun.com die
wir so kennennee.com steht für Component Object Model und ja
ist quasi eine. Ja ne System API wie man also n
systeminterface betriebssysteminterface kannst
du fast sagen, ne API und zwar für Microsoft Windows Punkt,
sonst für nix ja also Mac OS hat es irgendwie versucht auch man
hat es versucht n bisschen zu bauen und Linux sowieso nicht
hör zu ja wir sprechen halt von Microsoft ja genau davon hab ich
gesprochen und dieses.com ist quasi nen ja ist quasi ne ne
Technologie ne Idee n Standard ne System API um.
Ja, um das zu machen, was man damals machen wollte, nämlich
Software, ein bisschen modularer aufbauen, ja, dann, jetzt gebe
ich noch mal kurz einen großen Kontext für diese Folge, wir
haben, wo kommen wir her, wir hatten ganz am Anfang der
Softwareentwicklung große monolithische Software Anwendung
und auch die ersten Versionen von Word gehörten dazu.
Ja, das sind also viele Zeilen C oder C plus plus, ja, in so
einer heftigen Programmiersprache geschriebene
große Dinger. Die haben zwar funktioniert,
aber die haben halt alle Nachteile wie das was so n
modulitisches Ding halt hat ja schwere Wartbarkeit im Team
arbeiten, testen von diesen ganzen Sachen, alles nicht so
einfach. Ja man wollte halt dazu
übergehen, dass man n bisschen modularer die Software aufbaut.
Ja und davon sprechen wir heute von dieser Folge, wie man das
gemacht hat mit com ist nämlich ne Art, dass Anwendung ihre
Business Logik teilen können und dass ich ne, dass ich innerhalb
von einer Anwendung auf Funktion von einer anderen Anwendung
zugreifen kann und so weiter also modularer.
Code, den ich auch mehrfach einsetzen kann und ich ihn
einmal geschrieben habe. Funktionaler gedacht,
Komponentenmäßig gedacht halt ja bis zu dem was wir heute machen,
was Weiterentwicklung dieser Idee ist, würde ich sagen zu
microservice orientierten Architekturen, die basieren auf
einem anderen, auf einem anderen Technologie unterliegen, nämlich
dem HTTP, das ist ja damals auch gerade erst entstanden, das
wollte ich vielleicht auch noch mal sagen, also das HTTP 10
Protokoll was die Grundlage unseres modernen Internets ist,
kam 96 auch erst zur Welt, da. So und und und was haben wir
heute? Wir haben im Prinzip genau die
ja nicht genau die gleiche Idee, aber wir haben gekapselte
Entitäten, ja, wir nennen es heute Microservices, alles
funktioniert typischerweise über das HTTP interface oder CSTP und
und und. So bauen wir quasi große,
skalierbare Anwendungen hin, indem wir sagen, OK, das ist
halt gekapselt funktional, domain spezifisch,
microservicemäßig gekapselt, ja, und dieses diese.com Idee war
quasi die der, der die Vorstufe dieser.
Microservice Architektur, die wir eigentlich heute betreiben,
würde ich sagen. Verstehe, wusste, wusste dir das
jetzt genau untergekommen? Also wie bist du drauf gekommen?
Also ich bin schon zweimal in meinem Leben vorbeigekommen,
beides waren es Legacy Integration, es gab eine große,
sehr große Pharmafirma, die ich nicht nenne, die ich nicht
benennen will, hier, die auch für für die Pipeline
abfüllablagen und so weiter kombbasierte Softwarekomponenten
im Einsatz hatte, die. Digitalisiert werden sollten ja
in Workflow System mit Eingegleist werden und so weiter
ja also und da hatte man mich gefragt, kannst du helfen?
Kannst du was machen? Wir haben ja irgendwie so DL, Ls
und so weiter und wir haben keine Ahnung was ist das da, da
sind wir das erste Mal vorbei gekommen und jetzt ganz aktuell
haben wir es da weil auch quasi wieder Legacy, also sehr alte,
in dem Fall cnc Maschinen dessen Steuerung quasi.
Ja, normiert, standardisiert, wurde ansprechbar ist über
diese.com Technologie. Ja, da wurde quasi die die also
da wurde auch Funktionalität gesplittet, zum Beispiel
Maschinenstatus auslesen oder Maschinenkonnektivität oder es
gibt sogenannte Werkzeugtabellen und so weiter das wurde quasi
ausgegliedert in einzelne Komponenten und die wurden
dargestellt als Objekte damals in dieser.com Bibliothek komme
ich gleich noch mal drauf, ganz genau, aber genau und und diese
Maschinen sind halt im Feld, die sind dann halt Gerrit 30 Jahre
alt oder irgendwas, ich weiß es nicht.
Und das Software Interface ist nach wie vordieses.com Interface
und das muss man halt benutzen, weil es gibt nichts anderes.
Und zweitens es ist so, dass das immer noch von Microsoft
unterstützt wird. Also du kannst heute noch
Software kompilieren und bauen und dass du jetzt Windows 311
installieren musst oder irgend sowas, das funktioniert auf
Windows 10 mit Visual Studio hat Microsoft das quasi
abwärtskompatibel gehalten und du kannst selbst mit den
neuesten Technologien quasi diese alten Sachen wieder.
Noch mal quasi schreiben, ja, musst aber wissen, was da
funktioniert und was nicht. Ja wie das funktioniert.
Cool also das mal zur Einordnung von com, dem component object
model. Ich mach es mal n bisschen
greifbarer vielleicht also Microsoft selber hatte nen.
Also die Geschichte ist wohl so und ich ich basier jetzt mir
auch mein Wissen auf Büchern und so weiter aber die Geschichte
ist wohl so, dass Microsoft selber n Problem hatte was sie
lösen wollten, was zu dieser ersten Idee geführt hat zum
Inhouse Whitepaper über diese Technologie kommen ja und zwar.
Gibt es ja schon immer Word und Excel, das ist ja so.
Also wenn man an Windows denkt, dann denkt man ja nächsten
Schritt an den Word Prozessor Word und an den
Tabellenkalkulationen Excel. Ja die gab es auch schon in
Windows 311 ja und es gab auch schon gleich am Anfang dieses
Problem, was passiert denn eigentlich wenn ich so eine Art
Compound Dokument, das ist das Fachwort compound Dokument, also
ein Dokument was halt nicht nur aus Textzeilen besteht aus den
Buchstaben die wir in Text machen, sondern wenn ich zum
Beispiel Tabelle drin hab, ja. So, da kann ich, das ist heute
noch n aktives Problem, weil ich kann natürlich in mein Word
Dokument ne Tabelle rein tun, die dann einfach nur ne Tabelle
in Textform ist oder? Und das sollte man machen, die
Tabellenkalkulation quasi einbetten, also quasi ne Excel
nen in einem Excel Tabellenkalkulationsprogramm ne
Tabelle haben die dann im Word Dokument auftaucht ja so dass
wenn ich sie in Excel verändere, sie auch in einem Word verändert
ist, dass es quasi gelingt ist ja die Objekte Tabelle und Word
Dokument gelingt sind ja. Das wollte man lösen.
Das das ging damals nicht. Ja, und das hat man aber
hinbekommen und und zwar durchdiese.com Technologie ja
Object Linking and Embedding ist da das Stichwort, das hieß es am
Anfang Ole, also ich, wir werden heute n paar Fachbegriffe durch
die Gegend schmeißen, weil weil das ist unglaublich verwirrend,
man hat damals auch schon Marketing betrieben noch und
nöcher und hat zig Vokabeln erfunden und die Bedeutung
wieder verschüttet und noch mal neu gemacht und so weiter und es
hängt irgendwie alles miteinander zusammen, ich
versuch das mal n bisschen zu dissin tangeln heute auch ja
also OLE. Steht für Object Linkin and and
Wedding und ist die unterliegende Technologie, die
Anwendungen und Informationen austauschen können.
Und es gibt noch heute im Windows Ordner die OLED 32 DLL
ja ist alles 32 bit und die die macht das ja, die findet man da
immer noch ich glaub. Die hab ich schon mal gesehen.
Die die ist sehr prominent. Ja, da steckt das ganze Know How
drin. Ja, das ist das war das
Ursprungsproblem was man lösen wollte, ja.
Ja, total, total nachvollziehbar, greifbar.
Ja, kann man heute, wenn man. Ne Tabelle einbettet irgendwie n
Word Dokument oder auch bei Google in den Tools, da kann man
wird man gefragt willst du die Tabelle verlinken tatsächlich,
sodass die sich immer synchronisiert oder willst du
sie als Bild einfügen oder sowas zum Beispiel ne also statisch
nicht als Bild sondern eben als unverlinkte Tabelle ist
wahrscheinlich heute nicht mehr nicht mehr kommen.
Ich glaub auch nicht. Aber ist es da greifbar?
Und jetzt noch mal, du sagst also ich, ich rufe quasi Objekte
auf, irgendwo anders so mehr oder weniger, ja und ist das
denn? Vergleichbar mit so einem
Datentyp Objekt ist das das gleiche Objekt wie der Datentyp.
Objekt ist eigentlich die Frage. Ja, das neue, das das neue
Problem, was da überhaupt entstand, ist, die Datentypen
sind ja auch noch mal ganz egal. Es gab halt vorher gar nicht die
Möglichkeit, dass 2 Anwendungen was ist.
Was ist denn das, wenn das Word startet, dann hab ich ne exe,
das kennt ja jeder, also davon werden wir viel sprechen.
Ja exe es gibt ja immer nur 2 Sachen, es gibt ne ausführbares
Programm in Windows, das nennt sich dann immer exe hinten dran
manchmal ist das Punkt bat oder Irgendsowas ja.
Aber da klickst du halt doppelt und dann startet ein Programm.
Ist ein executable Executable oder es gibt eine sogenannte
Softwarebibliothek, die kann ich nicht direkt ausführen, da ist
quasi nur ein Haufen voll Code, der irgendwie mehr oder weniger
hoffentlich sinnvoll ist. Ja wo quasi Funktionalität
implementiert wurde, das heißt halt DLL in Windows ja also ich
habe diese 2 Dinger, das sollen wir erst mal auseinanderhalten,
executable und DL so und früher war es halt einfach schon
schwierig überhaupt zu sagen. Von meinem Word aus, was ja eine
Anwendung ist, eine Excel, ein Prozess läuft im Speicher, ja,
kann ich nicht, also innerhalb dieses Prozesses konnte ich
schon immer machen, was ich wollte, bin ich in C plus plus,
ja kann ich mich beziehen auf Funktionen, die halt in meinem
monolithischen Werk drin stecken, kann ich alles machen,
ja, aber das das tabellenkalkulationsprogramm
Excel, das lag halt quasi ich komm grad aus dem Skiurlaub, ja
das war also quasi auf einem anderen anderen Gebirge ja so
da, da kam ich einfach nicht dran ja ich hab keine
Möglichkeit. Muss man jetzt mal wissen.
Als Softwareentwickler eigentlich C plus plus, egal
welche Sprache ich hab, wenn ich einfach in einer Anwendung
stecke, das ist heute noch so, ja dann hab ich meinen
Anwendungsspeicher und dann seh ich alles was lokal zu mir ist.
Ich kann nicht trivialerweise auf irgendein anderes Programm
zugreifen, was irgendwie auch läuft auf dem Computer ja oder
sogar krasserweise gar nicht auf dem Computer sondern auf
irgendeinem Server. Ja also das ist das, das ist das
erste Problem was gelöst werden muss, ja dann nennt das
Interprocess Communication, das muss man halt auch mal noch kurz
auseinanderziehen. Wenn das jetzt was kommen,
nämlich auch löst. Also ich hab im Prinzip hab ich
3 Sorten ja ich wenn ich innerhalb meiner Anwendung bin
kann ich direkt auf Objekte und auf Funktionen innerhalb meiner
Anwendung zugreifen. Durch sogenannte Pointer MC plus
Plus, also Zeiger die darauf hinzeigen, dann kann ich einfach
die Funktion aufrufen. Ja dann hab ich das nächste
Problem, wenn ich aber gar nicht in der gleichen Anwendung bin
sondern das ne andere Anwendung ist, die aber noch auf dem
gleichen Computer läuft ist wichtig ja dann hab ich also
kein. Nicht notwendigerweise brauch
ich ein Netzwerk. Sondern ich brauche nur eine
Art, wie kann ich mit dem einen Prozess, der auf dem gleichen
Computer läuft, mit einem anderen Prozess, der auf dem
Computer läuft, sprechen. Ja, man nennt das Inter Process
Communication, das ist das Wort dafür, ja, das muss ich, da muss
ich mir Gedanken machen, und warum ist das schwierig, weil
immer, wenn ich jetzt, immer wenn ich meinen
Anwendungsbereich verlasse und mit einem anderen Programm
spreche, muss ich die Daten, die sich austauschen, serialisieren,
ja, ich kann. Also während ich quasi innerhalb
eines Software Codes sehr komplexe Datentypen halten kann,
also strukturierte Daten mit, so wie man es heute kennt von Jason
und so weiter also irgendwelche Structs, so heißen die auch in C
plus structs da, das hat irgendwie n Namen so und da
steckt dann drin integer und string und so weiter das zum
Beispiel struct Adresse, da stecken halt mehrere Sachen
drin. Ja das kann ich einfach
verwenden, ich kann aber dieses strukturierte Objekt, dass ich
in der Anwendung hab, nicht einfach einer anderen Anwendung
hingeben, ich muss es serialisieren, serialisieren
heißt ich muss es. In Bytes auflösen, Einsen und
Nullen hintereinander quasi klemmen tatsächlich und
rüberschicken ja, und auf der anderen Seite muss ich das
Dekodieren, ja, muss diese einzelnen Nullen, die als quasi
als langer, als lange Schlange ankommen, Zurückfalten in diese
Struktur, ja in diese strukturierten Sachen, ja, das
ist vielleicht noch einfach, wenn ich die gleiche
Programmiersprache hab, also wenn zum Beispiel mein Word in C
plus plus geschrieben war und das Excel auch.
Dann falte ich quasi pack was ein schick das durch den durch
die Post einen Brief und Pack es wieder aus und die gleiche
Technologie die es einpackt und auspackt.
Das ist aber auch schon Luxus weil die reale Welt ist so, dass
wir nicht nur eine Programmiersprache haben auf der
Welt und damals auch schon nicht hatten, sondern dass wir
verschiedene Programmiersprachen haben, die haben ganz
verschiedene Ideen wie Sie ihre Daten intern verwalten und die
aussehen ne das heißt C plus Plus packt zum Beispiel ein und
Visual Basic sowohl auspacken ja oder andersrum ne.
Und das sind die Probleme, die die wir heute auch haben, die
damals aber das erste Mal gelöst werden mussten.
Ja, und da gab es natürlich auch viele verschiedene Ansätze,
nicht nur dascom Modell von von Microsoft gab es auch andere, ja
corba und so weiter aber das war halt eines was sich durchgesetzt
hat und was im Prinzip eigentlich auch für ne große
Zeit lang sehr erfolgreich war. Prima, das ist perfekt für die
Einordnung. Hat mir jetzt sehr geholfen
dann. Gucken wir uns mal an, wie das
technisch funktioniert. Sollen wir darauf eingehen, ist
das ist das der Plan? Ja, das ist der Plan.
Wir gucken uns das mal n bisschen an, was da was da was
da los ist. Ja, ich versuch das mal n
bisschen zu erzählen. Ja, erzähl das mal n bisschen.
Ich mag das so als Geschichte. Ja, ist ja nicht nicht auf jedes
3. Lette Akonom ewig eingeht, aber
so kapieren was da seifig los ist.
Natürlich nicht schlecht, ja. Ja genau, OK.
Genau also also noch mal kurz genau gesagt, was.com ist also
im Prinzip ist com eine ne API für das System selbst für das
Windows System. Jetzt muss man einmal verstehen,
was was ist. Denn die API auf was greift die
zu, was ist das Abtraktionslevel ja, und wir hatten ganz am
Anfang mal folgen gemacht. Wie funktioniert überhaupt
Software? Ja ja und das müssen wir kurz
noch mal aus dem Schrank holen jetzt hier, weil das muss man,
das muss man also mindestens verstehen, bevor man kommen
verstehen kann, alle mögliche Software die und Software ist ja
quasi gegeben durch ne Programmiersprache Quelltext hat
Basic Komponenten das sind immer Funktionen ja also ich hab immer
Funktionen. Kurz erinnert, Funktion ist ich
geb Parameter oben rein beliebig viele von verschiedenen Sorten,
dann passiert irgendwas zum Beispiel n Eintrag in ne
Datenbank oder Irgendsowas und dann krieg ich n Returnwert raus
auch wieder irgendwas kann ich mir aussuchen als Programmierer
mich völlig frei kann also funktionfrei definieren ne und
das nächste Level was eigentlich im Prinzip jede jedes fast jedes
Programmiersprache unterstützt sind die sogenannten Objekte.
Ja also wenn ich wenn ich jetzt nicht die Funktionen alleine
ohne Kontext sehe, sondern wenn ich sage ich hab n bestimmtes
Objekt. Ja, zum Beispiel Database als
Objekt. Ja dann, dann kann ich da
Funktionen reinpacken in diesen Kontext des Objektes.
Ja, also zum Beispiel Insert, Update, Delete und so weiter von
Records in der Datenbank ja so das macht, da sind das halt
Funktionen die die gehören, semantisch logisch, technisch
irgendwie zusammen, die Pack ich n Objekt ja genau und Objekte
haben noch die Eigenschaft, dass sie quasi wenn sie sie kennen
kreiert werden. Also es gibt ne sogenannte
Instanz eines Objektes. Ja dann hab ich die.
Und während das Objekt quasi lebt, merkt es sich seinen
Zustand. Also ich kann ja quasi, ich
könnte zum Beispiel nen Zustand hervorrufen, wenn ich sage mache
jetzt n Insert in die Datenbank und das Objekt zum Beispiel
merkt sich den letzten Wert, der jetzt in die Datenbank
eingespeichert wurde in seinem State, danach könnte ich das
Objekt fragen, was war denn das letzte was du inserted hast?
Dann gibt es dir halt zurück ja zum Beispiel ja, also im Prinzip
hat n Objekt also also ne ne Lebenszeit ja es wird
instanziert. Und irgendwann stirbt es wieder.
Ja, und das ist wichtig, weil diese Objekte nehmen als quasi
auch Speicher brauchen Speicher, um ihren um ihren Zustand quasi
abzuspeichern damals aber. Jetzt nicht verwechseln.
Also du hast jetzt die Datenbank als Objekt da genommen, die
Datenbank bleibt schon da, es ist jetzt geht es nicht um die
Datenbank per se die das Objekt. Ist, nein, nein, die Datenbank,
die Datenbank, das ist quasi das Objekt, dass die Datenbank
kontrolliert steuert so mit dem ich quasi in die Datenbank was
reinschreiben kann. Genau das ist gut, danke, dass
du es noch mal klar gemacht hast.
Ja, Ende genau so. Und jetzt sind wir immer noch
ganz tief in Programmiersprachen.
Das nennt sich Objektorientiertes programmieren
ja, was n Konzept ist, was es bis heute gibt.
Ja, es gibt dann noch das Funktionale, hat man nicht so
viele Objekte, aber im Prinzip ist das State of the Art immer
noch ja, und jetzt muss man verstehen, dass dieses kommen
quasi die Idee hinter kommen, das kann man, das kann man jetzt
verstehen, wenn man das mit den Objekten verstanden hat, ist,
dass es eigentlich Wurst ist, von wem diese Objekte kommen.
Also ich hatte ja am Anfang gesagt, Wir haben zum Beispiel
mehrere Executables oder DL, LS oder Irgendsowas.
Ja, da stecken in den DL LS steckt auch nichts anderes drin
als Objekte. Ja gibt alle möglichen, es gibt
n Objekt, es kann zum Beispiel nen Button in damals auf dem
Windows Desktop ändern ja und implementiert das ganze UI krams
wenn du klickst dass da irgendwas passiert und so weiter
ja oder oder oder diese Ganzen gab es damals ja schon, also wir
hatten damals schon dropdowns und checkboxen und und und Radio
Buttons und was weiß ich so ja. So und das das wurde auch damals
schon als Objekte programmiert, irgendwo, aber ja, in
irgendwelchen Files, in irgendwelchen Access oder
irgendwelchen DLS oder irgendsowas.
Ja und jetzt kommt.com und sagt Ach wie cool wär denn das, wenn
alle diese Objekte irgendwo sich zentral registrieren und so ne
Art Telefonbuch gibt für diese ganzen Objekte und wenn ich
jetzt ne Anwendung schreibe ne neue, dann kann ich einfach
sagen OK ich brauch jetzt irgendwie hier nen
datenbankobjekt weil ich will jetzt irgendwie in meine MS
Microsoft access Datenbank irgendwas reinschreiben.
Ah, gucken wir mal. Da haben wir schon ein Objekt.
Irgendjemand hatte das schon geschrieben, vielleicht sogar
von Microsoft, ja, ist registriert, ja, kann ich
einfach, kann ich einfach benutzen in meiner Anwendung,
ja, ist quasi eine Dependency, ja muss ich nicht noch mal
selber machen und selber machen war damals richtig kompliziert,
weil ich musste in C plus plus schreiben, ja ist wie Latein ne
ist Katastrophe also wenn es schon irgendwas gab habe ich es
gern genommen und und was kaum erlaubt ist.
Das dynamische Einladen von Objekten, die schon existieren,
die irgendjemand gemacht hat in meinen, in meine Codewelt, in
meine Anwendung. Dabei ist es egal.
Und dabei muss es nicht, muss es tatsächlich nicht direkt in
meiner Anwendung programmiert sein, es kann dieses Objekt kann
in einem anderen Prozess laufen und benutzt werden, oder es kann
sogar, und dann sind wir bei Distributed Distributed kommen,
das ist mandie.com, es kann sogar, das kann dann später auf
einem anderen Server liegen und ich kann es benutzen, ja.
Es erlaubt quasi, dass gewisse Objekte als geteilte Ressource
verwendet werden können. Letzten Endes ne über über über
Software hinweg. Ganz genau, auch ganz genau, ja,
und und diese Objekte, so fangen wir mal an, die liegen, die
Lagen typischerweise in DLLS, ja, und wenn es jetzt mal erst
mal ganz einfach ist, dann habe ich quasi ein Programm gebaut,
ja, mit C plus plus mit auf com Technologie basierend, da gibt
es natürlich regeln, wie man das zu machen hat.
Das heißt, wenn und wenn ich das Programm dann fertig gemacht
habe und kompiliert habe, dann entstand eine Punkt exe, also
ein ausführbares Programm und dann konnte ich quasi
Bibliotheken, die ich nicht selber geschrieben habe, DLLS,
die wurden quasi automatisch eingeladen und ich hatte Zugriff
innerhalb meiner Anwendung auf diese Objekte und zwar so
einfach und das ist wichtig. Ja jetzt, das glaube ich ganz
schwer zu erklären, für denjenigen, der noch nie eine
Software geschrieben hat, ja, aber wenn ich.
Wenn ich hatte Gerhard, der hat ja ganz am Anfang gesagt, ich
kann ne Instanz erzeugen von einer Klasse, also die Klasse
ist ja immer das ja die Blaupause für ein Objekt.
Ja, ich hab, also ich geh jetzt noch mal auf das Beispiel
Datenbank Controller oder wie auch immer zurück, also nicht
die Datenbank selber oder das Objekt was Funktion hat um ne
Datenbank zu beschreiben, zu lesen und so weiter ja ich kann
innerhalb meines Codes einfach ne Instanz erzeugen, ja sag ich
zum zum Beispiel New irgendwas ja ich sage ich brauch jetzt so
n Objekt da für mich ja und das Krieg ich zurück, ich krieg
quasi ne Art Pointer zurück n Händel.
Und wie ist wie ne? Kann man sich vorstellen wie ne
Variable. Ja und jetzt auf diesen
Variablen hab ich dann Zugriff sagen wir mal ja New Database
Controller und ich nenne das zum Beispiel DB oder Irgendsowas als
Variable. Ja und jetzt kann ich sagen DB
Punkt Insert DB Punkt Update DB Punkt ich hab jetzt quasi
Zugriff auf diese ganzen Methoden die dieses Objekt
kapsuliert ja indem ich einfach diesen pointer nehme und die
dann aufrufe ja und dadurch dass ich diesen Pointer in der Hand
hab spreche ich halt genau mit diesem einen Objekt mit dieser
Instanz, das ist wichtig, ja. So, und jetzt kommen hat quasi
dieses Kreieren von diesem Objekt so abstrahiert, dass ich
manchmal habe ich tatsächlich, wenn das Objekt tatsächlich in
meiner Anwendung läuft, weil ich eine DLL eingeladen habe, die
direkt bei mir läuft, dann kriege ich tatsächlich einen
Pointer zu diesem echten Objekt. Wenn es aber nicht so war, wenn
es irgendwo anders lag oder sogar im Netzwerk, dann
funktioniert es einfach trotzdem.
Ich kann trotzdem als als Quellcode schreibender es
verwenden, als wäre es neben mir und.
Als wäre es in meiner Anwendung direkt vorhanden.
Ja, ich muss mir keine Gedanken machen, was aber technisch im
Hintergrund passiert und das ist die Neuerung was passiert, wenn
das nämlich nicht bei mir ist. Dann wird nämlich meine mein
Aufruf der Methode, ich sag ja DB Punkt Insert und jetzt sag
ich ja was da kommen ja Datentypen rein, welche Tabelle
tabellenname ja Tabelle 1 zum Beispiel Komma und dann was weiß
ich Vorname Agathe ja so, das sind ja Strings die ich da die
ich da reinkippe in diese Funktion ja.
Und wenn diese, wenn jetzt aber diese dieses Objekt mit der
Funktion da drauf gar nicht bei mir liegt.
Jetzt muss ich dieses Realisieren machen was ich am
Anfang gesagt hab, jetzt müsste ich eigentlich das in Einsen und
Nullen verwandeln, ich muss es verpacken, abschicken, den
richtigen Prozess zuordnen, übers Betriebssystem geben oder
sogar übers Netzwerk noch komplizierter und auf der
anderen Seite muss ausgepackt werden, ne passiert automatisch
macht kommen für mich sieht so aus als wär es ganz normal.
Neben mir ist es aber nicht, ja und wenn es ist auch egal.
Ja ich muss mir einfach es 7 ist ja ich muss mir einfach keine
Gedanken machen ne. Wieso n Wurmloch?
Wieso? N Wurmloch ja.
So, und jetzt Achtung, ja, das heißt also, um das ganz klar zu
machen, das existiert jetzt nicht irgendwie zweimal noch
noch mal in dieser Exe mit drin oder so.
Nein, das ist nach wie vor, dieses Objekt ist in der DLL,
ich ruf es nur auf oder ich rufe die Methoden darin auf und
deswegen darf ich auch keine DLLS weglöschen ja, weil dann
eventuell manche meine Exen nicht mehr.
Funktionieren ganz genau. DLS Weglöschen ist überhaupt gar
keine gute Idee. Ja nee, genau das stimmt.
Also, und das ist die die grundlegende Idee von Common,
das ist ziemlich revolutionär, ja, und es bedeutet aber, dass
ich quasi und jetzt nehm ich noch n Wort in den Mund, dass
ich quasi, wenn das Objekt mal nicht bei mir liegt, dann ruf
ich es quasi remote auf, ja, ferngesteuert ja, und deswegen
nennt man das Remote Procedure Calls.
RPC ist das Stichwort, ja, und ich hab jetzt hier eine, ich hab
jetzt hier eine Verbindung zwischen Prozessen oder
Anwendungen, die auf Funktions beziehungsweise Objekt.
Leveldicht auf der Abstraktionshöhe Höhe von
Objekten, das heißt, Ich bin noch relativ dicht an der, wie
soll ich mal sagen, an der Logik von den 2 interagierenden
Partnern dran. Ich muss genau die Funktionen
kennen und ich muss genau die Parameter kennen die die das
Remote Objekt mir zur Verfügung gibt und ich muss es richtig
aufrufen, aber so war damals die Idee, so ist das
Abstraktionslevel. Und jetzt spring ich noch mal
kurz bevor wir weiter technisch gehen.
Jetzt hab ich gerade schon mal n bisschen was technisches gesagt,
ja vielleicht andere, also n paar Zuhörer haben wir jetzt
vielleicht schon irgendwie, ich weiß auf der Stirn oder
Irgendsowas deswegen. Nein, nein, ich hab kein Test
geschrieben danach. Nee, stimmt ja genau, wird nicht
abgefragt. Das Entertainment und als das
kam ich hatte ja nur als Beispiel genannt Word Dokument
mit Excel aufrufen, das können wir jetzt verstehen wie das
geht. Jetzt ist zum Beispiel so, dass
diese Excel. Das Excel Programm, ja das das
lädt quasi seine ganzen Objekte die es braucht um zum Beispiel
die Tabellen anzuzeigen, in diese.com Sphäre hoch sag ich
gleich wie das geht ja, also es stellt das quasi zur Verfügung,
ja und der Word Prozessor, der sagt jetzt einfach oh ich brauch
jetzt aber hier n echtes Excel Objekt ja und da hol ich mir das
jetzt hol ich mir jetzt echt ab vom Excel mit den echten Daten
was du gesagt hast ist richtig Gerrit das existiert dann auch
nur einmal und deswegen synchronisiert sich das dann
auch ja ich hab dann diese eine Excel objekttabelle.
Irgendwo von irgendeiner DLL lebt die halt und ist
gespeichert und deswegen hab ich halt auch wenn ich ins Excel
gucke die gleiche Information, die wenn ich in das Word gucke,
was quasi rüberlinkt ja und so funktioniert das ja und dann hat
man aber erkannt, cool, damit kann ich noch viel mehr machen.
Ja und und jetzt würd ich sagen, gab es die allererste No Code No
Code Anwendung nicht für Webanwendung aber für Desktop
UIS ja also für so richtig schöne schlichte Windows ihr
kennt das Fenster auf so diese Form so wie das so schön aussah
ja und es nannte sich Visual Basic.
Und zwar gab es das in verschiedenen Versionen.
Und da die Ausbaustufe ist, glaube ich von war es 98 oder
96, war die letzte Version von Visual basic.
Was mir nicht lügen ist auch egal.
Und das das sieht sehr ähnlich aus wie heutige, Na ja, sehr
ähnlich, also sehr ähnlich Inhalt mit alten Pixeln und so
weiter und Alter und alter CSS soll ich fast sagen, gab es noch
nicht, also alten Styling und so weiter.
Aber es machte das, was heute auch moderne Low Coat Tools
machen. Du hattest also quasi einen
Editor, da konntest du, hast du eine Vorschau gehabt von deinem
Fenster Windows Fenster und da konntest du per Drag and Drop
damals schon ja Elemente draufschieben, Knöpfe, Radio
Buttons und so weiter und dann konntest du so ein bisschen wenn
du konntest das doppelklicken, wenn du zum Beispiel einen Knopf
draufgeschoben hattest. Und wenn du Doppel geklickt
hattest, dann kam ein Code Editor hoch wo du dann.
Nur noch den Code eingefüllt hast.
Was soll passieren, wenn jetzt jemand hier klickt?
Ja und das hast du geschrieben in Visual Basic.
Das Visual Basic war damals das, was heute das Python ist.
Sag ich mal ja oder das Java Script war so ne so ne einfache
Sprache und da konntest du so n bisschen grob geschnetzt so ja
da konntest du so n bisschen rounding sowieso wie diese
Anfänge von Java Script, das war halt nicht so, damit konntest du
nicht das machen was du mit C plus plus machen konntest.
Du konntest da nicht irgendwie auf irgendwelche Systeme oder
irgendwie festplattenzugriffe oder irgendsowas, aber du
konntest da so n bisschen Business Code schreiben, ja.
So und jetzt jetzt hatte man aber dann die Idee, war dann
einfach, dass diese ganzen Knöpfe und so weiter diese
ganzen Komponenten die du da drauf geschoben geschrieben
konntest. Per Drag and Drop, die waren
halt alle im Prinzip so das warenalles.com Objekte, ja die
hatte irgendjemand schon mal mit dem weißen Kopf geschrieben.
Ja und das war Hardcore C plus plus, das muss ja funktionieren,
ne dass das Widget quasi sich rendert und das richtige macht,
ja. Und dann konnte man, und dann
kam gleich die Idee, jetzt kann ich das ja erweitern, jetzt
brauch ich auf einmal ne Datenbank.
Ja weil ich hab ich hab jetzt frag jetzt hier zum Beispiel ne
Form ab, ich bau mir selber so ne kleine Form App wo ich
irgendwie nach Nachname Vorname registrieren und mal für
Studenten zum Immatrikulieren irgendsowas Hole und jetzt will
ich das in meine MS Access Tabelle speichern ja ja dann
konnte ich halt einfach sagen OK liebe visual Basic 6 ich brauch
jetzt hier noch nen weiteres Objekt dann gab es riesenlisten
konnte ich durchgehen ja von. Von möglichen Objekten, die ich
hätte laden können, dann gibt es halt auch die Datenbank accessor
Objekt. Ja dann kann ich mir das
Reinladen, dann krieg ich dann Widget und dann kann ich das
verbinden und so so funktionierte das damals und so
wurden 2 Drittel der der Business Anwendungen was wir
heute so auch als Digitalisierung vom im
Kleinunternehmen sag ich mal verstehen, wurden damals schon
mit Visual Basic 6 so zusammengebaut.
Ja und und das C plus plus da mit verteilten Objekten mit
Visual Basic sprechen konnte, das ging halt erst dadurch
dass.com. Quasi das alles transparent
gemacht hat, dass die Daten hin und her getauscht werden
konnten. Ich glaub das hab ich sogar ich
noch gemacht. Also in Excel konnte konnte man
ja auch oder kann man wahrscheinlich immer noch Makros
schreiben mit Visual Basic und dann auch seinem Excel Sheet
irgendwie den Button hinzufügen oder andere Elemente und die
dann mit Funktionalität bestücken, eben durch Visual
Basic. Also das hab ich sogar auch
gemacht mal und ich bin der Meinung da wo ich das mal gebaut
hab fürs Unternehmen da läuft das bestimmt auch noch.
Das war doch nicht so. Ja, das ist manchmal so gewesen,
ja, genau, und um das noch mal klar zu sagen, das Visual Basic
gibt es bis heute und ist auch von Microsoft offiziell
angekündigt und wird nicht mehr abgekündigt, bleibt unterstützt
durch alle Windows Versionen in Zukunft hinweg.
Es ist aber nicht mehr, also es gab einen Bruch und das war
tatsächlich dann Ende der 2000 2001 kam dassogenannte.net
Framework auf. Und im Prinzip hat diese
ganze.net, das hat man vielleicht auch schon mal
gehört, ich sag es einfach nur, ohne es genau zu
erklaerenaber.net ist quasi der Nachfolger von dieser ganzen.com
Technologie und mit dem Herannahen von dot net hat man
quasi das klassische Visual Basic, was auf diesem.com
Technologie basierte, so wie ich es gerade erklärt Hab, hat man
abgelöst und es gab im Prinzip n neues Visual Basic.
Intern wurde es auch weiter Visual Basic 6 war quasi letzte
Version die auf com Technologie basiert hat und dann Visual
Basics 7 819 und so weiter. So haben die das nie nach außen
benannt, aber intern lief so weiter.
Es war im Prinzip auf dot net Technologiebasierend und das ist
das, was man heute, wenn man Visual Basic heute in die Hand
nimmt, ist es das ja, also man ist nicht mehr bei dem
klassischen, da müsste man schon wirklich ein altes Windows
installieren und sich dann noch mal das Visual Studio von damals
irgendwie die Idee ist und das Visual Basic quasi installieren,
dann sind wir bei dem klassischen ja das wollte ich
nur mal auseinanderdröseln, weil das sind wirklich 2
verschiedene, sind noch mal 2 verschiedene Welten, aber die
Ideen. Die Ideen sind die gleichen, ja
die Technologie, wie man es implementiert, hat sich
geändert, aber die die grundsätzlichen Ideen sind sehr
ähnlich, ja genau das nur noch mal so als Teaser, weil das also
das Visual Basic war, war schon n Kracher damals.
Ja das war so das Rapid Programming Rapid Development
hat man es damals genannt, also schnelles Entwickeln, aber auch
damals hat man schon gesagt, ja was muss ich jetzt, ich will mir
hier nicht irgendwie 2000 3004 1000 zahlen C plus plus Code
tippen. Um so ne blöde Dreizeilige
formabfrage zu machen, was man hätte machen müssen.
Ja, es war unglaublich aufwendig.
Ja, es gab ja noch keine, keine Server und Clients und so weiter
jadieses.com hat es halt und das ist noch mal n wichtiger Punkt.
Ja es hat es war ne Standardisierung, ja ich hatte
das vorher immer alleine machen müssen, jetzt auf einmal gab es
n großes dickes Brett was ich einfach nehmen konnte was mir
diese ganze. Kommunikation zwischen
verschiedenen Prozessen oder auch verschiedenen Servern
abgenommen hat, ja dann dahinter steht Client und
Servertechnologie, das kam damals auf, das ist das auch,
ja, also wenn ich im Monolithen muss ich nicht über Client und
Server sprechen, weil das hab ich nicht, im Monolithen bin ich
in meiner Anwendungssoftware fertig und aus da gibt es das
Konzept Client und Server nicht, aber mit com kam das Konzept von
Client und Server richtig zum Schein ne also da hab ich ich
hab halt einen der Client ist halt immer derjenige der der
eine. Von einem Server zur Verfügung
gestellte Funktion abfragt und benutzte und der COMM Server ist
halt derjenige, der die Objekte, die er kennt und hat, zur
Verfügung stellt und der Client, der läuft typischerweise in der
Anwendung, die du dann baust und der Client ruft quasi
Funktionalität ab und nutzt sie selbst.
Ja, und dieses kleinen Serversachen waren aber wohl
versteckt, indem sie quasi weg abstrahiert wurden durch die
Technologie, durch die COMM Technologie und ich quasi so
gesprochen hab als hätte ich das Objekt direkt in der Hand.
Ja und das realisiert quasi. Durch die Technologie des Remote
Procedure Calls RPC ja im Hintergrund ja, müssen wir mal
kurz reinzuwickeln was ich gesagt hab, ja.
Super eingewickelt. Ja, und wenn einem das ja heute
noch in der Praxis entgegenkommt, was so ist, aber
wie wie gut ist das alles, sag ich mal dokumentiert, wie
einfach findet man sich da zurecht?
Also ist das ist das alles selbsterklärend oder oder ich
hab ja diesen Ding Schinken da auf deinem Schreibtisch schon
gesehen mit com und so. Oder auch noch mal anders.
Wie lohnt es sich da sich da auch als junger Entwickler oder
junge Entwicklerin noch reinzufuchsen?
Kannst du das mal n bisschen einordnen?
Hände weg, alles uralter Logistikkrams ja, also ich würde
als junger Entwickler erstens nicht diese alten Sprachen, also
C plus plus, also wenn man, wenn man Mut zur Selbstkasteiung hat,
dann kann man das schon machen. Ja, also wenn ich Software
entwickeln will, dann kann ich nur modernere Sprachen nehmen,
die Konzepte sind trotzdem die gleichen, da verpasse ich
nichts, ja. Und kommen ist einfach, ist tot.
Ja, die Technologie ist tot. Ist Legacy, also man muss sie.
Ich hab auch diesen dicken Schinken, das ist auch nicht
einfach diese ganzen Erkenntnisse, die ich heute in
der Folge teilen und deswegen mach ich das so gerne, die hab
ich nicht innerhalb von n paar Stunden mir inhaliert also ich
hab wirklich mich lange lange lange mit der Materie befasst.
Ich musste mir auch n Buch kaufen, was ich sonst eigentlich
nicht tue normalerweise hat das Internet genügend Informationen
aber ich ich nenn ihn mal und es ist n cooles Buch also wenn man
es denn braucht ja wenn man mal in der Not ist so wie ich, dass
man sowas Legacy mäßiges implementieren muss.
Da kann man sich von John E. Swankel Swank also SWANKE, wie
auch immer hier ausgesprochen wird, dasbuch.com Programming by
example holen, da steht sehr viel drin, sehr viel drin, was
einem sehr viel sehr viel weiterhilft, ja, denn es gibt es
gibt nämlich so n paar versteckte Wahrheiten, die muss
man halt auch erst mal wissen. Ja und die erzähl ich kurz noch
hier, die hab ich nämlich noch nicht erzählt ich, ich hab
nämlich nur erzählt, dass irgendwie diese Objekte
registriert sind und dann irgendwie da sind und so dieses
irgendwie. Ist die Windows Registry Gerrit,
hast du schon mal was von der Windows Registry gehört oder den
Regedit Windows? Es gibt dieses Regedit, also ich
weiß nicht ob, da hat man schon mal drum rum gehackt weil man
irgendwie ich hab früher irgendwie auch n bisschen
gezockt und so weiter manchmal konnte man dann der Regedit
irgendwie auch irgendwie die Spiele und die Lizenzenschlüssel
wieder rückwärts drehen und so weiter und sofort.
Ich hab auch schon drin rumgespielt.
Ich meine als ich wollte meine Taskleiste unter Windows 11
irgendwie nach oben verlegen, was nicht mehr vorgesehen ist.
In den Standardeinstellungen in den oberen Weltrand und ich
meine da hab ich in der Registry irgendwas.
Kann gut sein, ne genau ja, also die Registry von Windows ist ne
Art riesiges globales Konfigurationsmenü.
Ja wo ich irgendwie also keywörter und Schlüssel hab und
so weiter ja und die die ist jetzt nicht erfunden worden,
weil es com geben muss, die gab es schon immer, ja also aber die
hat man also die ist quasi. So ne Art globales
Telefonkonfigurationsbuch ist auch nicht grafisch oder
irgendsowas. Ja ist furchtbar zu bedienen,
musst genau wissen was du da tust und wenn du was falsch
machst und ist es auch eher schlimm so ungefähr wie ne DL
weglöschen kann sein, dass da nichts mehr funktioniert ja,
aber man hat halt quasi diese Registry genommen als quasi als
globale Entität. Ja und wenn man wenn ich jetzt
zum Beispiel ein Objekt habe, was in der kommen Welt benutzt
werden darf, ja dann und dann programmier ich quasi meine
Anwendung so. Dass ein Registrierungsschritt
folgt, also wenn die quasi kompiliert ist.
Und es ist egal ob das ne DLL ist oder ne exe, es geht beides,
ja, dann wird die quasi registriert.
Das und was heißt das im Prinzip speichert Windows tatsächlich
den Pfad zu der DLL oder zu der exe, also C doppelpunkt, slash
mein verrückter Pfad zu meiner DLL oder irgendwas slash
backslash backslash ja ist ja nicht vorwärts slash sich alles
in ihrem Windows ja. Egal also die liegt ja irgendwo
im System, diese DL irgendwie, wir wissen das alle selber, die
liegen ja irgendwie kreuz und quer verteilt in Windows, ja ist
aber Wurst wenn die wenn die quasi installiert wird die DLL
dann wird ein Eintrag gemacht in der Registry über die sogenannte
Class ID, sondern es ist sehr verwirrend.
Die Class ID ist aber im Prinzip der Pfeilpfad zu der DLL oder zu
der exe die in der Lage ist komm Objekte zu teilen ne das wird in
der das wird in der Registry hinterlegt ja.
Und jede Klasse, also jede echte Programmierklasse.
Also so unser ne Adresse oder der Datenbankkontroller und so
weiter die diese Viecher, die kriegen eine sogenannte Instanz
IDID und diese Instanz ID wird auch hinterlegt.
Das heißt ich hab quasi in der Registry ne ne Class ID, das
sagt quasi welche DLL und welche exe, das gibt es überhaupt die
auch kaum Objekte machen, das sind sehr sehr viele und da
drunter hierarchisch alle Objekte die die halt so können
mit globalen IDS ja. Die Juliet heißen die, die
heißen auch nur in Windows, so GUID Global Unique ID.
Ja, die sind also auf dem ganzen Universum und über die Zeit
hinweg global. Ja und identifizieren quasi eine
gewisse DL einer Version und ein Objekt einer gewissen Art, ja
die sich dann aufrufen kann. Ja und quasi über die Mitte der
der Windows Registry lad ich dann quasi in einer in in 2
verschiedenen Anwendungen. Können die quasi die Registry
abfragen und sehen quasi zentral?
Was ist denn alles zur Verfügung?
Was kann ich denn machen und die letzte und das letzte Ding was
ich auch noch erwähnen will ist, das ist heute nicht, also war
damals nicht so einfach wenn ich jetzt RPC hab also remote
procedure Calls wenn ich jetzt zum Beispiel von C plus plus aus
Visual Basic aufrufen möchte, dann musste ich damals ein IDL
File erstellen, ein Interface Definition language file.
Und da steht im Prinzip drin in einer sehr abstrakten,
Programmiersprachen übergreifenden Art.
Wie heißen die Funktionen, die ich aufrufen kann und was welche
Art von Parametern muss ich übergeben und was ist der ist
der Antwort wert. Ja, also ich hab quasi ne Art
Funktionsdeklaration auf einer standardisierten Art und Weise,
sodass quasi alle möglichen Programmier.
Sprachenhersteller quasi auch wieder Bibliotheken machen
können, die dieses ITL File verstehen und dann entsprechend
quasi dieses ein und Auspacken realisiert bekommen.
Ne, das ist quasi eine Art standardisierte Anleitung zum
Austausch der Daten zwischen Funktionen, ne hast festgehalten
in diesem IDL File, da gibt es auch extra Compiler.
Ja und wenn ich jetzt zum Beispiel C plus Plus benutze und
hab irgendein IDL File von irgendjemandem zur Hand, dann
kann ich quasi mit einem sogenannten Middle Microsoft IDL
Compiler. Das Ding quasi kompilieren und
das erstellt mir quasi den schon mal.
Das Skelettchen sag ich mal von C plus plus Funktionen, die
quasi dann so gebaut sind wie sie gebaut sein müssten um zu
kommunizieren. Mit irgendeiner Ansprache steckt
in dem IDL File drin ne ja und und das alles zusammen also das
ist schon ganz schön viel, das ist schon ganz schön dickes
Brett was da irgendwie gebaut wurde und das alles zusammen
funktioniert dann so, dass ich quasi auf Objektebene und
funktionsebene mich austauschen kann, ne?
Ich glaub, das ist der entscheidende Punkt da.
Ja, war. Es das zur Technik.
Ich glaub schon. Ich glaube, ich muss aufhören.
Ich könnt natürlich noch ewig weitermachen, aber ich glaub es
reicht. Na ja, kann man ja sonst noch
mal nachfragen, ja wenn man es genau ist, da kann man dich ja
anhauen denk ich mal. Da kann man mich, da kann man
mich mal, kann man mich fragen, das Buch hast Du immer mal,
kauft sich dieses oder man kauft sich dieses Buch hab ich
tatsächlich inhaliert, da aber harter Topakt das kann ich jetzt
sagen, ja wollen wir noch n bisschen auf irgendwelche
Herausforderungen oder sowas dabei eingehen ja ich glaub das
hattest du noch mal. Vorbereitet so n bisschen ja.
Also man kann jetzt, man kann jetzt, man kann sich jetzt
fragen, warum hat sich jetzt nicht durchgesetzt, warum gibt
es jetzt was anderes und so weiter es gibt auch viel Kritik
an dem Comcomes, da ist halt viel zu komplex und zu
kompliziert ist es auch, hab ich ja selber gesagt, braucht hat n
riesen Lernkurve, kriegst du nicht einfach verstanden ich
muss jetzt n bisschen in Schutz nehmen weil wie gesagt wir
müssen gucken wo sind wir in der Zeit, was hatten wir für
Technologien um uns rum ja es gab auch nicht so tolle
Programmiersprachen wie gesagt die es heute gibt also.
Und wenn ich halt C plus plus hab, dann muss ich halt auf C
plus plus Ebene, das irgendwie auch so anbauen.
Das heißt das wird in sich sowieso kompliziert, weil C plus
plus ganz viele verschiedene Datentypen hat und so ist alles
nicht so einfach. Ja genau, und dann hab ich
damals auch, und das muss man auch wissen, Parallelität hatten
die auch schon das Problem ja gleichzeitiges Zugriff von von
von Objekten und so weiter du hast ja schon gesagt ne, also
ich hab ein Objekt so, aber vielleicht sind ja zum Beispiel
mehrere gleichzeitig interessiert an diesem Objekt,
das muss ich alles mitdenken, ja und das haben wir einfach.
Damals hat man nur Threads gehabt und so.
Das war unglaublich kompliziert und das musste ich alles wissen
und ich musste das richtig konfigurieren, klicken und am
Ende war es im Prinzip so kompliziert, dass man das Halt
als Entwickler hätte nicht mehr alleine machen können und so gab
es halt quasi die IDE, also die Integrated Development
Environment, quasi das Tool, mit dem ich Code schreibe unter
Microsoft damals war das Visual Studio, gab es schon mit von
Anfang an ja auch cool über die Zeit hinweg einfach mitgegangen
und im Visual Studio gibt es halt Wizards.
Da kann ich halt sagen, ja, ich brauch jetzt halt irgendwie ne
comm, ne comm interface ne comm klasse und so weiter und das hat
die dann halt quasi schon 90% dahin gedonnert und zwar durch
Co Generation. Ja es hat ne auch schon mal ne
Folge, also es hat quasi dir den Code schon mal vorgeneriert,
damit du nicht irgendwie nen Herzinfarkt gekriegt hast als
Entwickler. Also es war schon, es war schon
kompliziert, du musst schon relativ viel drum rumschreiben
noch damit es geht ja obwohl es dir schon so viel weggenommen
hat, ja genau und dann war natürlich das größte Hindernis
war. Und warum sich es halt auch
nicht wirklich durchgesetzt hat. Aber es lief halt nur unter
Windows. Ja und es kam mir dann aber und
und in Windows war halt irgendwie dann kam ein beddit
Systeme, dann kam Linux auf und so weiter ja gerade im
Maschinenindustriepark hast du halt nicht überall nur n Windows
installiert, ja und es hat auch viele Nachteile, quasi auch wenn
du wenn du jetzt tatsächlich so n com Objekt brauchst nur um ne
Maschine zu steuern brauchst du ja kein erstmal keinen
Bildschirm und nichts zu ja aber Windows halt kommt ja immer
gleich mit diesen ganzen Grafiken, overhead und so weiter
mit also war war auch bestimmt n Grund warum warum es nicht
durchgesetzt hat. Aber jetzt?
Das wollte ich dich tatsächlich noch fragen.
Gibt es dann ähnliche Entwicklungen unter unter
anderen Betriebssystemen, also zum Beispiel jetzt Linux, oder
ist dann dein nachfolger.net, wenn ich es richtig verstanden
habe, für alles geeignet? Aber.net war ja aber auch
erstmal wieder nen Merk Microsoft Produkt konntest du
auch nirgendwo, also mit dot net kamen ja neue Sprachen, auch zum
Beispiel C Sharp ich würde sagen C Sharp ist das ist die Sprache
mit der du quasi das alles wieder machen konntest.
Nur auf einfache Art und Weise zu der Nachfolger, Ich sag mal
von C plus plus ja. Soll das glaub ich auch der Name
indizieren. Also C.
Sharp ist ja noch mal noch mal schärfer als C plus plus oder
was? Das ist übrigens auch noch mal n
Thema wo wir mal einsteigen müssen, ja.
Können wir machen? Ja, ist ne sehr sehr schöne
Sprache, aber leider Windows aber auch nicht mehr ganz
richtig. Also das dasanfängliche.net war
tatsächlich Windows Only und das heutige.net.net Core und das das
ist noch nicht ganz abgeschlossen, aber ich glaube
90% läuft schon systemübergreifend.
Also du kannstheute.net und C Sharp.
Unter Linux verwenden verwenden ja, das ist so.
Ja, damals war es noch nicht so genau, es gab ne
Parallelentwicklung, die Systemübergreifender waren, die
hatten dann aber also zum Beispiel Corba hatte ich ganz am
Anfang mal erwähnt, corba war auch so ne Idee, quasi wie kann
ich plattformübergreifend quasi Ressourcen teilen, Komponenten
teilen, Component based softwarearchitektur schreiben,
ja die gab es, Corba funktionierte auch über RPC
innen drin. War dann aber von den Sprachen
her da musstest du halt irgendwie das Java machen.
Ja, das war für C plus plus auch absolute Wahnsinn das irgendwie
anzukoppeln. So also hast du richtig gute
Alternativen, gab es irgendwie nicht und dann hab ich ja
gesagt, ich glaube was dann kam und das was bis heute blieb ist
das kam mir das Internet auf ja und es kam HTTP auf.
Ja wir haben halt Internetserver aufgebaut, ja wir haben halt
rest APIS also das das HTTP war quasi der neue Standard ja also
mit den ganzen Browsern und dem Internet.
Und dem Ganzen, das brauch ich ja nicht noch mal erzählen, das
ist ja klar, was da passiert ist.
Ja, das hat halt quasi auch die ganze Traction auf die auf die,
auf die Browser und so weiter die Webservices kamen hoch und
so weiter ja, der Browser wurde quasi auf einmal das neue
Interface Serve zum Ausführen. Ja dadurch entkopple ich mich
sowieso von diesem Betriebssystem.
Ja wenn ich den Browser hab ja und das HTTP mit dem HTTP server
ist glaub ich ja ist quasi der Standard den es braucht um mit
Anwendungen. Oder um Funktionalität von
Anwendungen, die eigentlich verteilt und die unterwegs sind
in einen in trotzdem in eine logische, also für den Nutzer
logische gefühlte Anwendung zu gießen.
Das ist halt heute unser HTTP. Ja, ich würde sagen, die Rest
API ist der Nachfolger von diesen Ideen, die es damals
schon gab, von com und von corba und funktioniert ja
hervorragend, aber jetzt Vorsicht noch mal ne Einordnung
und deswegen gibt es viele Leute die kritisieren immer RPC.
Denn das Abstraktionslevel ist hier ein anderes.
Während ich mit com und Corba zulasse, dass quasi eine eine
beliebige Anwendung ein beliebiger Client auf mich
zugreift, als Objekt, wie ich programmiert wurde und meine
Funktion, das ist ja ziemlich direkt ne, also du gehst hin,
gerät und programmierst halt quasiein.com Objekt, ja und
jemand greift direkt auf dich zu, auf deine Funktion, ne
instanziert dich als Klient, ja. So funktioniert der Rest API
nicht. Da habe ich quasi noch mal eine
Schutzwahl vor mir. Da würdest du also ich
vergleiche das jetzt mal, da würden wir unser Datenbank
Controller, den wir jetzt hätten, der der würde nicht
direkt angesprochen, wenn wenn du jetzt einen Rest Server
wärst, sondern da gibt es quasi den Rest Server als als Band,
erstmal als Eingangstor. Ja und da muss ich dann sagen
get. Table oder irgendwas von mir
aus? Ja und und jetzt implementierst
du beides, den Restserver und dein Objekt, dein
Datenbankobjekt und du Implementierst vor allen Dingen
das Get Table diesen Aufruf, da hast du jetzt quasi noch mal
Zeit was zu machen, selber ja in deinem als als zur
Verfügungsteller dieser API. Ja kannst du auf diese Get table
Methode irgendwie was machen und am Ende wirst du auch irgendwie
ne Instanz haben von einem Objekt und gibst das zurück.
Aber du bist nicht so direkt exponiert, sag ich mal auf
deinem Objekt. Also es hat sich herausgestellt,
dass das RPC für viele Anwendungsfälle eine noch zu
direkte Kopplung der Funktionalitäten in den Software
Dingern sind und dass es besser ist, ein Abstraktionslevel noch
dazu zu nehmen. Um es einfacher zu machen, n
stabiles, denn das ist ja wichtig n stabiles Interface zu
behalten. Ja auch in in dem Moment wo du
nur eine Änderung machst und so n Objekt.
Wir sind ja an der anderen Clients Angeschmiert, die müssen
das dann ja wissen und so weiter es im Detail gibt es halt zig
zig Dinge die man brachten. Ich hatte gerade ich hatte.
Gerade so n im Kopf irgendwie so n so n Stapel Post, weil hier
gerade bei mir so n Stapel Briefumpflege liegt.
Ja, ich kann es nicht entweder jemanden erlauben direkt so n
Briefumschlag aufzumachen und reinzugucken irgendwie oder ich
kann ja sagen, sag mir mal was in dem mit dem Briefumschlag
drinne ist und dann. Mach ich es mit meinen eigenen
Methoden eben auf und sage Bescheid, da steht jetzt ne
Rechnung drin oder was auch immer.
Ja also komisches Bild, aber erlaube ich direkten Zugriff
eigentlich auf die Anwendung, auf die Methoden oder fordere
ich nur irgendwas an, was dann breitgestellt wird, ne?
Und im Prinzip ist es, wenn man es jetzt noch mal in der Linie
sieht, wenn man, wenn man sagen monolithische Software a ja dann
Component Komponentenbasierte softwarearchitektur b zum
Beispiel durch sowas wie.com, durch RPC Methoden, durch
direkte Funktions und Objektaufrufe oder Corriba.
Und dann C microservice Architektur und da fällt auch
noch mal das zur Einordnung früher diese ganzen Plugin, das
ist ja Plugin Mechanismus auch was ich mit Visual Basic 6
erzählt hab ja aber wenn ich da neue Funktionalität einlade, was
tue ich dann lade ich halt eine DLL in meinen in meinen Prozess
mit ein, ja sei es jetzt über diese.com Technologie oder wie
auch immer, ja aber am Ende mache ich das auf diesem Level
bin ich und heute mit Microservices lade ich keine
DLLS mehr starte dockercontainer ja.
Das ist auch noch mal wichtig. Wir sind, wir sind noch weiter
weg im Abstraktionslevel von dem von dem echten Quellcode, ja wir
wir, den schützen wir noch besser ist noch kapsulierter als
es damals war, weniger exponiert heutzutage, und das konnten wir
damals halt auch nicht machen, weil ich meine, was hatten wir
für Computer 26 und 80er 36 und 80er, 46 und 80er und so weiter
die das war ja auch diese Zeit, ja, da hättest du noch nicht mal
einen Dockergrund, den da starten können auf dem Ding, da
wäre Speyer schon voll gewesen, so ja, also insofern.
Können wir es uns auch heute erst leisten, auf dieses krasse
Abstraktionslevel zu gehen, dass wir sagen, OK, unser
Microservice, und wenn man jetzt, wenn man, wenn man diese
Analogie machen möchte, ich weiß nicht, ob sie gut ist, der
Microservice ist quasi das, was früher mein geteiltes Objekt
war, im in der.com Welt, ja, der ist dann quasi schon quasi n
Minibetriebssystem mit allen Abhängigkeiten zusammengekapselt
so und hat halt als als Interface dieses den Rest Server
ne Rest API. Ja, dadurch bin ich natürlich
noch viel Loser gekoppelt und viel.
Wie soll ich sagen, viel besser unterwegs, was meine innere
Entwicklung und Weiterentwicklung angeht bei
gleichzeitiger Stabilität des Interfaces als als in dieser
Kommenwelt, wo ich doch ziemlich direkt irgendwie meinen
Quellcode irgendwie geteilt habe.
Ja, um das noch mal sozusagen zu einverstanden, ne?
Genau müssen wir jetzt ja vielleicht nicht in jedem Detail
irgendwo den Vergleich da finden, aber ich glaube, es ist
wichtig, dass rüberkommt und das ist, muss man sich rüberkommen,
wie du es eingangs sagtest, dass diese Ideen und beziehungsweise
die die Antworten auf die Probleme, die da waren.
Damals wir heute ähnlich sind, aber eben in einem ganz anderen
Technologie Umfeld ganz. Genau.
Und manchmal ist es vor. Also es gibt auch kleine
Zurückentwicklung, ich finde nämlich habe ich auch schon oft
gesagt, zum Beispiel diese Rest API, die die viele Vorteile hat,
erlaubt zum Beispiel aber nicht das einfache Zurücksenden von
Events zum Server aus, ja was bei.com ultracool ging ja, du
konntest halt sagen ja in diesem.com Objekt, ich
registriere mich quasi für Events, die der Server mir gibt.
Callbacks nennt man das ja, und da habe ich einfach, das nannte
sich da Sync. Dann konnte ich einfach eine
Sync definieren und darauf habe ich eventstore gekriegt und so
funktioniert das heute. Also in diesen Legacy
Anwendungen wo ich habe ja auch am Anfang von der CNC Maschine
gesprochen, die sehr alt ist. Ja der Klassiker, ja die hatten
Alarm, irgendein Fehler passiert und der passiert ja nicht beim
Client, der passiert ja an der Maschine wo der Server ist, ja.
Und dann? Dann will der Server mir
eigentlich schnell mal Alarm rüberschicken ja und ich kann
mich halt einfach registrieren auf sogenannte alarm events.
Ja das kann ich nicht so einfach mit mit Rest APIS, da muss ich
auch schon wieder mit Websockets nachdenken und so weiter und
sofort ja, also es hat immer so seine vor und Nachteile und aber
was ich sagen will ist ja die die Software softwarethemen was
ich grundsätzlich lösen will bleibt ja voll das gleiche ja
und war ich die letzte Kurve und dann können wir den den können
wir die Folge glaub ich abhaken. Wir haben ja auch noch mal für
uns selber als Heisenware bei der Kurve auch noch mal ne
andere Abbiegung gemacht und sind wieder von der vom
Abstraktionslevel näher an das was kommen ist gerückt.
Aber wir haben nämlich im Prinzip auch nen RPC Remote
Procedure Calling basierend, aber auf einer ganz neuen
Technologie auf asynchronen also wo ganz viele Probleme, die wir
da damals hatten mit der synchronen RPC und den ganzen
Threads und den Exception Handling und den.
Diesen ganzen Datentypen, Bestimmungen zwischen den ganzen
Programmiersprachen und so weiter das kann man auch alles
mit moderner Technologie wegnehmen und dann doch
vielleicht aber von der Architektur her im
Abstraktionslevel bisschen wieder näher aneinander rücken
bei den Funktionsaufrufen und Voila kriege ich auch noch mal
ein ganz anderes Bild und kann dann auch einmal wieder so zum
Beispiel Events entgegennehmen, ganz einfach und sofort, ja,
also. Ich glaube, so wie das auch so
in bei den Aktienkursen ist, wabert immer so n bisschen hin
und her und es entwickelt sich weiter.
Aber ich glaube und deswegen ist es total relevant sich diese
alten Technologien anzugucken, mit neuen Mitteln gelöst sind
diese alten Ideen vielleicht sogar dem, was wir dann heute
Status quo nennen, überlegen, ja mal gucken, OK und?
Für die, die jetzt noch Interesse daran haben zu wissen,
worüber du gerade gesprochen hast.
Quasi Remote Procedure Calls von von Heisenwehr.
Die können einsteigen noch mal bei Folge 3233 das ist auf jeden
Fall n cooler Anschluss an der Stelle.
Ja dann haben wir es. Ich glaub schon, wenn du, wenn
du noch ne Frage hast und bin nicht gerne da ansonsten.
Nein, ich, ich hab leider keine Fragen.
Ich fand es cool und Top Performance nach deinem Urlaub
voller Frische und Energie. Das muss ja auch so sein.
Akku ist wieder aufgeladen, ja, sehr gut.
Dann entlass ich dich in den Rest des Tages.
Und ja. Danke dir, danke euch fürs
zuhören, wir hören uns in 2 Wochen wieder bei einfach
komplex und bis dahin macht's gut alles Gute.
Tschüss aus Hamburg. Einfach komplex wird präsentiert
und produziert von Heiseware. Wir freuen uns auf deine Fragen
und deinfeedbackanpodcast@heiseware.com
vielen Dank fürs Hören dieser Folge bis Dienstag in 2 Wochen
und Tschüss aus Hamburg.