Um Teamarbeit bei der Softwareentwicklung geht es im Interview mit Christian Kranert in der einhundertachtundachzigsten Episode des IT-Berufe-Podcasts.
TL;DR
Bei meinen IT-Azubis gehört Teamarbeit ab dem ersten Ausbildungsjahr zum Alltag, weil komplexe Software das Wissen verschiedener Menschen braucht. Gemeinsam mit Christian Kranoth gehe ich darauf ein, wie du dich vom ersten Gespräch über ein Problem bis zum Testen einbringst und dabei von anderen lernst. Frühe Gespräche mit dem Fachbereich, gemeinsam abgestimmte technische Konzepte und regelmäßiger Austausch helfen dabei, bessere Software zu entwickeln. Als IT-Azubi kannst du von Anfang an echte Aufgaben übernehmen, während dich erfahrene Kolleg:innen begleiten und dir durch Feedback helfen, selbstständiger zu werden.
Podcast: Play in new window | Download (Duration: 1:02:39 — 43.0MB)
Abonnieren: Apple Podcasts | Spotify | RSS
Kapitelmarken
- [00:00:00] Thema und Einführung in Episode 188
- [00:02:23] Teamarbeit als Teil der IT-Ausbildung
- [00:03:07] Christian Kranoths Weg in der Softwareentwicklung
- [00:05:38] Warum Softwareentwicklung Teamarbeit braucht
- [00:08:13] Technische Komplexität und verschiedene Fachgebiete
- [00:10:04] Mit dem Fachbereich Probleme und Lösungen besprechen
- [00:13:25] Offene Gespräche und Unternehmenskultur
- [00:15:04] Teamarbeit in Wasserfall und Scrum
- [00:17:11] Täglicher Austausch und das Daily
- [00:20:44] Produktideen bewerten und das Backlog priorisieren
- [00:23:18] Das technische Konzept gemeinsam erarbeiten
- [00:26:06] Aussagekräftige Namen im Team festlegen
- [00:27:58] Pair Programming und Code Reviews
- [00:28:35] Mit der Qualitätssicherung zusammenarbeiten
- [00:30:27] Sinnvolle Meetings und aktive Beteiligung
- [00:35:41] Verantwortung für die Teamkultur
- [00:37:07] Das Phasenmodell der Teamentwicklung in der Praxis
- [00:39:50] Hierarchien und weitere Schwierigkeiten im Team
- [00:42:15] Zurückhaltende Kolleg:innen ermutigen
- [00:45:35] Führung und Konflikte im Team
- [00:47:11] Fehlerkultur und verbindliche Checklisten
- [00:49:42] IT-Azubis und Junior-Entwickler:innen einbeziehen
- [00:52:40] Mit Checklisten und Dokumentation selbstständiger arbeiten
- [00:54:08] Folgen dauerhaft abgelehnter Teamarbeit
- [00:55:31] Erfahrene Entwickler:innen und der Begriff 10x Developer
- [00:57:00] Wissen weitergeben und gemeinsam wachsen
- [00:58:13] Abschließende Gedanken zur Teamarbeit
- [00:59:32] Kontakt zu Christian Kranoth
- [01:00:33] Feedback und Ausbildungsbegleitung per Newsletter
Inhalt
Vorstellung Christian Kranert
Christian hat sich schon in Episode 164 des Podcasts über Softwarequalität ausführlich vorgestellt, aber hier noch einmal die wichtigsten Eckdaten.
- Christian Kranert
- seit 17 Jahren in der IT und Softwareentwicklung tätig
- angefangen mit Visual Basic 6 auf Windows 95
- Ausbildung zum Fachinformatiker für Anwendungsentwicklung absolviert
- viel im SAP-Umfeld mit ABAP entwickelt
- inzwischen hauptsächlich mit C# unterwegs
- lebt und arbeitet in Nürnberg bei Head On Solutions GmbH
- entwickelt dort Cloud-Software für lokale Geschäfte wie Friseur-Studios zum Planen von Terminen, Kassieren, Buchhaltung usw.
- ist Abteilungsleiter mit eigenem Team
Teamarbeit in der Softwareentwicklung
Warum brauchen wir Teamarbeit bei der Softwareentwicklung?
- bei der Komplexität heutiger Software ist es fast undenkbar, diese alleine zu entwickeln
- heutige Webanwendungen enthalten z.B. sehr viel UI-Entwicklung und sind im Backend und Frontend sehr komplex, Stichwort: Full Stack
- Christians Unternehmen hat ein eigenes Team ausgelagert nur für VueJS im Frontend
- durch das Team entsteht auch bessere Software
- wir wollen doch die „echte Welt“ übersetzen in Code und dort gibt es auch mehr als einen Benutzer
- gemeinsam zu entwickeln macht mehr Spaß, ist sozial, man kann voneinander lernen, man kann sich weiterentwickeln
- die interdisziplinäre Zusammenarbeit mit dem Fachbereich bzw. Kunden ist auch extrem wichtig
Wie sieht erfolgreiche interdisziplinäre Zusammenarbeiten zwischen dem IT-/Entwicklungs-Team und anderen Abteilungen aus?
- der Fachbereich erklärt den Entwickler:innen die Fachlichkeit
- Entwickler:innen dürfen/müssen das aber auch hinterfragen und ggfs. bessere Lösungen vorschlagen
- man sollte erst über das Problem reden und nicht schon über Lösung
- es muss die generelle Bereitschaft zur Teamarbeit vorhanden sein und eine entsprechende Kultur
Welche Prozessmodelle (z.B. Wasserfall, Scrum) unterstützen/behindern die Teamarbeit?
- das klassische Wasserfallmodell ist eher hierarchisch aufgebaut mit Lasten-/Pflichtenheft und passt nicht so gut zur Teamarbeit
- Scrum ist aber auch kein Allheilmittel
- das Daily ist sehr wichtig, denn Kommunikation ist der Schlüssel zu erfolgreicher Teamarbeit
Wie sieht richtig gute Teamarbeit in der Softwareentwicklung aus?
- Kommunikation ist das A und O, z.B. wenn ein Feature fertig ist, damit die Kolleg:innen darauf aufsetzen können
- alle Teammitglieder:innen sollten auch aktiv Hilfe anbieten und einfordern
- die gesamte Softwareentwicklung ist Teamarbeit und die geht schon mit der Produktidee los
- dabei kann es helfen, verschiedene Perspektiven einzunehmen, um ein besseres Bild der Anforderungen zu bekommen
- auch weitere Aufgaben lassen sich besser im Team lösen: Risiken abschätzen, Prioritäten ableiten, Product Backlog füllen
- wenn das Verhältnis von Kosten und Nutzen passt, startet die Implementierung und Aufgaben werden im Team verteilt
- in Christians Team werden Konzepte z.B. gemeinsam erarbeitet, ganz einfach in OneNote*
- das Team startet mit einem Datenmodell als Diskussionsgrundlage und legt dann die Datentypen fest
- außerdem werden Mockups erstellt, um darüber gemeinsam zu diskutieren
- sehr wichtig ist auch das gemeinsame Festlegen von Namen im Team, denn viele Köpfe haben mehr (fachliches) Wissen als einer alleine
- der große Vorteil bei dieser Vorgehensweise ist, dass früh erkannte Fehler bei Anpassungen wenig kosten im Vergleich zu späteren Projektphasen, wenn alles schon umgesetzt ist
Warum ist die Teamkultur nicht nur beim Code Review wichtig und wie sieht sie aus?
- Christians Team entwickelt oft im Pair Programming zusammen und führt danach noch Code Reviews durch
- hier war oft insb. beim Testen die Einstellung, dass das doch jemand anders macht und nicht die Aufgabe der Softwareentwickler:innen sei
- aber gerade beim Testen ist die Abstimmung mit den Tester:innen wichtig, damit man nicht den kompletten Code umschreiben muss, wenn man am Test vorbei entwickelt hat
Wie stellt man sicher, dass alle Teammitglieder:innen sich aktiv einbringen und wie kann eine Führungskraft Teamarbeit fördern/behindern?
- die Führungskraft ist sehr wichtig, denn ihre zentrale Aufgabe ist die Pflege der Teamkultur
- die häufig anzutreffene Skepsis bei Entwickler:innen gegenüber Meetings muss von der Führungskraft abgebaut werden
- Meetings müssen aber natürlich auch einen Mehrwert für alle Teilnehmer:innen bieten und müssen vernünftig geplant und vorbereitet werden
- auch für Entwickler:innen sind Meetings wichtig, da sie helfen, offene Fragen zu klären und Entscheidungen herbeizuführen
- Teamarbeit kann die Teammitglieder:innen motivieren, wenn man gemeinsam eine gute Lösung findet und z.B. eine „harte Nuss“ knackt
Braucht ein Team eine Leitung?
- das kommt stark auf das Team an
Storming, Forming, Norming, Performing: gibt es das wirklich in der Praxis?
- Christian hat das mal in einem Buch gelesen, aber nur dunkel in Erinnerung
- in der Praxis durchlaufen die Teams diese Phasen wohl tatsächlich, aber intuitiv verhalten sich die Mitglieder:innen meist den Phasen entsprechend
Wie sieht häufig die (negative) Realität in Sachen Teamarbeit aus bzw. an welchen Fehlern scheitert Teamarbeit häufig?
- Juniors werden vernachlässigt und bekommen keine oder zu wenig Unterstützung
- Hierarchiedenken, gerade wenn Softwareentwicklung nicht das Kerngeschäft des Unternehmens ist
- Introvertiertheit der Teammitglieder:innen
- aber auch Extrovertiertheit bzw. Egozentrik bei Teammitglieder:innen
- Mangel an Diversität im Team
Wie wird man als Entwickler:in „teamfähig“?
- Persönlichkeitsentwicklung! dazu gibt es viele gute Bücher
- eine fördernde und fordernde Führungskraft ist wichtig für das Empowerment der Teammitglieder:innen
- die Führungskraft sollte z.B. One-on-Ones mit Mitarbeitenden führen, immer wieder nachfragen und auch die eigene Entwicklung aufzeigen
- loben und wertschätzen sollten bei jeder Führungskraft dazu gehören
- Empathie ist auch wichtig
- Konflikte sollten schnell gelöst werden
Wie wichtig ist eine gute Fehlerkultur?
- sehr wichtig
- Fehler müssen erlaubt sein und dürfen nicht „geahndet“ werden
- aber was ist eigentlich ein Fehler? Schludrigkeit ist sicherlich kein Fehler
- Checklisten können helfen, eine gewisse Basisqualität sicherzustellen
Wie können schon Azubis in die Teamarbeit integriert werden?
- einfach mal loslegen und sie an die Hand nehmen
- Azubis direkt in echte Projekte einbinden, aber ohne harten Deadlines oder großes Fehlerpotential
- viel loben
- Checklisten helfen auch hier beim Einstieg
Was sind die Folgen, wenn nicht im Team gearbeitet wird?
- Christian hat noch nie jemanden kennengelernt, der/die sich aktiv gewehrt hat gegen Teamarbeit
- eher haben die Kolleg:innen evtl. Angst mitzumachen
- den berühmten „10x-Develover“ gibt es nicht, aber Seniors können als Multiplikatoren im Team wirken und Juniors voranbringen und damit das gesamte Team
Wie/wo kann man dich erreichen?
Links
- Permalink zu dieser Podcast-Episode
- RSS-Feed des Podcasts
- Qualitätssicherung bei der Softwareentwicklung mit Christian Kranert
- Christian Kranert bei LinkedIn
- Head-on Solutions GmbH bei LinkedIn
Zusammenfassung
Warum du im Team arbeitest
Wenn ich neue IT-Azubis begrüße, spreche ich mit ihnen darüber, wie sie im Team zusammenarbeiten. Bei komplexer Software kommen verschiedene Fachgebiete zusammen, die jeweils eigenes Wissen verlangen. Durch den Austausch mit anderen entstehen stabilere Produkte, deren Funktionen besser zu den Bedürfnissen der Benutzer:innen passen.
Christian Kranoth bringt dazu 17 Jahre Berufserfahrung in der Softwareentwicklung mit. Nach seiner Ausbildung zum Fachinformatiker arbeitete er zunächst mit SAP und ABAP, bevor er sich auf Web- und Cloudsoftware mit C# konzentrierte. Heute leitet er eine Entwicklungsabteilung, die Cloudsoftware für lokale Geschäfte entwickelt.
Weil Software Abläufe aus der realen Welt abbildet, brauchst du auch die Perspektive der Menschen, die diese Abläufe kennen. Dazu gehören der Fachbereich und das Produktmanagement sowie Kund:innen. Im Entwicklungsteam lernst du durch die Erfahrungen deiner Kolleg:innen dazu und kannst gemeinsame Erfolge erleben.
Mit dem Fachbereich früh ins Gespräch kommen
Bereits wenn eine Produktidee entsteht oder Benutzer:innen ein Problem schildern, sollte das Entwicklungsteam einbezogen werden. Zu diesem Zeitpunkt lässt sich gemeinsam herausfinden, welches Problem gelöst werden soll und welche Wege dafür infrage kommen.
Aus meinem Ausbildungsalltag kenne ich Situationen, in denen schon IT-Azubis eingefahrene Abläufe hinterfragen. Manche Prozesse haben sich über Jahre gehalten, obwohl inzwischen andere technische Möglichkeiten bestehen. Wenn du nachfragst und eigene Ideen einbringst, kannst du dazu beitragen, eine fachlich passende Lösung zu finden, deren Code sich später gut erweitern lässt.
Damit solche Gespräche funktionieren, müssen die Beteiligten bereit sein, ihre Annahmen zu hinterfragen. Mit deiner Haltung und der Art, wie du Fragen stellst, trägst du dazu bei. Auch die Unternehmenskultur bestimmt, wie offen miteinander gesprochen wird.
Scrum und der tägliche Austausch
Auch in Scrum-Teams kommt es vor, dass fertige Konzepte mit der Erwartung vorgelegt werden, sie genau so umzusetzen. Wie gut Menschen zusammenarbeiten, hängt deshalb wesentlich davon ab, wie sie miteinander umgehen.
Im Daily kannst du erfahren, wo Unterstützung gebraucht wird und welche Arbeit als Nächstes ansteht. Meldet ein:e Kolleg:in ein fertiges Feature, lässt sich beispielsweise klären, wann du den Pull Request prüfst. Bei einer schwierigen Fehlermeldung kannst du Hilfe anfragen oder ein Gespräch über die Architektur verabreden.
Christian hält einen täglichen Austausch auch außerhalb von Scrum für sinnvoll. Aus den Informationen im kurzen Meeting entstehen konkrete gemeinsame Schritte, sobald die Beteiligten darauf eingehen.
Ideen bewerten und Aufgaben priorisieren
Wenn das Produktmanagement die Bedürfnisse der Benutzer:innen einbringt, ergänzt das Entwicklungsteam seine Kenntnisse über den bestehenden Code. So lässt sich früh einschätzen, wie aufwendig ein Feature wird und welche technischen Risiken damit verbunden sind.
Diese Einschätzung fließt bei Christian in die Reihenfolge der Aufgaben im Product Backlog ein. Ein Feature, das einen begrenzten Mehrwert bietet und umfangreiche technische Änderungen verlangt, erhält entsprechend eine niedrigere Priorität. Dabei kann etwa berücksichtigt werden, ob vorher ein Refactoring erforderlich ist oder ein neues Framework eingeführt werden muss.
Das technische Konzept gemeinsam erarbeiten
Bevor Christians Team mit dem Code beginnt, bespricht es das Produktkonzept mit dem Produktmanagement. Sobald alle verstanden haben, was entstehen soll, arbeitet das Team die technische Architektur aus. Die Ergebnisse hält es häufig in einem frei aufgebauten OneNote-Dokument fest.
Darin werden unter anderem folgende Fragen geklärt:
- Welche Datenbanktabellen werden gebraucht und welche bestehenden Tabellen müssen erweitert werden?
- Welche Datentypen und Feldlängen passen zu den Daten?
- Wie lassen sich die vorgesehenen Inhalte in der Oberfläche darstellen?
- Welche Bibliotheken oder Frameworks sind erforderlich?
- Welche Namen sollen im Code und in der Datenbank verwendet werden?
Beim Besprechen eines Datenfelds kann beispielsweise auffallen, dass die vorgesehene Oberfläche zu wenig Platz für den benötigten Text bietet. Solche Fragen lassen sich in dieser frühen Phase mit geringem Aufwand klären. Werden sie erst beim Testen oder im laufenden Betrieb entdeckt, kosten Änderungen mehr.
Für Namen nimmt sich Christians Team bewusst Zeit. Gemeinsam festgelegte, aussagekräftige Begriffe helfen dir, den Code zu verstehen. Dabei wird auch geprüft, wo ein Begriff bereits verwendet wird, damit die Namen eindeutig bleiben. Das technische Konzept hält die vereinbarten Begriffe für das gesamte Projekt fest.
Zusammen programmieren und Qualität sichern
Während das Team Features umsetzt, arbeitet es regelmäßig im Pair Programming zusammen. Bei den anschließenden Code Reviews wechseln die beteiligten Kolleg:innen, sodass verschiedene Perspektiven in die Prüfung einfließen.
Entwickler:innen schreiben Unit Tests für ihren Code. Manuelle Regressionstests übernimmt eine andere Person, die die betreffende Funktion selbst nicht entwickelt hat.
Für die Qualitätssicherung muss außerdem bekannt sein, welche Bereiche des Codes geändert wurden und welche Tests bereits erfolgt sind. Eine Änderung kann weitere Funktionen betreffen, die im ursprünglichen Konzept gar nicht auftauchen. Wenn diese Information bei den Tester:innen ankommt, können sie die betroffenen Bereiche ebenfalls prüfen.
Wer sich um die Teamkultur kümmert
In Christians Entwicklungsteams übernimmt jeweils ein:e fachliche:r Teamleiter:in die Aufgabe, die Teamkultur zu pflegen. Je nach Erfahrung und Zusammensetzung des Teams kommen andere Rollen infrage; bei Scrum kann sich der/die Scrum Master:in darum kümmern.
Zu dieser Aufgabe gehört, Besprechungen sinnvoll zu gestalten und ihren Zweck verständlich zu machen. Die zuständige Person achtet auch darauf, dass sich jedes Teammitglied beteiligt und genügend Zeit zum Programmieren bleibt. Regelmäßige Gespräche mit dem Fachbereich geben dir einen verlässlichen Ort, um offene Fragen zu klären.
Das Phasenmodell der Teamentwicklung wird als Prüfungsstoff für die AP1 angesprochen. Christian hat dazu nur noch vage Erinnerungen. In seinem Führungsalltag spielen der Austausch mit erfahrenen Kolleg:innen und praxisnahe Weiterbildung eine Rolle. Mit Empathie geht er auf die unterschiedlichen Bedürfnisse einzelner Teammitglieder ein.
Zurückhaltende Teammitglieder einbeziehen
Wenn starre Hierarchien den Austausch bestimmen oder einzelne Personen Gespräche stark an sich ziehen, wird es für andere schwieriger, sich einzubringen. Auch soziale Ängste können dazu führen, dass jemand sich zurückzieht. Unterschiedliche berufliche Hintergründe und Erfahrungen bringen zusätzliche Perspektiven ins Team.
Christian führt monatliche Vieraugengespräche, in denen er zurückhaltende Kolleg:innen ermutigt, eigene Ideen beizutragen. Dabei macht er deutlich, welchen Beitrag sie in einer Architekturdiskussion leisten können. Im nächsten Gespräch greift er konkrete Situationen wieder auf und würdigt, was die Person eingebracht hat.
Eine Idee kann weitere Gedanken auslösen und damit zur gemeinsamen Lösung beitragen, selbst wenn sie in einer anderen Form umgesetzt wird. Solches Feedback hilft dabei, sich nach und nach stärker zu beteiligen. Wenn im Team Konflikte entstehen, sollte die zuständige Führungskraft früh eingreifen, damit sie sich nicht festsetzen.
Mit Fehlern und vereinbarten Regeln umgehen
Bei einem Fehler schaut Christian darauf, welche Informationen zum betreffenden Zeitpunkt vorlagen. Hat jemand das verfügbare Wissen berücksichtigt und dennoch eine falsche Entscheidung getroffen, kann das Team daraus lernen.
Für verbindliche Arbeitsschritte gibt es in seinem Team Checklisten. Vor einem Commit müssen beispielsweise fünf bis sechs Punkte geprüft werden. Werden solche vereinbarten Schritte ausgelassen, spricht die Führungskraft die fehlende Sorgfalt an und arbeitet darauf hin, dass die Regeln eingehalten werden.
Als IT-Azubi von Anfang an mitarbeiten
Wenn du neu ins Team kommst, kannst du bereits an echten Features oder Issues arbeiten, deren Umfang zu deiner Erfahrung passt. Bei Christian nimmt eine neue Person möglichst ab dem ersten Tag an den üblichen Abläufen teil. Dazu gehören Gespräche über Produktideen und technische Konzepte genauso wie das Schreiben von Code. Auch Code Reviews und Unit Tests werden früh einbezogen.
Währenddessen steht das Team für Fragen bereit. Durch regelmäßiges Feedback werden konkrete Situationen aufgegriffen, wobei hilfreiche Beiträge ausdrücklich gelobt werden.
Mit einer Commit-Checkliste kannst du vereinbarte Schritte selbst prüfen. Eine ausführliche Code-Review-Checkliste hilft dir, Code Stück für Stück durchzugehen. Bei sehr unerfahrenen Kolleg:innen folgt ein zweites Review, aus dem sie weiter lernen können. Dokumentation unterstützt dich dabei, die Software kennenzulernen.
Erfahrung im Team weitergeben
Auch erfahrene Entwickler:innen müssen sich mit dem bestehenden Produkt und den Bedürfnissen der Kund:innen vertraut machen. Wenn sie ihr Wissen weitergeben, helfen sie anderen dabei, sich fachlich zu entwickeln. Dadurch wächst das Team insgesamt.
Für Christian gehört die Bereitschaft zur Teamarbeit zur langfristigen Zusammenarbeit. Wer sie dauerhaft ablehnt, passt aus seiner Sicht zu einem anderen Arbeitsumfeld. Er erlebt vor allem Menschen, die anfangs zurückhaltend sind und sich mit entsprechender Begleitung stärker beteiligen.
Weiterführende Angebote
Mein früheres Gespräch mit Christian zur Qualitätssicherung findest du in Episode 164. Die Shownotes zu Episode 188 enthalten auch den Verweis auf sein LinkedIn-Profil, über das du ihn kontaktieren kannst.
Über meinen kostenlosen Newsletter begleite ich dich durch die drei Jahre deiner IT-Ausbildung.
Transkription der gesamten Episode
Automatisch erzeugte Transkription der Episode
Herzlich willkommen zum IT-Berufe-Podcast, dem Podcast rund um die Ausbildung in den
IT-Berufen. In dieser Episode gibt es ein Interview mit Christian Kranoth zum Thema
Teamarbeit in der Softwareentwicklung, aber ich glaube, das gilt auch für alle
anderen IT-Bereiche. Viel Spaß!
Hallo und herzlich willkommen zur 188. Episode des IT-Berufe-Podcasts. Und heute
habe ich eine kleine Premiere für dich, denn zum einen habe ich seit langem mal
wieder ein Interview hier am Start, einen sehr interessanten Interviewpartner. Und
die Premiere ist, dass ich jemanden zum zweiten Mal zum Interview da habe. Das
hatte ich mich bislang, glaube ich, noch nicht, soweit ich weiß. Und zwar habe ich
den Christian Kranoth nochmal mitgebracht. Der hat schon in Episode 164, also vor
über 20 Episoden, aber das ist tatsächlich schon ein bisschen länger her. Ich habe
in den letzten Jahren nicht so viel gepostet, wie mir aufgefallen ist. Auf
jeden Fall, wir haben vor zwei Jahren schon mal gesprochen über Qualitätssicherung
bei der Softwareentwicklung. Und damals fand ich das Gespräch hochinteressant.
Ich habe mir auch viele Sachen nochmal mitgenommen und ganz viele Denkanstöße
für die Praxis im Alltag, wie man Qualitätssicherung in der Softwareentwicklung
umsetzen kann. Super gutes Interview. Wenn du da nochmal reinhören willst, gerne
164. Wie immer findest du die Episoden ja unter it-berufe-podcast.de
slash 164 für die 164. Episode. Und schon mal Spoiler, die Show-Note zur
heutigen Episode findest du unter der 188, weil 188. Episode. Und der Christian
wird sich gleich im Podcast auch nicht nochmal vorstellen, weil er in 164 hat
das schon sehr ausführlich gemacht. Da haben wir so ein paar allgemeine Fragen
geklärt. Wie ist er dazu eigentlich gekommen? Was kann er für Bücher empfehlen?
Und so weiter. Was ich sonst eigentlich immer mit allen Podcast-Interview-Partnern
immer mache. Aber da wir uns ja schon kennen, in Anführungszeichen, und du dir
das da einfach nochmal anhören kannst, hör doch einfach in die 164. Und jetzt
wird er sich einfach gleich nur ganz kurz und knapp vorstellen. Und wir steigen
direkt ein ins Thema. Und zwar Teamarbeit. Sehr, sehr spannend. Ich hätte vor dem
Interview nicht erwartet, dass wir darüber locker eine Stunde quatschen
können. Weil Teamarbeit, das macht man halt. Aber nein, es gibt da ganz schön
viel, was man auch vielleicht bedenken muss. Sowohl als Mitarbeiter, als auch als
Führungskraft. Und ob Instagram, ob im Wasserfall-Modell für introvertierte
Menschen oder nicht. Also wir haben ganz viele Themen gestreift. Fand ich wirklich
sehr, sehr spannend. Und ja, da ich jetzt schon wieder ewig plaudere und das
Interview auch ein bisschen länger ist, würde ich sagen, komm, wir legen direkt los.
Ich starte mal ins Interview. Viel Spaß dabei.
So, wir wollen heute ein bisschen sprechen über Teamarbeit in der Software-
Entwicklung und zur Einleitung. Also wenn ich neue Azubis bei mir begrüße, mache
ich immer so ein erstes Meeting, wo ich so ein bisschen darauf eingehe, wie wir
bei uns so zusammenarbeiten. Und ich sage dann immer, du kannst bei uns nichts
alleine erreichen. Wir müssen im Team zusammenarbeiten. Und mach dir das nochmal
extra bewusst. Und heute wollen wir mal ein bisschen drüber reden, was das denn
wohl eigentlich so heißt, Teamarbeit. Und was vielleicht gute Teamarbeit ist und wie
man die sogar vielleicht verbessern kann. Und dafür habe ich jemand Spannende
mitgebracht und zwar den Christian. Das ist eine absolute Premiere. Das ist nämlich
schon zum zweiten Mal hier. Ich hatte noch keinen Interviewpartner, der zweimal
da war, aber der Christian macht das jetzt zum ersten Mal. Und bevor wir
einsteigen in das spannende Thema Teamarbeit, würde ich sagen, Christian,
erzähle doch nochmal ganz kurz, wer du bist, was du so machst, wo kommst du her.
Leg mal los. Ja, hi Stefan. Ja, erstmal vielen Dank, dass ich diese Premiere mit
dir feiern darf. Freut mich sehr, wieder dabei zu sein.
Viel geändert hat sich nicht im Vergleich zum letzten Mal. Ich bin ein
bisschen älter geworden und jetzt dann schon seit 17 Jahren in der
Softwareentwicklung berufstätig. Angefangen habe ich ja schon sogar ein
paar Jahre vorher. Damals mit VB6 zu programmieren, meine ersten Gehversuche
mit meinem ersten Buch zu Hause an einem Windows 95 Rechner. Eingestiegen bin ich
dann auch mit einer Ausbildung zum Fachinformatiker. Also das, was eigentlich
viele Zuhörerinnen und Zuhörer hier entweder gerade absolvieren oder schon
absolviert haben. Das war damals in der Automobilindustrie. Da habe ich begonnen
mit der Entwicklung von SAP ERP Systemen mit der Programmiersprache ABAP. Da ich
mich da aber ein bisschen davon weg entwickeln wollte, habe ich mich dann
technologisch verändert. Wollte mehr Richtung Web und Cloud gehen in
Verbindung mit C-Sharp, was ich damals auch schon privat gemacht habe als Folge
von Visual Basic. Und da bin ich dann fündig geworden in Nürnberg bei der
Hotel DRG. Habe dort mehrere Jahre in verschiedenen Teams, an verschiedenen
Produkten rund um deren Hotelbuchungsplattform mitentwickelt.
Und von dort bin ich dann schlussendlich gewechselt zur Head on Solutions GmbH.
Die Head on Solutions GmbH hat damals als Startup hier in Nürnberg begonnen,
eine Cloud Software zu entwickeln für lokale Geschäfte. Ich war damals der
erste interne Entwickler und ja, unser Auftrag, unser Ziel war es eine Cloud
Software zu entwickeln für Geschäfte wie Friseurstudios, Kosmetikstudios und
viele andere lokale Geschäfte, die mit der Software ihr komplettes Business
managen können. Also über Terminbuchung, Kasse, Kundenverwaltung, Buchhaltung, viele
Marketingfunktionen, also alles drum und dran. Und genau das mache ich auch heute
noch. Heute deutlich größer. Jetzt bin ich mittlerweile dann
Abteilungsleiter und darf ein Team leiten. Und ja, darum soll es ja heute
auch gehen. Also nicht um die Leitung, sondern eher um die Zusammenarbeit in
dem Team. Ja, das ist spannend. Ich habe jetzt die ganze Zeit überlegt, wie kriege ich eine Überleitung hin. Aber da muss ich jetzt
einsteigen auf VB6. Also wenn ich mit VB6 arbeiten müsste, würde ich mir auch
schnell ein Team suchen, um gemeinsam heulen zu können, über die Sprache
wahrscheinlich. Aber wenn es nicht scharf ist, sieht es natürlich jetzt ein bisschen anders aus.
Spannend, spannend. Ja, dann gucken wir mal. Teamarbeit. Ich habe es ja schon gesagt, ich
sage meiner Zuwiese auch immer, man kann nichts alleine schaffen. Das wäre jetzt
so mal so als einen Satz zusammengefasst. Software ist heute so groß, so komplex,
dass ich die nicht als ein-Personen-Ding hier irgendwie selber durchziehen kann.
Das geht gar nicht. Und ja, da muss man zwangsläufig mit anderen zusammenarbeiten.
Aber vielleicht kannst du ja auch mal beschreiben, warum deiner Meinung nach
Teamarbeit bei der Software-Entwicklung vielleicht wichtig ist. Gibt es da noch andere Gründe oder?
Ja, den Aspekt, den du gerade genannt hast, der ist tatsächlich schon sehr wichtig. Ohne ging es
eigentlich bei der Komplexität, die wir heute zu bewältigen haben, gar nicht mehr. Es ist an
vielen Stellen, zumindest in vielen Software-Produkten, undenkbar. Aber es gibt viele
weitere Vorteile. Also gerade aus Unternehmensperspektive bin ich tief überzeugt davon,
dass man in der Lage ist, bessere Software zu entwickeln. Das heißt, stabiler bei angemessener
Geschwindigkeit und besserer Leistungsstärke im Sinne von Funktionen und damit auch deutlich
wettbewerbsfähiger sein kann. Ja, darüber hinaus, wenn wir einen Schritt zurücktreten und mal
schauen, was wir da eigentlich machen, dann übersetzen wir ja die reale Welt in die virtuelle
Welt in Form von Code. Wir nehmen Prozesse aus der echten Welt und schreiben Software dafür,
die damit die Prozesse abbildet. Und so wie das eben ist, wird es in der in der echten Welt auch
gemeinsam benutzt. Und deswegen wäre es eigentlich naiv, wenn wir das alleine mit unseren eigenen
eingeschränkten Perspektiven sinnvoll übertragen könnten. Allein schon deshalb sollten wir hier
sehr eng zusammenarbeiten. Aber ich würde sagen, dass auch für die Entwicklerinnen und Entwickler
selbst Teamarbeit sehr von Vorteil ist. Es macht einfach schon mal mehr Spaß, sozial zusammen zu
arbeiten. Man kann viel voneinander lernen und sich dadurch auch stetig weiterentwickeln. Ja,
und schlussendlich ist natürlich auch die interdisziplinäre Zusammenarbeit, also nicht nur
im Team, sondern auch zwischen dem Entwicklungsteam und anderen Teams wie dem Produktmanagement und
der Fachabteilung oder den Kundinnen und Kunden sogar von großer Bedeutung. Also damit möchte
ich sagen, wir sollten, wenn wir über Teamarbeit sprechen, nicht nur über die Teamarbeit innerhalb
des Entwicklungsteams sprechen, sondern eben auch auf sämtliche Schnittstellen drumherum in der
Zusammenarbeit mit anderen Teams schauen. Das kann ich mir gut vorstellen. Jetzt ist bei dir,
ich habe jetzt gehört, du machst Software oder arbeitest an Software mit für Friseure. Ich bin
jetzt zum Beispiel in der Krankenversicherung. Wenn ich keinen Fachbereich bei uns hätte,
ich wüsste nicht, was ich da programmieren muss, weil ich kenne mich halt nur mit Versicherung
aus. Und ich vermute, das geht dir ähnlich mit Friseuren, bis du angefangen hast zu programmieren.
Also das ist schon mal ein wichtiger Hinweis. Was ich ganz schön fand, besseres Software durch
Teamarbeit habe ich auch noch nie so drüber nachgedacht. Aber klar, eine Person kann halt
auch nicht alles perfekt vom UI bis Security, bis Datenbank, bis DevOps, was man heute so braucht.
Das muss man halt auf mehrere Schultern wahrscheinlich verteilen, weil das einfach
viel für viel zu viel ist für eine Person. Ja, das auf jeden Fall. Also du sprichst ja
jetzt gerade so die technologischen Aspekte an. Das ist auch was, was wir in den letzten Jahren
sehr deutlich gesehen haben. Zum Beispiel der Anspruch an Frontends, der ist sehr,
sehr deutlich gestiegen. Also die sind ja heute viel leistungsstärker als vor ein paar Jahren.
Es gibt jetzt mittlerweile mit Angular, React und Future S sehr, sehr leistungsstarke
Frontend-Frameworks, die es uns ermöglichen, ganz andere Produkte zu realisieren, als es noch vor
ein paar Jahren der Fall war. Aber das bringt auch eben mit sich, dass die Komplexität allein
in dem Bereich Frontend sehr stark gestiegen ist. Es ist jetzt nicht mehr jQuery mit ein paar
Funktionen, ein bisschen DOM hin und her schieben, sondern wir haben jetzt hier komplexe
Frameworks mit einem eigenen Ökosystem. Das ist quasi eine Anwendung in der Anwendung. Also
einfach eine Anwendung innerhalb der gesamten Full-Stack-Lösung. Und wir sind jetzt mittlerweile
dann beispielsweise auch den Weg gegangen, dass wir tatsächlich ein Team haben, das sich allein
um Future S kümmert, weil einfach die Komplexität von der alleine schon so groß ist, dass es nicht
mehr zu bewältigen wäre in Form von Full-Stack-Entwicklung. Ja, aber auch darüber hinaus
macht es in vielerlei Hinsicht Sinn, zusammenzuarbeiten, wenn wir jetzt beispielsweise
die Schnittstellen zwischen Entwicklungsteam und Produktmanagement oder bei euch dem Fachbereich
nehmen. Dann bist du jetzt zwar darauf angewiesen, dass dir natürlich der Fachbereich die Bedürfnisse
erklärt und dich da hinführt, wie das dann letztendlich zur Zielerreichung kommt. Aber
deine Perspektive ist ja dabei genauso wichtig. Erstens mal hast du möglicherweise auch viele
Ideen. Allein schon dadurch, dass du dir das Ganze erklären lässt, den eigentlichen Lösungsansatz
zum Ziel und das Ganze nochmal hinterfragst, wird der ganze Prozess oft nochmal hinterfragt. Ich
weiß nicht, ob du es schon mal erlebt hast, dass bei so einer Diskussion auf einmal die
Frage gestellt wird, ist denn der Prozess eigentlich so sinnvoll? Also da kann ich aus,
das sehen schon unsere Azubis, dass sie dem Fachbereich ab und zu auch mal direkt vorschlagen
müssen, dass man es nicht so machen sollte, wie sie es tun. Weil manchmal haben sich einfach
Sachen eingebürgert seit Jahren, weil es nicht anders ging und da fragt auch keiner mehr, warum
man es so macht. Und das merken sogar schon Einsteiger, dass das nicht immer optimal ist,
was die Leute da machen, auf jeden Fall. Ja, genau. Und da haben wir schon so zwei
Unterschiede herausgearbeitet. Wenn ein Unternehmen an dieser Schnittstelle nicht
eng im Team zusammenarbeitet, dann wird es halt dazu führen, dass so ein Konzept,
wie es von Anfang an im Raum stand, auch umgesetzt wird mit all seinen Nachteilen,
mit all seinen Einschränkungen, vielleicht auch mit der übermäßigen Komplexität,
die dadurch reinkommt. Und jetzt nehmen wir das andere Beispiel. Wenn ihr euch austauscht,
wenn ihr das nochmal hinterfragt, wenn beide dafür offen sind, das Ganze zu hinterfragen und
die Ideen in einen Topf zu schmeißen, dann können dadurch neue Lösungsansätze kreiert werden,
die langfristig viel Mehrwert stiften und in vielerlei Hinsicht zum Beispiel auch bessere
zu warten sind oder in Zukunft auch einfach besser zu erweitern sind. Ja, das ergibt auf
jeden Fall Sinn. Ich würde es dann immer so sagen, hört man ja auch ganz oft in der Realität,
der Fachbereich oder der Kunde weiß ja selber gar nicht, was er will. Das heißt,
da muss man ja so ein bisschen auch vielleicht mal einen Tipp geben. Mensch, hier so und so,
keine Ahnung, im UI mit so und so einem Control könnte man das machen. Oder hier,
mach doch das als Tabelle oder sonst irgendwas. Das ist ja dann auch unsere Expertise als Devs,
sage ich mal, um da so ein bisschen zu sagen, so könnte man das lösen. Und gemeinsam kommt man
dann zu einer guten fachlichen und technischen Lösung. Das funktioniert nicht, wenn ich es
alleine mache. Das stimmt. Absolut, absolut. Also mir ist auch viel lieber, da von Anfang an
erstmal über das Problem zu sprechen, anstatt sofort über die Lösung zu sprechen. Typischer
Fall ist ja, dass ich dann letztendlich schon mal ein Konzept präsentiere, was letztendlich die
Lösung darstellen kann. Aber eigentlich, und das wäre der erste Tipp an der Stelle in Sachen
Teamarbeit in der interdisziplinären Softwareentwicklung, einfach schon sehr früh anfangen,
darüber zu sprechen. Sprich Entwicklungsteam und Produktmanagement oder Fachbereich fangen sehr
früh an, über ein Problem oder eine Idee zu sprechen, noch bevor das erste Konzept steht.
Dabei kann schon viel Ideenaustausch stattfinden. Dafür kann schon viel Steuerung für das ganze
Produkt dann, was letztendlich entstehen soll, passieren. Ja, okay. Da sind wir quasi schon
mittendrin in dieser interdisziplinären Zusammenarbeit. Gibt es da, also damit das
alles funktioniert, gibt es da irgendwie, jetzt hast du schon gesagt, so einen ersten
Tipp oder so, dass das auch klappt? Also ich weiß zum Beispiel bei uns jetzt in der Firma,
wir sind jetzt über 300 Leute. Je nachdem, mit welchem Fachbereich man da arbeitet,
das klappt mal besser, mal schlechter. Gibt es da irgendwie so einen Tipp, dass das immer gut klappt?
Ja, ich glaube, also da muss erstmal eine entsprechende Kultur da sein. Also als einzelner
Entwickler, als einzelne Entwicklerin kann ich da sicherlich auch dazu beitragen, aber es muss
generell auf beiden Seiten einfach diese Bereitschaft geben, über die Lösung offen zu
sprechen. Wenn die da ist, dann kann vieles passieren, aber wenn die Bereitschaft nicht da
ist, dann kann ich vielleicht versuchen, darauf hinzuwirken. Da hängt allerdings dann auch viel
von der Unternehmens- und Teamkultur ab. Letzten Endes, wenn es zum Beispiel sehr
hierarchisch ist, dann kann das mir natürlich passieren als Entwickler, dass mir das Ganze
sozusagen diktiert wird und von mir erwartet wird, dass ich das eins zu eins so umsetze,
wie es im Konzept steht, was dann halt eben auch heißt, dass dann auch die Einschränkungen,
Schwierigkeiten, übermäßigen Herausforderungen und so weiter so umgesetzt werden. Aber ja,
es gibt da an der Stelle nicht den einen Tipp. Ich glaube, die Kultur muss stimmen und ja,
ich selbst kann natürlich schon auch dazu beitragen oder muss dazu beitragen durch meine
Haltung, durch meine Rhetorik, dass überhaupt erstmal so ein Milieu entstehen kann.
Okay. Jetzt meintest du gerade, das wird mir von oben vorgegeben und so weiter. Das
hört sich jetzt für mich so ein bisschen nach diesen klassischen Vorgehensmodellen an.
Wasserfall, da kommt ein Pflichtnerv auf den Tisch, dann wird das runterprogrammiert und
dann gibt man das ab und sieht das nie wieder. So nach dem Motto, ging das jetzt gerade in die
Richtung oder woher kennst du das oder was kann man dagegen tun?
Ja gut, ich habe tatsächlich noch nie im Wasserfallmodell gearbeitet, aber ich kann
mir sehr gut vorstellen, dass das in solchen, wenn man nach solchen Modellen arbeitet,
genau da dann auch passiert. Aber in gewisser Weise gibt es das auch im Scrum. Also ich kann
ja zwar im Scrum innerhalb des Entwicklungsteams schlecht ohne Teamarbeit arbeiten, aber tatsächlich
habe ich das schon öfters gesehen, dass dann quasi einem Scrum-Team dann ein Konzept präsentiert wird,
mit der Absicht, das genauso umsetzen zu lassen und da dann in der Schnittstelle Entwicklung und
Produkt sehr viel verloren geht an Potenzial, einfach durch so eine gewisse Starrheit. Das
kann natürlich vorkommen. Das ist auch mit Scrum oder anderen agilen Entwicklungsmodellen möglich.
Ja, das heißt so, wenn wir jetzt nach einer perfekten Lösung für all unsere Probleme suchen,
ist der Prozess schon mal keiner, weil es am Ende doch wieder auf die Menschen ankommt,
ist ja sogar Teil des AG-Manifests. Die Menschen sind immer wichtiger als der Prozess. Das heißt,
nur weil ich jetzt Scrum mache, habe ich jetzt nicht automatisch gute Teamarbeit, ja?
Ja, das würde ich so unterstreichen grundsätzlich, ja. Ich meine, Scrum an sich und die meisten
anderen oder eigentlich alle anderen agilen Methoden, die ich kenne, sind darauf ausgelegt,
im Team zu arbeiten. Also man muss sich schon aktiv dagegen wehren, wenn man das dann nicht möchte
und trotzdem in dem Prozess arbeitet. Aber nichtsdestotrotz gibt es auch schon auch ein
Mehr und ein Weniger von Teamarbeit innerhalb solcher Entwicklungsprozesse.
Aber würdest du dann zum Beispiel sagen, also jetzt Scrum ist ja so ein schönes Prüfungsthema,
kann man eben auswendig lernen. Da gibt es natürlich dieses Daily Scrum, wo man sich jeden
Tag zusammenstellt. Das ist ja schon, sage ich mal, in dem Prozess mit eingebaut, dass man sich
im Team da zumindest auch austauscht. Ich meine, man muss immer noch selber den Mund aufmachen,
aber ich habe jeden Tag eine Möglichkeit und werde sogar in Anführungszeichen gezwungen,
mit meinem Team zu reden, zu interagieren. Das ist ja schon ein erster Schritt in Richtung
Teamarbeit. Das würde also vielleicht die Zusammenarbeit ja etwas besser unterstützen,
als einfach nur, hier ist ein Pflichtenheft, implementiere das jetzt, oder?
Auf jeden Fall. Also auf jeden Fall so ein täglicher Austausch, ob man jetzt Scrum macht
oder nicht, so ein täglicher Austausch ist unfassbar wichtig. Ich würde nie mehr ohne
arbeiten. Aus meiner Sicht macht es keinen Sinn, ein Entwicklungsteam zu führen, ohne irgendeine
Form von täglichen Austausch zu etablieren. Und da ist das Daily, wie man es im Scrum macht,
aus meiner Sicht absolut geeignete Mittel dafür. Okay. Ja, wie kriege ich jetzt die Kurve? Wenn
wir im Daily, wenn wir das einfach so runterrattern, die üblichen drei Fragen,
was habe ich gemacht, was werde ich machen, wo sind meine Probleme? Also ist das jetzt schon
Teamarbeit? Oder also, wenn ich jetzt weiß, was meine Kollegen machen, ja, das ist ja schön. Also
was heißt eigentlich für dich gute Teamarbeit? Oder wie würde jetzt so ein Daily dabei helfen,
gute Teamarbeit zu machen? Was bedeutet das für dich?
Na ja, das Daily ist Kommunikation. Und Kommunikation ist einer der wichtigsten Teile
von Teamarbeit. Ohne Kommunikation keine Teamarbeit. Ich meine, klar, es bringt relativ wenig sich da
ins Daily reinzustellen und es über sich ergehen zu lassen. Aber wenn ich basierend auf der
Kommunikation dann letztendlich auch in die Interaktion gehe, dann kann dadurch auch sehr
viel Teamarbeit entstehen. Beispiel, jemand teilt mit, dass er am Morgen oder am gestrigen Abend
noch ein Feature fertiggestellt hat und das jetzt bereit ist, dann weiß ich, ich könnte mir jetzt
heute als erstes den Pull-Request anschauen. Vielleicht tauscht man sich noch kurz ein
bisschen zur Dringlichkeit aus, dass da schon jemand aus dem Fachbereich nachgefragt hat,
wie es denn aussieht. Ja, da ist vieles möglich, was da innerhalb von diesen fünf,
vielleicht zehn Minuten transportiert werden kann. Da können dann schon die Prioritäten für den Tag
abgesteckt werden und gerade für mich als Entwicklerin oder Entwickler ist es dann auch
sehr wertvoll, das Daily als Plattform zu nutzen, um aktiv Teamarbeit anzuberaumen. Zum Beispiel,
wenn ich an der Sache dran bin, die besonders komplex ist, bei der ich einfach nicht weiterkomme,
wenn ich eine blöde Fehlermeldung habe, bei der ich nicht weiterkomme oder wenn irgendjemand
anders sagt, dass er dringend Hilfe braucht oder an der Stelle vom Konzept gekommen ist,
wo er nochmal über die
für Architektur sprechen möchte, da ist vieles denkbar.
Also, das Daily an sich ist erstmal die Kommunikationsplattform,
aber das ist ganz einfach, die Kommunikation ist ganz einfach die Basis,
um letztendlich dann auch in die Interaktion der Teamarbeit zu kommen.
Okay, da höre ich jetzt nochmal eins raus, Kommunikation.
Ich bin jetzt fertig, jetzt kannst du weitermachen.
Also, schön, produktiv, Features umsetzen, fertig werden.
Und auf der anderen Seite habe ich aber gerade gehört, ich komme da nicht weiter, ich habe ein Problem.
Also, ich suche Hilfe, ich biete Hilfe an.
Das wären jetzt vielleicht so zwei Sachen, die Teamarbeit gut macht, glaube ich.
Also, wir werden gemeinsam schneller fertig und wir helfen uns auch untereinander.
Gibt es irgendwie noch was, was für dich zur Teamarbeit dazugehört oder sind das die wichtigen Sachen?
Oh, ne, da gibt es noch viel, viel mehr.
Also, für mich ist in der Softwareentwicklung quasi der gesamte Entstehungszyklus Teamarbeit.
Und wie ich vorhin schon gesagt habe, das geht bei der Produktidee los oder bei dem Benutzerproblem,
wie auch immer, was auch immer da initial im Raum steht.
Hier sollte aus meiner Sicht der erste Austausch zwischen Entwicklungsteam und Produktmanagement-Fachbereich stattfinden.
Was kann dabei passieren?
Also, erstmal dieser kreative Ideenaustausch, wie wir es vorhin schon gesagt haben.
Wie wir die Lösung gemeinsam erarbeiten und durch die verschiedenen Perspektiven einfach nochmal Annahmen hinterfragen
und letztendlich dadurch schon das Produkt aufwerten.
Aber es geht noch weiter.
Ich meine, wir haben dann auf der einen Seite die Perspektive von Produktmanagement- und Fachbereich.
Das ist einfach die Seite, die hier die Bedürfnisse seitens der Benutzerinnen und Benutzer vertritt.
Und wir haben auf der anderen Seite das Entwicklungsteam, die die technische Perspektive haben,
die den Code kennen, die Komplexität vor allem auch abschätzen können, die mit so einer Sache einhergeht.
Und wenn wir jetzt diese beiden Perspektiven zusammennehmen,
dann kann ich hier in der sehr frühen Phase schon sehr viel abschätzen.
Beispielsweise eben Komplexität oder aber auch technische Risiken.
Wenn ich das schon so früh weiß, dann kann ich das Ganze nutzen, um daraus wiederum Prioritäten abzuleiten.
Also wir machen das sehr regelmäßig, dass wir mit diesem Wissen von beiden Seiten
letzten Endes dann auch unser Product-Backlog priorisieren.
Weil ich natürlich, wenn ich auf der einen Seite weiß, ich habe hier ein Feature, das ist so,
ja, das stiftet so mittelmäßigen Mehrwert.
Also es gibt schon eine ausreichend große Zahl von Kundinnen und Kunden,
die ein Bedürfnis daran hätten, es zu benutzen, aber gleichzeitig stiffelt es extrem viel Komplexität.
Wir müssen vielleicht noch irgendein Refactoring erstmal umsetzen.
Wir brauchen möglicherweise neue Technologie im Sinne irgendeines Frameworks.
Dann habe ich hier eher eine ungünstige Gemengelage aus Bedürfnis und Komplexität, Schrägstrich Kosten.
Das sollte dann eher dazu führen, das Ganze nach unten zu priorisieren.
Also das wäre mal so ein Mehrwert, der durch Teamarbeit in der sehr frühen Phase
des Entstehungszyklus schon entstehen kann.
Wenn wir jetzt einen Schritt weiter gehen, wir haben ein Feature,
bei dem also Kosten und Nutzen in einem sehr guten Verhältnis stehen,
und wir entscheiden uns jetzt dafür, das Ganze in die Implementierung zu geben,
dann ist der typische Fall, dass dann das oft so im Team einfach verteilt und umgesetzt wird,
je nachdem, wie groß es ist, auf eine größere oder kleinere Anzahl von Entwicklerinnen und Entwicklern.
Was bei uns da passiert ist, dass wir dann erstmal gar nicht anfangen zu entwickeln,
sondern wir setzen uns hin, diskutieren tatsächlich auch da nochmal das Produktkonzept gemeinsam mit dem PM.
Lasst uns das auch nochmal vorstellen.
Alle im Team werden nochmal abgeholt, was wir jetzt eigentlich haben wollen.
Das ist ja auch sowas sehr typisches, was man im Scrum macht.
Und wenn dann alle dieses Produktkonzept verstanden haben,
dann ist der erste Schritt, dass wir gemeinsam das technische Konzept entwickeln.
Und das technische Konzept ist im Grunde die gesamte Arbeit im Sinne der Softwarearchitektur,
die für dieses Produkt, das geplant ist, notwendig ist.
Technisches Konzept klingt vielleicht erstmal so ein bisschen bürokratisch, ist aber eigentlich nicht.
Das ist letzten Endes irgendeine Form von Dokument, bei uns ganz oft OneNote,
da kann man schön zusammenarbeiten.
Und in diesem Dokument, das auch von seiner Aufbauung, von seiner Struktur her sehr frei ist,
da wird letztendlich alles an technischen Belangen festgehalten, die wichtig sind für dieses Projekt.
Und das geht fast immer los mit einer Diskussion über das Datenmodell.
Also, welche Datenbanktabellen brauchen wir?
Welche bestehenden Datenbanktabellen müssen wir erweitern?
Und wenn wir das schon mal wissen, dann ist die nächste Frage, was brauchen wir denn eigentlich für Datentypen?
Um den Datentyp von der Datenbankspalte festzulegen, muss ich mich früher oder später entscheiden,
wie lange soll die Datenbankspalte sein?
Da geht dann schon so Diskussion los, wo man dann ganz schnell merkt,
okay, wir haben eigentlich bisher nur einen Mockup, da ist das Feld einzeilig,
aber wir brauchen eigentlich 200 oder 300 Zeichen.
Wie kriegen wir das Ganze dann eigentlich in dem UI unter?
Und da wird dann schon wieder, das ist schon so die erste Prüfung für das ganze Konzept,
ist das realisierbar oder sollten wir da nochmal nachbessern?
Der Vorteil ist, wenn das jetzt schon diskutiert wird, dann ist das in einer sehr frühen Phase
und solche Nachbesserungen kosten quasi nichts.
Während dann, wenn das Ganze erst später auffällt, beim Test oder vielleicht sogar erst live,
dann wird es natürlich teuer, hier nachzubessern.
So, und außerdem gehören zum technischen Konzept dann noch eben andere Dinge,
zum Beispiel Prozesse oder technologische Belange.
Also auch hier wieder die Frage, habe ich alles einmal im Baukasten da, was ich brauche?
Sämtliche Bibliotheken, Frameworks, etc., pp.
Und ganz wichtig für mich, mit der wichtigste Teil im technischen Konzept,
wir legen alle Namen vorab fest.
Also Namen für Datenbanktabellen, für Spalten, die wir einbauen und so weiter.
Und da lassen wir tatsächlich sehr, sehr viel Mühe und Liebe reinfließen.
Nach meiner Erfahrung sind Namen einfach eines der besten Mittel,
um einer Software oder dem Code zur Software Komplexität zu entziehen.
Und diese Namen, die legt man am besten gemeinsam im Team fest.
Ein guter Name, der ist aussagekräftig und er grenzt sich gut von anderen bereits verstehenden Namen ab.
Das heißt, er ist möglichst unverwechselbar.
Aber aussagekräftig und unverwechselbar, das sind jetzt schon so ein paar schwammige Definitionen.
Das kann ich so oder so auslegen.
Das heißt, das Beste wäre, so ein Name wird nicht von einer Person festgelegt,
so wie es halt ganz häufig passiert während des Entwicklens,
sondern da schmeißen auch wieder alle ihre Perspektiven im Raum
und der eine weiß ganz genau, ja, der Name Voucher zum Beispiel,
der wird schon hier und da an der Stelle im Code verwendet.
Den sollten wir jetzt nicht nochmal verwenden, dann haben wir nämlich hier eine Verwechselbarkeit.
So, und diese Namen kommen auch alle ins technische Konzept, dann sind die einmal festgelegt,
die werden im ganzen Projekt wiederverwendet, das ist auch super komfortabel.
Jeder, der schon mal längere Zeit Software entwickelt hat, kennt diesen Struggle,
während des Entwicklens sich irgendeinen Namen ausdenken zu müssen und nicht so ganz sicher zu sein,
ist das jetzt richtig der Name für die Methode, für die Klasse und so weiter, versteht man das?
Diese Probleme haben wir überhaupt nicht, weil sowas steht bei uns im technischen Konzept.
Ja, das ist die zweite Stufe im Entstehungszyklus, die auch eben sehr Teamarbeit getrieben ist.
Die dritte Stufe, die kennen alle, das ist die klassische Implementierung.
Dort wird bei uns durchaus auch regelmäßig zusammengearbeitet, zum Beispiel in Form von Code Review.
Entschuldigung, nicht in Code Review, sondern in Peer Programming,
aber spätestens dann, danach im Code Review, da wird definitiv wieder zusammengearbeitet,
weil auch Code Review geht nicht ohne Teamarbeit.
Ja, und im Code Review, da wird bei uns auch munter durchgewechselt,
das heißt einmal macht sie, einmal macht er Review und dann wird das alles durcheinander getauscht,
also da kommt man auch überhaupt nicht dran vorbei, miteinander zu arbeiten
und schlussendlich nach dem Code Review kommt der Test und auch im Test wird sehr eng im Team zusammengearbeitet.
Jetzt sagt die oder der eine vielleicht, ja Moment, da gibt es doch bei uns im Team jemanden, der testet,
das muss er ja nicht selbst machen, das soll ja auch nicht so sein, dass Entwicklerinnen und Entwickler ihren eigenen Code testen,
was sie zwar hoffentlich mit Unit Tests tun, aber jetzt nicht der manuelle Regressionstest,
den macht hoffentlich jemand anderes, der nicht selbst entwickelt hat
und ja, das ist zwar grundsätzlich richtig, aber was aus meiner Sicht dabei sehr häufig vernachlässigt wird,
ist einfach auch hier an der Stelle die Kommunikation zwischen Entwicklungsteam und Qualitätssicherung.
Da muss eigentlich sehr viel an Informationen transportiert werden,
weil jemand aus der Qualitätssicherung relativ wenig darüber weiß, wie viel überhaupt an dem Code getestet wurde
und was durch die ganzen Änderungen möglicherweise noch mitgetestet werden muss,
aber als solches gar nicht am Konzept zu sehen ist.
Also ich habe es oft genug erlebt, dass bedingt durch Umstände im Code eigentlich mehr Funktionalität angepasst wurde
und damit eigentlich auch hätte getestet werden müssen,
letzten Endes diese Information aber nie im Qualitätssicherungsteam angekommen ist
und die Funktion dann halt leider auch nicht getestet wurde und im schlimmsten Fall dadurch dann ein Bug auf dem Produktivsystem entstanden ist.
Ja, also das war jetzt mal eine relativ lange Antwort auf eine Frage.
Um es halt zu schließen, ich würde sagen, dass Teamarbeit im gesamten Entstehungszyklus der Softwareentwicklung wichtig ist
und sehr viel Mehrwert stiften kann.
Also was ich jetzt gerade schon mal zwischendurch gehört habe, was ich sehr, sehr positiv finde,
dass ihr ein Datenmodell erstellt, ein Mock-up zeichnet, ein Glossar erstellt, hervorragend.
Das, was ich meinen eigenen Zuvies immer sage, dass man machen muss.
Schön, das auch nochmal von jemand anderem zu hören, dass das auch wirklich in der Realität gemacht wird.
Das Nummer eins, aber Nummer zwei, du hast jetzt wirklich ein bisschen länger erzählt,
wo ihr diese Teamarbeit und vor allem auch die Kommunikation überall in der Softwareentwicklung einsetzt
und wenn ich jetzt mal so ganz fies bin, ich bin ja so ein einheimischer Entwickler und ich will ja programmieren
und jetzt habe ich erstmal hier ein Meeting und da ein Meeting und hier muss ich noch im Glossar mitwirken
und so weiter. Wann wird denn da endlich mal gekodet, frage ich mich da.
Und das wird jetzt die Überleitung zur nächsten Frage und zwar, wenn ich darauf einfach keine Lust habe,
ich bin ja ganz fies, wie kann ich denn beitragen?
Also wie kann ich sicherstellen, dass alle im Team auch mitmachen?
Weil Teamarbeit, das kennt man ja vielleicht auch, so diese lustige Abkürzung,
toll, ein anderer macht's, da kann ich mich ja zurücklehnen.
Wie kriegt ihr das dann hin, dass man vielleicht auch in diesen, ich sag mal, langweiligen Phasen,
wo man gar nicht programmiert, trotzdem sich ja einbringen muss?
Gibt's da irgendwie Incentives, was kann man da machen?
Ja, da hat die Führungskraft bei uns eine sehr wichtige Funktion.
Also wir haben tatsächlich in allen Entwicklungsteams eine Führungskraft,
unterscheiden uns an der Stelle auch zu Scrum und manch anderen agilen Modellen,
aber tatsächlich würde ich das als eine der wichtigsten Aufgaben der Führungskraft bezeichnen
und das ist einfach die Pflege der Teamkultur.
Du hast ja gerade schon so ein schönes Beispiel angesprochen,
die Skepsis gegenüber Meetings, die kenne ich auch.
Und ja, da ist es einfach an der Führungskraft, darauf hinzuwirken,
zunächst mal ganz banal einfach den Wert von Besprechungen herauszustellen
und gleichzeitig aber auch eben dafür zu sorgen, dass Besprechungen Sinn machen
und daran nichts gerechtfertigt kritisiert werden kann,
weil es gibt natürlich Zustände in Besprechungen, die unhaltbar sind
und die entsprechend verhindert werden müssen
und gleichzeitig muss natürlich mit Meetings auf jeden Fall auch gespart werden.
Aber nichtsdestotrotz, die sind extrem wichtig
und meistens ist es eigentlich auch so, dass man dann nicht als einzelner Entwickler
oder Entwicklerin so ein Meeting hat, sondern dann eben das gesamte Team.
Das würde ich sagen, das trifft bei uns zu 80 Prozent, 90 Prozent zu,
dass sich das ganze Team trifft und dann letzten Endes ist jeder gefordert
und das ist auch wieder Aufgabe der Führungskraft,
dafür zu sorgen, dass sich da auch jeder mit einbringt.
Jeder gefordert daran auch teilzuhaben und entsprechend seinen Beitrag zu leisten.
Aber das geht, das geht sehr gut, wenn man da mal eine gewisse Teamkultur etabliert hat,
in der es eine Wertschätzung für solche Meetings gibt
und die tatsächlich dann auch effektiv Mehrwert stiften,
dann funktioniert das sehr gut.
Ich meine, das ist ja auch letzten Endes so,
dass man dann schon auch als Entwicklerinnen und Entwickler
Mehrwert daraus mitnehmen kann.
Wenn ich so eine Plattform habe in Form eines regelmäßigen Meetings,
in dem ich zum Beispiel rückfrage,
mit dem Produktmanagement- und Fachbereich diskutieren kann,
dann ist das ja erstmal im Alltag etwas Entlassendes.
Wenn ich jetzt hier während der Implementierung an einen Punkt komme,
wo ich sage, da bin ich mir jetzt nicht ganz sicher,
da weiß ich nicht, wie soll man das hier machen,
aber ich muss es jetzt auch nicht sofort wissen,
dann weiß ich, okay, da habe ich morgen ein Meeting,
da kann ich mich drauf verlassen, da kann ich das mit hinnehmen
und dann wird es da diskutiert.
Das hat ja auch etwas Entlassendes.
Und gleichzeitig kann es auch sogar etwas schon fast Euphorisierendes haben,
wenn man da mal im Team gemeinsam so eine harte Nuss geknackt hat,
weil es gibt gerade im Bereich der Softwarearchitektur
manchmal wirklich schwierige Herausforderungen,
bei der sehr kreative und gute Lösungen gefragt sind
und da können die Diskussionen auch manchmal richtig in Schwung kommen
und dann geht es hin und her,
aber am Ende steht dann oftmals eine Lösung,
an die vorher niemand gedacht hat
und die einfach nur durch dieses Gegenseitige hin und her,
sie hat eine Idee, stellt sie im Raum,
der Nächste sagt, ja, das kannst du aber nicht so machen,
aber wie wäre es, wenn wir den Teil aus deiner Idee nehmen
und das kombinieren mit der Klasse, die heute schon da ist
und da geht es manchmal, da wird es richtig,
man kann schon fast sagen wild,
natürlich aber auch auf eine gute Art und Weise
und letzten Endes bin ich immer wieder überrascht davon,
was da eigentlich an Lösungen manchmal dabei rauskommt
und das ist was, was wirklich auch einfach Spaß machen kann,
wenn man da rausgeht und sagt, damit hätte ich nicht gerechnet.
Das glaube ich sofort, das finde ich cool,
also auch das Ganze am Anfang schon mal irgendwo gesagt,
auch das Soziale beim Team,
man ist ja auch als Softwareentwickler nicht alleine auf der Welt,
man muss ja auch mit anderen Menschen zusammenarbeiten,
das kann auch Spaß machen
und wenn ich mich an unsere letzte Projekteinführung erinnere,
wo wir zu vier, fünf verteilt an unserem System saßen
und gespannt auf die Monitor gestarrt haben,
bis der erste Anmeldungsfall durchgelaufen war quasi,
das war schon ein cooles Gefühl auf jeden Fall, das macht Spaß
und das macht auch sicherlich mehr Spaß mit mehr Leuten,
als wenn man da alleine sitzt und sich freut,
also das kann ich auf jeden Fall mitgeben.
Jetzt würde ich noch mal einmal gern zurückgehen zur Führungskraft,
hast du jetzt gesagt, meinst du damit quasi die,
wie soll ich sagen, die Vorgesetzten der einzelnen Teammitglieder
oder braucht das Team an sich auch noch sowas wie ein Teamleiter,
ein Projektleiter passt vielleicht nicht so ganz,
aber irgendwie, wer ist dafür zuständig,
da dieses, was hattest du gesagt, diese Kultur zu pflegen?
Ja, bei uns ist es tatsächlich einfach in den Entwicklungsteams so,
dass es jeweils einen Teamleiter gibt,
das ist die fachliche Führungskraft
und die ist dann auch entsprechend dafür zuständig,
die Teamkultur zu pflegen,
aber ich würde das jetzt nicht verallgemeinernd
als Vorlage für alle nehmen,
sondern ich glaube, es ist immer stark von den Umständen abhängig,
das hat viel damit zu tun, welchen Erfahrungsschatz hat das ganze Team,
also sind da eher viel jüngere Entwicklerinnen und Entwickler,
wie sind die auch von ihrer Persönlichkeit her entwickelt,
neigen die alle eher zu Kooperation oder nicht
und ja, da gibt es mehrere Faktoren,
ich glaube, eine pauschale Lösung gibt es nicht,
es sollte aber auf jeden Fall jemanden geben,
der in irgendeiner Form für die Pflege der Teamkultur zuständig ist,
da gibt es auch andere Lösungen,
im Scrum würde das der Scrum Master machen,
das ist auch vollkommen okay,
wichtig ist nur, dass man das unbedingt im Blick behält,
weil davon vieles abhängig ist.
Okay, das ist mir jetzt spontan eingefallen,
aber das muss ich unbedingt unterbringen,
weil ein klassischer Prüfungsinhalt für AP1 der IT-Berufe ist,
dieses Phasenmodell der Teamentwicklung,
das kennst du vermutlich,
Storming, Forming, Norming, Performing und Joining,
ist das in der Realität wirklich so, hast du das festgestellt
oder ist das so ein Ding, was im Buch steht,
aber was eigentlich keine Praxisrelevanz hat?
Ja, das ist, da muss ich gestehen,
das ist so ein Ding, was ich mal im Buch gelesen habe
und ehrlich gesagt auch nur noch wahre Erinnerungen habe,
also es ist nicht so, dass für Führungsarbeit Theorie unwichtig wäre,
ganz im Gegenteil,
es ist sehr wichtig, dass man sich da regelmäßig auch im Führungsgreif
und auch darüber hinaus in Form von Weiterbildung,
externen Trainern und so weiter da auf dem Laufenden hält,
aber da dann doch gerne sehr praxisnah im direkten Austausch
mit erfahrenen Kolleginnen und Kollegen,
anstatt hier irgendwie die Theorie zu büffeln.
Aber wie ist das denn bei euch?
Wie wird das bei euch gelebt?
Ja, also das Ding kann man super auswendig lernen
und ich glaube, es ist auch wirklich so,
dass es diese Phasen durchlaufen werden,
aber jetzt kann man natürlich in dieser Phase,
muss die Projektleitung das und das machen,
damit das Team besser zusammenarbeitet in blauem Blubb
und ich glaube auch, dass es dann eher, sag ich mal, intuitiv ist,
wenn man vielleicht eine Führungskraft ist
oder auch ein Teamleiter oder manchmal,
also es braucht ja auch gar nicht momentan jedes Team explizit eine Teamleitung,
es ergibt sich ja auch einfach von alleine,
zum Beispiel, wenn man eher technisch unterwegs ist,
da macht es halt eher der Techniker,
bei, weiß ich nicht, Terminabstimmung macht es halt ein anderer,
also es kommt ja auch so,
das ergibt sich ja auch so ein bisschen natürlich, finde ich.
Und ja, ich glaube schon,
dass diese Phasen tatsächlich durchlaufen werden,
aber ob man sie jetzt so in der Detailtiefe jetzt auch kennen muss
und dann auch irgendwie deswegen in der Realität jetzt anders handelt,
ich glaube nicht.
Das ist dann, glaube ich, auch viel Intuition
oder einfach, dass das Mensch hier miteinander,
dass das automatisch passiert.
Ja, glaube ich absolut.
Also Intuition ist, glaube ich, das wichtige Stichwort.
Intuition in Verbindung mit Empathie
hilft da sehr, die täglichen Herausforderungen zu bewältigen,
die sich ja auch immer wieder wiederholen.
Also ganz typisch in so einem Entwicklungsteam
sind die jungen Entwicklerinnen und Entwickler,
um die man sich kümmern sollte
und die andere Form von Aufmerksamkeit brauchen
als solche, die erfahrener sind,
mehr Berufserfahrung haben,
aber auch einfach in der persönlichen Reife schon weiter sind.
Aber nichtsdestotrotz, innerhalb dessen gibt es bestimmte Muster,
die sich dann immer wiederholen
und in Verbindung mit Intuition und Empathie wert werden sollten.
Okay. Ja, wenn wir jetzt schon beim Thema sind, was vielleicht auch schieflaufen kann in beider Teamarbeit, also die Herausforderung haben wahrscheinlich viele Unternehmen, ich meine, wir sind hier gerade in einem Ausbildungspodcast, also wie kriegen wir die jungen Leute da integriert? Müssen wir ja irgendwo mal mit ins Team reinholen. Aber wenn du jetzt sagst, so eine Art worst practice ist, lass die Junior mal ihr Ding da machen, wir helfen denen nicht, sag ich mal so, gibt's sonst da irgendwie was, was vielleicht in der Praxis nicht so gut läuft im Team, wo du mal was gesehen hast, so, oh, das sollte man besser nicht machen?
Ja, da gibt's sicherlich mehrere Aspekte. Zuallererst mal natürlich einfach ein klassisches Hierarchie-Denken, das ja schon in manchen Unternehmenskulturen ziemlich stark verankert ist, gerade wenn jetzt Softwareentwicklung nicht das Kerngeschäft ist, aber einfach als Inhouse-Abteilung existiert.
Dann gibt's bei vielen etablierten Unternehmen eher so eine hierarchisch orientierte Unternehmenskultur und dann kommen auf einmal die Entwicklerinnen und Entwickler und fangen da an mit Scrum und wir sind jetzt alle gleich und so weiter, das kann dann, da können dann schon Welten aufeinander stoßen und das kann dann auch daran scheitern.
Darüber hinaus, was dann sicherlich auch noch schwierig ist, woran das Ganze scheitern kann, ist einfach eine gewisse Introvertiertheit einzelner Teammitglieder. Das ist ja gerade in der Informatik nicht so selten und da ist es dann auf jeden Fall auch wieder an der Führungskraft dafür zu sorgen, dass solche Kolleginnen und Kollegen sich jetzt nicht aus einer gewissen sozialen Angst heraus zurückziehen.
Und dann nicht mehr so am Team partizipieren, wie sie können. Ja, und dazu gibt es dann auch das Gegenteil. Besonders extrovertierte Menschen, die vielleicht zu einer gewissen Egozentrik neigen, auch das ist sehr schädlich, genauso wie auch einfach ein Mangel an Diversität in einem Team sehr schädlich ist.
Also ich bin da ein großer Freund von bunt durchgewürfelt hinsichtlich Alter, Geschlecht, Erfahrungsschatz, vielleicht auch ein bisschen unterschiedliche Berufslaufbahnen. Das kann schon, finde ich, sehr förderlich sein, letzten Endes auch für die Teamarbeit. Ja, das sind die Aspekte, die mir da so in Hinblick auf Anti-Patterns in der Teamarbeit einfallen.
Sehr schön, ja. Pattern, Anti-Pattern, da muss es in einem IT-Podcast auch immer fallen. Aber das bringt mir jetzt ein gutes Stichwort, was du sagtest. So die Introvertiertheit kann ich mir, das ist tatsächlich, glaube ich, wenigstens bei IT-Leuten etwas verbreiteter. Jetzt hast du gesagt, da kann eine Führungskraft irgendwie eingreifen, unterstützen, encouragen, weiß auch immer, wie man das nennt. Aber wenn ich jetzt überlege, ich bin jetzt so ein introvertierter Entwickler und meine Führungskraft sagt, das sind jetzt die völligen Klischees, jetzt komm doch mal aus dir raus, jetzt sag du doch auch mal was.
Da würde ich sagen, ja, vielen Dank, dadurch wird es jetzt nicht unbedingt besser. Kann ich denn selber irgendwie was machen, damit das besser klappt, damit ich besser teamfähig werde oder was kann ich tun?
Ja, man selbst kann sich da auf jeden Fall weiterentwickeln. Also Persönlichkeitsentwicklung tut jedem gut. Da gibt es tolle Bücher für sowas. Ich selbst würde sagen, ich war mal sehr introvertiert und habe auch irgendwann festgestellt, einfach, ich möchte davon weg. Also ich möchte mich da weiterentwickeln. Ich glaube, es würde gut tun, wenn ich da mehr aus mir rauskomme.
Aber nichtsdestotrotz ist eine Führungskraft, die das Ganze fördert, sehr, sehr wichtig, würde ich sagen, beziehungsweise die kann da eine sehr wichtige Rolle einnehmen und durch entsprechendes Empowerment jemanden nach vorne bringen.
Also ich pflege da sehr häufig dann einfach monatliche Eins-zu-Eins-Gespräche, Vier-Augen-Gespräche, in denen dann auch sowas einfach nochmal besprochen wird. Das einfach mal kurz zu erklären, was ist überhaupt dein Beitrag in so einer Besprechung, wenn es jetzt um eine Architekturdiskussion geht und habe keine Angst davor, dass du sowas noch nie gemacht hast, habe keine Angst davor, dass du vielleicht abgelehnt wirst.
Also die Person natürlich sowieso darf auf keinen Fall abgelehnt werden, aber dass die Idee dieser Person möglicherweise abgelehnt wird, also da dann einfach mal so das Ganze ein Stück weit vorweg nehmen. Das führt in der Praxis zwar oft, nur nicht sofort dazu, dass die Person dann in der nächsten Besprechung sofort reindonnert, aber so Stück für Stück und regelmäßige Ermutigung kann man sich da auf jeden Fall hinbewegen.
Da habe ich sehr gute Erfahrungen damit gemacht und dann ist es eben wichtig, wenn es das erste Mal passiert ist, dass man das dann auch im nächsten Monatsgespräch wieder hervorhebt und sagt, das fand ich super, dass du da deinen Beitrag gebracht hast und sehr wichtig ist dann in dem Fall, nehmen wir an, das war jetzt irgendwie die Idee für ein Datenmodell, die hat sich dann aber doch in der Diskussion noch nicht als 100% adäquat herausgestellt.
Dann gehe ich wirklich als Führungskraft hin und schreibe mir das Ganze auf und nehme das ins nächste Monatsgespräch mit und sage, ey, ich fand das super, dass du die Idee gebracht hast. Die hat, auch wenn wir das letztendlich so nicht umgesetzt haben, einen Mehrwert gestiftet, die hat von den anderen nochmal die Gedanken gelenkt, die hat die anderen nochmal zu neuen Gedanken angeregt und deine Idee, die hat definitiv auch einen Beitrag dazu geleistet, dass wir am Ende eine gute Lösung gefunden haben.
Und sowas wirkt, sowas wirkt definitiv, kann ich aus mehrfacher Erfahrung sagen. Also die Führungskraft kann einen sehr großen Einfluss darauf haben, dass sich solche Leute entwickeln. Ich habe noch keinen, ich habe wirklich jetzt noch nie jemanden erlebt, der da dauerhaft sich irgendwo hinter der Mauer versteckt hätte.
Okay. Hört sich dann andersherum vielleicht auch so an, wenn ich jetzt eine nicht so tolle Führungskraft habe, die das alles nicht macht und der das auf deutsch gesagt, egal ist, was ich da tue, dann kann so eine Führungskraft verschränkt das Team auch ein bisschen runterziehen, richtig?
Auf jeden Fall. Also da gibt es das mal als eines, als eine Ursache, um ein Team runterzuziehen, aber ja, da gibt es sicherlich noch mehr Möglichkeiten, um die Teamarbeit letzten Endes zu behindern.
Wichtig ist einfach überhaupt schon mal seitens der Führungskraft diese Wertschätzung von Teamarbeit, die Empathie auch für die einzelnen Aspekte, woran das Ganze scheitern oder auch sich entwickeln kann. Und ja, der Einfluss von der Führungskraft, der ist an der Stelle sehr sehr hoch. Es gibt viele Dinge, die es behindern können, aber es gibt auch viele Aspekte, die das Ganze fördern können.
Einen habe ich gerade schon genannt. Es gibt noch weitere Situationen, wenn beispielsweise mal ein Konflikt entsteht in so einem Team, dann ist das auch sehr gefährlich, was langfristig, wenn so ein Konflikt maßig festfährt oder gar eskaliert, hohen Einfluss haben kann auf die ganze Teamkultur und die Teamarbeit.
Da wäre es dann zum Beispiel wiederum an der Führungskraft, frühzeitig einzugreifen, das Ganze einzufangen. Wenn die Führungskraft aber sagt, lass mich in Ruhe mit dem kleinen Mist. Ich habe genug Probleme im Alltag, dann kann das sehr gefährlich werden und sich dann auch hinten raus zu einem großen Problem entwickeln.
Okay, jetzt hört man ganz oft immer, wir brauchen eine vernünftige Fehlerkultur im Unternehmen. Würdest du sagen, sowas trägt dann auch zur Teamarbeit bei? Wenn ich jetzt überlege, ich bin so ein eher zurückhaltender Mensch, habe vielleicht ein bisschen Angst, dass meine Idee auseinandergenommen wird oder dass es eine schlechte Idee ist oder wie du gerade sagst, das Datenmodell war doch noch nicht so ganz perfekt und dann fühle ich mich schlecht und so. Wenn eine Führungskraft auch noch dafür sorgt, dass man, sage ich mal, Fehler machen darf, würde das auch unterstützen?
Auf jeden Fall. Die Fehlerkultur zu bilden und zu steuern ist auch Aufgabe der Führungskraft. Man muss da immer ein bisschen unterscheiden, was ist dann tatsächlich auch ein Fehler. Das habe ich auch schon gesehen, dass dann oft halt, umgangssprachlich ausgedrückt, Schlutrigkeit oder Nachlässigkeit, Mangel der Disziplinen letzten Endes einfach als ein Fehler, der halt passiert ist, deklariert wurde und da muss man ganz klar unterscheiden.
Der springende Punkt ist an der Stelle, wurden da alle Informationen zum Zeitpunkt, zu dem der Fehler gemacht wurde, berücksichtigt oder hätte man es besser wissen können? Wenn man es nicht hätte besser wissen können, dann ist der Fehler einfach passiert. Dann muss man im Rahmen der Fehlerkultur sagen, so ist es einfach, das kann immer mal passieren. Kein Problem, wir lernen draus und entwickeln uns weiter.
Wenn der Fehler passiert, ist es aus einem Mangel an Disziplin. Wir, das habe ich in der ersten Folge schon vor drei Jahren tatsächlich erzählt, wir arbeiten ja ganz gern mit Checklisten und eine der wichtigsten Checklisten ist bei uns die Commit-Checkliste. Das sind so fünf, sechs Punkte, die man abarbeiten muss vor einem Commit.
Diese Commit-Checkliste zu vernachlässigen, das ist kein Fehler. Das ist Schlutrigkeit, das ist Mangel der Disziplinen und da gehört es dann dazu, darauf hinzuwirken, dass die Disziplin gelebt wird und das Ganze nicht im Kleid eines Fehlers, der eigentlich keiner ist, verkauft wird.
Thema Fehlerkultur ist es wichtig hinzuschauen, was der Ursprung dessen war und daraus dann letztendlich abzuleiten, wie darauf reagiert wird.
Ja, das finde ich gut. Das erinnert mich jetzt wieder an so den, ich glaube es kommt aus Clean Code hier, die Ärzte waschen sich ja auch immer die Hände vor der OP. Da kann ein Arzt auch nicht sagen, ach, wie habe ich vergessen, ist ein Fehler, Schwamm drüber.
Also eine gewisse Basisqualität irgendwie muss man schon an den Tag legen und kann sich nicht damit rausreden am Ende. Das finde ich auch gut. Aber zumindest, wenn man zum Beispiel was ausprobiert, was es noch nicht gab und man weiß nicht, ob es funktioniert und es hat nicht geklappt, ja gut, dann ist das halt so.
Aber klar, so die Basics unseres Berufs, glaube ich, die sollte man auf jeden Fall immer einhalten. Das bringt mich aber gleich zur nächsten Frage, denn Leute, die das vielleicht noch nicht so gut können, sind ja so, sage ich mal, die Junior-Leute, die hattest du vorhin auch schon angesprochen, die müssen ja auch irgendwie mit im Team integriert werden.
Gibt es da eine besondere Herangehensweise oder schmeißt man die einfach mit rein und sagt hier, mach mal oder nimmt man die an die Hand? Hast du da irgendwie eine Best Practice?
Ich würde einfach die beiden Punkte, die du gerade genannt hast, miteinander kombinieren. Also ja, reinschmeißen und dabei an die Hand nehmen. Ich finde es ganz wichtig, wenn jemand neu im Team ist, ist es egal, ob jetzt Azubi oder Junior, dann einfach von Anfang an an allen Prozessen teilhaben lassen.
Wir sind ja auch so, dass wir versuchen, niemals so irgendwelche Demo-Projekte zur Einarbeitung zu machen, sondern wir sammeln ganz bewusst Features und Issues, die von der Person, die noch nicht so viel Erfahrung hat, angegangen werden kann, aber das Ganze dann schon im Rahmen unserer üblichen Prozesse.
Das heißt, die Person ist von Anfang an bei Produktentstehungsdiskussionen dabei, die ist von Anfang an bei der Entstehung des technischen Konzepts dabei, die macht von Anfang an Code Review, die schreibt von Anfang an Unit Tests und die schreibt Code von Anfang an.
Also alles ab Tag 1 möglichst mitmachen und dabei aber jederzeit Support geben. Bei uns gilt die Devise, du kannst zu jedem Zeitpunkt jeden im Team fragen und das wird auch gelebt. Das heißt, wenn du im Büro bist und ein Problem hast, dann drehst du dich um und fragst jemanden am Schreibtisch neben dir und dir wird geholfen, da kannst du dich drauf verlassen.
Und das wäre letztendlich auch meine angestrebte Art und Weise, um jemanden da heranzuführen. Das Ganze halt begleitet auch wieder vor allem durch regelmäßige Feedback-Gespräche, in dem dann bestimmte Situationen nochmal aufgegriffen werden und dann auch das Ganze nochmal genutzt wird zur Motivation und vor allem, das finde ich immer sehr wichtig, dort dann auch viel loben.
Also aus meiner Erfahrung heraus und da bin ich sicherlich nicht alleine, kann ich sagen, das, was man besonders hervorhebt und lobt, das kommt dann auch nochmal mehrfach zurück. Das ist ganz einfach eine Formel, einfach das, was man noch mehr haben will, muss man loben und dann bekommt man es auch noch mehr.
Das ist wie bei Hunden. Wenn die was gut machen, Futter rein, dann machen sie es nochmal. Das ist gut.
Aber dann kann ich ja, ich sag mal so, ich hänge nicht die ganze Zeit an meinem Kollegen, der mir das zeigen muss, sondern ich kann auch schon mal ein bisschen selber was machen und dadurch, ja, wie soll ich sagen, kriege ich ja auch vielleicht schon mal so eine erste Motivation, hey, ich kann ja auch einen Teil schon mal alleine machen und kann schon was beisteuern zum Team wahrscheinlich, auch als Junior.
Definitiv. Also die Checklisten, du hast es gerade gesagt, die unterstützen da sehr. Neben der Commit-Checkliste gibt es dann beispielsweise bei uns noch die Code-Review-Checkliste. Die ist sogar ziemlich lang und ermöglicht es gerade Kolleginnen und Kollegen, die sehr neu im Team sind, da einfach mal so Stück für Stück das Ganze durchzuarbeiten.
Klar ist es dann, wenn jemand jetzt wirklich ganz neu und unerfahren ist, so dass danach noch ein zweites Code-Review stattfindet, weil bei so einem Review können dann natürlich Fehler passieren, aber da kann man ja dann wieder davon lernen und darüber hinaus ist es natürlich ohnehin wichtig in der Softwareentwicklung, wenn man solche komplexen Softwareprodukte entwickelt wie wir, dass man da eine gute, leistungsfähige Dokumentation schreibt.
Nicht nur für die jungen Kolleginnen und Kollegen im Team, aber es ist doch für sie sehr nützlich, sich diese Dokumentation dann am Anfang zu nehmen und damit auch einzuarbeiten. Also klar, das ist, das bedingt das eine, das bedingt das andere. Also Checklisten und auch Dokumentation helfen da ganz besonders am Anfang.
Ja, jetzt bin ich, es werden jetzt an mehreren Stellen verschiedene Klischees der üblichen Altila zurückhaltend introvertiert, wollen nur coden, keine Meetings etc. Jetzt bin ich so ein Typ und habe einfach keinen Bock auf Teamarbeit und will jetzt einfach nur vor mich hin coden. Hat das irgendwelche Konsequenzen? Also ist es eigentlich schlimm, wenn ich keine Teamarbeit mache? Also hat das irgendeine Folge oder sagen wir, ja, machst du halt nicht mit dem Team?
Also in meinem Team hätte das auf jeden Fall eine Folge. Das kann ich ganz sicher sagen. Aber ich habe noch nie jemanden gesehen, der sich da ernst dagegen gewehrt hat. Also ich habe schon Leute gesehen, die da eine gewisse, naja, vorsichtig ausgedrückt, Furcht davor hatten. Und da bin ich dann vorgegangen, wie ich es vorhin schon geschildert hatte.
Aber ich habe wirklich noch nie jemanden gesehen, der da langfristig sich dagegen gewährt hätte. Und aus meiner Sicht würde es dann auch keinen Sinn machen, da langfristig zusammenzuarbeiten, sondern das wäre wahrscheinlich dann besser, nicht in einem Team bzw. in einem gemeinsamen Unternehmen zu bleiben.
Weil aus meiner Sicht macht Softwareentwicklung ohne Teamarbeit an komplexen Softwareprodukten keinen Sinn. Man wird sich dadurch viele, viele Wettbewerbsvorteile entgehen lassen.
Okay. Aber ich habe gelernt, es gibt so 10x Developer. Die sind zehnmal so gut wie andere Entwickler. Die können ein ganzes Team quasi ersetzen und programmieren das einfach alleine runter. Gibt es sowas nicht?
Ist das so? Nein, ganz ehrlich. Also ein 10x Developer weiß ich nicht, ob es sowas tatsächlich gibt. Das ist wahrscheinlich eher so ein Label, das sich irgendwann mal jemand ausgedacht hat.
Aber natürlich gibt es Kollegen mit mehr Erfahrung und mit weniger Erfahrung. Das ist ganz unterschiedlich und auch ganz normal. Aber nur weil jemand viel Erfahrung hat, heißt das nicht, dass er nicht mit einem Entwicklungsteam noch besser seine Erfahrungen und all sein Wissen auf die Straße bringen könnte.
Im Gegenteil. Ich bin tief überzeugt davon, dass er erst dann im Team das Ganze zu 100% auf die Straße bringen kann. Weil auch jemand, der viel Erfahrung hat, kennt ja zum Beispiel noch nicht die ganze Software.
Gerade wenn er erst neu ins Team kommt, kennt noch nicht die ganze Software, kennt noch nicht die Namen, die da alle verwendet wurden und gleichzeitig nicht so gut die Kundenbedürfnisse.
Da bedingt so viel einander, was erst durch Teamarbeit letztendlich zum Tragen kommt, kann mir wirklich niemand erzählen, dass es Menschen gibt, die auf Teamarbeit verzichten könnten, nur weil sie besonders viel Berufserfahrung hat. Das würde ich definitiv abstreiten.
Ja, finde ich gut. Ich finde auch die Idee gut, dass man sich ja dann durch seine mehr Erfahrung noch wieder ins Team einbringt und die Teammitglieder dadurch ja wahrscheinlich auch wachsen und man dann so eine Art Multiplikator wird und das Team als Ganzes noch viel mehr schafft. So kann man es ja auch sehr positiv sehen, wenn man jetzt so jemand ist, der denkt, oh, ich bin hier der Beste. Warum soll ich den anderen das alles beibringen? Aber dadurch wird das Unternehmen insgesamt ja auch erfolgreicher und wir können ein noch besseres Produkt machen. Ja, eigentlich ziemlich cool.
Definitiv. Kann ich so nur unterstreichen. Und es kann ja auch eine tolle Erfahrung sein, da dann diese Berufserfahrung, die man schon gesammelt hat, an andere Kolleginnen und Kollegen weiterzugeben. Also das sollte man sich aus meiner Sicht auch nicht entgehen lassen, weil das ist ja schon auch ein schönes Erfolgserlebnis, wenn man sieht, dass sich da jemand mit einem mitentwickelt und das vielleicht sogar mal äußert. Kann ich jedem nur raten, dann auch entsprechendes Feedback zu geben und man selbst dann einfach sieht, okay, ich kann da auch so in dieser Hinsicht sogar noch mehr werden.
Ach, das wäre doch was. Also wenn das nicht hier der perfekte Schlusssatz wäre, weil wir haben ja auch ein paar Ausbilder und Ausbilderinnen, die hier zuhören. Die machen ja genau das den ganzen Tag. Das finde ich eine super Sache. Ich habe tatsächlich auf meinem Fragenkatalog zum Thema Teamarbeit alles mehr oder weniger abgehakt. Aber haben wir aus deiner Sicht noch was vergessen, was du gerne nochmal ansprechen möchtest? Dann Feuer frei.
Ergänzen würde ich direkt nichts, weil ich glaube, wir haben das ganze Thema schon jetzt sehr tiefgehend diskutiert. Abschließend würde ich einfach nochmal einerseits alle Entwicklerinnen und Entwickler ermutigen wollen, wirklich aktiv an Teamarbeit zu partizipieren, das sehr ernst zu nehmen und letztendlich daran und mit dem Team zu wachsen.
Und gleichzeitig möchte ich auch alle Unternehmen und das ist wahrscheinlich fast noch wichtiger, alle Unternehmen dazu motivieren ein großes Augenmerk auf die Teamarbeit in ihrer Softwareentwicklung und allen Schnittstellen rund um die Softwareentwicklung zu legen, weil darin liegt ein echter Wettbewerbsvorteil, den sich niemand entgehen lassen sollte.
Ja, das ist ein sehr schönes Schlusswort, finde ich gut. Wir haben es mehrfach gehört. Teamarbeit ist auch eine schöne Möglichkeit, selbst zu lernen und vielleicht auch von dem, was man selbst gelernt hat, wieder was zurückzugeben. Also ich finde es eine tolle Sache, hat mir sehr viel Spaß gemacht, habe heute viel mitgenommen, habe auch die ganze überlegt, wie ist das bei mir, wo finde ich meine Kollegen und mich vor allem auch selber wieder und so. Also sehr, sehr spannend. Vielen, vielen Dank. Und man kriegt auf jeden Fall mit, du hast da schon einiges gemacht in verschiedenen Teams und offensichtlich auch in verschiedenen Phasen des Entwicklungsprozesses.
Von daher sollte jetzt jemand dringend mit dir Kontakt aufnehmen wollen und dich mal ein bisschen fragen wollen zu dem Thema. Kann man dich irgendwo erreichen? Findet man dich online? Möchtest du kontaktiert werden? Wenn ja, dann kannst du gerne sagen, wo.
Ja, sehr gerne, darf man Kontakt zu mir aufnehmen und das dann am liebsten über LinkedIn. Wir haben ja wahrscheinlich die Möglichkeit, das Profil unten drunter.
Zu verlinken?
Auf jeden Fall, das machen wir.
Sehr schön, packe ich auf jeden Fall alles in die Shownotes.
Dann, Christian, vielen, vielen Dank, dass du heute zum ersten Mal mein zweiter Gast
oder der erste Gast, wie auch immer, auf jeden Fall schon mal wieder da warst.
Wir hatten zwei sehr, sehr spannende Themen.
Heute auch nochmal die Teamarbeit.
Eine schöne Ergänzung zu unserer Softwarequalität vom letzten Mal.
Vielen, vielen Dank, dass du dir die Zeit genommen hast.
Und ja, vielleicht sehen wir uns ja doch ein drittes Mal in drei Jahren.
Wer weiß?
Würde mich freuen.
Eine weitere Premiere dann mit dem dritten Mal.
Aber schon beim zweiten Mal hat es sehr viel Spaß gemacht.
Vielen Dank dir, Stefan.
Alles klar.
Tschüss.
Ciao.
So, das war unser zweites Interview im IT-Berufe-Podcast.
Ich sage nochmal vielen Dank in Richtung Christian.
Hat mir wirklich sehr viel Spaß gemacht.
Und ich habe auch nochmal drüber nachgedacht, was Teamarbeit eigentlich so heißt, weil
das für viele einfach so selbstverständlich ist.
Ja klar, im Teamarbeiten, nee.
Aber es ist doch wohl nicht.
Und ja, sehr, sehr spannend heute.
Ich fand es super.
Wenn du es auch super fandest, dann lass uns doch einen Kommentar da unter der Episode.
Die Shownotes, ich wiederhole es nochmal, itberufepodcast.de slash 188.
Da kannst du uns gerne schreiben.
Oder wie Christian gerade sagte, bei LinkedIn.
Ich bin übrigens auch bei LinkedIn und bei Instagram und bei X.
Also früher mal Twitter und Facebook sogar.
Und also du findest mich auch überall.
Und den Christian präferiert, wie gerade gehört, über LinkedIn erreichen.
Schreibe uns gerne.
Wir würden uns über dein Feedback freuen.
Wenn du anderer Meinung bist oder andere Erfahrungen hast, teile das auch gerne mit uns.
Dann geht es ja hier, dass wir voneinander lernen.
Ja, ich denke, das ist so eine All-Time-Favorite-Episode, die man einfach immer auch zum Einstieg in
die Ausbildung sich schon anhören kann, glaube ich.
Um nochmal die Überleitung zu schaffen zu meinem Newsletter.
Dann da werde ich die Episode auf jeden Fall auch empfehlen.
Und zwar schon im ersten Ausbildungsjahr.
Wenn du nicht weißt, wovon ich rede, unter itberufepodcast.de slash Newsletter kannst du
dich kostenlos anmelden.
Und da gibt es eine Ausbildungsbegleitung von mir durch die drei Jahre der Ausbildung.
Und in den ersten Jahren, im ersten Jahr sind ja nur drei, gibt es dann so Grundlagensachen.
Und da werde ich sicherlich diese Episode dann quasi immer wieder empfehlen.
Weil ja, Teamarbeit ist für uns wichtig.
Und zwar schon ab dem ersten Ausbildungsjahr.
Denn, ich sage es meinen eigenen Zubis auch, ich habe es im Interview gesagt, man kann alleine
heute nichts mehr erreichen.
Und ich beziehe das auch gar nicht nur auf die Softwareentwicklung, sondern auch insgesamt
auf die Arbeit in der IT.
Diese One-Man-Show, das funktioniert einfach nicht.
Das heißt, Teamarbeit ist wichtig.
Und ich fand die Episode entsprechend passend heute dazu.
Sehr, sehr schöne Inhalte.
Ja, ich glaube, ich wiederhole mich langsam.
Deswegen machen wir mal Feierabend für heute.
Ich hoffe, dir hat es auch gefallen.
Ansonsten schreibe uns bitte.
Und ich danke dir fürs Zuhören.
Wir hören uns beim nächsten Mal.
Tschüss!









Neueste Kommentare