All posts tagged: verbesserung

Skillbyte Podcast #40: 10 Lektionen, die wir in 40+ Jahren Softwareentwicklung gelernt haben (Teil 2)

Willkommen zum Skillbyte-Podcast! Skillbyte ist ihr Partner für digitale Exzellenz.

In diesem Podcast geht es um das Thema: 10 Lektionen, die wir in 40+ Jahren Softwareentwicklung gelernt (Teil 2)

// Inhalt //
01:27 – Masiar’s IT Katastrophengeschichte
02:29 – 6. Lektion: Verstehe zuerst das Problem, schreibe dann erst Code für die Lösung
08:18 – 7. Lektion: Frage um Hilfe wenn du nicht weiter kommst (ultimative Superkraft)
11:20 – 8. Lektion: Du wirst immer weiter lernen (müssen)
21:22 – 9. Lektion: Test driven development (TDD) ist ein Mythos
26:34 – 10. Lektion: Alles dauert länger als geplant. Lass dich nicht von willkürlichen Deadlines verrückt machen.

Abonnieren Sie diesen Podcast und besuchen Sie uns auf https://www.skillbyte.de

Feedback und Fragen gerne an podcast@skillbyte.de

// AUTOMATISCH GENERIERTES TRANSKRIPT //

Nein. Prozess. Prozess beim ersten Mal o. citta bibber und um Gottes Willen und die Welt geht unter. So, und dann machst du und tust du. Und dann bist am Wochenende da und nachts bis drei. Und hin und her. So wird es aber trotzdem später, weil irgendetwas passiert ist, wo du keinen Einfluss drauf hast oder merkst. So schlimm war das jetzt doch nicht, weil der der Druck gemacht hat. Der war dann auch entspannt. So, und wenn das ein paarmal passiert, dann zuck sogar wenn Merkel.

Herzlich Willkommen zu unserem Skill bald Podcast Episode Nr. 40 10 Lektionen, die wir in über vierzig Jahren Softwareentwicklung gelernt haben. Teil 2 Abonniert unseren Podcast für mehr spannende Themen aus dem Technologie Umfeld, wenn ihr die Entscheider oder die Fachkraft seid. Wenn ihr Hörer Fragen habt, sendet uns gerne eine E-Mail an Podcast als Skill bei D. Wir freuen uns immer über eine positive Bewertung und wenn ihr den Podcast an Freunde und Kollegen aus dem ähnlichen Arbeitsbereich weiter empfehlt ich bin heute hier wieder mit Mazur zum zweiten Teil.

Hallo Masiar, Hallo Maurice, du bist heute sehr Energized.

Ich bin heute total Energieriese. Ich hatte eine gute Woche und freue mich jetzt mit dir. Wirklich, wirklich. Weil die ersten 5 Lektionen sind schon super angekommen. Da hab ich viele Zuschriften bekommen per WhatsApp und freue mich jetzt mit dir. Lektion 6 bis 10 durchzusprechen voller Energie. Vorher allerdings möchte ich dich fragen Sind dir noch Katastrophen aus deinem Leben eingefallen?

Ganz im Ernst. Ich habe überlegt und überlegt, wie es wirklich nichts eingefallen. Allerdings muss ich sagen, jetzt letztens kam eine GERB für Gravity Kiwi so toll eingerichtet. Was dir berichtet, ob alles in Ordnung ist. Und da kam eine Falschmeldung und damit hat sich das Herz in die Hose gerutscht. Da hatte ich seit langem mal wieder Angst, weil ich unterwegs war und nix machen konnte. Aber es war eine Falschmeldung. Insofern war es wieder gut. Was stand in der Meldung, dass Gravity nicht verfügbar ist?

Also komplett offline? Ja, genau. Ah, okay. Ich dachte jetzt Datenbank kaputt. Hacker haben die Daten geklaut oder so irgendwas Relevantes.

Mir ist nichts passiert in der Richtung nichts passiert. Okay. Erst bauen und Fehlalarm.

Das ist bestimmt meine Aura, die sowieso alles abhält. Deine Aura möchte ich auch haben. Na gut, springen wir zur sechsten Lektion. Vielleicht fällt dir unterwegs noch eine Katastrophe auf, wenn wir durch die Lektionen gehen. Die sechste Lektion ist eine ganz wichtige. Und zwar verstehe zuerst das Problem und schreibe erst dann den Code für die Lösung. Das Problem hierbei ist es oft. Ich bin sicher, das hast du auch gesehen, dass wenn es um Softwareentwicklung geht, springen viele Leute sofort ins Coding.

Die haben die Anforderung gehört. Ach ja, ich weiß schon, was ich machen muss. Achja, da mache ich das so. Da braucht man hier in Cash und das und das und setzen sich sofort an die Tastatur und legen los. Neue Funktionen wenn, dann so iterativ, ganz schnell implementiert und laufend angepasst. Und man merkt erst nach einiger Zeit, dass man das Problem gar nicht korrekt verstanden oder vollumfänglich verstanden hat. Und dann fängt man nochmal von vorne an oder es kommt auf jeden Fall zu einem erheblichen Zeitverlust.

Ich bin sicher, das hast du auch schon gesehen.

Ja, absolut. Ich meine, ich hab mich selber schon mal dabei ertappt. Ich hab mir seit dem das war so in den Anfängen hab ich das so gemacht. Tatsächlich. Aber irgendwann hab ich mir angewöhnt, keine Sequenzer, Diagramme, Urmel, Diagramme und so weiter groß gemacht, sondern einfach auf ein Blatt Papier, so die Komponenten aufgemalt, die Beziehungen aufgemalt. Kann echt auf einem Blatt Papier sein, um einfach mein Kopf zu sortieren und dann steige ich habe auch schon gerne ein.

Mir liegt die Klassennamen auf oberster Ebene, verknüpfe sie, schreibe die ersten Tests Duala Test Driven und das funktioniert ganz gut.

Das ist so, bis ihn der Flow, denn ich habe genau das ist für mich ein ganz klarer Indikator, ob man es mit einem Junior Entwickler oder Senior Entwickler zu tun hat. Ein Senior Entwickler stellt erst einmal sehr viele Fragen und versucht das Problem genau zu verstehen oder die Anforderungen genau zu verstehen und ist halt erst Input fokussiert. Wie geht man das jetzt an? Also du hast es eben schon gesagt. In jungen Jahren geht der Tüftler mit einem durch und man möchte sofort einsteigen und loslegen.

Ich habe so zwei unterschiedliche Pattern, je nachdem ob es um Feature Entwicklung geht oder um Bugfix sing.. Fangen wir mal mit dem Einfacheren an. Das wäre das Bugfix sing.. Das Allerwichtigste beim Bugfix sing. ist, dass man erst einmal den Bug zuverlässig reproduzieren kann, weil erst dann sinnvolle Entwicklung eines Fixes möglich. Meiner Ansicht nach erst, wenn ich weiß, wenn ich hier klicke und da klicke und dann tritt der Fehler auf und das immer wieder machen kann. Erst dann kann ich ja quasi prüfen, ob meine Lösung das Problem wirklich löst.

Ein weiterer Hinweis und ich bin verblüfft, wie viele Leute das nicht machen ist, den Debugger zu verwenden, also wirklich Schritt für Schritt durch das Programm durch zu steppen und sich die Variablen anzugucken. Was passiert hier? Was passiert da gerade, wenn man das Programm selber nicht kennt oder es nicht selber entwickelt hat, dann wird es oft sehr einfach, da einen Fix zu entwickeln, weil man einfach genau sieht Ah, ok, an dieser Stelle muss etwas anderes passieren oder muss etwas weiteres passieren und das könnte man dann implementieren.

Einfach den die Bagger abklemmen und idealerweise wenn man den Bug dann gefixt hat, dann hinterher war man jetzt schon im Thema drin. Noch einen Testa zu schreiben, der prüft, dass der fix funktioniert und dass das Problem eben nicht nochmal auftritt. Das ist meiner Ansicht nach eine professionelle Möglichkeit ans Bugfix hing ranzugehen, um nicht direkt in den Code zu springen. Bei der Feature Entwicklung und da bist du wahrscheinlich bei mir ist es oft so, dass die Anforderungen gar nicht so klar sind.

Also das ist wirklich ganz ganz selten, dass der Projektleiter. Jeder auf einen zukommt und glasklar schon sagt Das soll so sein. Das soll so sein. Das soll so sein. Das soll so sein, sondern ja, wie hat man altes System? Und da lief das so und so und ich möchte das jetzt genau so haben. Nur hier und da, da muss etwas geändert werden. Also das tritt sehr häufig auf. Auch hier das Problem erst einmal voll umfassend verstehen.

Wenn schon Quote da ist. Also wenn z.B. das Feature eine Erweiterung darstellt, erst einmal diesen verstehen, dann ne Lösung Skizze erstellen, genau wie du sagst. Ich versuche mir immer die Eingabe und Ausgabe Daten erst einmal aufzuschreiben. Was geht rein, was soll rauskommen und dann eine Technologie Skizze zu machen. Und im Grunde ist für mich ein Computersystem in Daten Topf mit Code drumherum, also eine Daten Haltung die Transformationen auf diesen Daten durchführt. Und ich glaube, wenn man die Daten und die Transformations Schritte hinreichend genau beschrieben hat, dann wird das Problem mehr oder weniger klar und der Rest folgt fast automatisch.

Oder die Problemlösung folgt fast automatisch. Und bis man soweit ist, hat man sehr viel gelesen, aber noch keinen Code geschrieben oder sehr wenig Code geschrieben. Warum passiert das? Warum springt man sofort in den Code? All das einfacher ist, als sich Gedanken über das Problem zu machen. Das ist oft sehr schwierig. Man muss nachfragen, man hat es nicht genau verstanden. Man muss diese Zeichnung erstellen und direkt zu coden. Das möchte im Grunde jeder. Aber mit zunehmender Reife weiß man, dass das nicht unbedingt das zielführende Vorhaben ist.

Du bist auch motiviert, hast eine Idee im Kopf und setzt sich hin und willst das sofort machen. Also ich muss sagen, wenn ich tatsächlich eine Idee fest im Kopf habe, dann mach ich das auch schon mal hier und da setze ich mich hin und knallt die Klassen einfach rein. Das funktioniert auch ganz gut, aber ich glaube, das kannst du nur machen, wenn du gewissen Erfahrungsschatz mitbringst.

Erstens das und wenn das Problem hinreichend klein ist. Ja, definitiv. Also nicht bei super komplexen Funktionen oder wo sehr viele Transformationen gemacht werden müssen. Genau. Und dann ist es oft auch wichtig, das Problem korrekt zu erfassen oder das ist eigentlich das Wichtigste und dann das Problem zu lösen, anstatt irgendwie fancy mit Architektur Patterns technische Exzellenz zu zeigen. Das sehe ich auch relativ häufig. Dann werden dann einfache Sachen technisch exzellent gelöst, aber das Problem ist gar nicht so richtig verstanden worden.

Da gibt’s ein schönes Zitat und damit möchte ich die sechste Lektion abschließend von Abraham Lincoln Gib mir sechs Stunden einen Baum zu fällen und ich werde die ersten vier Stunden mit dem Schärfen der Axt verbringen.

Als Kind ist es echt schön. Ja, genau.

Ich kenne sogar so eine extreme Version. Da heißt es Gib mir fünf Stunden und 50 Minuten zum Schärfen der Axt, sodass man mit einem Hieb im Prinzip den Baum durchbekommt. Aber was heißt das hier? Ganz klar Desto genauer du das Problem verstehst, desto einfacher wird die Lösung hinterher. Nur man muss halt mehr Zeit mit der gedanklichen Beschäftigung mit dem Problem verbringen statt mit dem eigentlichen Coding. Deshalb ist das so schwierig zu befolgen. Die siebte Lektion ist für mich eine ultimative Superkraft.

Und zwar Frage um Hilfe. Wenn du nicht weiterkommst, wie machst du das?

Wenn ich nicht weiterkomme, muss ich sagen such ich tatsächlich im Internet. Stack Overflow ist definitiv eine Quelle, die mir sehr viel Tipps und Inspiration gibt, aber auch alle Menschen toll sehr Ego im Netz sind. Da werde ich für den speziellen Fall, wo ich nix finde, frage ich ja tatsächlich natürlich auch Kollegen.

Man verbeißt sich oft in Problem oder so geht’s mir manchmal. Du fängst an, alles ist ganz einfach. Dann kommen irgendwie Hindernisse, auf den gelangst du immer tiefer in diesen Kaninchenbau rein. Man probiert unterschiedliche Ansätze und wendet sehr viel Zeit auf. Also dann ist man richtig frustriert und fragt nach zwei Stunden vielleicht einen Kollegen. Und er sagt Ach ja, kenne ich schon. Du musst hier das und das machen. Boah, das hat mich damals drei Tage gekostet, das herauszufinden oder so, wo man so richtig schön per Facepalm dann denkt Oh Mann, da hätte ich mal vorher gefragt.

Das ist aber auch so eine Gratwanderung. Du kannst ja nicht wegen jeder Kleinigkeit den Kollegen fragen. Na weil, dann ist er auch irgendwann genervt. Manchmal, wenn du der Mensch bist, der sich am längsten mit einem Problem beschäftigt hat oder am längsten ein Projekt ist. Es ist einfach unwahrscheinlich, dass die andere weiterhelfen können. Natürlich Google Stack Overflow und alle Quellen benutzen, die man im Internet findet. Das ist das Naheliegendste. Aber hier soll es wirklich darum gehen, den Kollegen zu fragen oder die Kollegen Kolleginnen zu fragen, ob man weiterkommt.

Also ich mache das so, ich probier das erstmal eine halbe Stunde, sag ich mal. Wenn ich an ein Problem komme und wenn ich dann nicht weiterkomme, zwinge ich mich, aufzustehen und jemanden zu fragen oder eben patschert jemanden zu fragen. So um dann einerseits respektvoll mit der Zeit der Kollegen umzugehen, auf der anderen Seite aber auch nicht zu viel Zeit zu verständigen. Und das hat sich bei mir eigentlich als gutes Vorgehen herausgestellt. Aber du fragst nicht so viel, oder?

Nee, hat vielleicht auch ein bisschen mit Persönlichkeit zu tun. Ich versuche lieber selber zu lösen. Keine Ahnung, ist einfach so. Ich kann nicht sagen, warum. Aber ich will den Knoten selber irgendwie aufmachen.

Das hab ich auch, dieses Gefühl. Man hat schon so ein bisschen das Gefühl Ah, wenn ich frage.

Und das ist jetzt vielleicht eine einfache Sache, das geht so ein bisschen in die Berufsehre. Sitzt noch nicht mal irgendwie, aber so ich mache auch nicht gerne welche Superpower Grabbing oder sowas würde ich programmiere, möchte ich irgendwie allein sein. Ich hoffe, das versteht Cat irgendwie, oder ob das jemand nachvollziehen kann.

Ich glaube, das können sehr viele nachvollziehen. Bei mir ist das tendenziell auch so, aber ich hab ne Frustrationstoleranz, die sehr niedrig ist, wenn ich nicht in kurzer Zeit ausreichende Fortschritte mache. Also wenn ich das Gefühl habe, oh, mit jemandem zusammen komme ich schneller voran. Der Zweck heiligt die Mittel sozusagen. Dann setze ich mich auch zu zweit hin. Wenn ich das Gefühl hab, ich komme ja alleine weiter, dann hab ich auch kein Problem, das zu machen.

Aber ich glaube dennoch ab und an um Hilfe zu fragen. Kann einem sehr schnell sehr viel weiterbringen. Zumindest für das Team. Insgesamt ist es besser, als wenn jeder verbissen an seiner eigenen Lösung arbeitet. Die 8 Lektion. Hier geht es um Weiterbildung. Da haben wir ja auch schon in diversesten Episoden drüber gesprochen. Im IT-Sektor wirst du immer weiter lernen müssen. Das Technologie Umfeld ändert sich so schnell. Bestehende Technologien verlieren an Relevanz, neue kommen hinzu, die es noch gar nicht gab, die sehr schnell sehr prominent werden.

Und es wird gefordert, weil man ist ja Technologie Experte, dass man sehr schnell eine Einschätzung liefern kann. Was sind kurzlebige Trends und was sind wirklich längerfristige Entwicklung und was bedeuten diese für das eigene Umfeld? Im Grunde Welche Technologien muss ich lernen und welche kann ich einfach vorbeiziehen lassen? Wie machst du das? Hast du da bestimmte Kanäle, über die du dich informierst, abseits der üblichen wie Heise, Golem usw.?

So um Trends und so weiter mitzubekommen. Tatsächlich einfach im Internet. Heise Golem. Ich habe aber auch diese ich habe mal Subscription eins zu Cloud, Gusi und viele Yumi Kurse. Da schaue ich regelmäßig mal vorbei und gucke, was neue Kurse sind. Speziell ist es aber für die Bereiche Java oder DevOps. Wo ich unterwegs bin, suche ich gezielt danach. Und wenn mir irgendwas interessant erscheint oder mir ein Wort begegnet Technologie, von dem ich noch nicht gehört habe, dann gucke ich mal rein.

Dann suche ich danach explizit. Ich versuche halt immer so ein Level zu erreichen, wo ich verstehe, was das Tool macht. Will mir eins besonders interessant erscheinen, oder? Ich meine, das passt mir sehr gut den Kram. Dann mach ich auch schon mal so ein Tutorial mit, um einfach mitreden zu können, einfach zu wissen, was es ist, was man damit machen kann und so erweitere so nach und nach mein Tool. Schade. Oh dann, je nachdem ich das nächste Mal auf so ein Problem stoße, weiß ich Aha, da gab’s doch mal so ein Tool.

Okay, toss im Grunde diese Sternenkarte schon im Kopf. Und wenn ein neuer Stern auf ploppt, dann guckst du dir den kurz an und kannst ihn dann einordnen.

Ja, das halte ich auch für sehr wichtig. Ich finde, diese längerfristigen Entwicklungen oder diese großen Trends, die erkennt man relativ gut, weil sie auch mehrere Jahre bestehen. Also Cloud wäre z.B. ein Trend, Datenauswertung wäre ein großer Trend. Generell Megatrend ist natürlich Digitalisierung. Wobei tue ich mich schwer, das als Trend zu beschreiben, sondern das ist einfach eine weitere Entwicklungsstufe der Menschheit. Das möchte ich jetzt nicht als Trend verstanden sehen, sondern man kann technologisch einfach Prozesse effizienter abbilden, als man das manuell könnte.

Gerade jetzt mit Heimarbeit wird das offenbar an vielen Stellen, sodass das auf eine weitere Entwicklungsstufe ist. Aber es gibt auch Micro Trends, das sind z.B. Tools im Kobanê, das Umfeld oder im Container Umfeld, die man so ein bisschen im Auge behalten muss. Vielleicht hier als Tipp. Ich weiß nicht. Kennst du jeden Freitag auf dem Heise Newsticker diese Developer News in ein, zwei Sätzen? Du kannst mal auf Heise Slash Developer gehen, da kriegst du nur die für Developer relevanten Artikel angezeigt.

Ist für mich ein Super Life Hack und die ganzen Clickbait Artikel sind dann weg und da gibts es jeden Freitag so ein Digest, wo dann in zwei Sätzen immer dran steht. Das Tool ist und der und der Version entschieden. Das kann jetzt so und so.. Die Software hatte Sicherheitslücken, die wird nicht mehr gepflegt, die ist neu hinzugekommen. So und das sind immer 35 40 Einträge, wo man einfach weiß, was so abgeht. Dieses Symbolbild von dem Artikel ist immer das gleiche.

Daran erkennt man es dann sofort und man hat einfach einen schnellen Überblick. Viele Tools sagen einem auch nichts. Also wenn das sieht so aus dem Automotive Bereich kommt oder irgendein Spezialwerkzeug ist okay, dann hat einem das noch nicht berührt. Aber so hat man so einen Überblick. Und da guck ich dann rein. Wenn jetzt ein Tool schon zum dritten, vierten Mal Erwähnung findet, dann kann ich mir vorstellen Ah, okay, das scheint auf jeden Fall wichtig zu sein, oder?

Da wird häufiger drüber gesprochen, weil die Entwicklung da so rasant ist. Jede Woche eine neue Version ist ja dann schon eindeutig ein guter Tipp. Auf der anderen Seite, also wenn es schon gesagt. Im IT-Bereich wird man immer lernen müssen. Auf der anderen Seite finde ich auch desto mehr Erfahrung man hat, desto weniger Schrecken ein. Diese neuen Technologien, weil man immer wieder feststellt So wirklich, wirklich Neues. Das kommt vor. Aber es ist nicht so häufig, sondern oft erscheinen neue Frameworks oder Libraries.

Und die sind nur ein Aufguss einer bekannten Technologie aus einem anderen Kontext. Und alles war irgendwie schon mal da. Deshalb bin ich dazu übergegangen, mir eher die Konzepte anzuschauen Welches Konzept steckt denn hinter der Blockchain oder einem Paket Manager oder Haskell? Wenn du SQL kannst, da kannst du alle Datenbanken und nicht nur eine bestimmte. Wenn du weißt, wie ein Paket Manager funktioniert, dann kannst mit N.P. Umgehen, mit Maven, mit Neef, geht mit APC, mit Pacman Kapern und wie sie alle heißen.

Und wenn dann jetzt der nächste dazukommt, dann weiß man AOC, dass im Paket Manager DeWitt irgendwie so funktionieren. Ich weiß, was im Paket Manager macht und das ist dann der Achte im Bunde. So ungefähr auch Protokolle. Also ganz früher gab’s den Remote Procedure Call, der ist sogar noch vor meiner Zeit, den kennst du wahrscheinlich noch. Dann kam die Scope Schnittstelle. Heute sind wir bei Rest APIs angekommen. Wer weiß was danach kommt. Hier Proto Buffer oder so.

Bei Frameworks genauso Tools kommen auch andauernd neue hinzu. Na da gibt’s natürlich so mega Tools wie Git. Also Code Warning ist glaube ich schon in den letzten 15 Jahren extrem gepusht worden, wo früher die Leute ihre Dateien irgendwo gesichert haben. Es war ganz grausam und zwischen den einzelnen Ökosystemen, also dort net Java node Python you name it. Wenn irgendwo ein cooles Feature auf ploppt ist meiner Erfahrung wird das sehr oft geklaut.

Sehr gut. Ist ja normal. Ja, ich finde das auch gut. Das ist ja die Schönheit. Ein Open Source. Wenn einer was rausgefunden hat, können alle profitieren. Also wie schließen wir mit dieser Lektion ab oder was ist unser Empfehlung? Ich würde sagen, man muss nicht alles im Detail verstehen, aber man sollte halt die Konzepte verstehen und diese Themen einordnen können. So wie du das eingangs im Prinzip gesagt hast. Du hast diese Sternenkarte und kannst neue Sterne schnell platzieren.

Du versuchst halt zu abstrahieren, soweit wie möglich.

Was ist für dich eine Technologie der letzten Jahre, wo du gedacht hast Okay, das ist ein Megatrend? Mein Gott, da muss ich wirklich viel lernen.

Das ist das Thema Cluster Orchestrierung. Docker Dieses ganze Gebilde. Das war für mich völlig klar, dass ich meine, damals waren mehrere so am Start da visus Marathon, kybernetisch, die waren alle gleich auf. Und interessanterweise, das hab ich auch schon bei einem anderen Podcast erwähnt. Ich hab mich am Anfang komplett gegen diese Docker Technologie gewehrt, als die Kollegen das angesprochen haben. So ein bisschen erklärt hab. Ich fand das halt mega abstrakt. Ich hab das alles gar nicht verstanden wie Leya und wie.

Ich kann da nicht reinschreiben was soll der Scheiß. Nach und nach je mehr die das gemacht und eingeführt haben, umso mehr hab ich verstanden. Mein Gott und dann hat es irgendwann Klick gemacht. Hat euch boah wie geil darunter. War mir klar, das willst du lernen. Ja, da hab ich mich rein gekniet. Das war vor fünf Jahren. Und dieses Universum expandiert wie das richtige Universum, wie es permanent neue Tools erfindet sich neu. Da kommt K3 is leichtgewichtige Scobel net das, was du quasi auf dem Raspberry laufen lassen kannst.

Das explodiert quasi diese Technologie. Und ich liebe es aber auch so dran zu bleiben. Kugel und auch Madhya. Das ist super und find ich klasse. Also diese Technologie war für mich so zu all dem was die letzten Jahre passiert ist mit ein Gamechanger der Wahnsinn.

Nachdem du dich zuerst gewährt hast, wusste ich gar nicht. Hast du gedacht, das ist so kleinteilig?

Und was braucht man mehr als VMS oder genau was bringt da auch so außer jetzt eine riesen Lernkurve? Muss das jetzt sein? Sah ich so halt als Spielerei der Admins an und eigentlich war diese Erfahrung ganz gut, weil wir ich jetzt quasi bei einem Kunden bin. Und du hast meinetwegen so einen alteingesessenen Unix Systemadministrator, der diesem Konzept entsprechend auch nicht aufgeschlossen gegenüber ist. Dann kann ich das super nachvollziehen und weiß dann, wie ich den anderen führen kann. Was so?

Weil du diese Entwicklung selber mitgemacht hast, kannst du sozusagen auf der empathischen Schiene sagen. Ich weiß, die Bedenken hatte ich auch. Aber sieh mal folgendes Ja, da kommen mehrere Sachen zusammen. Mit Docker hattest du so eine erste Abstraktionsebene und Docker alleine bringt ja nicht so viel. Aber in dieser Kombination mit dieser Cluster Technologie und diesem Paradigmenwechsel dieser da wir eine Episode gemacht dieser 12 Faktoren für Cloud Native Apps kannst du ja Anwendungen komplett anders bauen, die dann eben wirklich weltweit skalieren.

Also du kannst mit den großen Gagfah Unternehmen mithalten, vom technischen Standpunkt aus, wenn du diese Software nach diesen Paradigmen entwickelst und diese Gaffer unternehmen haben die sie ja entwickelt. Das ist nicht nur Technologie, sondern auch so ein Mindset plus auch diese Cloud. Denke da kommt alles zusammen. Und das ist eine größere Blase oder ein eigenes Universum, was man nicht so isoliert betrachten kann. Und für dich? Du hast ja mal gesagt, dass du auch früher viel IT Administration gemacht hast.

Also Netzwerk Administration, Linux Administration nehme ich mal an..

Die SEMA Administration oder so Backoffice wirklich, oder?

Ich war Third Level Support einmal und zum zweiten haben wir mit einem anderen Kollegen via Mail und Unix Systeme. Administriert mit send Mail. Ja, das waren noch Zeiten. Okay, da war noch nichts Container visiert. Äh, nicht so wirklich.

Ich kann mich genau erinnern, wo der Kollege ankam mit 20 Disketten und Material. Guck mal, Linux hier, Ledoux da. Das war also damals das Linux System. Putzer und Linux kam gerade erst auf und VM, wer will ich nie faxen? Wir sagte hier Guck mal die Virtualisierung von VM. Wer und wie ich da Disketten reingeschoben hab und damit rumgespielt hab. Und da waren wir auch. Glaube, da könnte was draus werden und diese war so Vollbild geworden ist.

Das stimmt. Also dieses Feld wandelt sich weiter und wie im Universum. Es gibt schnelle Sterne, es gibt langsame Sterne, große Sonnen, die nicht mehr weggehen. Und das kommt in der IT auf jeden Fall mit. Man muss sich weiterbilden in allen 40 Jahren oder in all der Zeit. Dann die neunte Lektion. Ich weiß nicht, ob es schmerzhaft ist oder lustig. Test Griffen Die Welt abmahnt ist ein Mythos, heißt die Lektion. Und was ich damit meine ist Testserver Development, dass man zuerst die Tests schreibt und dann anhand der bestehenden Test da rein die Funktion implementiert.

Das hab ich schon so oft gehört. Bei Kunden und in der Theorie macht das auch Sinn, dass man sich zunächst über alle Grenzfälle einer Anwendung Gedanken macht und das Verhalten genau bestimmt. Und wie soll es denn sein? Wie soll sie sich verhalten, dass man anschließend alle diese Annahmen in Unit oder Integrations Test niederschreibt und dann im Prinzip die Komponente selbst entwickelt und nur noch die Komponente so minimal entwickeln muss, dass alle Tests grün sind, also alle Tests erfolgreich durchlaufen werden.

Und dann hat man sozusagen die minimale Lösung, die alle Tests erfüllt. Das habe ich in der Praxis noch bei keinem Projekt gesehen, wo das wirklich funktioniert hat. Ich freue mich schon über die Zuschriften.

Gerne melden, wenn es bei euch in der Firma funktioniert oder wenn ihr ein Projekt kennt, wo es funktioniert hat. Aber ich habe es einfach noch nicht erlebt. Und ich glaube, das Problem besteht darin, dass die Anforderungen für ein neues Feature oder für eine neue Anwendung oft nicht so messerscharf spezifiziert werden können, dass sich daraus Tests direkt ableiten können. Ist da deine Erfahrung?

Ja, Test am Anfang hat man immer gemeint. Also ganz ehrlich, ich gehörte auch dazu. Tests machen die Sache nur teurer, weil du ungefähr ein Drittel deiner Zeit damit verbringen musst. Wenn du Test Rival entwickelst. Aber je mehr ich in komplexeren Projekten eingestiegen bin, um so mehr ist mir bewusst geworden, wie wichtig doch Tests sind. Und inzwischen gibt’s ja Tests irgendwie. White Box Testing, Blackbox Testing, Tschiche Test Varianten und jedes für sich macht Sinn.

Ja, je mehr, desto besser. Weil so hältst du deine Software wandelbaren, gewitzte, gewisse Sicherheit da auch Änderungen zu machen. Und du hast einfach keine Chance, manuell irgendetwas zu testen, wenn du in irgendeiner Ecke rumschrauben.

Ich glaube, da spielen mehrere Faktoren eine Rolle. Und zum einen verändert sich Software heute schneller als früher, weil sich die Geschäfts Anforderungen schneller ändern. Man ist gewöhnt. Ah, ich muss die Software nur ändern und dann ist die neue Funktion da drin und das funktioniert sofort. So, das ist bis in die Vorstandsetage hoch Geblubber. Und deshalb ist die Erwartung. Ich kann die Software schnell ändern, dann können wir das abfangen gestiegen. Also die Zeiträume bis hin zur Implementierung sind halt kürzer.

Wenn die Zeiträume kürzer sind, heißt das aber auch Development to Market ist kürzer. Und wenn du jetzt keine Tests hast, dann ist das so, als wenn du in schneller Folge beim Domino Day die Dominosteine aufstellen willst und umgeben bist von anderen Dominostein. Die Gefahr, dass du da irgendetwas anderes um stößt, ist gerade in komplexen Systemen riesig. Das heißt, die meisten Projekte, so kenne ich das, verwenden schon automatisierte Tests, meistens Unit Tests für einzelne Funktions Komponenten, die dann von der CCD Pipeline, also Git Lab, Bruna, Maven Tests usw.

angestoßen werden und Schlüssel Komponenten testen. Die IBAN sieht die richtig aus? Stimmen, die Datums Konvertierungen usw. und sofort. Aber eben nicht alles abdecken. Auch RPI Tests gibt es mehr und mehr, die einfach die Funktionsweise von Schnittstellen testen. Aber niemand hat 100 prozent und im Falle des Falles unter Zeitdruck fallen die Tests halt einfach runter. So, das ist meine Erfahrung und definitiv. Das sieht ja auch erstmal niemand.

Also du hast 100 Funktionen, 99 davon sind getestet, eines ungetestet. Jetzt machst du noch 10 Funktionen, noch 10 Funktionen ohne Tests, sodass nur so graduell wird das immer schlimmer. Aber das ist wie Carius. Erst einmal sieht man es nicht. Und irgendwann wird es dann offenbar. Und ich will nicht sagen, dann ist es zu spät. Aber dann muss man es dann doch behandeln. Ich glaube, ein guter Kompromiss ist hier die Kernfunktion, also kritische Sachen, wenn es um Transaktionen geht von Benutzerdaten, also datenschutzrechtlich relevanten Inhalten oder Zahlungsarten.

Das ist super wichtig, dass man das alles ab testet.

Es gibt dabei in jeder Anwendung auch unkritische Bereiche, da muss man sich ganz so genau nehmen. Unit Tests zumindest Völklein Komponenten halte ich für wichtig. Ja, und auf Front in Tests gibt es mehr und mehr und auch desto länger die Software besteht, desto mehr lohnen sich Tests. Gerade wenn viel verändert werden soll, hast du noch einen Tipp, wie man vielleicht dieses Tests Problem besser lösen kann? Also wie machst du das? Wie teilst du dir die Zeit ein für Tests?

Machst du Tests oder nur wenn es gefordert ist? Oder bestehst du darauf?

Nee, also so rigoros oder stringent bin ich nicht. Wenn ich meine, dass eine Interaktion zwischen Komponenten oder einer Komponente selber für mich in gewissem Komplexitätsgrad übersteigt, wo ich meine Oh, wenn es hier eine Änderung gebe, dann könnte es zu Problemen führen. Oder wäre das schön, wenn die anderen Komponenten das das bastel ich mir so im Kopf zusammen. Und wenn das einen gewissen Sprechrolle übersteigt, dann mach ich die Tests auch nicht für jede Klasse und jede Methode, sondern wirklich da, wo ich der Meinung bin, das könnte schwierig werden.

Später für die Worker oder Helper oder Converter oder sowas. Eben genau die sehr oft aufgerufen werden und die so eine Kernfunktion dann bewerkstelligen. Ja, sehe ich auch so. Haben wir schon einen gleitenden Übergang zur zehnten und letzten Lektion. Und davon können alle die Mitarbeiter und IT-Fachkräfte und Projektleiter ein Liedchen singen. Die zehnte Lektion heißt Alles dauert länger als geplant. Lass dich nicht von willkürlichen Deadlines verrückt machen. Das geht eher in Richtung Entwickler. Alles dauert länger als geplant. Wäre vielleicht die richtige Überschrift hier.

Was ist das Problem? Das Problem ist bei Kreativ Arbeit und nichts anderes ist ja die Erstellung von Programmcode. Im Grunde genommen ist ja nicht so, dass man da Mathematik rechnet, sondern eher kreativ sich eine Lösung überlegt und die dann runter codiert oder eine Formsprache bringt. Bei kreativer Arbeit ist es schwierig eine realistische Zeit Abschätzung abzugeben, gerade wenn die Anforderungen nicht klar sind. Zudem gibt es eine Vielzahl von Zeitfresser. Das erlebe ich immer wieder, die niemand auf dem Schirm hat.

Neue Bugs kündigen sich nicht an. Man kriegt einen problematischen Mertz Request von jemand anderem zugewiesen und brauch dafür 2 3 Stunden länger als gedacht. Mitten im Projekt gibt es Bibliothek, Updates oder Sicherheitslücken, die nicht warten können. Diese Bibliothek Updates ziehen Schnittstellen Änderungen nach, die man sofort machen muss. Was sonst funktioniert es nicht mehr? Irgendetwas funktioniert nicht wie beschrieben, kommt auch relativ häufig vor. Ein Kollege muss eingearbeitet werden, ein Kollege fällt aus. Es gibt viele Meetings.

Die Firma hat eine Restrukturierungen. Es wird kommuniziert, was jetzt alles restrukturiert wird und so weiter und so fort.

Und das taucht in keiner Zeit Abschätzung auf. Also ich habe noch bei keiner Sheets Runde gehört. Ja, also eigentlich würde ich sagen, ich brauch Tag, aber wenn wir restrukturiert werden unterwegs sollte ich vielleicht mal 2 Tage einplanen, weil beweiß. Dann bin ich ein Tag mit Meetings zugeschüttet oder so. Ich hatte jetzt letztens eine das hat mich nicht selber betroffen, aber eine Mitarbeiterin, die für ein Promo Video der Firma einen Tag quasi zur Verfügung stehen sollte. So was wird natürlich auch vorher nicht abgeschätzt.

Also was bedeutet das? Es dauert immer länger als du denkst. Sogar wenn du weißt, dass es länger dauert als du denkst. Wie gehst du damit um? Weil da wird ja manchmal schon relativ starker Druck gemacht. Extrem entspannt.

Also da drüber bin ich echt hinaus, um mir Druck machen zu lassen von Projektmanagerin oder Product Owner. Bei den Schätzungen gehe ich so vor, dass ich so eine Excel Liste mache und wir die jeweiligen Features Zeile für Zeile aufschreibe. Und dann mach ich eine Abschätzung für den Best Case, eine Abschätzung für den Worst Case dmit dort den Schnitt und addiere darauf nochmal 30 prozent für Unvorhergesehenes. So und so eine Schätzung gebe ich dann ab. Und wenn es dann länger dauert?

Ich versuche dann halt immer so ein bisschen zu dokumentieren, wenn was dazwischen kommt, was nicht auf dem Schirm war. Einfach um nachher, wenn einer fragt bis eine Liste raus und kann sagen Ja, das und jenes, welches ich habe keine Information bekommen nicht gebraucht habe oder der Kollege Z. Als Ansprechpartner war drei Wochen krank, ohne Vertreter, Regelung und und und, um einfach so ein bisschen sicher zu sein. Ansonsten kann ich es sagen. Wenn es dann noch länger dauert, dann ist es halt so.

Also du hast dieses Lass dich nicht von willkürlichen Deadlines verrückt machen völlig verinnerlicht.

War das bei dir immer so oder ist das ein Prozess?

Nein. Prozess. Prozess beim ersten Mal oh citta bibber und um Gottes Willen. Und die Welt geht unter. So und dann machst du und tust du. Dann bist am Wochenende da und nachts bis drei. Und hin und her wird’s aber trotzdem später, weil irgendwas passiert ist, wo du keinen Einfluss drauf hast oder Bergsee. So schlimm war das jetzt doch nicht, weil der der Druck gemacht hat. Der war dann auch entspannt. So wird das ein paarmal passiert da ja auch.

Was will man machen? Also zuckte du noch mit den ATL dieses Druck machen?

Ich sag mal ein bisschen Druck machen, okay. Aber dieses starke Druck machen? Es ist ja nicht so, dass du am Fließband stehst und jeden Tag in acht Stunden acht Autos Ponti hast. Und wenn du da zehn Stunden stehst, montiert du zehn Autos. Du denkst ja nicht schneller, weil du unter Druck geraten bist. Also. Ich weiß nicht. Bei mir funktioniert das nicht. Ich werde dann eher geblockt oder so. Wenn ich weiß Oh du Dexia, die schneller.

Ja, das ist ja sozusagen die Denke, da trödelt jemand, die mach ich jetzt.

Beine Nee, das kommt so aus der Industrialisierung und den setze ich unter Druck.

Und dann konzentriert er sich besser oder bleibt eher an der Sache dran. Das funktioniert bei Creativ Arbeit ja nicht. Also wenn ich einem Künstler sage mach schneller! Dann wirft er den Farbeimer gegen die Staffelei und dann kann er auch nicht sagen Ich bin fertig. Also vielleicht kann er das sagen, aber dann ist das Kunstwerk nicht gut. Und das sieht man leider auch mancher Software an, dass sie unter großem Zeitdruck entstanden ist.

Ich habe aber auch das Gefühl, Entwickler schätzen tendenziell zu positiv. Ich weiß nicht wieder.

Deine Erfahrung ist das kann ich so nicht sagen. Weiß ich das? Ich würde weder sagen positiv noch mal ist es klar mehr positiv, mal negativ heckt und ein bisschen damit zusammen, wie viel erfahrener oder unerfahrener Kollegen du im Team hast. Also eine generelle Tendenz kann ich glaube ich nicht sehen.

Ich hatte schon mal den Fall, dass Projektmanager bei Schätzungen gedrängt haben und sagen Nee, das ist zuviel, das muss schneller gehen und selber dann die Schätzung visieren oder beeinflussen.

Das auf jeden Fall halte ich für sehr gefährlich, es sei denn, der Projektmanager sagt vorher ganz offen Du, wir müssen unter diesem und jenem Level bleiben, um das Projekt genehmigt zu bekommen. Wenn das dann einmal läuft, dann wird es keiner mehr stoppen, wenn es länger dauert. Das hatte ich auch schon. Dass das so offen kommuniziert wurde, ist natürlich auch grenzwertig, aber das passiert manchmal. Aber klar, wenn das Projekt einmal läuft und man hat es schon 60 Prozent geschafft, dann wird es vielleicht der oberen Etage schwerer fallen zu sagen Na, wir stoppen das jetzt, weil das Budgets aufgebraucht, lass die letzten 20 Prozent weg.

Macht jetzt nochmal 20 Prozent und dann ist out.

Ich habe einmal erlebt, wo ein Produkt oder ein Kollegen so gedrängt hat, wird er das jetzt so so schätzt oder nicht fertig wird, dann gibt’s als mit dem Bonus nix.

Also wenn er es schätzt oder wenn es nicht fertig bekommt in der Zeit nicht oder so grob geschätzt.

Und dann sagte er Ja, es dauert halt so lange oder sagt sie Nee, auf keinen Fall. Dann gibt es wieder Modus. Nix gibt’s alles.

Ich hoffe, sie meint es nicht ernst. Doch ich war dabei.

Wenn’s nur auf die Schätzung ankommt, dann wird immer alles ganz schnell geschätzt.

Echt so, die Softwareentwicklung? Ja, manchmal ist es schon verrückt, meiner Erfahrung nach. Man kann sehr zuverlässige Schätzungen abgeben. Allerdings nur für sehr kleine Projekte oder sehr kleine abgegrenzte Probleme. Wenn die eingesetzten Werkzeuge und der Anwendungsfall sehr genau bekannt ist und man sicher gehen kann, dass man nicht von extern gestört wird. Das sind dann aber kleine Projekte und da weiß ich nicht. Die finden in den Firmen nicht so häufig statt. Meiner Erfahrung nach Bara sind dann nicht so wichtige Themen.

Ist denn in deiner Erfahrung mal ein Projekt vor der veranschlagten Zeit fertig geworden?

Ja doch, auf jeden Fall auch schon erlebt.

Ist zwar extrem selten gewesen, aber da gibt’s definitiv bei SKL bei Tamir einfallende, wo wir supergut im Zeitplan lagen. Oh, das war mega. Aber ansonsten. Ich muss mal überlegen. Na gut, auf der anderen Seite wir sind eine Consulting Firma und wir werden meistens angerufen, wenn in Excel schon eine rote Zelle erscheint.

Ja also diese Feuerwehr Geschichten gibt’s natürlich auch der Druck entsprechend groß ist.

Ja, das waren die 10 Lektionen. Unglaublich. Ich bin auf die nächsten 40 Jahre gespannt oder?

Ich hoffe nicht. Da mache ich so eine Abschluss Folge zur Verrenkung. Dann was ich gelernt habe, wenn unsere Zuhörer Fragen haben zu der aktuellen Episode oder auch so können Sie uns eine E-Mail an Podcasts Gilbert D.

Senden. Wir freuen uns immer über Bewertungen oder wenn ihr den Podcast abonniert. Empfehlt den Podcast auch an eure Freunde und Kollegen weiter und schaut auf der Skill bei D. Slash Jobs Seite vorbei. Weitere spannende Technologie Artikel findet ihr Weißgerber D im Blog Masa Es war wie immer ein pures Vergnügen mit ihr zu sprechen. Danke Rorys, dann wünsche dir noch einen schönen Abend.

Maurice KnoppSkillbyte Podcast #40: 10 Lektionen, die wir in 40+ Jahren Softwareentwicklung gelernt haben (Teil 2)
Mehr

Skillbyte Podcast #39: 10 Lektionen, die wir in 40+ Jahren Softwareentwicklung gelernt haben (Teil 1)

Willkommen zum Skillbyte-Podcast! Skillbyte ist ihr Partner für digitale Exzellenz.

In diesem Podcast geht es um das Thema: 10 Lektionen, die wir in 40+ Jahren Softwareentwicklung gelernt

// Inhalt //
01:20 – 1. Lektion: Halte die Komplexität in IT-Projekten so niedrig wie möglich
08:24 – 2. Lektion: Der beste Code ist einfacher Code.
14:44 – 3. Lektion: Gutes Projektmanagement ist wichtiger als das Vorgehensmodell
22:36 – 4. Lektion: Es ist sehr wichtig eine verantwortliche Person zu bennen
25:07 – 5. Lektion: Katastrophen werden passieren – stelle dich darauf ein!

Abonnieren Sie diesen Podcast und besuchen Sie uns auf https://www.skillbyte.de

Feedback und Fragen gerne an podcast@skillbyte.de

// AUTOMATISCH GENERIERTES TRANSKRIPT //

Also das Gefühl, wenn du so ein Ding gelöst hast. Das ist. Ich weiß es nicht. Ich kann nicht sagen, es ist besser als beim Sex. Aber es ist halt klar, den noch viele ein bisschen Aufregung und Spannung. Endorphine werden ausgeschüttet und wenn es dann gelöst, dass man das Adrenalin weg ist, dann fühlt sich einfach nur so hey, quasi.

Herzlich Willkommen zum Skill bald Podcast Nr. 39 10 Lektionen, die wir in mehr als 40 Jahren Softwareentwicklung gelernt haben. Teil 1 Abonniert unseren Podcast für mehr spannende Themen aus dem Technologie Umfeld er Entscheider oder die Fachkraft seid. Wenn ihr Hörer Fragen auf der Prisoner habt, sendet uns gerne eine E-Mail an Podcasts. Geh weiter. Bewertet diese Episode gerne mit 5 Sternen und wir uns immer bei Weiterempfehlung an Freunde und Kollegen und schaut auch bei der Skill BYD Jopp Seite vorbei. Ich bin hier heute wieder mit Malaysia.

Hallo Malaysia. Hallo Boris, grüß dich.

Freut mich, dass du da bist und dass wir heute aus deinem ganzen Erfahrungsschatz schöpfen können. Ich hoffe, da bin ich ganz sicher. Ich springe einfach mal mit der ersten Lektion rein und illustrer kurz das Problem und dann können wir gemeinsam darüber sprechen. Die erste Lektion ist Halte die Komplexität in Projekten so niedrig wie möglich. Was bedeutet das genau? Das Problem besteht darin, dass häufig in Projekten alle möglichen Werkzeuge verwendet werden Libraries, alte wie neue. Daraus entsteht eine sehr, sehr hohe Komplexität und ein Wartungsaufwand.

Weil natürlich jede Library dies irgendwann mal ins Projekt geschafft hat, muss mitgeschleppt, gewartet werden, weiterentwickelt werden. Gegebenenfalls. Wenn Sicherheitslücken auftreten, müssen die gefixt werden, was zu einem sehr großen Aufwand bei Versions Upgrades führt. Denn all diese Inhalte, die einmal ins Projekt gekommen sind, die laboris, müssen mitgezogen werden.

Das wird insbesondere dann kritisch, wenn man Komponenten verwendet hat, die aus dem Support raus sind, also die einfach nicht mehr gepflegt werden, weil es sich beispielsweise um eine veraltete Technologie handelt. Ich bin sicher, da kannst du auch eine ganze Menge zu sagen. Leider ja. wÃchentlich wir aber bei dem Lieblingsthema Scrum, wo die Verantwortung ja quasi dem Team obliegt und das Management diesen Prozess komplett vertraut. Nämlich, dass das Team sich selber organisiert. Dass das Team, bevor sie neue Tools und Technologien einführt, sich einig ist.

Ich muss jedem Mensch mit tatsächlichen Augen öffnen sein. Dem ist nicht so. In jedem Projekt, wo ich war, wo das so mal rigoros gelebt worden ist, haben Entwickler Tools Frameworks eingeführt, wie sie wollten. Natürlich, der Entwickler will dazulernen. Das ist auch völlig legitim. Er will mit neuen Technologien spielen. Aber leider hat halt der Entwickler, gerade jüngere Entwickler, nicht dieses Bewusstsein, dass das ja auch später jemand betreiben muss. Jemand muss das verstehen, der, der nach ihm kommt oder wie auch immer.

Das heißt, diese Betriebs Komponente, diese Langfristigkeit hat er leider nicht im Auge, sondern in dem Moment hatte erst mal nur seinen eigenen Vorteil oder seinen eigenen Spieltrieb nachgegeben und das fällt dem Projekt hinterher auf die Füße. Das sind nicht nur Tools. Also es gibt Projekte, wo ich erlebt habe, dass auf ihr für verschiedene Test Frameworks eingeführt worden sind. Im schlimmsten Fall hätte einer nicht mehr erkannt was das sollte und baute sein eigenes Ding. Machen hat seins drüber gestülpt.

Schwuppdiwupp hast du diese 400 Frameworks drin und es ist einfach nur noch Kraut und Rüben. Und das mal der ganzen Komplexität, die jedes Buch für sich mitbringt. Security Patches, Versions Upgrade, was du erwähnt hast und so weiter und so fort. Oder es wurde entschieden. Okay, Kafka ist es cool in aller Munde. Lass uns Kafka, nutze dem Projekt. Dann wurde das einfach eingeführt, dass das jemand betreiben muss, dass da zu einem Kafka viel mehr gehört als in Docker Run.

Das wird halt ausgeblendet. Aber nachher muss die Software drauf laufen. Und wenn dann tatsächlich Probleme auftauchen, blickt keiner durch. Eine schlimmsten Fall ist der, der das einführt. Hat 3, 4, 5, 6 Monate später weg und dann läuft das Ding halt irgendwo.

Ich bin auch auf jeden Fall dafür, dass man so eine Art Architektur Verantwortlichen hat im Team, der die Langfristigkeit der Anwendung im Blick hat, der den Application Lifecycle kennt, also dem bewusst ist Wenn das hier ein Erfolg ist, dann muss das noch 5 Jahre erstens weiterentwickelt werden und dann gepflegt werden und irgendwann ist die heiße Entwicklungsphase vorbei. Dann geht es in den Betrieb und der ist eben nicht mehr so von neuen Werkzeugen geprägt, sondern da kommt es darauf an, dass die Werkzeuge, die man hat, möglichst lange eben supported werden.

Und oftmals kristallisiert sich in einem Team ja schon so jemand raus. Das Problem ist, wenn der formal nicht die Macht bekommen hat. Da kann man gleich noch zu Neiman Lektion zu sagen Okay, so machen wir das. Oder auch die Frage zu stellen Wenn da eine neue Technologie eingeführt wird, was bringt uns das, was kostet uns das? Also ich sehe auch die Lösung dieses Problems darin, dass man als guter Entwickler tendenziell mit möglichst wenig Abhängigkeiten auskommen sollte ein Testing Framework und dann ein möglichst branchenübliche, was halt wahrscheinlich noch lange Unterstützung findet.

Bewährte Tool Scheines einsetzen. Nicht unbedingt das neueste und heißeste, sondern etwas, was es. Einige Jahre gibt und was eine gewisse Verbreitung erfahren hat, dass man halt auch Infos zum Internet findet. Aber dennoch, ich meine, das muss uns ja auch klar sein. Einen gewissen Prozentsatz an neuen Technologien muss man in jedem Projekt einsetzen, sonst würde man ja stehenbleiben. Absolut.

Mir geht es auch weniger so, dass man sie hinterher betreiben kann. Es ist ein Punkt für sich. Ja, aber das größere Problem sich in der Komplexität. Ja, du hast ein System und dieses System hat ne gewisse Entropie. Und jedes Tool, jedes Framework, jedes Stück, was du dazu nimmst, erhöht die Entropie. Das heißt, das System wird komplexer und ihr komplexes wird es. Mehr Manpower Bausumme um das am Laufen zu halten.

Da kann ich wirklich auch aus meiner Historie sprechen in einem Projekt, das es noch gar nicht so lange her. Dann werden auch ich glaube zwei oder drei verschiedene Test Frameworks benutzt, das einem brauch Not und p.m. Als Abhängigkeit, damit es funktioniert. Das andere ist von Java STANDARD Framework und da sieht man richtig die verschiedenen Altersstufen des Projektes, wann mal was Neues probiert wurde. Und das führt dazu, dass irgendwann einer sagt Boah, wir müssen das alles neu machen, weil keiner mehr durchsteigen.

Also halte die Komplexität niedrig. Weniger Komplexität ist meiner Ansicht nach ein Genie Streich. Also jemand, der darauf achtet, da hat man schon so viel gewonnen. Weniger Komplexität heißt weniger Bugs, weniger Probleme, weniger Sicherheitslücken und generell ein besseres Software Verständnis von dem entwickelten Artefakt. Ein Aufschwung aus dieser Lektion hört man z.B. in der Skill BYD Podcast Episode Nr. 18, warum IT-Projekte so teuer sind. Die Komplexität führt nämlich dazu, dass die Preise irgendwann explodieren oder der Aufwand explodiert.

Also für mich bedeutet professionelle Softwareentwicklung auch nicht, jedem Trend ungefragt hinterherzulaufen, sondern primär eine konsistente Architektur anzustreben und Neuerungen gezielt einzubauen. Ich hab mal gelesen, dass man pro Projekt 15 bis 25 prozent an neuen Komponenten einsetzen kann, wo man hofft, dass die möglichst lange gewartet werden. Das wäre dann so ein guter Wert.

Es ist schwierig, das so in Prozenten auszudrücken. Ich glaube, jedes Projekt ist sehr spezifisch. Bei dem einen bedarf es mehr an neuer Technologie. Keine Ahnung. Wenn du sagst, ich möchte jetzt auf Echtzeit Streaming gehen, dann kommt halt nur ein oder zwei Tunes in Frage. Will sagen, es ist finde ich schwer nachzuvollziehen, so Prozentzahlen zu sagen. Drittel der Komponenten sollten neu sein. Also jetzt rein subjektiv. Aus meiner Erfahrung kann ich jetzt nicht an irgendwelche Zahlen festmachen.

Es ist immer individuell.

Das stimmt. Und wichtig wäre noch darauf zu achten, dass wenn man so eine Komponente einsetzt, sondern eine neue Technologie einsetzt, dass es eine saubere Schnittstelle gibt. Wenn du jetzt sagst Echtzeit Streaming, dann gibt’s ja irgendwie ein Interface, um diese Streaming Komponente anzusprechen, dass das halt sauber ist, dass man das nötigenfalls mal wechseln kann. Das sehe ich genauso. Also neue Tools können ausprobiert werden und jeder von uns hat natürlich den Drang, das zu tun und möglichst viele Sachen neu auszuprobieren.

Aber in einem professionellen Projekt muss man das abwägen, ob das wirklich immer sinnvoll ist. Die zweite Lektion stößt ja ein bisschen ins gleiche Horn. Der beste Code ist einfacher Code. Das ist meiner Ansicht nach auch ein Problem, wenn man die Entwickler sich selber überlässt. Also dieses Prinzip do not repeat yourself.

Die R ui, das kennt sie ja bestimmt auch. Das wird ins Extreme verkehrt. Also da werden Konfigurationen über Bilder Patterns gebaut und verschiedene Dinge, wo ein einfaches Textteil gereicht hätte. Ja, weil man diese Konfiguration nur einmal sozusagen einliest und dann nicht mehr braucht. Da werden Konstrukte aufgesetzt, die wahnsinnig komplex sind für eine einfache Sache. Und man guckt mehr darauf, ne Funktion nur wirklich einmal zu implementieren, statt dass man sagt Okay, is of reading ist hier wichtig.

So eine flache Konfigurationsdatei, auch wenn sich da irgendwie einen Wert doppelt. Ja, also Server für Datenbank und Server für sagen wir mal E-Mail ist jetzt vielleicht der gleiche, dann steht zweimal der gleiche Wert da drin, dass man trotzdem die beiden Werte einfach reinschreibt, anstelle dass man die Konfiguration dann wiederverwendet.

Also ich würde tatsächlich auch Einfachheit über Dry favorisieren, wenn es hart auf hart kommt. Sich entscheiden müsse ich mich persönlich immer wiederholen, als das Ganze kompliziert zu machen.

Würde ich auch so sehen. Also es gibt natürlich für jedes Pattern die Entwicklungspfad, dann haben natürlich ein Sinn. Ich möchte hier überhaupt nicht gegen Patterns wettern, aber ich habe es schon gesehen. Statt einer einfachen for-Schleife wurde ein komplexes Producer Consumer Pattern implementiert. Wurde dann irgendwie zehn Werte von irgendeinem Dienst consumers wurden, wo man denkt ja okay, die zehn Werte jetzt auch einfach als Liste übergeben können, da hätte jeder verstanden, was du willst. Und so muss man das erst ausgraben.

Man muss ja sagen, die Idee Unterstüzung ist ja auch tatsächlich so weit, dass sie auch q blöcke wär, wenn du sie wiederholst erkennt das sei es. Sowas lässt sich schneller auffinden, weil Dojo BDO Set kommt er dann zum Tragen, wenn du Code verändern willst? Und muss irgendeine Änderung reinnehmen, dass du seine Stelle machst und an der anderen Stelle vergisst. Hast du ein Bad drin? Sowas lässt die Idee dann schon erkennen, dass das die Unterstützungs entsprechend da.

Das spricht dann für mich auch eher dafür, dass sich das System mir einfacher halte oder mein Boot, als es zwingend unter allen Umständen auf Teufel komm raus diesem Prinzip gerecht werden muss. Genau.

Also ich glaube ein gutes Beispiel für Dohna Creepy yourself wird z.B. die Berechnung der Mehrwertsteuer, die aktuell bei 16 prozent statt bei 19 prozent liegt. Wenn das natürlich komplett durchs Programm verstreut ist, wird es sehr aufwendig, alle Stellen zu erwischen. Da will man natürlich eine Methode haben, die dann überall aufgerufen wird.

Aber gerade bei Configuration Klassen oder Klassen, die so Rest Calls aufrufen oder so. Da kann man sich dann doch sehr Fahrkünste an Was mir zu diesem Thema sofort einfällt ist eher so diese wie sich verschachteln Stream Map Filter Konstrukte über mehrere Zeilen gehen. Das ist für mich ja. Man mag sich dann hip vorkommen, weil man tolle neue Features benutzt hat, die in anderen Programmiersprachen schon länger da sind. Und es mag shiny sein, aber kann man argumentieren wie man will?

Es macht den Code schwer lesbar und das ist es mir definitiv nicht wert. Dann hab ich lieber drei Bout Blöcke, was man einfach lesen kann wie ein Buch statt sich da so einzudecken. Weil es ist ja so, du hast ja eine anonyme Funktion hinter der anderen. Diese Ketten, die aus dieser JavaScript Server Seuche herkommt. Und du musst ja wenn du das bitte folgen willst mit dem Kopf, dann musst du ja quasi ins Deck bilden. Der Rekursive ist und das strengt mich so an und Leute, das hat nix mit meinem Alter zu tun, sondern das ist einfach Mist.

Das fällt jedem schwer, als wenn ich das quasi in einfachen Zeilen hab.

Ja dieser Landa Notation, die verführt halt dazu, dass man immer ach und man filtert das. Achja und dann sortiert man es noch. Achja und dann macht man noch das Ding und dann dies und dann jenes und dann entsteht so eine Kaskade. Und in der Sekunde wo man da drinne ist ist das toll, weil man einfach da so runter schreiben kann. Aber ich hab auch schon mal eine lange Landa Funktion in zwei oder drei Blöcke aufgeteilt, weil ich einfach dann so ein Zwischenergebnis haben wollte und sage Okay, das ist die gefilterte Liste beim nächsten Mal.

Okay, das ist jetzt das tilgte Liste. Okay, das nächste Mal, da sind die gefundenen Treffer drin oder so. Sodass man dir dann eben folgen kann, wenn das irgendeiner mal anfassen muss.

Das ist also sehr richtig gesagt. In dem Moment, wo du selber dich quasi diesem Kontext aufgebaut hast und drin bist, dann lässt sich das relativ einfach runterschreiben. Aber der nächste muss ja auch da rein und der übernächste.

Also meine Regel ist, wenn der Quellcode nicht direkt auch von den Junior Entwicklungs Kollegen verstanden werden kann, was da passiert ist, dann ist er zu kompliziert. Punkt. Also klar, dass man mal ein Pattern erklären muss oder dass man sagen muss Oh, hier hab ich eine neue Funktion benutzt, dies in der neuen Version gibt. Das verstehe ich aber da Verschachtelung Stephen und irgendwelche wilden typisierten.

Ja genau das ist das nächste Ding.

Funktionen, die sich dann selber aufrufen. Ja, dann wird’s ein bisschen zu wild und man muss sagen hör mal, was machen wir eigentlich? Weil meistens mag man ja nur Daten irgendwie aufeinander, wenn man programmiert und arbeitet. Nicht immer Spaceshuttle, Steuerung und auch die Map letztlich nur Daten, auch sehr beliebt.

So typisierte Methoden Rückgabewert mit Wildcards und auch sehr Nies nicht.

Also nochmal Patterns haben natürlich ihren Sinn, aber man muss immer gucken ist das hier die richtige Hammerl Größe für das richtige Problem? Ich glaube das ist ganz wichtig.

Man muss einfach auch an andere denken, die dann kommen, vielleicht nicht nur den Skill Level haben.

Ich habe auch festgestellt, die besten Entwickler wenn eine Lösung entwickelt haben, dann hören die nicht auf und committen das einfach, sondern die lesen das dann nochmal von oben nach unten durch und vereinfachen auch komplizierte Funktionen. Also es gibt diesen Spruch Jeder Schwachkopf kann Dinge kompliziert machen, aber es braucht ein Genie um Dinge einfach zu machen. Und die gehen wirklich nochmal diese extra Runde, dass sie sagen Okay, jetzt hab ich zwar eine Lösung, die funktioniert. Aber was mache ich hier eigentlich nochmal?

Okay, das ist ein Zwischenschritt, der logisch. Das ist ein Zwischenschritt des logisch und zergliedern. Das entweder in einzelne Methoden oder einfach in logische Blöcke. Manchmal recha das Einführen von Leerzeile schon, weil du kennst ja bestimmt zu klickst in einer Datei auf nach so ne Wall of Text 300 Zeilen ohne eine Leerzeile dazwischen. Da denkt man schon Boah, was ist hier passiert? Da ist es wichtig, dass man auch diese logischen gedanklichen Schritte dann eben voneinander absetzt und dann möglichst ein einfachen Fluss hinbekommt.

Da kommen wir zur dritten Lektion und da bin ich ganz sicher, wirst du ganz viel zu sagen können. Die dritte Lektion Gutes Projektmanagement ist wichtiger als das Vorgehens Modell.

Was meinst du damit mit Vorgehens Modell? Das Vorgehens Modell könnte das agile Vorgehens Modell sein. V Modell x t Wasserfall Modell ganz klassisch oder irgendeinen meißtens wenn die Vorgehens Modelle ja nicht in Reinform ausgeführt, sondern es entsteht so eine mehr köpfige Hydra, die sich an allen Vorgehens Modellen irgendwie bedient und dann ein neues Monster erschafft. Nachdem das Team dann arbeitet nein, es soll gar nicht so negativ sein. Also natürlich gibt’s kein Vorgehens Modell in Reihenfolge. Es muss auch immer zur Firma und zum Projekt passen.

Aber ich glaube, nach den Jahren kann man schon sagen, dass man gutes Projektmanagement von schlechtem Projektmanagement unterscheiden kann.

Aber Moriz Projektmanagement gibt’s doch gar nicht mehr. Ist doch alles agil.

Ja, auch ein Kilis Projektmanagement ist ja Projektmanagement. Was ich festgestellt habe ist Es gibt so Projektmanagement, das sich so im Unternehmen entwickelt hat und was dann so implizit durchgeführt wird oder was du von oben aufgestört wird. Agil wäre z.B. ein Beispiel für Da kommt eine Entscheidung und das wird häufig von oben aufge stülpt. Ja, wir haben das jetzt gehört. Wir machen es jetzt alle. Aber diese von oben aufgestellten Modelle scheitern oft an der Realität. Also das agile Paradigma wird ausgerufen, es wird ein Sprint geplant, die Leute fangen an zu arbeiten und nach zwei Tagen kommt jemand rein und sagt Nee, das ist aber jetzt ganz wichtig.

Dann sagt man Ja, schreibs ins Backlog. Gucken wir uns zwei Wochen an So, und jetzt hasst der Lackmustest. Gelingt das jetzt? Oder sagt jemand Ja, Moment. Ich bin aber der Geschäftsführer. Ich will das jetzt sofort. Und so sterben dann die guten agilen Ansätze dann auch ein. Also die verwässern so nach und nach. Ich will das gar nicht so negativ klingen lassen, aber dann landet man meistens bei irgend so einer Zwischenform. Also um Priorisierung von oben.

Notfälle passieren. Naja, Hacker-Angriff, Sicherheitsprobleme. Das Leben bewegt sich ja auch. Es ist ja auch nicht so stark, dass es sich in ein Modell quetschen lässt. Schlüsselpersonen geht. Neue Mitarbeiter kommen, die noch keine Vorkenntnisse haben. Jemand wird krank. All das kann während der Projekte geschehen und es gibt keinen Plan, der alle Eventualitäten abdecken kann. Das ist die Realität. Wie löst man das gut?

Grundsätzlich ist es ja bei dem agilen Vorgehen. Es ist eigentlich eine Wohltat für die bisherige Softwareentwicklung gewesen. Gar keine Frage. Wir alle oder nicht alle? Vielleicht die? Die jüngeren Zuhörer nicht. Dieses Modell, das man sich vorher im Prinzip schon qualmende Ingenieuren, die Anforderungen genau holen musste, niederschreiben musste und abschätzen musste oder Modell Werkvertrag gemacht. Das hat alles nicht funktioniert. Insofern ist agil schon super. Aber ich glaube, dieses so völlig rigorose Agilität, wie das Agile Manifest sagt oder was daraus geworden ist, sag ich mal, das ist totaler Humbug.

Du kannst keinem Management erklären. Pass mal auf. Wir können dir nicht sagen, was es kostet. Wir können dir nicht sagen, wann es fertig wird. Wo hast du sowieso nichts zu melden, außer die Kohle da hinzulegen? Das funktioniert einfach nicht. Selbst wenn das Management von großen Firmen sagt Ja, wir führen das jetzt ein und egal was wir machen, ist agil, agil, agil. Trotzdem fragen sie immer nach Wann ist es fertig? Was kostet das?

Trotzdem wird Projektmanagement nicht mehr gemacht. Man merkt, dass Sie nicht loslassen können. Klar. Ich meine das selbst ich als Softwareentwickler dieses Modell ja mitgemacht hat und sehr froh ist, dass es das auch gibt, sagt. Das ist totaler Quatsch. Entwickler können machen was sie wollen. Hin und her. Das funktioniert einfach nicht. Deswegen vermischt sich das im Moment. Klar, wenn du nur diese Menschen sind, Firmen und Coaches und so weiter. Die verdienen ihr Geld damit, dieses Modell einzuführen.

Aber aus der Praxis, so wie ich es erlebe, entsteht irgendwie eine Mischform. Dadurch aber, dass diese Mischformen links beschrieben ist, vermisse ich das Alte mit dem Neuen. Und da kommen ganz komische Konstrukte raus. Mein Punkt ist jetzt gar nicht mal so finanziell und Management und Zeit, Berechnungen usw. Also auch das werden mit Sicherheit 99 prozent der Zuhörer zustimmen. Irgendwie schleicht es sich ein, dass die Komplexität Punkte plötzlich in Tagen weiter kommuniziert werden. Aber mein Punkt ist rein technisch im Moment.

Und dass sich diese Architektur Thema, dieses Setzen eines Rahmens, in dem man sich frei bewegen kann und nicht einfach blind vertrauen und sagen, dass die Macht es schon. Ah, braucht das Team einen Rahmen. Es fühlt sich wohler. Der Entwickler fühlt sich wohler, wenn ein Rahmen, in dem er sich bewegen kann, im Grunde wie ein Bauplan auf der Baustelle.

Na, da baut ja auch nicht einfach jeder drauflos, wie er lustig ist, sondern es gibt einen großen Plan und das so muss das am Ende zusammenpassen.

Genau, du gehst ja auch nicht, wenn du ein Haus bauen willst und schmeiß irgendwie schon haben wir kein Geld ins Gesicht und sagt so guck mal wir das OP’s aufbaut. Nee, du gehst mal schon denken als erstes. Genauso ist das mit der Softwareentwicklung. Es ist auch sehr schwer, wenn du als Dienstleister, was wir hier sind Verträge machen wollen. Weil wenn ich dem Kunden komme, sagt Ja. Wir arbeiten zwar als verlängerte Werkbank, das ist unser Modell, das nach timen Material.

Aber wenn wir Projekte machen und ich sage agil, dann kommen genau diese Fragen. Und wenn ich dem sage, jetzt mal nichts zu sagen, wir machen das und du kannst nur sagen Stopp nach allen 14 Fahnenmeer und Sprint Review hast. Mit dieser Zeit kannst du das Projekt stoppen. Toll. Deswegen entstehen diese Mischformen und auch Verträge. Was wir machen ist dann kein Dienstleistungs Vertrag, kein Werkvertrag, sondern agiler Vertrag. Also dieses Konstrukt gibt’s tatsächlich, wo man gewisse Rahmen festsetzt.

Ich hoffe, das wird noch ein bisschen dauern, bis das, was ich jetzt gerade sage, den Unternehmen auch tatsächlich bewusst wird und man erkennt. Rein so agil, wie es Groom oder diese Coaches einem propagieren, so geht’s einfach nicht. Das wird früher oder später kommen, spätestens wenn dann Projekte zeitlich und finanziell aus dem Ruder laufen. Wenn man sich wieder fragen warum, wieso, weshalb? Und dann, wenn das Argument auf den Tisch kommt, dann überlegt man sich etwas Neues.

Also das beste Projektmanagement, was ich erlebt habe. Es hat total problemorientiert. Das guckt wo sind die Stolpersteine oder was steht uns im Weg, was steht unserem Erfolg in weg und kümmert sich darum? Also es räumt im Grunde einfach nur Hürden aus dem Weg und lässt dem Team schon viel Autonomie. Aber kommuniziert die Ziele immer sehr klar. Also da wollen wir hin, da wollen wir hin. Da wollen wir hin und alles, was da im Weg steht. Probleme müssen gelöst werden.

Leute müssen überzeugt werden und darum kümmert sich das Projektmanagement. Und auf der anderen Seite schützt ist das Team, das das Team in Ruhe arbeiten kann und nicht in endlosen Meetings Runden verhaftet wird, um alle Stakeholder, die es irgendwie geben könnte, abzuholen. Das sind die effektivsten Projekte, in denen ich bisher gearbeitet habe, wo man einfach gesagt hat Okay, wir räumen alle Probleme aus dem Weg. Ihr könnt in Ruhe arbeiten, natürlich alle zwei Wochen oder je nach Sprint Ende wird gezeigt, woran ihr gearbeitet habt.

Und dann sagt der Kunde, wohin es als nächstes geht. Natürlich gibt’s so einen groben großen Plan, was man erreichen möchte. Mit den Schlüssel Features. Aber das war sehr zielorientiert und die Projekte, die ich so gemacht habe, waren sehr erfolgreich. Vielleicht können wir hier auch festhalten. Also das ist so mein Fazit aus dem Punkt gutes Projektmanagement. Wenn Projekte scheitern. Ich hab das noch nie erlebt, dass ein Projekt, eine Technologie scheitert, weil irgendwas nicht gegangen wäre oder so vielleicht.

Bei Raumfahrtunternehmen ist das so. Aber ganz oft sind es menschliche Faktoren, Firmenpolitik oder einfach nicht gut durchgeführtes Projektmanagement, wo dann hinterher das ganze Team demotiviert war. Das sind so die Gründe, warum Projekte scheitern.

Meiner Ansicht nach ja, ist schon so. Aber ich hatte auch. Also muss ich wirklich hervorheben einige Projekte, die wirklich super erfolgreich waren, wo gutes Projektmanagement stattgefunden hat, wo dem Team der Rücken gestärkt wurde und alle Probleme organisatorischer Art eben aus dem Weg geräumt wurden. Also super klasse gelaufen, muss ich wirklich sagen. So ein bisschen in die dritte Lektion Gutes Projektmanagement spielt die vierte Lektion hinein, würde ich sagen. Die ist nämlich Es ist sehr wichtig, eine verantwortliche Person zu benennen.

Was ist das Problem? Also das kennst du bestimmt auch bei Retro oder auch so werden Missstände benannt, was vielleicht nicht so toll ist, was man besser machen kann. Dann gibt’s eine Diskussion im Plenum, da spricht man darüber und dann wird darum gebeten, meistens von höherer Stelle, dass sich darum gekümmert wird, ohne explizit eine Person zu benennen. Vielleicht wird sogar noch ein Ticket erstellt im Backlog. So, und das wars. Und bitte kümmert euch darum.

Heißt für mich Keiner kümmert sich darum. Gerade wenn das ein heißes Thema ist. In erfolgreichen Projekten, so ist es meine Erfahrung, wird eine verantwortliche Person benannt, wenn das Thema wichtig ist. Wenn ein Thema nicht wichtig ist, dann wird keine Person benannt, aber dann braucht man es auch nicht aufschreiben. Und diese Person ist dann dafür verantwortlich, dass dieses Thema weiterverfolgt ist und hat dann die Themenführerschaft da drüber und kümmert sich auch. Und das ist gar kein Fingerprint Ding, das man sagt Okay, du kümmerst dich jetzt darum.

Sondern jeder hat ein paar Themen, für die er verantwortlich ist. Dadurch entfällt diese ganze Fragerei, wenn irgendwie Probleme in einen gewissen Themenkomplex fallen. Man weiß sofort Aha, Person X oder Epsilon ist dafür verantwortlich. Brauch halt nicht weiter zu fragen, hat sofort einen Ansprechpartner. Auf der anderen Seite hab ich ja selber drei Themen, für die ich verantwortlich bin, sodass da auch kein Ungleichgewicht entsteht. Ich weiß nicht, wie hast du das erlebt? Also auch da ist ja das Team kümmert sich.

Also wenn wir es beim Business-Modell Scrum bleiben, heißt es ja, das Team ist eigenverantwortlich und wenn ich eine gute Durchmischung hab von jüngeren und erfahrenen Entwicklern, dann erfolgt quasi alles im Team. Und die sollen sich selber organisieren. Faktisch aber auch jetzt organisatorisch, innerhalb. Selbst wenn man das Modell macht und man im Team Dinge bespricht, ist es ganz wichtig für jedes Thema Verantwortliche zu benennen. Das ist ja dieses Prinzip. Ja, das hat eine andere schon mal vielleicht gehört.

Ja, wenn du in einer Menschengruppe unterwegs bist und irgendeiner hat einen Herzinfarkt, wenn du sagst Kann jemand mal einen Arzt rufen, macht es am Ende keiner, weil sich jeder von anderen verlässt. Aber wenn du dann jemanden anguckst und sagst, kannst du einen Arzt rufen, dann ist die Wahrscheinlichkeit viel größer, dass derjenige oder vielleicht wenn du dir selber bis überlebt.

Genauso ist es in IT-Projekte vielleicht nicht weniger dramatisch. Man braucht vielleicht nicht so oft ein Arzt, wobei das auch vorkommen kann. Je nach Katastrophen Lage. Ja. Oh mein Gott, ich seh gerade das war ja ein wundervoller Übergang. Die fünfte Lektion Katastrophen werd passieren, stell dich drauf ein. Da können wir jetzt ja mal wirklich von ein paar Katastrophen erzählen, die wir bisher erlebt haben. Ich fange mal von meiner allerersten Katastrophe an, da war ich noch Student und hab.

Eine Webseite betreut und hub zu einem gewissen Zeitpunkt des Vormittags Club zehn oder elf Uhr morgens ein Update gemacht. Dieser Webseite und die Webseite gehört einen riesigen Dax-Konzern habe das Update eingespielt. Okay, und auf die Webseite und drücke 5 aus passiert gar nichts. Und das Rad dreht sich und das Rad dreht sich und das Rad dreht sich. Ich drück nochmal 5! Das Rad dreht sich, das Rad dreht sich. Man geht auf Google um zu gucken. Hat der Rechner kein Internet oder sowas.

Alles funktioniert. ernÃhren, Webseiten funktionieren. Nochmal zurück auf die eine Webseite Rad dreht sich das Rad dreht sich, kommt keine Webseite. Da wurde mir heiß, kalt, heiß, kalt in schneller Folge mich aufgestanden und zu meinem Manager gegangen und hab gesagt Hammerl, ich habe gerade in D dein Schild an die Webseite lädt nicht mehr und er macht seinen Browser auf, geht auf die Webseite und das Rad dreht sich. Das Rad dreht sich und das Rad dreht sich.

Das war so wie im Trance, muss ich wirklich sagen. Ich war total. Oh mein Gott, was soll ich machen? Und dann griff er zum Telefon, auch relativ hektisch dann und hat wild rum telefoniert. Wahrscheinlich hat es nur 10 Minuten gedauert, aber für mich gefühlt ne Ewigkeit. Und dann hat der Kunde angerufen und gesagt, dass er gerade eine Wartung von diesem Server macht, wo ich gerade drauf wie Pleul hatte. Ich war also gar nicht schuld.

Es lag gar nicht an meinem Release, sondern der Kunde selber hatte den Server neu gestartet und dann auch noch in andere Firmen auf diesem Server drauf. Also es war quasi eine kurze Downtime von paar Minuten, wo ich nichts konnte, weil ich einfach nicht wusste, dass da jetzt durchgestartet wird oder so. Das heißt, am Ende war ich nicht schuld, aber das will ich nie vergessen. Das war für mich eine Katastrophe und das wäre auch für die kleine Firma, für die ich damals gearbeitet habe, eine Katastrophe gewesen.

Am Ende des Tages ist alles gut ausgegangen, aber das weiß ich noch ganz genau. Das war so die erste Feuerprobe. Und ich bin sicher, jeder Entwickler kennt diesen Moment und kann von anderen Situationen erzählen, wo dieses Heiß kalt Gefühl aufgekommen ist. Also was ist die Lektion hier? Trotz aller Vorbereitung wird es irgendwann zur Katastrophe kommen. Downtime ganzer Produktionssystem durch Softwarefehler oder Datenbank Updates schlecht reproduzierbare Bugs. Ich weiß, wir haben mal in einem Projekt zusammen gearbeitet, da es alle sechs Wochen ein komplettes Rack ausgefallen.

Das inklusive braucht ein BIOS Update oder so. Aber wahnsinnig aufwendig zu reproduzieren. Und jedes Mal wenn der Fehler aufgetreten ist, ist das ganze System abgestürzt, sodass ein riesen Impact hatte. Datenverlust, Hardware, Defekte alles schon dagewesen. Betrug, Hacking, Diebstahl, DDoS also das wird passieren, da muss man darauf vorbereitet sein. Was war deine Katastrophe in jüngster Vergangenheit oder die größte, die du je erlebt hast?

Also ganz ehrlich, ich kann nicht sagen, es war jetzt eine große Katastrophe hier oder da. Der ganz normale Wahnsinn. Solche Ausfälle hier, da. Oh Gott, unser Gitt baut nicht und oh Gott, unsere Produktion Server ist down. Das ist eigentlich Normalität, dass das kommt. Ich muss ganz ehrlich sagen, es ist nichts dabei, was mich geschockt hätte. Ja so! Gerade wo ich angefangen hatte. Und so dachte ich Jo, hier in IT-Systemen.

Alles Ingenieure und komplexe Systeme. Wenn das läuft, dann läuft und da passiert nix. Wurde erst in ein, zwei Mal Sucks, du bist hier abwanderten. Also das ist wie Hartmut weißt. Klar werde ich nie vergessen. Irgendwie bei der großen Systemhaus am Anfang, wo wir Mailserver betreut haben für Kanal so 20000 Leute und die konnten keine Mails verschicken. Da ist gezittert und bibbert. Aber es kam danach noch schlimmere Dinge hinterher.

Wenn das Problem gelöst ist, kann man darüber lachen. Aber in dem Moment, wenn man nicht weiß, woran es liegt.

Es ist schon also das Gefühl, wenn du sunde gelöst, dass das ist. Ich weiß es nicht. Ich kann nicht sagen, es ist besser als beim Sex.

Aber okay, ja, ich weiß, was es so weit kommt sich vor wie Superman.

Ja, auf jeden Fall. Es ist halt klar die Endorphine, ein bisschen Aufregung und Spannung, Endorphine werden ausgeschüttet und wenn es dann gelöst und das andere Adrenalin weg ist, da fühlt sich einfach nur so Hey Vasile, das Widersprüchliche hier an der Lektion ist ja, dass die Unternehmen oder gerade auch Großunternehmen einen unglaublichen Aufwand betreiben, dass es eben nicht dazu kommt.

Also viele Back ups, redundante Systeme, 24/7 Support. Und trotzdem Irgendwann bist du fällig. Irgendwann passiert die Katastrophe. Ich weiß nicht. Gerade wenn man ein System schnell weiterentwickelt. Irgendwo ist ein Fehler drin, den keiner bedacht hat. Ob es ein Schaltjahr ist, das hatte ich auch mal bei einem System. Da fehlte der letzte Tag, weil das Jahr 366 Tage hatte statt 365. Das war nicht bedacht worden. So konnte am letzten Tag keine Buchung erfolgen.

Das sind alles so Dinge, die können passieren und das Wichtige ist, damit zu rechnen. Ich finde, daran erkennt man immer so supergut den Unterschied zwischen Junior Developer und Senior Development, weil da passiert das, was du beschrieben hast. Die einen haben die Hornhaut, die anderen haben die noch nicht. Pferde Junior Developer ist so wie ich damals schweißnass gebadet. Völlig paralysiert und weiß nicht, was er machen soll, und der Senior Developer zieht die Handschuhe an und greift ins Feuer.

So ungefähr. Bleibt ruhig. Okay, das Kind ist jetzt im Brunnen gefallen. Welche Optionen haben wir? Was können wir machen? Was man die letzten Schritte, die du getan hast? Welchen Impact hat das im Grunde? Wie gehen wir jetzt vor? Natürlich zügig, aber diszipliniert wird an einer Lösung gearbeitet.

Und das ist auch sozusagen die Lösung dieser Katastrophe. Das ist auch ganz wichtig, dass das Management mitspielt. Task Force zusammenstellen, alles stehen und liegen lassen und sich um das Problem kümmern. Den Rücken dieser Task Force freihalten. Ja, vielleicht alle paar Stunden mal den Status abfragen, damit man das entsprechend kommunizieren kann. Richtung Vorstand oder Kunden, den Fortschritt und das aktuellen Problem Status Monitoren. Was kann man machen? Wo befinden wir uns und wirklich sehen, dass das Team die volle Konzentration auf das Problem werfen kann und nicht gestört wird?

Kein Telefon und so weiter. Also außer zur Problemlösung dann erlaubt und auch dem Team dann die nötigen Ressourcen, also Experten z.B., die sich mit einer Technologie ganz besonders gut auskennen, die dann eben Hilfestellung geben können, in kritischen Situationen zur Verfügung stellen. Und Annas Team muss man einfach sagen Bleib dran, ihr müsst durchhalten. Es gibt ein tolles Zitat von Winston Churchill. Das fällt mir in diesem Zusammenhang immer wieder ein If you going to hell, keep going.

Also nicht stehenbleiben, weitermachen, dranbleiben, das Terrier gehen, auspacken und einfach weiter daran arbeiten, bis das Problem gelöst ist. Und unterwegs Schadens Minimierung betreiben. Natürlich.

Aber ich kann es immer noch nicht glauben. Du hast keine Katastrophe erlebt.

Nee, ich überlege echt die ganze Zeit. Aber wie gesagt, es ist halt relativ Katastrofe.

Also ich weiß, dass wir schon in Projekten gearbeitet haben, wo Leute panisch über den Flur gelaufen sind, weil die Webseite offline war. Wenn das dich nicht aus der Reserve gelockt hat, dann hast du auf jeden Fall mehr Hornhaut als ich.

Die Sache ist eine Sache der Perspektive. Willst du brauchst einen kühlen Kopf bewahrt.

Ich weiß, einmal ist ein Manager aus dem Urlaub zurückgekommen, hat sein Notebook eingesteckt, dann auf dem Notebook lief noch irgendwas Server Komponente vom Produktiv System, die in der Entwicklung dann noch gestartet war und dann klappt das Notebook auf. Und dadurch, dass er eine Zeitlang im Urlaub war, zieht das Notebook alle Events von Zeitpunkt. Ich gehe jetzt in Urlaub bis Zeitpunkt. Ich bin wieder da. Nach dem Produktionssystem und blockiert das ganze Produktionssystem stundenlang und keiner wusste, woran es liegt, weil keine Änderung erfolgt ist, außer dass dieser Mensch aus dem Urlaub zurückgekommen ist, was man ja auch erst nicht weiß.

Das war auch eine heiße Phase, diesen verkehrssicher auf Rädern, weil sie rausgefunden haben, da haben nicht wir geschwitzt, da hat er dann geschwitzt, aber das weiß man dann erst nicht.

Es sind einfach so Sachen. Technologie ist manchmal wunderbar wie Magie und manchmal auch sehr einfach. Und sehr dumme Fehler passieren. Das muss man auch sagen. Na ja, ich freue mich, mit dir im zweiten Teil über die Lektionen 6 bis 10 zu sprechen, nachdem wir jetzt die Lektionen 1 bis 5 durchgegangen sind.

Ja, sehr gerne freue ich mich auch. Bis dahin ganz schön nochmal überlegen, ob wir noch ähnliche Katastrophen erleiden wollen.

Genau da greifen wir den Faden wieder auf und machen noch so einen Marsyas Katastrophen Blog am Anfang. Sehr schön bin ich gespannt, wo die die meiste Hornhaut gewachsen ist. Wenn unsere Zuschauer Fragen haben oder Feedback zur aktuellen Podcast Episode, können Sie uns eine E-Mail schreiben an Podcasts. Geh weiter. Wir freuen uns immer über Bewertung oder Weiterempfehlung des Podcasts an eure Freunde und Kollegen. Schaut darauf, dass Gilbert Jopp Seite vorbei. Wenn ihr mehr spannende Technologie Themen lesen möchtet, schaut auch auf der Skjelbred Website Slash Blog vorbei und abonniert natürlich unseren Podcast.

Ja, es war wie immer eine Freude. Ich wünsche noch einen schönen Abend.

Bis dahin.

Maurice KnoppSkillbyte Podcast #39: 10 Lektionen, die wir in 40+ Jahren Softwareentwicklung gelernt haben (Teil 1)
Mehr

Skillbyte Podcast #16: Werde immer besser!

Willkommen zum Skillbyte-Podcast! Skillbyte ist ihr Partner für digitale Exzellenz.

In diesem Podcast geht es um das Thema: Werde immer besser!

// Inhalt //
01:26 – Verbesserungen sind überall
03:04 – Kontinuierliche Verbesserung hat eine lange Geschichte
04:09 – Viele kleine Verbesserungen statt des einen Quantensprungs
05:01 – Deutschland, traue dich Fehler zu machen…
06:40 – …oder fahre im Windschatten?!
07:00 – Beschleunigung und schnelle Iteration
08:04 – Sicherheit vs Geschwindigkeit
12:38 – Die Transformation von Nokia
13:33 – IT-Bereich: Scrum als iteratives Modell
14:10 – Das Pareto Prinzip
15:19 – „Beharrmoment“ vs Innovation bei Organisationen
16:19 – Innovation: Online Weinprobe
17:12 – Zusammenfassung: Kontinuierliche Verbesserung
17:45 – Tools für die persönliche Verbesserung
26:25 – Buchtipp: Atomic Habits
27:50 – Positives Mindset: der Stoiker
30:05 – Positives Mindset: Sieh Probleme als Herausforderungen
31:03 – Positives Mindset: Sport als Energielieferant
32:12 – Positives Mindset: Weiterbildung
32:55 – Positives Mindset: regelmäßige Reflexion
33:36 – Belohnungen und Motivation

Abonnieren Sie diesen Podcast und besuchen Sie uns auf https://www.skillbyte.de

Feedback und Fragen gerne an podcast@skillbyte.de

Maurice KnoppSkillbyte Podcast #16: Werde immer besser!
Mehr