Und was Sie tun können, um die nächste Stufe zu erreichen.
Ein Junior-, Mid-Level- oder Senior-Entwickler zu sein, hat nicht nur mit den Jahren an Programmiererfahrung zu tun, die man hat. Ein Junior-Entwickler kann sogar älter sein als ein Senior-Entwickler. Es kommt auf die Fähigkeiten an. Das bedeutet nicht, dass ein Senior-Entwickler in allem ein Experte sein muss, aber man kann mit Sicherheit sagen, dass Senior-Entwickler viel geschickter sind als Junior- und Mid-Level-Entwickler.
Aber es sind nicht nur die Programmierkenntnisse, die einen Senior Developer von einem Mid-Level oder Junior Developer unterscheiden. Was genau sind also die Unterschiede?
Wissen
Ein Senior-Entwickler hat natürlich viel mehr Wissen als ein Junior- oder Mid-Level-Entwickler. Kenntnisse über Entwurfsmuster, Architektur, Testautomatisierung, Leistung, Sicherheit usw. sind eine gute Möglichkeit für Junior-Entwickler, die Wissenslücke zu mittleren und älteren Entwicklern zu schließen.
Es ist wichtig zu wissen, wie man bei der Softwareentwicklung vorgehen sollte. Aber nur weil man all diese Dinge weiß, ist man noch lange kein erfahrener Entwickler. Wissen ist nicht der größte Unterschied zwischen Entwicklern - es ist nur ein Faktor.
Codierung
Im Gegensatz zu dem, was die meisten Leute denken, geht es beim Programmieren nicht darum, mit einem Computer zu kommunizieren. Beim Kodieren geht es darum, mit Menschen zu kommunizieren und Computern Anweisungen zu geben. Letztendlich wird der Code kompiliert und in Nullen und Einsen übersetzt.
Der Code sollte für andere Entwickler, die in Zukunft mit ihm arbeiten werden, sinnvoll sein. Ein neues Team, das den Code noch nie gesehen hat, sollte in der Lage sein, den Code zu öffnen und mit der Arbeit an neuen Funktionen oder Fehlerbehebungen zu beginnen. Hier liegt der große Unterschied zwischen Junior- und Senior-Entwicklern.
Ich werde den mittleren Entwickler in diesem Vergleich weglassen, weil der mittlere Entwickler so etwas wie eine Grauzone ist, wenn es um Programmierkenntnisse geht. Er ist offensichtlich irgendwo zwischen Junior und Senior angesiedelt. Wahrscheinlich tendiert er eher zur Senior-Seite. Das hängt vor allem mit der Erfahrung zusammen, denn Mid-Level-Entwickler haben wahrscheinlich den gesamten Entwicklungszyklus mindestens einmal durchlaufen. Sie haben viele der einfachsten Fehler gemacht und daraus gelernt.
Wie erkenne ich einen Nachwuchsentwickler?
Junge Entwickler sind unerfahren. Die meisten kommen frisch von der Universität und beginnen ihre erste Vollzeitstelle. Die Denkweise eines Nachwuchsentwicklers besteht oft nur darin, den Code zum Laufen zu bringen. Funktionierende Software und gute Software werden als dasselbe angesehen.
Einfachen Code zu programmieren ist schwer. Und es ist etwas, was junge Entwickler nicht tun. Junge Entwickler schreiben anspruchsvollen Code. Einen Nachwuchsentwickler erkennt man an seltsamen Einzeilern und übermäßig komplexen Abstraktionen. Das ist die Art und Weise, mit der junge Entwickler angeben und andere Entwickler wissen lassen, wie gut sie programmieren können. Und das ist falsch.
Junge Entwickler konzentrieren sich auf die rechnerische Seite des Codes und vernachlässigen die menschliche Seite.
Und was ist mit dem leitenden Entwickler?
Wenn Sie sich den Code eines erfahrenen Entwicklers ansehen, denken Sie vielleicht: Ist das alles? Wo ist der Rest des Codes? Ein erfahrener Entwickler schreibt einfachen, geradlinigen und vielleicht sogar dummen Code. Das ist eine der besten Qualitäten, die ein Entwickler haben kann, wenn es um das Programmieren geht. Ein erfahrener Entwickler folgt dem KISS-Prinzip: Keep it simple, stupid. /Keep it simple, stupid.
Ein erfahrener Entwickler denkt anders über seinen Code nach als ein junger Entwickler. Der Code eines erfahrenen Entwicklers wird mit Blick auf Wartbarkeit und Skalierbarkeit geschrieben. Dies ist eine völlig andere Denkweise als bei einem Junior-Entwickler - der Senior denkt an die Menschen, die mit dem Code arbeiten müssen, während der Junior nur daran denkt, dass er für den Computer funktioniert.
Mehr als nur Programmierkenntnisse
Abgesehen von den Programmierkenntnissen gibt es noch einige andere Faktoren, an denen Sie erkennen können, welcher Typ von Entwickler Sie sind.
Junior-Entwickler führen im Allgemeinen die einfachsten oder wenig anspruchsvollen Aufgaben aus. Sie entwerfen keine Architektur. Mid-Level-Entwickler entwerfen ebenfalls keine Lösungen, sondern führen nur Aufgaben aus. Der Unterschied zu Junior-Entwicklern besteht darin, dass sie diese Aufgaben mit weniger Aufsicht durchführen, solange sie mit relativ routinemäßigen Aufgaben betraut werden. Senior-Entwickler können eine Anwendung völlig eigenständig entwickeln.
Das heißt aber nicht, dass der erfahrene Entwickler keine Probleme hat. Jeder Entwickler hat jeden Tag eine Menge Fragen und das wird sich auch nicht ändern. Das ist bei erfahrenen Entwicklern nicht anders.
Der Unterschied besteht darin, dass erfahrene Entwickler wissen, wie man die richtigen Fragen stellt und wie man diese Fragen beantwortet. Entwickler der mittleren Ebene können die richtigen Fragen stellen, wenn es um ihre relativ routinemäßigen Aufgaben geht, brauchen aber Hilfe bei komplexeren Aufgaben.
Der erfahrene Entwickler ist immer auf dem Laufenden und weiß, wie er das Problem mit den richtigen Maßnahmen weiterverfolgen kann. Das bedeutet nicht, dass ein erfahrener Entwickler nicht andere Entwickler um Hilfe bitten kann. Manchmal ist es am besten, einfach andere Entwickler mit Erfahrung in diesem Bereich um Hilfe zu bitten.
Auch ein Entwickler der mittleren Ebene sollte in der Lage sein, die richtigen Fragen zu stellen, solange er nicht mit sehr komplexen Aufgaben betraut wird, die ein tiefgehendes Wissen erfordern.
Sie sollten nicht erwarten, dass ein junger Entwickler sofort die richtigen Fragen stellt. Da Nachwuchsentwickler noch unerfahren sind, brauchen sie die Anleitung eines erfahreneren Entwicklers. Der Nachwuchsentwickler muss die notwendigen Ressourcen erhalten oder einen großen Anstoß in die richtige Richtung bekommen.
Die nächste Stufe erreichen
Wir alle wollen uns verbessern und als Entwickler besser werden. Aber was sind die Schritte, die Sie unternehmen können, um die nächste Stufe zu erreichen?
Junior- bis Mittelstufe
Da Nachwuchsentwickler noch unerfahren sind, ist es wichtig, den gesamten Entwicklungszyklus zumindest ein paar Mal zu durchlaufen. Auf diese Weise werden Sie in viele Fallen tappen und lernen, wie Sie diese beim nächsten Mal vermeiden können.
Wenn es um die Programmierung geht, müssen Sie lernen, wie man einfachen Code schreibt. Denken Sie an die nächste Person, die an diesem Code arbeiten wird. Sie müssen auch lernen, wie man Fehler behebt, da Sie dann besser verstehen, was im Prozess vor sich geht.
Darüber hinaus sollten Sie sich mit bewährten Verfahren vertraut machen und sich über Architektur, Leistung, Sicherheit usw. informieren. Füllen Sie die Wissenslücke, die zum Erreichen der Zwischenstufe erforderlich ist.
Mittel bis Senior
Der Übergang von der mittleren zur höheren Ebene kann recht schwierig sein. Einige Entwickler bleiben während ihrer gesamten Laufbahn auf der mittleren Ebene.
Erfahrene Entwickler wissen, wo man Abstriche machen kann und wo man sie nicht machen sollte. Dies sind hart erlernte Lektionen aus vergangenen Fehlern.
Wenn Sie ganz nach oben kommen wollen, müssen Sie bereit sein, die Aufgaben zu übernehmen, für die niemand eine Lösung weiß. Man muss mehr wissen, als nur, wie man die Arbeit erledigt.
Als erfahrener Entwickler ist es auch Ihre Aufgabe, weniger erfahrenen Entwicklern zu helfen. Sie sind die Anlaufstelle für andere Entwickler, wenn diese nicht wissen, wie sie etwas tun sollen.
Und es mag Sie nicht überraschen, dass erfahrene Entwickler ihren Tech-Stack beherrschen. Es geht um mehr als nur um Programmierkenntnisse. Machen Sie sich mit allen Tools und Anwendungen vertraut, die in dem Unternehmen, für das Sie arbeiten, verwendet werden.
Schlussfolgerung
Der Unterschied zwischen einem Junior-, Mid-Level- und Senior-Entwickler besteht nicht nur in den Jahren der Erfahrung. Natürlich kann man sagen, dass erfahrene Entwickler besser ausgebildet sind als Junior- und Mid-Level-Entwickler. Aber das Wissen ist nicht der wichtigste Faktor.
Ältere Entwickler schreiben leichteren Code und haben eine andere Denkweise als junge Entwickler. Aber es geht um mehr als nur um Programmierkenntnisse. Es ist wichtig zu wissen, welche Fragen man stellen muss und wie man diesen Fragen nachgeht. Und das ist etwas, das nur ein erfahrener Entwickler mit seiner umfassenden Erfahrung in allen Situationen beherrscht.
Um sich als Junior-Entwickler weiterzuentwickeln, müssen Sie sich darauf konzentrieren, einfachen Code zu schreiben und mehrere Entwicklungszyklen zu durchlaufen. Um von der mittleren zur höheren Entwicklungsstufe aufzusteigen, müssen Sie sich darauf konzentrieren, mehr zu lernen als nur Routineaufgaben zu lösen. Sie müssen bereit sein, die schwierigsten Aufgaben zu übernehmen und Ihre Technologien zu beherrschen. Eine weitere Aufgabe eines Senior-Entwicklers ist es, weniger erfahrenen Entwicklern als Backup zu dienen.
Ich möchte Sie mit einem Zitat von Martin Fowler zurücklassen: "Jeder Dummkopf kann Code schreiben, den ein Computer verstehen kann. Gute Programmierer schreiben Code, den Menschen verstehen können."