Episode 225, Modernes C++ – effiziente Softwareentwicklung mit neuen Standards und Best Practices, Herzlich willkommen beim Zukunftsarchitekten, der Systems Engineering Podcast für Machende und Entscheidende. Am Mikrofon ist wieder Björn Schorre. Als Systemingenieur gebe ich dir Tipps und Impulse, damit du dein Projekt zum Erfolg führen kannst. Music.
So wirst du in der heutigen Episode erfahren, warum es sinnvoll ist, seine Softwareentwicklung mit modernen Programmiertechniken auszuführen und weshalb Weiterbildung zum integralen Bestandteil der Arbeit werden muss. Ja, mein heutiger Gast ist Coach und Trainer für C++. Er hat zu seinem Thema mehrere Bücher geschrieben. Seine Kurse sind auf der ganzen Welt gefragt, ob in Präsenz oder online. Ja, herzlich willkommen hier bei mir im Podcast, Rainer Grimm.
Vielen Dank für deine Worte, Björn. Ich freue mich, heute was erzählen zu können. Ja, magst du vielleicht noch selber was zu dir sagen? Oder habe ich damit schon alles erschlagen mit meinem kleinen und kurzen Intro? Ich kann ein bisschen was zu mir sagen, aber das soll ja keine Werbekampagne werden.
Ja, was soll ich denn sagen? 2002 habe ich meine Firma, die Fortbildungsrunde, initiiert und im Zeiteffekt von dem war, dass ich immer mehr Schulung gehalten habe und immer mehr in die Schulungsende reingekutscht bin. Seit 2013, von 2013 bis 2016 war ich verantwortlich für das Team und Software auf Defibrillatoren. Das war dann bis 2016. Ich muss nämlich sagen, ich habe drei Berufsausbildungen. Ich bin Mathematiker, Krankenpfleger und Rettungsantäter.
Seit 2016 mache ich nur das, was mir Spaß macht. Ich gebe Zebrismus-Schulungen und meine Pein-Vergangenheit holt mich auch noch ein bisschen ein. Seit 2004 gebe ich Pein-Schulungen auch. Wie gesagt, seit 2016 bin ich selbstständig und sehr, sehr zufrieden. Ja, du hast das gerade schon angesprochen, Defibrillatoren, das sind ja Embedded-Systeme, die du da entwickelt hast und du hast dich dort mit der Entwicklung von Software beschäftigt.
Es gab ein bisschen mehr, was für mich ein Neuland war, die Systemarchitektur und Sicherheit. Ah, Systemarchitektur. Die Sicherheitsbetrachtungen. Ah, genau. Das war für mich total neu. Okay, okay. Das passt ja auch so ein bisschen zu dem Thema mit meinem Hintergrund, nämlich die Systementwicklung.
Worin, oder muss ich ein bisschen anders fragen? Also wir haben jetzt auf der einen Seite schon mal festgestellt, du hast bei der Embedded Systementwicklung und bei den Software-Systemen oder Software-Anteilen daran mitgewirkt. Und was war das Besondere für dich an diesen Software-Anteilen? Das ganz Besondere für mich war, ich war für die Systemarchitektur verantwortlich, wo man dann die Teile separiert und Interfaces dazwischen klemmt.
Das ganz Besondere war, dass die Architektur nicht durch Funktionalität, sondern durch das Sicherheitsgedanken getrieben ist. Das war für mich ganz neu. In der Desktop-Umgebung machst du Exception Handling, Error Handling immer danach. Hier fängst du damit an. und überlegst dir, was passiert, wenn zum Beispiel du keinen Stromimpuls mehr setzen kannst. Was passiert, wenn einer das Signal meldet, einer nicht? Wie kommst du zur Mehrheitsentscheidung?
Das waren ganz, ganz neue Gedanken und auf der Grundlage dessen wird die ganze Architektur gebaut. Nicht auf der Grundlage dessen, dass das Teil funktioniert. Es schon funktioniert, aber du musst eigentlich immer in einem wohl definierten Zustand sein. Ja, klar. Du musst genau wissen, was das Teil tut. Ja, genau. Wollte ich auch gerade sagen.
Das war für mich ganz, ganz, ganz neu. Okay, was mich dann immer gleich auch interessiert ist, also auf der einen Seite hast du die Software-Architektur entwickelt und die separiert, hast du es gerade gesagt? Ja, genau, die berühmte Segregation. Ja, in einzelne Teile. Entworfen oder zugeschrieben die Funktionalitäten und Schnittstellen dazwischen definiert. So habe ich dich richtig verstanden.
Genau, da ist es ganz wichtig, dass die Schnittstellen nicht nur die Funktionalität abbilden, sondern was passiert, wenn das schief geht. Wenn ein Input-Subsystem zum Beispiel kann zwei Dinge liefern, einen Wert und einen Fehler. Und der, der das Input-Subsystem, das ist ja kein Subsystem, ein Board muss mit beiden Dingen leben können. Ja, ja. Der muss gegen beide Dinge programmieren und gerade der Fehler, der sogenannte nicht-funktionale Kanal, Vergisst man meistens.
Und das ist ganz, ganz, ganz übel nachhinein. Und das schmeißt dann denjenigen, der das aufruft, dieses eine System, der schmeißt ihn dann raus, wenn er darauf nicht reagieren kann. Zum Beispiel, was ganz wichtig ist, wir reden, wir müssen jetzt nicht Exceptions machen, aber ich gehe mal von Exceptions aus.
Wenn eine Exception geschmissen wird, dann wird die im Input-Subsystem auf ein paar ganz wesentliche runtergedammt, sodass der Anwender genau weiß, diese fünf Ausnahmen können bei mir nur passieren. Und diese übersetzt von Ausnahmen in einfache. Die muss an der Schnittstelle passieren. Sonst, wenn du das überall im Code machen würdest, kriegst du so eine Art Go-To-Code. Wenn du überall im Code Exceptions ausfängst, schaffst du keine Ahnung mehr über den Kontrollfluss.
Und durch das ist das ganz wichtig, meiner Ansicht nach, ein ganz klares Interface festzulegen. Und auf dieser Ebene muss man alles regeln. Gut. Ja, jetzt sind wir schon ein bisschen reingestiegen. Exceptions hast du gesagt, du hast Interfaces gesprochen. Vielleicht bleiben wir noch ein bisschen allgemeiner. in welcher Sprache hast du das entworfen? Also ich meine, du hast auf der einen Seite von Python eben gesprochen, dass du das auch genutzt hast.
Aber in welcher Sprache hast du denn diese Embedded System geschrieben? Das habe ich lustigerweise in Python geschrieben. Okay. Auf meinem Simulator, weil es viel schneller geht. Dann habe ich den ganzen Workflow abgebildet. Das ist nicht völlig kompliziert bei Defis. Die Teile laufen in verschiedenen Ländern mit verschiedenen Regularien. Und das muss ich konfigurieren können.
Das war hochkomplex. Dann habe ich es mit mit der Workflow-Maschine, in Python abgebildet, damit wir gewusst haben, das tut so. Dann ist der nächste Schritt, dann wird das in Hardware gekostet. Mit der State-Maschine, da kannst du verschiedene Sachen auswählen. OO-basiert, Template-Beta-basiert, Case-Statements, es gibt halt verschiedene Dinge, wie du es abbilden kannst. Okay, gut. Diesen Schritt habe ich nicht mehr gemacht, weil da habe ich die
Firma dann verlassen. Aber ich habe alles vorbereitet. Okay. Perfekt. Ja, ich wollte eigentlich darauf hinaus, du hast ja dann oder bist ja dann als Trainer für C++ in Erscheinung getreten, hast ja das weitergemacht. Wie bist du dazu gekommen, dass du dann C++ als das Thema ausgewählt hast, wo du eine Expertise hast? Guter Punkt, haben wir noch gar nicht so genau überlegt. Doch, ein bisschen natürlich schon.
Ich bin ein wahnsinnig neugieriger Mensch. Mich hat das immer wahnsinnig gestört, dass in Firmen zu wenig Fortbildung getrieben wird. Und durch das habe ich Fortbildung in den Firmen ganz, ganz hoch geschoben und habe auch Freiraum bekommen. Dann wollte ich, haben mich zwei Sprachen eigentlich drei sehr interessiert. Python, C++ und Haskell. Das ist ganz zäh in Sprachen wahrscheinlich im Endeffekt. Und dann habe ich mir gedacht, eigentlich kann Python jeder. Mache ich doch ein bisschen mehr C++.
Also ich war genauso früher auch als Python-Experte verschrien. Das kann ich immer noch ziemlich gut, aber der Einstieg bei C++ ist deutlich schwieriger. Dann gab es den Punkt, wo ich mir gedacht habe, eigentlich will ich doch mal selbstständig werden. Dann habe ich mir gedacht, wenn ich peinlich selbstständig werde, habe ich gegenüber meinen zu schulenden Vorsprung von ein, zwei Jahren an Wissen. In C++ habe ich ein Wissen von zehn Jahren mindestens.
Bis jemand das Wissen hat, was ich im Kopf habe, dauert es zehn Jahre, sich das zehn Jahre intensiv beschäftigt. Und durch das habe ich natürlich einen gewissen Schutz. Ein bisschen pragmatisch habe ich auch gedacht. Und so halte ich jetzt zur Zeit so zehn 10 Pein-Schulungen pro Jahr und 30, 40 C++-Schulungen. Also bis dieses Jahr, dieses Jahr ist es besonders. Aber so ungefähr. Ja, okay. Ja, okay, also so bist du dann dahin gekommen, dass du C++ schulen oder geschult hast.
Jetzt hast du, ich weiß gar nicht, ob es ganz zu Anfang gewesen ist, aber deine Webseite heißt ja Modernes C++. Warum genau dieser Name? Das war eigentlich ein Zufall oder Absicht, je nachdem. Ich habe beim Blog auf Deutsch angefangen. Der wurde dann relativ schnell relativ populär. Dann wollten die Engländer lesen, konnten sie natürlich nicht. Oder Englischsprachige. Dann habe ich ihn automatisch auf Englisch übersetzen lassen. Aber den deutschen Titel behalten, Modernes.
Und irgendwann habe ich dann angefangen, gleich auf Englisch zu schreiben. Und dann übersetze ich am Sonntag meine Artikel aufs Deutsche und dann landen sie bei Heise. Heise Developer. Und ich habe damals übrigens die Entwickler gefragt auf Heise. Braucht ihr die Artikel wirklich noch auf Englisch? Auf Deutsch haben sie gesagt, ja. Ja. Die Mehrheit der Leute will immer noch Deutsch lesen. Und so bin ich halt mit den zwei Sparen, da hab ich geendet.
Und jetzt heißt es nicht Modernes, sondern Modernes. Weil mein Blog ursprünglich aus dem Deutschen kommt. Ich glaube, ich habe jetzt seit 14 bei Deutschen. 14 Blogs oder was meinst du? Seit 14 habe ich meinen Blog. Seit 2014, ja, okay. Sorry, ich war zu kurz. Erklär uns mal ein bisschen, was ist für dich modernes C++? Was fasst du da drunter zusammen? Okay, jetzt überlege ich gerade, wie werde ich ausholen, aber ich hole ein bisschen aus.
Es gibt praktisch, der Einzelhandel veröffentlicht, drei ganz große C++-Standards. Der erste, wo C++ überhaupt definiert wurde, 1998. Dann der zweite Standard 2011. Da hat C++ total, laut Bjarne Stobstorp, feels like a new language. Und dann der dritte ist 2020. Im Allgemeinen wird 2011 als modernes C++ bezeichnet. Und da gehört auch nur 14 und 17 dazu. Das sind kleinere Standards. Alles für 11 gilt als Legacy. Und mit 20 für 20 haben wir noch keinen Namen gefunden. Da gibt es einfach keinen.
Also das sind die drei Sprünge. 98, 11, 20. Und der 26, über den ich nächste Woche anfange zu schreiben, Das ist wieder der nächste Sprung. Die Welt ändert sich, die Anforderungen ändern sich, also müssen sich auch unsere Werkzeuge ändern oder verbessern. Ja klar, kann ich verstehen. Das heißt also, wir haben dann dort neue Konzepte, überarbeitete Konzepte und so weiter. Ich kann es mal ganz auf drei Punkte runterbringen, um das ganz einfach zu machen.
Okay, damit so ein bisschen die Zuhörer wissen, ob es drei Punkte sind, weiß ich nicht. Ich habe gelogen, ich war gerade falsch. Nee, aber zum Beispiel, will. Das erste Mal hat C++ eine Idee von Multitraining. Das ist 9.11. Dann wurde die sogenannte Move-Semantik eingeführt. Ich nehme jetzt mal ein ganz blödes Bild, weil ich nicht weiß, wie viel ich annehmen kann. Wenn ich das Haus vom Nachbarn will, gibt es zwei Optionen. Ich kann es kopieren oder ich kann es moven.
Kopieren heißt, ich muss das ganze Haus zu mir überkopieren, dann kann ich mir auf den Finger hauen. Da können wir Ressourcen ausgeben. Und das dauert. Das ist riesig ressourcenintensiv. Moven bedeutet, gerade in dem Augenblick, wo ich es haben will, stirbt mein Nachbar und er schmeißt mir seinen letzten den Anzug des Schlüssels zu. Und das kann der Compiler öfter sehen. Daten, die nicht mehr benötigt werden, kann er wiederverwenden. Und das ist ein Warts-Performance-Vorteil.
Und das wurde implizit eingeführt. Das passiert implizit mit Elf. Nennt sich Move-Semantik. Früher wurde da immer ein neues Objekt erzeugt und dann weggeschmissen. Heute klaust du dir das. Ach so, das heißt also, so ein Objekt, was mal irgendwie angelegt worden ist, das wird gar nicht mehr wirklich dann ... Wenn der Compiler es sicherstellen kann, dann macht er das. Also es wird nicht wirklich gelöscht, sondern es wird quasi irgendwo vorgehalten. Der Besitz wird übergeben, ja.
Und wenn jemand anders den Besitz haben möchte, dann kann er damit machen und tun, was er will. Du kannst dir das vorstellen wie ein Auto oder ein Haus, wo die Daten, ich schließe das Haus, und die Autor testet nur den Schlüssel dazu. Was übergeben wird, ist der Handy, der Schlüssel. Ja, genau. Und damit kann ich dann einsteigen. Und durch das hat man mitbekommen, dass die großen Applikationen um 20 bis 30 Prozent schneller wurden.
Ohne was am Source Code zu ändern. Nur neu kompiliert mit einem neuen Standard. Die ganz großen Firmen arbeiten alle in der Standardisierung mit. Wie Microsoft, Google, Nvidia, du kennst sie alle. Okay. Und das war jetzt 2011? Das war 2011. Also das, was da mit reingekommen ist. Also auf Kernsprache würde ich sagen, war es Move-Semantik, was ich gerade erzählt habe. Auf Library-Ebene war es auch die Smart-Pointer. Machst du Python? Ich jetzt persönlich? Ja, ja. Nee, leider nicht.
In Interpretersprachen ist es typischerweise so, dass jedes Objekt einen smarten Pointer drin hat. Und immer wenn das Objekt out of scope geht, räumt sich die Datenstruktur selber auf, weil die mitzählt, wie häufig sie benutzt wird. Ach so, die zählt also die Anzahl der genutzten Verlinkungen und wenn die abgegeben werden, wird es wieder reduziert und wenn es auf Null ist, dann kann man das Objekt wegräumen. Stell dir das vor wie Autolosing.
Jeder hat einen Schlüssel, wenn jeder einen Schlüssel abgegeben hat, kann man das Auto löschen. Ja, genau. So funktioniert Shared Pointer. Es ist automatisch in jedem Interpreterspeicher wie Python drin, in jedem Objekt. Und in C++ kann man es explizit machen. Da haben wir verschiedene Smart Pointers. Also Pointer, die sich selber aufräumen. Alles klar. Und durch das gibt es im modernen C++ auf Anwendungsebene keinen Grund mehr, Speicher zu allokieren.
Weil das ist genauso schnell, genauso ressourcenarm und es gibt ja die zusätzliche Sicherheit. Das wird automatisch aufgeräumt. Und das ist das wichtigste Feature auf der Library. Bremen. Ah, das heißt also, ich brauche nicht wirklich nochmal herzugehen und diesen Speicher zu allokieren, was ja auch dann wieder für viele Leute dann, ja, das ist ja auch ein anderes Gedankenkonstrukt, was man dann verfolgen muss, ne? Wir haben was in C++, das ist gigantisch.
Und da muss ich sagen, ärgert es mich immer, wenn jahre Leute das nicht verstehen. Wir haben deterministisches Destruktionsverhalten. Das heißt, wir haben die Garantie, wenn was out of scope geht, übrigens auch in C, wird automatisch der Destrukt aufgerufen. Da können wir uns auf den Kopf stellen, können tun, was wir wollen, kommen nicht drumherum. Und dieses Feature ruft uns mehr aus.
Okay, und der Vorteil im C++ ist jetzt, also im Vergleich zum Java, was du jetzt gerade ja gesagt hast, beim Java muss immer dann dieser Garbage-Collector laufen und das dann wegräumen. Und der ist nicht deterministisch. Genau, und im C++ ist es genau in dem Moment, wo der Pointer auf Null geht, also der Smart-Pointer keine Referenz mehr nachweisen kann, dann räumt er das weg. Genau, und aus dem Grund, Python ist da genauso wie Java drauf übrigens.
Aus dem Grund können wir ganz, ganz kritische Operationen im Destructor machen. Was in Java oder Python du nicht machen darfst. Jetzt warst du aber immer noch bei dem modernen C++ aus dem Jahre 2011. Dann hupfe ich jetzt zu 20, oder? Ja, genau, mach mal. Oder nee, ich mache keinen Switch. Wir wollen ja so ein bisschen Einblicke geben, was modernes C++ ist. Ich mache einen kleinen Zwischenhub. Die STL hat über um die 100 Algorithmen.
In 17, das ist ein kleines Feature. Und jetzt kann man fast alle Algorithmen in parallel oder vektorisiert ausführen. Man kann es sagen Sort, und dann sagt man, stut, exec, par, und dann wird es parallel gestortiert. Das ist einfach ein Fleck, das mitgibt. Und dann wird es unter der Decke auf eine, vielleicht auf einen Memory Pool umgeleitet, auf einen Thread Pool, sorry. Auf einen Thread Pool umgeleitet, und dann läuft es auf einen Thread Pool.
Unter Windows wird da die PPL verwendet, Parallel Pattern Hybrid. Unter GTC-Linux klang die TBP, die Static Building Blocks vom Intel. Das heißt, du kannst diese genialen Algorithmen, die wir haben, 100 Stück automatisch parallelisiert oder auch vektorisiert ausführen, also mit Vektorinstruktionen. SIMD zum Beispiel oder so Zeug. Wo eine Operation nicht auf einem, sondern auf mehreren Elementen gleichzeitig stattfindet. Okay, ich glaube, mich hast du jetzt gerade abgehängt.
Weil ich so tief nie in diese SDL eingestiegen bin. Naja, aber das ist einfach ein riesiger Bunch von Algorithmen. Und die Algorithmen kannst du jetzt einfach parallel ausführen. Ich glaube, das kann man noch ein bisschen greifen. Das war auch noch ein wichtiger Zwischenschritt in diese kleinen Änderungen, hast du gesagt, 2017. In 17, ja. Und jetzt kommt 20 mit einer ganz großen Änderung. Du musst sofort mich unterbrechen, wenn ich sage, ich bin wieder zu tief abgedriftet.
Ich weiß nicht genau. Wir wollen ja hier noch eine C++-Schulung machen, damit musst du ja noch Geld verdienen. Ja, ja, ja, da habe ich genug noch. Da habe ich noch andere Untiefen, sag ich mal so. In C++ gibt es Templates. Templates haben ein riesiges Problem. Wenn du einen generischen, zum Beispiel stell mal vor, du hast einen Algorithmus, der für Addition steht, wie jetzt.
Dann kannst du mit jedem Datentyp aufrufen. Aber das geht natürlich nicht bei jedem, weil nicht jeden Datentyp kann man addieren. Und aus dem Grund haben Templates ein Problem hier. Weil es gibt keine generischen Datentypen. Fällt dir eine Funktion ein, die für alle Datentypen funktioniert? Vielleicht concatenieren? Da brauchst du ein Plus. Brauche ich auch ein Plus? Noch weniger Anstrengungen hat Identity. Die Funktion Identity, die Elemente da draußen wieder rausreicht.
Ich will nur sagen, es gibt keine generischen Datum. Es gibt keine Datum, auf denen alle Algorithmus laufen. Aus dem Grund hat man in C++20 ein Typsystem für das generische Programm hineingeführt. Da kannst du einen Algorithmus definieren und sagst, du darfst hier nur rein, wenn du eine Zahl bist. Also es geht nicht darum, ob es bool ist, float oder double. Es geht darum, ob es eine Zahl ist. Ob es zum Beispiel plus, minus, bar, log, geteilt kann. dann musst du dir überlegen, was Zahl bedeutet.
Dann kannst du Algorithmen definieren, die auf Ordnung basieren. Oder Klassen. Du darfst hier nur rein, wenn du in die Ordnung unterstützt. Wenn du weißt, was da kleiner ist. Und das ist eine Programmierung auf einer ganz, ganz abstrakten neuen Ebene. Das sind Concepts, nennt sich das. Ein Typsystem für Templates. Bin ich ehrlich gesagt ein Riesenfan davon. Und damit hören diese ekligen Fehlermeldungen, für die C++ berüchtigt ist bei Templates auf.
Die werden deutlich lesbarer und auf paar Zellen reduziert. Das war ein Riesenproblem bei Templates. Das zweite Ding, was neu ist, und das wird jetzt ein bisschen technisch. Fangen wir mal mit dem an. Das zweite sind Module. Das heißt, wie in Python und anderen Programmier-Sparen wollen wir von Include-Dateien wegkommen. Und wir wollen auf Module kommen. Das ist wie ein vorkompilierter Source Code. So wie in Python oder auch in Java.
Du hast sowas in Module. Eher wie in Python, aber das ist jetzt egal. Der Vorteil ist riesig. Erstens, Markos machen immer noch Probleme. Doppel definiert. Ich zeige dir von ab, welche Reihenfolge du nimmst und so weiter. Und zweitens ist das, das dauernde Inkludieren vom z.B. Header String ist wahnsinnig teuer. Und die Erfahrung hat gezeigt, wenn du große Libraries von Header auf Module umstellst, dass die Kompilierzeiten sich auf den Faktor 10 mindestens verbessern.
Das heißt, in C++23, so jetzt bei deinem Sprung, sagst du nur Import STD, du hast die ganze Library drin. Das ist alles. Das ist wahnsinnig benutzerfreundlich, wahnsinnig einfach. Und du deutlich die Kompilierungszeiten nach oben schießt. Die Zahlen sind übrigens nicht vermindert von Bjarne selber. Also Bjarne ist tost, weil ich es immer sage. Okay. Das ist schon das zweite große Feature. Das dritte sind, ich weiß nicht, wer es hier kennt, Co-Routine.
Das ist ein Stück, das man in Verbindung bringt. Bitcoin-Code, das ist etwas anderes. Co-Routine ist eine verallgemeinete Funktion, die man anrufen kann und die dann pausiert. Du rufst die Funktion auf, dann arbeitet sie, dann sagt sie, ich bin fertig, dann geht sie wieder zum Aufrufen zurück. Und später kannst du nochmal aufrufen und dann arbeitet sie an der Stelle weiter. Das nennt sich Asynchronen-Programmierung. Okay, warum springt sie an die Stelle zurück, wo sie aufgehört hat?
Beziehungsweise warum hat... Das ist die Magie des Frameworks, die sich den Zustand wirkt. Warum musste sie denn an der Stelle aufhören, diese Core-Routine? Zum Beispiel... Zum Beispiel, es gibt ganz klassische Beispiele. Immer wenn du viel warten musst, Python macht das sehr viel, willst du intelligent werden, du willst nicht blockieren, sondern du willst was anders tun. Du hast einen Server, der wartet auf einen Incoming-Request, der soll nicht blockieren.
Da geht der Server zurück an jemand anderes und dann, wenn der Client fertig ist mit seiner Konnektion, sagt der Server, hey, komm wieder zurück, du kannst die Verbindung annehmen. Ah, okay. Und dann springt er wieder da rein. Und dadurch kannst du ganz intelligent Es gibt in der Core-Currency praktisch zwei Prinzipien, performance-orientiert. Es gibt Dinge, die sind rechenintensiv und es gibt Dinge, die sind wartintensiv.
Rechenintensiv wäre, du möchtest eine ganz große Lass-Elektro zusammenartieren. Da hilft dann nur viel Hardware. Aber wartintensiv bedeutet, du kannst warten, wenn was passiert. Dann kannst du jemand anders laufen lassen. Ja. Und das Endspiel von Core-Routine, das wird ein bisschen technisch, du kannst auf dem Userspace einen Scheduler schreiben, der nur Co-Routine.
Du kannst praktisch sowas wie Spreading simulieren. Weil die Funktionen, die angehalten werden, wieder aufgenommen werden, kannst du dir vorstellen, wie das wird. Dann schreibst du einen kleinen Scheduler und der sagt immer, jetzt lauft der nächste Lauf. Und du musst gar nicht in den Körner runter. Und teuer war. Das ist das riesige nächste Feature, Co-Routine. Gibt es fast in jeder Programmiersprache mittlerweile.
Hört sich interessant an. Habe ich selber noch nicht benutzt, weil aus der Softwareentwicklung bin ich ja dann irgendwann 2016. 17 mehr und mehr rausgekommen. Das ist keine Entschuldigung. Korotin waren Vorfunktionen da. Die sind 1960 erfunden worden. Der Spezialfall von der korotinischen Funktion. Die hupft am Anfang rein, hupft zum Schluss wieder raus. Ja, okay. Ich wollte nur sagen, das ist ein ganz altes Konzept.
Alles klar, gut. Ja, hast du einen Ausblick, was 2026 als Erweiterung reinkommt in den Standard oder als Standard mitkommt? Also der wird wieder groß und es sind ein paar Dinge, die sind genial. Das Erste ist, es wird jetzt Reflexion geben zur Compile-Zeit. Das heißt, du kannst fürs Testing oder fürs Serialisieren die Datenstrukturen unter Fly aufbauen. Du kannst den Klazchen fragen, hey, welche Methoden hast du? Du wirst sagen, das ist doch langweilig, das können alle Programme nicht machen.
Die anderen machen es aber zur Laufzeit. Wir müssen es zur Compile-Zeit machen. In C++ gibt es den ganz, ganz wichtigen Grundsatz oder Meta-Regel. Don't pay for anything you don't use. Das heißt, jede Abstraktion muss umsonst möglich sein. Und das ist Compile-Time-Reflexion. Und das ist ein ganz geniales Feature. Da sind wir in der Ecke wahrscheinlich auch wieder so Richtung Bleeding Edge. Also C++ ist in vielen Bereichen Bleeding Edge.
Das kriegen viele aber nicht mit. Spar ist ganz anders als früher. Das Zweite, was ganz, ganz neu ist, ist, Design by Contracts. Die ganz alte Idee von Eiffel aus dem letzten Jahrtausend. Die Idee ist, vor der Funktion schreibst du Vorbedingungen, Nachbedingungen und Invaliden. Dann prüft die Funktion, wenn du es willst, ob er die Funktion mit dem richtigen Argument aufgerufen hat. Und das nennt sich Design by Contract.
Geht auf, glaube ich, Bertram Meier zurück und der hat die Sprache Eiffel vor langer, langer, langer Zeit entwickelt. Und da sind wir auch die Ersten. Und das Dritte ist, es wird ein ganz großes, das ist genial, es wird ein ganz großes, ich nenne es jetzt mal, gibt es verschiedene Namen dafür. Die verwenden wir als Exekutor-Modell geben. Das heißt, wir haben bei Programmieren viele Dinge, die parallel laufen. Die von des eigenen Ausführens. Mit Algorithmus und Code hier.
Was man jetzt in C++ macht, ist folgendes. Man nimmt das Baustein Führer aus und extrahiert es überall heraus. Und dann kannst du das Baustein Führer aus in den beliebigen Algorithmus reinschmeißen, dann läuft er parallel. Oder läuft er auf der GPU. Du willst praktisch wie bei Speicherallokation auch als separates Baustein verwendet. Willst du dein Algorithmus nicht mehr mit der Art oder ganz los verknüpfen, wo es ausgeführt wird. Ach so.
Warte mal, jetzt muss ich mal gerade in meinen Worten, also du kannst einer Funktion oder einem Thread sagen, wo er, auf welchem Prozessor er quasi laufen soll. Zum Beispiel das. Das hängt von dir ab. Oder was du willst beim Threading ist, dass da nicht so viel klonär kopiert wird. Dann verknüpfst du zwei Threads und sagst der zweite, vergleiche den CPU-Lauf mit dem ersten. Und das wird als Komponente raus extrahiert. Nennt sich formal Exekutoren. Und das ist ein ganz, ganz geniales Konzept.
Und das Schwierige war, wir haben erst die ganzen Abstraktionen erfunden rund um Threading und danach die Infrastruktur. Das war jetzt der falsche Weg. Aber du kriegst das nicht mehr anders gebacken wie so. Und dann können zum Beispiel Nvidia ja, das Zeug sollte blendieren, dass es, wenn sie es reinschmeißen, auf ihre GPUs läuft.
Genau. Das habe ich mich nämlich schon immer gefragt. Wie machen die das mit der KI, dass diese ganzen KI-Anwendungen dann auch wissen, okay, jetzt müssen wir hier auf der GPU laufen. Im Prinzip kannst du das auf diese Art machen. Und so haben wir praktisch zehn verschiedene Dinge, die man ausführen kann.
Und jetzt kannst du einfach dir sagen, ey, lass es auf der CPU laufen, lass es lokal laufen, lass es lazy sie laufen, das heißt, erst wenn ihr jemand das Gremium braucht, lasst es Eager laufen, sofort, lasst es auf der Threadpool laufen, das wird default sein und das ist einfach genial. Das glaube ich. Ja, cool. Dann, jetzt haben wir ganz viel schon über die, über modernes C++ gesprochen, was ist denn da jetzt in diesen ganzen Standards, oder wie hat sich dieser Standard immer weiterentwickelt?
Wenn man nur eine platte Antwort einzieht, wäre wohl der Digger, aber egal. Vielen Dank. Aber ich glaube, mir persönlich hat es jetzt schon mal was gebracht. Ich werde das auch noch mal so ein bisschen mitnehmen in die Shownotes, dass man sich das noch mal nachlesen kann. Ich fand es schon ganz spannend, dir da jetzt zuzuhören, was für Konzepte zu welcher Zeit in diese Standards mit reingekommen sind.
Wir hatten ja im Vorgespräch auch ein bisschen darüber gesprochen, dass du, also du bist ja auch Autor, du hast ja ganz viele Bücher geschrieben und ich glaube, dass eines der letzten Bücher ist ja dein, wie hieß es noch, Core Guidelines für C++, ne, genau. Und da geht es ja auch quasi ganz stark um den sogenannten Clean Code. Genau, da würde ich ein paar Worte dazu sagen. Genau, was, genau, vielleicht einfach mal erklären, was bedeutet das Clean Code,
wenn man das hört? Ich fange mal ein bisschen hinten drüber an. Ja, dann. Okay, das Folgende ist, in unseren Bereichen, ich gehe jetzt davon aus, ich mache doch die Defis. Genau. Es gibt Standards, MISRA oder AUTOSAR. Ja. So musst du programmieren. Und den dritten großen Standard, den gibt es in den C++ Core Guidelines. Die werden aber von der Community getragen. Die zwei Hauptchefs sind der Bernd Stusdorp und der Hauptstuder, der Vorsitzende der Standardisierungskomitees.
Ich bin ein riesiger Fan dieser Prinzipiencode. Code. Einfach best practices wie man es heute beschreibt. Das ist im Prinzip die Code, also, ganz schnell in und her interpretieren. Ich bin ein riesiger Fan davon, von daher habe ich 100 Blogposts geschrieben. Dann habe ich dem Bjarne ein E-Mail geschrieben und habe gesagt, ich bin ein Wahnsinnsfan von den Guidelines, aber in der Form könntest du es niemandem verkaufen. Das muss lesbarer werden.
Dann haben sie gesagt, wir wollen ja, wir haben schon einen Buchvertrag mit einem Verlag und dann haben sie zu mir gesagt, aber Rainer, du kannst das Buch für uns schreiben. Und so bin ich zu dem Buch gekommen. Und jetzt kann ich es dir ja heimlich nicht sagen. Am Anfang hatte ich eine kleine Schreibblockade, Weil ich wusste jetzt, dass Bern mein Zeug gegenliest. Das war schon komisch. Ja, das glaube ich. Ja, aber es war total gut und das Buch habe ich dann veröffentlicht.
Du könntest jetzt Clean Code nennen, aber im Prinzip sind es einfach Best Practices von Modernistik. Bis 2017 geht es. Ja. 2017. Bis zu dem Standard. Die Konzepte sind dort mit drin und alles, was dann danach kommt, das hast du quasi nicht mit abdecken können. Da gab es noch keine Best Practices. Genau. Die müssen sich erst entwickeln. Ich habe da mal reingeguckt in das Inhaltsverzeichnis, was du denn da alles reingeschrieben hast. Also da findet ja jeder was zu allen möglichen Themen.
Ich bin immer ein großer Fan vom Errorhandling gewesen, weil das war ja in, ich habe damals mit C noch gearbeitet. Das musstest du ja alles per Hand einbauen und dir vorher dann diese querschnittlichen Konzepte darüber Gedanken machen. Das ist hier in der Sprache jetzt quasi schon mit drin, wenn ich das so sehe. Da gibt es doch den deutlichen Fortschritt in 23. Da gibt es den deutlichen Datum, das ist nicht erwartet. Der hat zwei Kanäle, einen Fehlerkanal und einen Wertekanal.
Und sobald der Fehlerkanal bedient wird, geht es ganz schnell durch und du musst auch nicht testen. Du musst nicht so was Blöds machen wie bei Error Handling, über Nachfragen, was ich da hören werde. Das passiert automatisch. Dann kann man das ganz schön funktionierend komponieren und dann der Fehler wird durchgeleitet und der Wert, je nachdem, was passiert ist. Okay. Aber wie gesagt, das ist jetzt nur ein Punkt, den ich daraus gepickt habe.
Dann gibt es hier die parallele Verarbeitung und wie schreibe ich Performantencode und so weiter. Ja, ja. Das sind alles Themen, die in den Core-Guidelines dann abgedruckt werden. Ich muss noch erwähnen, das ist ein lebendes Dokument. Das wird immer erneuert. Aber die Leute, die es editieren, sind in der Regel nur Leute vom Standardisierungskomitee. Das heißt, das ist qualitativ extrem hochwertig. Und die stehen auch in Diskussionen
mit MISRA und AUTOSAR. Okay. Wenn das ein lebendes Dokument ist, also du verkaufst ja die Bücher, hast dann da aber auch immer wieder Aktualisierungen drin. oder wie muss ich das verstehen? Wenn es sich richtig stabilisiert hat, werde ich irgendwann eine Aktualisierung machen müssen. Ah, okay. Verstehe. Zurzeit ist man noch zu wenig, wie gesagt, Best Practices hat sich vor ein paar Jahren damit beschäftigt.
Ich wollte noch was erwähnen zu den Guidelines. Ja. So ähnlich wie bei MISRA gibt es auch die Guidelines Support Library, kurz GSL, und die kann helfen, die Regeln zu prüfen. Das ist nochmal GSL? GSL, ja. Ja, gehe ich ein. DSL. Ah ja, Guideline Support Library. Und mit der kann man sozusagen die Regeln prüfen. Man kann prüfen, ob man die ganzen Regeln da oben richtig angewandt hat. Und wenn nicht, kriegt man einen Fehlerbericht.
Das heißt, so ähnlich wie beim MISRA, kann man so einen MISRA-Checker, kann man so einen Guideline-Checker auch drüber laufen lassen. Das ist alles nur eine Header-Datei, die du jetzt checkst. Das heißt, das funktioniert überall. Und dann kriegst du dann beim Compile-Vorgang? Oder wann bekommst du diese Fehler-Meldung? In der Regel beim Compile-Vorgang. Aber ich habe das genauer erklärt bei den Blogposts. Also da musst du einen Link reinsetzen.
Und Windows ist das total gemütlich. Da kannst du in Windows die Häkchen schon angeben. GCC und Linux verwende ich den Klang-Tidy. GCC und Klang verwende ich Klang-Tidy. Aber es geht auf allen Plattformen. Ich werde den Link auf dem Blogpost raussuchen. Genau, das ist der eine letzte Artikel. Zur Guide-Support-Library. Okay. Okay, was in unserem Vorgespräch, was dir da auch noch ganz besonders wichtig war, war der Hinweis darauf, liebe Leute, setzt moderne Techniken ein.
Was verstehst du darunter? Warum war dir das so wichtig, das mitzugeben? Worauf soll man da achten? So allgemein kann ich so, sagen wir mal so, C++ hat einen Fluch und einen Segen. Und der Fluch und Segen heißt C. Das heißt, wir müssen irgendwie das C unterstützen. Aber durch das C ist es immer auch groß geworden, das ist das Segen. Aber wir können die ganzen. Schweine reinmachen, die man C auch machen kann. Das soll man aber nicht unbedingt.
Und jetzt erkläre ich in meinen Schulungen, wie man das nicht macht. Und die Techniken sind immer was Zusätzliches. Man muss das immer noch so können wie früher. Das ist für Bjarne ganz wichtig. Und immer, wenn was besser wird, das muss was Neues sein. Zum Beispiel initialisiert man in C++ nicht mit runden Klammern, sondern mit geschweiften Klammern. Warum? Weil geschweifte Klammern Narrowing Conversion detektieren. Das heißt, wenn du ein Double in den Int reinsteckst, finden die das raus.
Das sollst du nicht tun, aber die runden Klammern kriegen das nicht mit. Und das machen aber die geschweiften Klammern. Darum sage ich, immer mit geschweiften Klammern hinzuzasieren. Okay, das heißt also, das ist eine von diesen modernen Techniken, die wir nutzen sollen als moderne C++-Programmierer, damit wir halt frühzeitig schon auf Fehler gestoßen werden, die wir aus Versehen vielleicht gemacht haben. Damit du aus einer 3,5 die 3 machst.
Ja. Und so gibt es wahnsinnig viele Regeln, die ich in den Core Guidelines erkläre. Zum Beispiel, dass man keine nackten Speicher mehr verwenden soll. Dass man SmartPoint verwenden soll. Zur Performance habe ich es vorher erzählt. Wenn zu mir einer kommt und sagt, sein Programm ist jetzt besser, es ist schneller, dann glaube ich dem das nicht. Ich brauche erst einen Test mit realistischen Daten. Und das sind lauter so Regeln, und das erkläre ich in dem Buch.
Da setze ich schon ein bisschen C++-Verständnis voraus. Und dann sage ich, man macht das so oder so. Ja, okay. Ich glaube, das ist kein Grundlagenbuch. Das setzt voraus, dass du schon ein bisschen drin bist. Man könnte es zur Not auch lesen, indem man dann immer nachblättert. Aber das Entscheidende ist eigentlich, das Buch erzählt, ich würde es mal so sagen, wenn du die Regeln des Buches anwendest, ist dein Programm per Design so gut wie richtig. Das ist einfach die Idee des Buchs.
Okay, es reicht aber auch aus, das ist jetzt eine kleine Nachfrage so ein bisschen, ich muss jetzt nicht das Buch von vorne bis hinten durcharbeiten und alles gleich anwenden, sondern es reicht auch, wenn ich mich auf gewisse Themen erstmal konzentriere und sage, okay, da will ich besser werden. Ich will zum Beispiel, ich weiß, dass ich Concurrency habe hier in meinem Programm, ich konzentriere mich erstmal da drauf.
Genau, das ist auch vollkommen klar. Ja. Und wenn ich das für mich etabliert habe im Kopf, dann kann ich auch weitergehen und sowas aufnehmen wie Error-Handling oder eines der ersten Themen waren ja deine Interfaces. Interfaces, Funktionen, Klassen, Inheritance. Ja, also dass ich mich Stück für Stück dann immer weiter mit diesem Buch beschäftige und mit den Best Practices, die du da beschreibst. Und das halte ich für ganz, ganz, ganz wichtig.
Ich sage kein Stamm, weil es muss mein Buch sein oder aber es ist ganz wichtig. Das hilft übrigens auch, wenn man sich mit Autosatz beschäftigt. Überleg, warum gibt es die Regel? Was ist die Begründung dafür? Einfach bewusst programmieren, ganz wichtig. Zu wissen, was man tut und diese Regel zu hinterfragen und dann drauf zu kommen, ja, ist eine gute Idee. Das macht richtig viel Sinn. Und ich bin im Nachhinein erschrocken, wieso bei mir früher die Programme funktioniert haben.
Ich glaube, mit der Erfahrung fragt sich das jeder, der irgendwann mal in die Softwareentwicklung eingestiegen ist. Du kennst mein Lieblingsbild für Programmieren. Der Programmierer ist ein Mensch mit tausenden Leben, der läuft im Sumpf und immer wenn er untergeht, nimmt er beim nächsten Mal einen anderen Weg und irgendwann kommt er über den Sumpf drüber. So stellen wir Programmieren vor. Genau. Man versteht es nicht, aber hat aus Erfahrung gelernt, da komme ich dann um.
Ich habe da immer so ein bisschen anderes Bild im Kopf, aber das jetzt zu skizzieren, das ist ein bisschen aufwendiger. Aber so ist es auch, ja. Ja, genau. Ja, Rainer, du hast mir doch erzählt, du bist gerade dabei, an deinem Mentoring-Programm weiterzuarbeiten. Okay, da bin ich gerade voll ergeschürt. Ich will mal ein bisschen ausholen. Ich schule schon ewig lang. Und ich halte drei Tagesklassen für gut, aber nicht das Optimum.
In eine Firma muss irgendwie eine Fortbildungskultur reinkommen, deren feste Ansicht bin ich. Das heißt, man braucht pro Woche ein paar Stunden, wo nur für Fortbildung da ist. Weil in unserem Bereich, der ist einfach so wahnsinnig schnelllebig. Wir kommen nicht drum herum und es dauert zu arbeiten. Das ist eine Erfahrung gemacht. Wie gesagt, ich bin Krankenpfleger. Da geht es viel gemütlicher zu.
Aus dem Grund oder aus dem anderen Grund, dass es in Deutschland, ich bin ja mal bösartig, nur fünf bis zehn gute Trainer gibt, aber viel mehr Leute, die es nötig haben, haben wir ein Problem. Und aus dem Grund habe ich ein Mentoring-Programm mitgeworfen. Die Idee von Mentoring ist das folgende. Ich arbeite gewisse Themen auf in kleinen Videoeinheiten, wo ich die Theorie erkläre und erkläre dann ein Thema in 16 bis 32 Wochen.
Dann setze ich voraus, dass man pro Woche mindestens drei Stunden investiert. Man kann mehr, weil ich mehr Material habe. Und das ist mein Programm. Das heißt, ich habe drei Komponenten. Der erste ist Theorie erklären, der zweite ist Praxis. Da erkläre ich die Theorie noch mal ein Beispiel. Die Teilnehmer kriegen Übungsaufgaben und die Lösung als Video aufgenommen. Und es gibt ein Forum, wo die Leute die Übungsaufgaben diskutieren können.
Und die dritte Komponente pro Woche ist noch die Q&A. Das ist typischerweise am Freitag. Da werden wir Fragen zu den Übungsaufgaben zur Theorie gestellt. Und so arbeite ich die Thema auf in 16 bis 32 Wochen. Mittlerweile habe ich fünf Mentoring-Programme und einige Leute, die schon durchlaufen haben. Ja, und was wollte ich noch sagen? Die bauen, warte mal, du sagst fünf Mentoring-Programme, die bauen Die bauen aufeinander auf.
Die bauen aufeinander auf, ja. Würde ich theoretisch bei dem ersten Programm anfangen und dann könnte ich ins zweite, ins dritte, vierte, fünfte. Also das erste Mal, wenn ich es unschlecht erklärt habe, soll man Kontakt mit mir aufnehmen. Das zweite ist einzig für Beginner, das heißt Fundamentals. Der Grundlage für mich war das, der zu sagen, was verlange ich von einem, der sagt, er kann C++ und ich soll den einstellen. Das war die Messlatte für mich.
Und dann gibt es zwei Intermediate Design Patterns, Architektur Patterns. 10 plus plus und 10 plus plus 20. Und dann gibt es zwei Advanced Concursi, das ist richtig anspruchsvoll. Und gerade eben entwickelst du und es sind ein paar Wochen fertig Templates. Ja, und das sind die fünf und zwei wird es noch geben. Zwei wird es noch geben. Eins zu Performance und eins zu Embedded-Programmierung. Und dann habe ich im Prinzip alles abgedeckt. Und das ist.
Wenn ich das jetzt richtig verstehe, bauen die ja nicht aufeinander auf, sondern das ist ja wie so eine Plattform, wo man sich auswählen kann, okay, ich brauche jetzt was zum Concurrency, dann muss ich hier dieses Mentoring-Programm mir auswählen. Also sagen wir, das Erste ist ja Grundlage, die brauchst du einfach. Ja, klar. Sonst darfst du nicht programmieren. Und das Zweite sind Spezialisierungen. Ja. Und die weitere, wobei Design und Architektur ist so halb Grundlage, halb Spezialisierung.
Okay. Du weißt es ja selber. Ja, klar. Kann ich mir was darunter vorstellen. Man könnte Könnte schon in die Concurrency gehen, aber vielleicht ist es doch sinnvoll, mal noch die Architektur besucht zu haben vorher, damit man weiß, welche grundlegenden Aspekte aus der Architektur denn vielleicht noch da rangezogen werden.
Und das Schöne an dem Mentoring-Programm ist, da wir ein Feature nicht nur aus einem Aspekt, sondern aus fünf Blickwinkeln anschauen und immer mal wieder, sitzt es viel tiefer im Hirten. Das ist also viel nachhaltiger, viel nachhaltiger. Aus fünf Blickwinkeln, wie meinst du das? Du hast in jedem Mentoring-Programm so fünf Blickwinkel? Du kannst Move-Symmetrie erklären. Ich habe vorher Move-Symmetrie erzählt. Da habe ich dir aus dem Aspekt von Performance ein bisschen erzählt.
Ich könnte es aber jetzt auch aus dem Aspekt vom Design von der Klasse erzählen. Wie man klar sieht, was man damit automatisch moven kann. Dann ist es eher Design. Ich könnte es theoretisch erzählen mit R-Value und L-Value. Bei Referenzen-Zocken habe ich immer verschiedene Zugänge. Und durch das sitzt das viel, viel tiefer. Und die Idee von mir ist einfach die folgende, wenn jemand mitmachen will, da sitzt seine Firma für drei Stunden pro Woche und für den Kurs sponsert.
Der Kurs kostet genauso viel wie eine typische Dreitagesklasse, aber wesentlich wertvoller. Wesentlich. Okay, und du kannst es dann quasi aus dem Büro oder von zu Hause bearbeiten, weil für diese drei Stunden, die du eben gesagt hast, würde ja keiner durch die Welt fahren und sich irgendwo in den Klassenraum setzen. Genau. Das ist eine kleine Herausforderung. Ich habe Teile von der ganzen Welt. Von Südamerika bis nach Australien. Durch das biete ich zwei Q&As an, wenn ich die Zeit hole.
Okay, ja, das ist gut. Das ist natürlich eine Herausforderung. Weil die sind ja 20 Stunden auseinander. Ja, und die Mentoring-Programme sind prinzipiell dann auf Englisch, weil du die dann wahrscheinlich… Die sind auf Englisch und auch die Q&A, die zeichne ich auf, also selbst wenn man keine Zeit hat. Ja, also da kann man dann nochmal reingucken. Ja, und ich wollte noch was sagen.
Danach kann man von der Mentimembership in die Community membership gehen und dann kann man alles konsumieren, was man mal gekauft hat für ewig, für unbestimmte Zeit. Ach so, okay, verstehe. Ich hatte einige Teilnehmer gehabt, was passiert, wenn man die Frage erst einmal ja einfällt? Dann bin ich ja nicht mehr im Forum, da sage ich, ja, stimmt eigentlich. Und aus dem Grund habe ich die alten, die meisten noch drin. Das ist eine relativ kleine Gebühr, 150 Euro und da ist Leben lang Zugriff.
Weil ich will eine Community aufbauen, die miteinander diskutiert. Ja, sehr schön. Was haben wir jetzt besprochen, Rainer? Ich komme ja eigentlich aus der Systementwicklung und aus dem Requirements Engineering und sorge dafür, dass Anforderungen erhoben werden, dass bekannt ist oder dass herausgearbeitet wird, was das System leisten soll. Und ja, über die Architektur wird dann aufgeplant oder überlegt, wie hast du es eben gesagt, Segregation, also die Aufteilung in entsprechende Teilsysteme.
Ein Teilsystem davon ist immer wieder die Software. Manchmal hat man auch mehrere Softwareteile in so einem komplexen System. Und genau das sorge ich quasi für mit den Lastenheften und Pflichtenheften und du hast jetzt quasi mit dem modernen C++ dafür gesorgt, dass wir auch einen gescheiten Quellcode erstellen können.
Genau, also ich fange bei der Architektur an, ganz grob gesagt, auch wenn ich im letzten Beispiel, im letzten Job doch deutlich mehr gemacht habe, aber im Prinzip fange ich bei der Architektur an und ich versuche die Architektur durch Design und gute Anwendung von C++ umzusetzen. Genau. Das ist eigentlich meine Aufgabe, weil ich relativ gut weiß, was sind die Idealtechniken, weil manchmal mache ich auch für Firmen Code Reviews.
Okay, genau. Das ist sozusagen meine Baustelle, wo ich relativ gut bin. Ja, genau. Und deswegen ergänze ich das auch immer ganz gut, finde ich, oder in diesem Fall unser Interview, weil auf der einen Seite haben wir halt die Feststellung, was sind die Anforderungen und auf der anderen Seite, da kommst du dann ins Spiel und kannst den Menschen aus dem Software-Bereich helfen, da sauberen Code, also clean Code zu schreiben, der sich kompilieren lässt, der sauber auch in der Laufzeit funktioniert.
Also nochmal ganz andere Aspekte mit reinbringst, als das, was ich beschrieben habe, was funktional quasi das System machen soll. Das heißt also, deine Mentoring-Programme können nicht nur von Menschen genutzt werden, die jetzt im Medizinbereich unterwegs sind, so wie du es zu Anfang mit den Defibrillatoren genannt hast, sondern alle, die irgendwo Software schreiben, C++ schreiben, für die ist es ja auch geeignet.
Ja, stimmt, aber was das auf den Punkt bringt, meine Hauptkunde ist die Automobilindustrie. Ohne Zulieferer, also das ist immer schon eine gewisse Tendenz zur Hardware. Okay. Weil das sind einfach die Herausforderungen, die wir haben. Sind meiner Ansicht nach, kriegen wir die Automobilindustrie ins nächste Jahrtausend, die dieser VMS jetzt ist. Und das Entscheidende ist Software, meiner Ansicht nach. Wir müssen lernen, andere Kulturen aufzubauen in Firmen.
Unsere Softwarefirma wird ganz anders betrieben als die Hardwarefirma. Ja, das stimmt, das stimmt. So, jetzt hatten wir so den Kreis hinbekommen, dass ja auch klar ist, warum habe ich hier im Systems Engineering jetzt jemanden dabei, der Softwareentwicklung betreibt und Mentoringprogramme für Softwareentwicklung betreibt. Ich finde, das war eine ganz wunderbare Erweiterung. Freut mich. Wir haben vorher ja aber auch noch über was anderes gesprochen.
Und zwar, wer es vielleicht mitbekommen hat, Reiner hat jetzt hier im Interview immer mal wieder ein bisschen abgehackt gesprochen. Reiner, du bist krank geworden im letzten Jahr. Ja klar, da gehe ich auch ganz, ganz öffentlich damit um. Was eine sehr gute Entscheidung war. Ich habe alles und wer weiß, was es ist. Das ist das, was das Team von Hawkins gehabt hat. Bei ihm ist es doch ganz untypisch verlaufen. Weil normalerweise lebt man zwischen 2 und 5 Jahren und nicht 40 Jahre damit.
Und das Abgehackte kommt daher, damit ich sauber rede, kriege ich so, habe ich in der Nase so eine kleine Luftunterstützung und immer wenn die Luft reinbläst und ich dann anfangen will zu reden, dann passt das nicht. Da muss ich kurz pausieren. Das ist ein Synchronisationsproblem. Da kommt wieder der Techniker durch, genau.
Genau. Ja, dir ist es ganz besonders wichtig, dass wir nochmal das Thema ALS ansprechen, Weil es muss, oder es ist aktuell nicht so in den Medien, so bekannt in den Köpfen von den Menschen. Also ich will jetzt nicht groß jammern, aber das Problem ist einfach, ALS wurde lange Zeit sehr stark gegründet, bis zum Tod von Stephen Hawkins. Dann gab es die Ice Bucket Challenge 2014. Ja, vielleicht kann ich da noch viel erinnern. Die gerade nach zehn Jahren wieder
aufgewirbelt wird. Es ist gerade auch wieder eine Welle. Ja, genau. Die Ice Bucket Challenge gibt es aus dem Grund, in der Endphase von ALS führt man sich, wie wenn das Eis über dich drüber geschmissen wird. Der ganze Körper zieht sich zusammen, du kannst dich nicht berühren. Da kommt die Challenge. Das ist das Gefühl von ALS nachzustellen. Das guckt, das wusste ich zum Beispiel auch nicht. Ich weiß es auch nicht, der Gestern. Also, sehr interessant, das mal zu erfahren, warum...
Dieser Schluss getroffen worden ist damals, ja. Das Problem ist einfach, in den letzten Jahren hat sich viel erforscht, rund um Krebs und langsam kriegt man den Krebs ziemlich gut unter Kontrolle. Sie vermuten schon, dass es jetzt bald schon Impfungen geben, Krebsart gibt. Das musst du dir mal vorstellen, das finde ich genial. Und jetzt wird der Fokus mehr auf diese Nervenkrankheiten gelegt. Wie zum Beispiel, meine Krankheit ist relativ verwandt, auch zum MS oder auch zu Parkinson.
Und jetzt versucht man halt immer mehr, und es gibt schon kleine Durchbrüche, bei meiner Krankheit was zu tun. Einerseits die symptomische Linder oder andererseits vielleicht sogar ursprünglich anzugehen. Was bei ALS passiert, ist folgende. Die Motorneuronen, die meine bewusste Muskulatur ansteuern, gehen kaputt. Durch das bin ich praktisch, weil ich immer mitgelebt habe. Und ich bin es bereits oben, selbst bin ich stark, oben ab und zu nicht.
Aber wie gesagt, es soll jetzt kein Jammern sein. Mir geht es total gut. Ich bin voll von Energie und mir geht es gut. Also so wie ich dich hier erlebe, sprühst du quasi wirklich vor Energie, dass du doch dieses Mentoring-Programm fertigstellst. Du hast die Pläne für weitere Mentoring-Programme. Das ist wunderbar. Nee, das freut mich wahnsinnig, dass ich das so umsetzen kann. Sorry, das habe ich unterbrochen.
Ja, alles gut. Ich habe dadurch, dass ich auch mit meiner Frau darüber gesprochen habe, über die Erkrankheit, die du hast, sagte sie, ja, und hier in der Nachbarschaft, da war auch jemand, der ist vor mehreren Jahren daran gestorben. Und dann kam noch mal irgendwo jemand, also ein Name ins Spiel, da hieß es auch, ja, der hat auch ALS. Und da ist mir erstmal bewusst geworden, okay, das ist gar nicht so eine seltene Krankheit, es gibt die wirklich häufiger.
Ja, die ist halt total unterfinanziert und wird nicht wahrgenommen. In Amerika gibt es einen größeren Topf jetzt, wo sie Forschung vorantreiben, aber in Deutschland passiert noch nicht so viel. Und das ist das Traurige, das läuft hauptsächlich über Spenden. Das ist einfach ein bisschen traurig. Und gerade wird aber der Fokus weg von Krebs, Richtung die Richtung gehen. Ja, genau. Es hat einen lustigen Namen. Es gilt als die häufigste seltene Krankheit.
Ja, sie gilt als seltene Krankheit und die tritt aber wiederum am häufigsten auf. Die häufigste, ja. Ja, genau. Ja, und du hast es ja gerade gesagt, so tief stecke ich da nicht drin, aber wenn es schon Impfungen für die ersten Krebsarten geben könnte, dann ist das ja ein wahnsinniger Schritt. Und die andere Krankheit, die ja immer wieder bekannt und durch die Medien gegangen ist, ist Aids. Und da ist ja auch vor, wann haben wir das Vorgespräch gehabt?
Ich glaube vier Wochen ist es her oder so. Und kurz davor ist eine Meldung über das Radio gekommen, dass in der Charité in Berlin der dritte Mensch in Deutschland quasi von Aids als geheilt gilt. Das ist eine Geheilsumme, ja. Ja, weil wenn man fünf Jahre lang den HIV-Virus nicht nachweist, dann gilt man als geheilt. So ist die Definition. Und das ist bei dieser Person wohl passiert. Das ist jetzt der dritte in Deutschland und der sechste weltweit.
Also da passiert auch einiges. Und da gebe ich dir durchaus recht. Da wird die nächste Krankheit dann natürlich auch jetzt finanziert werden müssen. Und gerade die Charité Berlin ist ganz wichtig bei alles. Die hat ein ALS-Zentrum und ich arbeite mit denen ab und um zusammen bei dem Hawaii. Die haben auch eins. Weil ganz wichtig bei solchen Krankheiten allgemein, man muss zu dem größten Spezialisten gehen, den man findet.
Weil die anderen wissen gar nicht damit umzugehen. Die machen das total falsch. Und das ist eine ganz allgemeine Empfehlung, immer wenn man sowas hat. Spezialisten aufsuchen. Ja, genau. Spezialisten aufsuchen. Das ist auch unser Stichwort. Wenn man Lastenhefte braucht, geht man zu mir. Hier, wenn man modernes C++ lernen möchte, geht man zu Rainer Grimm. So sollte es eigentlich auch sein. Ja, Rainer, haben wir irgendwas vergessen in unserem Gespräch?
Das kann ich mir nicht vergleichen, auf jeden Fall. Aber es erinnert nichts dran. Okay. Wenn du 1300 Blog-Artikel geschrieben hast, hast du ein paar andere Sachen im Kopf. Okay, gut. Ich werde auf jeden Fall deinen Blog oder deine Blogs verlinken in den Shownotes. Auch das Buch, die Mentorung-Programme, alles das finden die Zuhörer dann in den Shownotes und können sich da eher umtun oder anmelden, um mehr zu lernen
über modernes C++. Plus. Und bei mir, durchaus, Sie können sich auch bei mir rühren, ich drücke es auf beides zu, sowohl auf die Krankheit wie auch auf C++. Okay. Ich will einfach nur helfen, egal in welche Richtung. Alles klar. Werde ich dann auch nochmal so reinschreiben. Ja. In diesem Sinne, vielen Dank, dass du dabei warst. Rainer, tiefen Einblick in Softwareentwicklung bekommen. Wir wissen jetzt, was die wichtigsten Meilensteine in den Standards waren und wie man sich da weiterbilden kann.
Vielen Dank, hat mich gefreut. Ja, danke auch. Tschüss, Rainer. Hat Spaß gemacht. Ade. Das war mein Gespräch mit Rainer Grimm. Zusammenfassend zur heutigen Episode seine drei Tipps. Verwende moderne Techniken für deine Software. Die Anwender werden es dir danken. Tipp Nummer zwei. Programmiere anhand der Core Guidelines für C++, denn es sind Best Practices aus der Community. Und nutze mindestens drei Stunden pro Woche für Weiterbildung, um so an den neuesten Technologien dran zu bleiben.
Brauchst du Unterstützung bei der Erstellung eines Lastenheftes oder hast eine Frage dazu, dann findest du meine E-Mail in den Shownotes. Klicke da drauf oder kopiere sie in dein E-Mail-Programm und schicke mir eine Mail. Wir vereinbaren einen kostenfreien Termin und sprechen über deine Herausforderungen. Das war die heutige Episode des Zukunftsarchitekten, der Systems Engineering Podcast für Machende und Entscheidende. Mein Mein Name ist Björn Schorre und ich danke dir fürs Zuhören.
Hab Spaß an dem, was du machst und vor allem wünsche ich dir einen hohen Wirkungsgrad. Tschüss und bis zum nächsten Mal. Music.