Wer als Junior-Entwickler:in in die Berufswelt einsteigt, hat in aller Regel bereits fundierte Kenntnisse in mindestens einer Programmiersprache und bereits kleinere Projekte (oft zu Übungszwecken) absolviert. Um gute Senior- oder gar Lead-Developer zu werden, müssen Entwickler:innen nun aber weitere Fähigkeiten erwerben, die oft ganz anders geartet sind, als die ursprünglich erworbenen Programmierkenntnisse. Zunächst kommen Fähigkeiten hinzu, sauberen, wartbaren und aufgeräumten Code zu schreiben, Projekte zu analysieren und Schwachstellen zu verbessern. Von Senior-Entwickler:innen werden Kompetenzen im Bereich der Softwarearchitektur verlangt und Lead-Developer müssen insbesondere über kommunikative und Führungskompetenzen verfügen.

Die Anforderungen an die verschiedenen Karrierestufen unterscheiden sich teilweise grundlegend. So sollen Seniorentwickler:innen plötzlich über Kompetenzen in der Softwarearchitektur verfügen, ohne dass dies zuvor bereits zu ihren Aufgaben gehörte. Es ist ein Irrglaube, diese Fähigkeiten entwickelten sich einfach als Ergebnis mehrjähriger Erfahrung. Sie müssen vielmehr explizit erworben werden. In manchen Unternehmen gibt es spezielle Mentoringprogramme für junge Softwareentwickler:innen. Aber nicht jedes Unternehmen kann entsprechende Ressourcen aufbringen. Außerdem verfügt nicht jeder Senior-Kollege und Mentor über entsprechende didaktische Erfahrung und Freude an der Weitergabe seines Wissens.

Viele Kompetenzen, die den Unterschied markieren zwischen Einsteiger:innen in die professionelle Softwareentwicklung und gestandenen Seniorentwickler:innen, beziehen sich nicht auf eine konkrete Technik oder bestimmte Programmiersprache, sondern auf Fragen des Softwaredesigns, der Architektur und des methodischen Vorgehens. Domain Driven Design, Test-Driven Development und Modularisierung lassen sich in ganz verschiedenen Sprachen erreichen (und eben auch verfehlen). Gerade diese Kompetenzen kommen in der Weiterbildung leider oft zu kurz – zumindest insofern sich Entwickler:innen nicht selbst in Meet-Ups und Selbststudium damit beschäftigen oder durch Glück an einen versierten Mentor oder eine versierte Mentorin geraten.

Gerade mittelständische Unternehmen haben im Wettbewerb um qualifizierte Softwareentwickler oft das Nachsehen gegenüber den großen Unternehmen wie Amazon, Google oder Otto, die nicht nur mit hoher Bezahlung, sondern auch mit einem hochprofessionellen Umfeld und begeisternden Aufgaben punkten können. Die Herausforderung an das Recruiting ist nicht nur, Softwareentwickler:innen zu finden, sondern gerade auch, solche Entwickler:innen zu finden, die entsprechende Kompetenzen und Erfahrungen mitbringen, um Projekte erfolgreich zu meistern. Gerade in Sprachen wie PHP oder JavaScript (und generell in der Web-Entwicklung) verfügen viele Softwareentwickler:innen nicht über die Fähigkeiten und Erfahrungen, um komplexe Herausforderungen zu meistern.

Heutzutage sind viele Entwickler:innen keine ausgebildeten Informatiker, sondern kommen aus verschiedenen anderen Fachrichtungen und Berufen. Diese Menschen haben sich das Coden selbst beigebracht oder entsprechende Fortbildungen und Workshops (Boot-Camps) besucht, die ihnen die Grundlagen ihrer Tätigkeit beibrachten. Data Scientists und Business Analysts haben oft einen akademischen Hintergrund in Mathematik oder Wirtschaftswissenschaften und gießen ihre Fachexpertise in Software, ohne zuvor im eigentlichen Sinne Softwareentwicklung gelernt zu haben. Quereinsteiger bringen eigene Perspektiven und Fähigkeiten ein und bereichern Unternehmen damit um etwas, was mit homogeneren Teams nicht zu erreichen wäre. Mehr als andere sind sie dafür auf ein Training on the Job angewiesen. Während ihre Kollegen mit Informatikausbildung bereits von Design Patterns und hexagonaler Architektur gehört haben, müssen sie auch diese Konzepte nachträglich erlernen, um zu seniorigen Entwicklerinnen und Entwicklern zu werden.

Was es braucht

Was meines Erachtens benötigt wird, ist eine systematische Fortbildung von Entwickler:innen in den allgemeinen Kompetenzen der Softwareentwicklung. Und genau daran mangelt es noch immer: Es fehlt eine Fortbildungskultur in der deutschen IT-Landschaft, wie kürzlich Rainer Grimm nochmal völlig zurecht beklagte (Mangel an Fortbildung: Warum die Kulturlosen keine Chance haben). Es reicht nicht, mal ein einzelnes Seminar zum Clean-Code zu besuchen. Stattdessen müssen wir die Fortbildung verstetigen, indem wir Junior-Entwickler mit Software-Craftsmanship vertraut machen und Intermediate- und Senior-Entwickler systematisch in Softwarearchitektur schulen.

Es genügt auch nicht, sich mit Videos und Tutorials auf Plattformen wie Udemy zu versorgen. Softwareentwicklung ist wie Handwerk ein ganz praktisches Können, das zur Ausbildung der Übung bedarf. Viele ambitionierte Software-Engineers setzen daher auf sogenannte Katas, die sie immer wieder üben, um ihre Fähigkeiten zu perfektionieren. Katas (der Begriff bezeichnet ursprünglich eine Übungsform in Kampfkünsten) sind kleine, in sich geschlossene Aufgaben, die darauf abzielen, bestimmte Aspekte der Software-Entwicklung zu verbessern, wie beispielsweise Design, Code-Qualität oder Testbarkeit. Katas können auch verwendet werden, um neue Programmiersprachen oder Frameworks zu erlernen und zu üben. In der Regel werden sie allein oder in kleinen Gruppen durchgeführt und können dazu beitragen, ein regelmäßiges Übungsprogramm zu etablieren, das die Fähigkeiten und Kenntnisse der Software-Entwickler verbessert.

Meine Vision ist ein Fortbildungsangebot für Entwickler:innen, das sie von Beginn an begleitet:

• Junior-Devs werden in Software-Craftsmanship geschult, der Basis für jeden weiteren Erfolg.
• Intermediate- und Senior-Devs erhalten einen Einblick in die Softwarearchitektur.
• Alle Einheiten sind kompetenzorientiert und enthalten Übungen, die auf die täglichen Aufgaben als Entwicker vorbereiten und wirklich benötigte Kompetenzen fördern.

Meine Expertise

Ich kenne den Weg als Quereinsteiger in die Softwareentwicklung aus eigener Erfahrung. 2015 beschloss ich, die universitäre Laufbahn nach der Promotion zu verlassen und eine ganz andere Richtung zu versuchen. Ohne viele Kenntnisse im Bereich Software und IT entschied ich mich, Programmieren und Web-Entwicklung zu lernen, und heuerte in einer Agentur in Leipzig an. Zwei Jahre später wurde ich Senior-Entwickler bei einem großen deutschen Vergleichsportal.

Auf dem Weg dorthin hatte ich bereits viel gelernt: PHP, JavaScript, HTML, CSS, SASS und MySQL, Git und Continuous Integration, aber vor allem auch, was es heißt, Clean Code zu schreiben, testgetrieben zu entwickeln, Design Patterns zu verstehen, zu entwerfen und zu diskutieren, und warum es oft besser ist, alles in Form von Code zu verwalten statt in Wikis und Word-Dokumenten. Ich hatte mitgeholfen, Docker im Unternehmen einzuführen, und hatte ein erstes Projekt in einer damals noch wenig verbreiteten Sprache initiiert: Golang (freilich zu 80% in meiner Freizeit). Daneben schob ich einen wöchentlichen Workshop innerhalb des Unternehmens an: Unter dem Titel DevSamurai wurden wöchentlich neue Technologien vorgestellt sowie SOLID-Prinzipien und Fragen der Softwarearchitektur diskutiert.

Sicherlich half mir, dass ich während meines Studiums und als wissenschaftlicher Mitarbeiter an der Universität darauf getrimmt wurde, mir Wissen und Fertigkeiten selbst anzueignen. Ich weiß, wie ich an Informationen komme und was ich tun muss, um mir eine Fertigkeit selbst beizubringen. Ebenso weiß ich, wie ich das Wissen an andere Menschen weitergebe: Schon im Studium verdiente ich einen Teil meines Lebensunterhalts als Nachhilfelehrer und Tutor. Als wissenschaftlicher Mitarbeiter und Lehrbeauftragter konzipierte und leitete ich eine Vielzahl eigener Lehrveranstaltungen und begeisterte mich für kompetenzorientierte und methodisch versierte Unterrichtsformenin. Genau das mache ich nun auch im Bereich der Softwareentwicklung – und helfe so Neueinsteigern auf ihrem Weg zum professionellen Senior-Softwareentwickler.

Inhalt

Die technologieübergreifenden Kompetenzen, die wir auf dem Weg von Programmieranfänger:innen zu Senior-Entwickler:innen erwerben müssen, lassen sich grob in zwei aufeinander aufbauende Bereiche einteilen: Am Anfang stehen Fähigkeiten und Gewohnheiten, die ich unter dem Titel Software-Craftsmanship zusammenfasse, und die von Clean Code über Unit-Testing bis hin zum versierten und verantwortungsvollen Umgang mit Design Patterns reichen. Darauf aufbauend geht es um die verschiedenen Themen der Software-Architektur, die sich mit den ganzen Softwaresystemen befasst und die Zielsetzungen das Software-Craftsmanship auf einer abstrakteren Ebene verfolgt.

Software-Craftsmanship

Die Entwicklung von Software ist ein Handwerk – nicht im rechtlichen Sinne (der Handwerkskammer müssen wir als Softwareentwickler:innen nicht beitreten), aber doch in der Art der Tätigkeit. Dieser Einsicht folgend sprechen engagierte Softwareentwickler:innen auch von Softwareentwicklung als einer Handwerkskunst (Craftsmanship). Software Craftsmanship ist ein Ansatz zur Softwareentwicklung, der sich auf die Qualität der erstellten Software und auf die kontinuierliche Verbesserung der Fähigkeiten der Entwickler konzentriert. Es geht um die Schaffung von Code, der nicht nur funktioniert, sondern auch sauber, lesbar, wartbar und erweiterbar ist. Dies beinhaltet zum Beispiel:

• Kontinuierliche Verbesserung: Software-Craftsmanship fördert die kontinuierliche Verbesserung der Fähigkeiten eines Entwicklers sowie der Qualität des Produkts.
• Clean Code: Software-Craftsmanship legt großen Wert auf sauberen Code, der leicht zu lesen und zu verstehen ist. Dies ermöglicht es anderen Entwicklern, den Code leichter zu warten und zu erweitern.
• Best Practices: Dies umfasst unter anderem die Verwendung von Versionierungstools, Test-Driven Development (TDD), Continuous Integration (CI) und Continuous Deployment (CD).
• Teamarbeit: Software-Craftsmanship verbessert die Zusammenarbeit zwischen Entwicklern. Durch die Zusammenarbeit und Kommunikation können Entwickler ihr projektspezifisches Wissen erweitern und bessere Software entwickeln.

Software-Architektur

Softwarearchitektur befasst sich mit der Planung und dem Entwurf der Struktur und Organisation von Software-Systemen und zielt darauf ab, die funktionalen und nicht-funktionalen Anforderungen an eine Software vor dem Hintergrund realistisch eingeschätzter Rahmenbedingungen zu erreichen. Sie hat damit das Ganze eines Softwaresystems vor Augen und nimmt eine leitende Funktion innerhalb des Gesamtprozesses ein. Damit ist Softwarearchitektur eine entscheidende Kompetenz guter Senior- und Lead-Developer und nach dem Software-Craftsmanship der nächste Schritt in der Entwicklung übergreifender Kompetenzen.

Eine gute Softwarearchitektur ermöglicht es, komplexe Systeme in klar definierte Teile zu zerlegen, die unabhängig voneinander entwickelt, getestet und gewartet werden können. Die Aufgaben der Softwarearchitektur sind vielfältig und umfassen unter anderem:

• Anforderungsanalyse: Die Softwarearchitektur muss die Anforderungen der Benutzer verstehen und diese in eine Architektur übersetzen, die diese Anforderungen erfüllt.
• Design: Die Softwarearchitektur muss eine Struktur für die Software entwerfen, die es ermöglicht, dass die verschiedenen Komponenten effektiv zusammenarbeiten, um die Anforderungen der Benutzer zu erfüllen.
• Auswahl von Technologien: Die Softwarearchitektur muss die richtigen Technologien auswählen, die am besten geeignet sind, um die Anforderungen der Benutzer zu erfüllen und die Ziele der Software zu erreichen.
• Implementierung: Die Softwarearchitektur muss sicherstellen, dass die Implementierung der Software den Entwurf der Architektur und die ausgewählten Technologien korrekt umsetzt.
• Integration: Die Softwarearchitektur muss sicherstellen, dass die verschiedenen Komponenten der Software effektiv integriert werden, um sicherzustellen, dass die Software wie geplant funktioniert.
• Bewertung und Überprüfung: Die Softwarearchitektur muss die Architektur der Software regelmäßig bewerten und überprüfen, um sicherzustellen, dass sie den Anforderungen der Benutzer entspricht und effektiv und effizient funktioniert.
• Dokumentation: Die Softwarearchitektur muss die Architektur der Software dokumentieren, um sicherzustellen, dass andere Entwickler die Architektur verstehen und effektiv damit arbeiten können.

Die Bedeutung der Softwarearchitektur wird in IT-Projekten oft unterschätzt: Wenn Projekte in's Stocken geraten, die Komplexität langsam unbeherrschbar wird und neue Features schwer zu implementieren sind, dann liegt das nicht zuletzt an einer schlechten Architektur. Wir merken dass, wenn die Liste der Bugtickets immer länger wird und wir uns im Planning Poker immer öfter verschätzen.

Vorteile für Unternehmen

Eine systematische Schulung der Entwickler:innen bringt dem Unternehmen dadurch eine ganze Reihe von Vorteilen:

• Verbesserte Produktqualität: Software-Entwickler, die ihre Fähigkeiten und Kenntnisse in diesen Bereichen verbessern, können dazu beitragen, eine höhere Qualität der entwickelten Software-Produkte zu gewährleisten. Dadurch können die Produkte besser den Anforderungen der Kunden entsprechen und eine höhere Kundenzufriedenheit erreichen.
• Reduktion von Projektrisiken: Gerade bei komplexer werdenden Projekten steigen mit der Zeit die Projektrisiken, die aus mangelnden handwerklichen und architektonischen Fähigkeiten erwachsen. Im schlimmsten Fall droht ein Projekt wegen falscher Technologieauswahl, mangelnder Qualitätskontrolle oder unrealistischen bzw unklaren Anforderungen vollständig zu scheitern. Oft erlebe ich auch, dass Projekte von dem dienstältesten Entwickler am Standort abhängen und gerade anspruchsvollere Aufgaben nur von dieser einen Person erledigt werden können. Was aber geschieht, wenn diese einzelne Person krank wird oder aus dem Unternehmen ausscheidet? Besser ist es, solche Entwicklungen von vornherein zu vermeiden, Kompetenzen breiter zu verteilen und bestehende Projekte zukunftssicher aufzustellen. Durch eine systematische Investition in die Kernkompetenzen der Entwicklerinnen und Entwickler entstehen so zukunftssichere Projekte.
• Erhöhte Effizienz: Laut einer Studie des CISQ (Consortium for Information & Software Quality) aus dem Jahr 2022 büßen Entwickler:innen etwa ein Drittel ihrer Produktivität durch schlechten Code ein. Erfahrene Entwickler:innen wissen: Je komplexer ein Projekt ist, desto gravierender werden die Auswirkungen technischer Schulden, wenn es um die Implementierung neuer Features geht. Waren neue Features zu Beginn des Projekts noch schnell implementiert und ausgerollt, wird der Prozess mit der Zeit quälend langsam und fehleranfällig. Da mehren sich die Bug-Tickets im Backlog und Entwickler:innen benötigen ein Vielfaches der geschätzten Zeit für die Umsetzung ihrer Tickets. Durch das Beherrschen von Software-Craftsmanship und bessere architektonische Entscheidungen können Projekte auch langfristig schneller abgeschlossen werden und das Unternehmen kann schneller auf Marktveränderungen reagieren.
• Höhere Mitarbeitermotivation: Fortbildungsmöglichkeiten können dazu beitragen, dass Mitarbeiter sich wertgeschätzt und unterstützt fühlen. Dadurch kann die Mitarbeitermotivation gesteigert werden, was zu einer höheren Arbeitsqualität und Produktivität führt sowie zu geringerer Personalfluktuation. Zugleich erwirbt sich das Unternehmen dadurch einen Vorteil im Recruiting: Perspektiven für die berufliche Entwicklung aufzuzeigen kann der entscheidende Faktor in der Anwerbung neuer Talente sein. Damit sprechen Sie genau diejenigen an, die motiviert in ihren Beruf starten.

Vorteile für Entwickler:innen

Für Entwickler:innen, die sich weiterentwickeln möchten, ist es interessant, weil sie dadurch bessere Entwicklungsmöglichkeiten haben und ihr Potential besser entfalten können.

• Ihnen stehen bessere Karrieremöglichkeiten offen, da sie sich früher für Positionen als Senior oder Lead-Developer qualifizieren. Damit einher gehen anspruchsvollere Aufgaben und interessantere Projekte. Nicht zuetzt geht damit die Aussicht auf ein höheres Gehalt einher. Schließlich werden bessere Entwickler:innen auch für ihre Arbeitgeber interessanter und steigern so ihren eigenen Marktwert.
• Nur wer sich weiterentwickelt, wird zukünftig weiter lukrative Betätigungsfelder vorfinden. Einfache Programmieraufgaben werden zunehmend obsolet und durch smarte Technologien ausgeführt. Low Code und KI sind aktuelle Trends, die die Existenzgrundlage des Code Monkeys akut gefährden. Nur wer sich weiterentwickelt und für anspruchsvollere Aufgaben qualifiziert, wird eine Zukunft in der Softwareentwicklung haben. Das bloße Ausführen vorgegebener Programmieraufgaben können uns heute schon Maschinen abnehmen.
• Schlussendlich geht es uns immer auch darum, Freude an der Tätigkeit der Softwareentwicklung zu haben. Linux Torvalds sagte einmal, die besten Entwickler arbeiteten nicht des Geldes wegen, sondern weil es ihnen einfach Spaß macht. Spaß macht Softwareentwicklung aber nur, wenn das Ergebnis qualitativ gut ist und wir den steigenden Herausforderungen gewachsen sind.

Fazit

Die Ausbildung technologieübergreifender Kompetenzen von Softwareentwicklern wird in vielen Unternehmen sträflich vernachlässigt. Software-Craftsmanship und Softwarearchitektur sind integrale Bestandteile agiler Softwareentwicklung, werden aber nicht immer als solche erkannt. Das begrenzt nicht nur das Entwicklungspotential von Entwickler:innen und die Qualität der Resultate, es führt zu Mehrkosten und unüberschaubaren Projektrisiken. Denn miese Softwarequalität ist teuer und riskant. Wer sich weiterentwickeln möchte – ob als Entwickler:in oder als Unternehmen – muss hier umdenken und den fortgeschrittenen Kompetenzen mehr Raum geben.