Welche Kenntnisse sollte ein Junior-Softwareentwickler mitbringen?

Wenn man eine Ausbildung zum Fachinformatiker macht oder Informatik studiert, beschäftigt man sich zwangsläufig mit vielen verschiedenen Themen aus der Softwareentwicklung. Je nach Ausbildungsbetrieb, Hochschule oder Studiengang unterscheiden sich die Schwerpunkte dabei allerdings teilweise erheblich.

Aus meiner eigenen Erfahrung habe ich festgestellt, dass es neben den klassischen Inhalten aus Ausbildung oder Studium noch eine Reihe von Themen gibt, deren Grundlagen für den Einstieg in den Beruf sehr hilfreich sein können. Dabei geht es meiner Meinung nach nicht darum, dass ein Junior-Softwareentwickler bereits jedes Tool beherrschen oder komplexe Systeme selbstständig entwerfen können muss. Viel wichtiger ist es, ein grundlegendes Verständnis dafür zu haben, wie moderne Softwareentwicklung und der Betrieb von Software funktionieren.

Die folgenden Punkte sind daher ausdrücklich meine persönliche Meinung und basieren auf meinen eigenen Erfahrungen. Sie stellen keine allgemeingültige Anforderung an Junior-Entwickler dar. Je nach Unternehmen, Team und konkreter Stelle werden sicherlich andere Kenntnisse wichtiger sein.

Ich sehe diese Themen vor allem als Ergänzung zu einer Ausbildung oder einem Studium. Wer sich bereits während dieser Zeit mit einigen der folgenden Themen beschäftigt, bringt meiner Meinung nach ein gutes Fundament für den späteren Berufsalltag mit.

Versionsverwaltung

Eine der ersten Grundlagen, die man meiner Meinung nach beherrschen sollte, ist der Umgang mit Versionsverwaltung. In der modernen Softwareentwicklung kommt man an Git eigentlich kaum noch vorbei.

Dabei reicht es meiner Ansicht nach nicht aus, nur zu wissen, wie man Änderungen mit git add, git commit und git push in ein Repository bekommt. Gerade im beruflichen Umfeld sollte man verstehen, wie die Zusammenarbeit mit anderen Entwicklern funktioniert.

Dazu gehören beispielsweise:

• Git als Versionsverwaltung
• GitHub, GitLab oder andere Git-Plattformen
• Git Forge und Repository-Management
• Pull Requests beziehungsweise Merge Requests
• Branches und Branch-Strategien
• Rebasing mit git rebase
• Übernehmen einzelner Commits mit git cherry-pick
• Zurücksetzen von Änderungen mit git reset

Insbesondere Pull und Merge Requests sollte man einmal selbst erlebt haben. Dabei lernt man nicht nur, wie Änderungen in einen gemeinsamen Branch gelangen, sondern auch, wie Code Reviews funktionieren und wie man konstruktives Feedback zu Code gibt und entgegennimmt.

Auch git rebase und git cherry-pick sind meiner Meinung nach Befehle, deren grundlegende Funktionsweise man zumindest kennen sollte. Man muss nicht jede komplexe Git-Historie im Schlaf reparieren können. Es hilft aber enorm, wenn man versteht, was Git im Hintergrund eigentlich macht und wie man Änderungen zwischen Branches verschieben kann.

Das Ziel sollte aus meiner Sicht daher nicht sein, eine möglichst lange Liste von Git-Befehlen auswendig zu lernen. Viel wichtiger ist ein grundlegendes Verständnis von Branches, Commits und der Zusammenarbeit in einem Repository.

Continuous Integration und Deployment

Software wird heute nur noch selten einfach auf einem Rechner entwickelt und anschließend manuell auf einen Server kopiert. In vielen Unternehmen werden Änderungen automatisiert gebaut, getestet und anschließend bereitgestellt.

Deshalb halte ich es für sinnvoll, bereits als Junior-Entwickler die Grundlagen von Continuous Integration und Continuous Deployment zu kennen.

Typische Werkzeuge sind beispielsweise:

• GitHub Actions
• GitLab CI/CD
• Jenkins
• oder vergleichbare CI/CD-Systeme

Hier sollte man meiner Meinung nach verstehen, was eine Pipeline ist und welche Aufgaben sie übernehmen kann.

Ein einfaches Beispiel wäre:

1. Ein Entwickler pusht Änderungen in ein Git Repository.
2. Die CI-Pipeline wird automatisch gestartet.
3. Der Code wird kompiliert oder gebaut.
4. Automatisierte Tests werden ausgeführt.
5. Ein Docker-Image wird erstellt.
6. Das Image wird in eine Registry übertragen.
7. Die Anwendung wird in einer Test- oder Produktionsumgebung bereitgestellt.

Man muss als Junior sicherlich nicht sofort eine hochkomplexe Pipeline mit mehreren Umgebungen und ausgefeilten Deployment-Strategien entwickeln können. Es ist aber sehr hilfreich, wenn man eine bestehende Pipeline lesen und nachvollziehen kann.

Auch das Verständnis dafür, warum automatisierte Tests und Build-Prozesse wichtig sind, gehört für mich zu den Grundlagen moderner Softwareentwicklung.

Containerisierung

Ein weiteres Thema, das mir im Berufsalltag immer wieder begegnet, ist Containerisierung.

Hier sollte man meiner Meinung nach zumindest die grundlegenden Konzepte von Docker verstehen. Dazu gehören beispielsweise Images, Container, Volumes, Netzwerke und Registries.

Als Werkzeuge würde ich insbesondere folgende Themen empfehlen:

• Docker
• Podman
• Docker Compose
• Kubernetes
• Helm

Gerade Docker Compose halte ich für einen guten Einstieg. Damit kann man relativ einfach mehrere Komponenten einer Anwendung lokal betreiben. Beispielsweise eine Anwendung, eine PostgreSQL-Datenbank und einen Redis-Server.

Dabei lernt man gleichzeitig einiges über Netzwerke, Umgebungsvariablen, Persistenz und die Abhängigkeiten zwischen einzelnen Services.

Kubernetes ist anschließend noch einmal eine deutlich größere Welt. Als Junior-Entwickler muss man meiner Meinung nach nicht in der Lage sein, einen kompletten Kubernetes-Cluster zu administrieren. Ein grundlegendes Verständnis davon, was Kubernetes überhaupt macht und warum Unternehmen ihre Anwendungen dort betreiben, kann aber sehr hilfreich sein.

Begriffe wie Pod, Deployment, Service, Ingress und Namespace sollte man zumindest einmal gehört haben.

Auch Helm kann in diesem Zusammenhang interessant sein. Viele Anwendungen werden in Kubernetes nicht mehr mit einzelnen YAML-Dateien verwaltet, sondern über Helm Charts bereitgestellt. Wer bereits einmal ein Helm Chart gesehen hat und dessen grundlegendes Konzept versteht, hat beim Einstieg in ein entsprechendes Projekt einen kleinen Vorteil.

Infrastruktur und Betriebssysteme

Auch wenn man sich auf eine Stelle als Softwareentwickler bewirbt, halte ich grundlegende Kenntnisse über Infrastruktur für sehr wertvoll.

Eine Anwendung läuft schließlich nicht einfach irgendwo. Sie benötigt ein Betriebssystem, Netzwerk, Speicher und häufig noch viele weitere Komponenten.

Aus diesem Grund würde ich mich bereits als Junior mit Linux beschäftigen. Dazu gehören meiner Meinung nach grundlegende Kenntnisse über:

• Dateisysteme
• Benutzer und Gruppen
• Berechtigungen
• Prozesse
• Netzwerkverbindungen
• DNS
• SSH
• Systemd
• Logs

Besonders hilfreich finde ich es, wenn man sich selbst einmal einen kleinen Linux-Server aufsetzt und darauf eine Anwendung betreibt. Dabei lernt man häufig mehr, als wenn man nur theoretisch über Linux liest.

Darauf aufbauend sind Automatisierungswerkzeuge wie Ansible und Terraform interessant.

Mit Ansible kann man beispielsweise die Konfiguration von Servern automatisieren. Terraform verfolgt einen etwas anderen Ansatz und wird häufig verwendet, um Infrastruktur deklarativ zu beschreiben und zu verwalten.

Auch das Thema Hardware-Management kann interessant sein. Begriffe wie BMC, IPMI oder Out-of-Band-Management sind im professionellen Rechenzentrumsumfeld durchaus relevant. Auch Technologien wie Intel AMT oder Redfish können einem im späteren Berufsleben begegnen.

Natürlich muss ein Junior-Softwareentwickler nicht wissen, wie man jeden Server über IPMI verwaltet. Ein grundlegendes Verständnis dafür, dass Server auch unabhängig vom installierten Betriebssystem administriert werden können, kann aber nicht schaden.

Public Cloud

Ebenfalls immer wichtiger wird meiner Meinung nach ein grundlegendes Verständnis für Public-Cloud-Plattformen.

Dabei muss man nicht direkt mehrere Zertifizierungen besitzen. Es kann bereits sehr lehrreich sein, sich einmal mit einer Plattform wie AWS oder Azure zu beschäftigen.

Interessant sind dabei beispielsweise die Fragen:

• Was ist eine virtuelle Maschine in der Cloud?
• Was ist ein Container?
• Was ist eine Managed Database?
• Was ist Object Storage?
• Wie funktioniert ein Load Balancer?
• Wie werden Ressourcen voneinander getrennt?
• Wie werden Zugriffsrechte verwaltet?

Auch hier geht es meiner Meinung nach zunächst um die Konzepte und nicht darum, jeden einzelnen Dienst auswendig zu kennen.

Wer bereits einmal eine kleine Anwendung in der Cloud betrieben hat, bekommt außerdem ein besseres Verständnis dafür, welche Infrastruktur hinter einer Softwareanwendung steckt.

Programmierung und Skripting

Natürlich darf die eigentliche Programmierung nicht fehlen.

Hier würde ich mich zunächst auf eine oder wenige Programmiersprachen konzentrieren und diese wirklich verstehen. Für einen Junior-Entwickler halte ich es nicht für sinnvoll, zehn Programmiersprachen oberflächlich zu kennen.

Zusätzlich zur eigentlichen Programmiersprache finde ich aber Kenntnisse in Python und Bash sehr hilfreich.

Python eignet sich hervorragend für kleinere Automatisierungen, Skripte und Tools. Bash ist insbesondere im Linux-Umfeld praktisch, um Aufgaben auf der Kommandozeile zu automatisieren.

Auch wenn die eigentliche Anwendung beispielsweise in Java, Go oder C# geschrieben wird, kann es im Berufsalltag durchaus vorkommen, dass man schnell ein kleines Skript benötigt.

REST und APIs

Software besteht heute nur noch selten aus einer einzelnen Anwendung. Häufig kommunizieren viele verschiedene Systeme miteinander.

Deshalb halte ich grundlegende Kenntnisse über REST und APIs für wichtig.

Man sollte meiner Meinung nach verstehen:

• Was ist eine API?
• Was ist eine HTTP-Anfrage?
• Was sind HTTP-Methoden wie GET, POST, PUT und DELETE?
• Was bedeuten HTTP-Statuscodes?
• Was ist JSON?
• Wie funktioniert Authentifizierung grundsätzlich?

Auch hier kann man mit einem kleinen eigenen Projekt viel lernen. Eine einfache REST-API zu entwickeln und anschließend mit einem Client anzusprechen, vermittelt meiner Meinung nach ein gutes Verständnis für die Kommunikation zwischen verschiedenen Anwendungen.

Datenbanken

Ein weiteres Thema sind Datenbanken.

Auch wenn man später nicht als Datenbankadministrator arbeitet, sollte man meiner Meinung nach verstehen, wie relationale Datenbanken funktionieren.

Dazu gehören beispielsweise:

• Tabellen
• Primärschlüssel
• Fremdschlüssel
• Beziehungen
• Indizes
• SQL
• Transaktionen

Als Beispiele würde ich mir PostgreSQL oder MariaDB ansehen.

Besonders wichtig finde ich dabei, nicht nur eine Datenbank über ein ORM anzusprechen. ORMs können die Entwicklung deutlich vereinfachen, aber sie sollten meiner Meinung nach nicht dazu führen, dass man keine Ahnung davon hat, was im Hintergrund mit der Datenbank passiert.

Daher halte ich es für sinnvoll, sowohl SQL als auch ein ORM zumindest grundlegend zu verstehen.

Wenn man weiß, wie eine SQL-Abfrage funktioniert und wie ein ORM daraus eine Abfrage erzeugt, kann man viele Probleme deutlich einfacher analysieren.

Projektmanagement und Arbeitsweisen

Neben technischen Fähigkeiten gibt es noch einen Bereich, den man meiner Meinung nach nicht unterschätzen sollte: Projektmanagement.

Softwareentwicklung findet schließlich selten alleine statt. Man arbeitet in Teams, mit Kunden, Product Ownern, Projektleitern und anderen Abteilungen zusammen.

Daher kann es hilfreich sein, zumindest die grundlegenden Konzepte verschiedener Vorgehensmodelle zu kennen.

Dazu gehören beispielsweise:

• Scrum
• Kanban
• Wasserfallmodell
• IPMA

Man muss meiner Meinung nach nicht bereits als Junior ein Scrum Master oder Projektmanager sein. Trotzdem sollte man wissen, was beispielsweise ein Sprint, ein Backlog oder ein Daily ist.

Gleichzeitig finde ich es wichtig, nicht den Eindruck zu vermitteln, dass Scrum die einzige mögliche Arbeitsweise ist. Je nach Unternehmen und Projekt können auch Kanban, klassische Vorgehensmodelle oder Mischformen sinnvoll sein.

Auch das Thema Projektmanagement-Zertifizierungen, beispielsweise nach IPMA, kann später interessant werden. Für den Einstieg in die Softwareentwicklung würde ich persönlich allerdings zunächst ein grundlegendes Verständnis der Methoden und deren Unterschiede als ausreichend ansehen.

Muss man das alles können?

Nein.

Zumindest nicht alles auf dem gleichen Niveau.

Ich würde von einem Junior-Softwareentwickler nicht erwarten, dass er Kubernetes administrieren, komplexe Terraform-Module schreiben und gleichzeitig eine Datenbank optimieren kann.

Meiner Meinung nach ist es viel wichtiger, die grundlegenden Konzepte zu verstehen und bereits einmal selbst ausprobiert zu haben.

Wenn ich beispielsweise einen Junior-Entwickler einstelle und dieser bereits einmal selbst eine kleine Anwendung mit Git verwaltet, automatisiert getestet, als Docker-Container gebaut und auf einem Linux-Server betrieben hat, dann finde ich das persönlich sehr interessant.

Dabei spielt es für mich eine untergeordnete Rolle, ob die Anwendung technisch besonders beeindruckend ist.

Viel wichtiger ist, dass die Person selbst erlebt hat, wie die einzelnen Komponenten zusammenhängen.

Mein persönlicher Lernweg

Wenn ich heute noch einmal am Anfang meiner beruflichen Laufbahn stehen würde, würde ich versuchen, mir diese Kenntnisse möglichst praxisnah anzueignen.

Ein kleines eigenes Projekt könnte beispielsweise so aussehen:

Eine Anwendung wird in Python entwickelt und stellt eine REST-API bereit. Die Daten werden in PostgreSQL gespeichert und über ein ORM angesprochen. Der Quellcode liegt in GitLab oder GitHub.

Bei jedem Push startet eine CI-Pipeline. Die Anwendung wird getestet und anschließend als Docker-Image gebaut.

Mit Docker Compose werden die Anwendung und die Datenbank lokal betrieben. Anschließend wird die Anwendung auf einem kleinen Linux-Server oder in einer Cloud-Umgebung bereitgestellt.

Die Serverkonfiguration wird mit Ansible automatisiert. Die benötigte Infrastruktur wird mit Terraform beschrieben.

Damit hätte man in einem einzigen Projekt bereits sehr viele der oben genannten Themen praktisch kennengelernt.

Der Vorteil eines solchen Projekts ist meiner Meinung nach, dass man nicht nur einzelne Technologien ausprobiert, sondern auch versteht, wie sie miteinander verbunden werden.

Fazit

Aus meiner persönlichen Sicht sollte ein Junior-Softwareentwickler vor allem eines mitbringen: Interesse daran, wie Software über den eigentlichen Quellcode hinaus funktioniert.

Eine gute Ausbildung oder ein gutes Studium vermittelt die Grundlagen der Informatik und Softwareentwicklung. Ergänzend dazu halte ich praktische Kenntnisse in Versionsverwaltung, CI/CD, Containerisierung, Linux, Infrastruktur, Datenbanken und Projektmanagement für sehr hilfreich.

Dabei sollte man sich meiner Meinung nach nicht zu sehr unter Druck setzen, jedes einzelne Tool perfekt beherrschen zu müssen. Technologien ändern sich und neue Werkzeuge kommen ständig hinzu.

Wer jedoch die grundlegenden Konzepte verstanden hat, kann sich meiner Erfahrung nach deutlich einfacher in neue Technologien einarbeiten.

Für mich wäre daher nicht die Frage entscheidend, ob ein Junior-Entwickler bereits jedes Tool aus dieser Liste kennt. Viel interessanter wäre die Frage, ob er oder sie schon einmal ein eigenes Projekt von der Idee über den Code bis hin zum Betrieb begleitet hat.

Denn genau dort beginnt für mich der Unterschied zwischen „Ich habe davon gehört“ und „Ich habe verstanden, wie es funktioniert“.