Die Leute bezeichnen sich selbst als Softwareentwickler oder Software-Ingenieur, aber es scheint keinen klaren Weg zu geben, den Unterschied zu erkennen. Wir hoffen durch diesen Artikel ein wenig Licht ins Dunkle zu bringen.
Definitionen von Wörtern sind eine Sache
Was ist also ein Softwareentwickler und was ist ein Softwareingenieur? Versuchen wir, uns einige Definitionen für die Wörter Entwickler und Ingenieur anzusehen, die uns helfen könnten, zum Kern der Unterscheidung zwischen diesen Berufen zu gelangen.
Entwickler: Eine Person oder ein Ding, das etwas entwickelt.
Ingenieur: Eine Person oder ein Ding, das etwas konstruiert.
Äh… Okay. Danke. Sehr hilfreiches Internet.
Wie wäre es, wenn wir dann nach Entwicklung und Engineering suchen.
Entwickeln: wachsen und reifer, fortschrittlicher oder ausgefeilter werden. (Oxford Sprachen)
Ingenieurwesen: die Anwendung wissenschaftlicher Prinzipien zur Gestaltung oder Entwicklung von Strukturen, Maschinen, Apparaten oder Herstellungsverfahren oder Arbeiten, die sie einzeln oder in Kombination verwenden. (Akkreditierungsstelle für Technik und Technik)
Ah, viel hilfreicher. Besseres Internet. Lasst uns an die Arbeit gehen.
Entwickler
Basierend auf der Definition von Entwickler und Entwicklung muss ein Softwareentwickler also eine Person sein, die Software wachsen lässt, reifer, fortschrittlicher oder ausgefeilter wird. Das scheint ziemlich beschreibend zu sein.
Softwaresysteme neigen dazu, immer komplexer zu werden und deutlich komplexer zu werden, wenn neue Anforderungen an das System notwendig werden. Dabei kann es sich um technologische oder verhaltensbezogene Bedenken handeln. Zu den technologischen Problemen gehören in der Regel Dinge wie Programmiersprachen, Frameworks, Infrastruktur, Tools, Nachrichtenbusse, Containerisierung und CI/CD. Verhaltensprobleme sind diejenigen, die wir häufiger mit den Bedürfnissen des Benutzers in Verbindung bringen: Neue Funktionen, neue Themen, neue Layouts usw.
Komplexität ist mehr als nur ein Begriff, der verwendet wird, um die Beziehungen zwischen Komponenten innerhalb eines Systems zu beschreiben. Komplexität ist auch eine logische Folge der kognitiven Belastung. Aus diesem Grund ist für die Wartung der meisten Anwendungen mehr als eine Person erforderlich. Je größer eine Anwendung ist, desto komplexer ist sie. Je komplexer es ist, desto höher ist die kognitive Belastung. Wenn die kognitive Belastung die Fähigkeiten des Betreuers übersteigt, müssen neue Teilnehmer hinzukommen, um einen Teil dieser kognitiven Last zu übernehmen. Wie diese kognitive Last am effektivsten verteilt wird, ist ein Thema von großem Interesse, das aber auf einen anderen Artikel warten muss.
Die Art und Weise, wie ein Entwickler mit Komplexität und kognitiver Belastung umgeht, unterscheidet sich wahrscheinlich stark von der eines Ingenieurs.
Ingenieur
Basierend auf der Definition von Ingenieur und Ingenieur muss ein Softwareingenieur wissenschaftliche Prinzipien anwenden, um Software zu entwerfen und zu entwickeln. Während also die Aufgaben für Entwickler und Ingenieure, also die Entwicklung, ähnlich sind, haben Ingenieure die zusätzliche Einschränkung, dass sie dafür die Wissenschaft nutzen müssen. Ich nenne das gerne die FAFO-Unterscheidung. Der Unterschied ist nicht, dass man herumf’n ist und es herausfindet, es liegt in der Methode, WIE man herumf’nt und es herausfindet.
Die wissenschaftliche Methode
Für diejenigen unter Ihnen, die nicht eingeweiht sind, läuft die wissenschaftliche Methode auf drei grundlegende Schritte hinaus:
- Erstellen Sie eine Hypothese durch induktives Denken
- Testen Sie es durch Experimente und statistische Analysen
- Anpassen oder Verwerfen der Hypothese auf der Grundlage der Ergebnisse.
- Wiederholen.
Technisch gesehen gibt es noch mehr, aber das ist das Wesentliche. Bilden Sie eine Hypothese, testen Sie Ihre Hypothese, passen Sie Ihre Hypothese an und wiederholen Sie den Vorgang.
Also, wer bist du?
Wie würden also wissenschaftliche Prinzipien auf Software zutreffen?
Nun, hier wird etwa die Hälfte von euch ihre Fäuste gegen mich schütteln, während ihr mich und mein Erbe verflucht. Die andere Hälfte von euch wird lächeln und mir für die klare Begründung danken, die euch endlich die Klarheit gebracht hat, nach der ihr gesucht habt.
Kurz gesagt, TDD ist die wissenschaftliche Methode.
Ich weiß. Ich bin ein Bastard. Ich bin ein Ketzer. Ich bin ein leerköpfiger Trogwischer für Tierfutter. Du hast nicht für mich gestimmt. Ich verstehe. Aber denken Sie darüber nach. Was ist TDD?
- Rote Phase: Schreiben Sie einen Test, der Ihre Hypothese beschreibt, wie sich der Code verhalten wird.
- Grüne Phase: Experimentieren Sie mit der Ablaufsteuerung und der Zustandsverwaltung, bis Sie in der Lage sind, den Test entweder zu bestehen oder zu beweisen, dass er nicht erreichbar ist (ja, das kommt gelegentlich vor).
- Refactoring: Passen Sie den Code und/oder die Tests an, um Ihr neues Verständnis der Domäne besser darzustellen.
- Wiederholen.
TDD hilft Ingenieuren, die kognitive Belastung zu bewältigen, indem es die Komplexität der Anwendung in kleine Teile überprüfbarer Funktionen zerlegt. Entwickler müssen andere Wege nutzen, um diese Komplexität zu bewältigen.
Wenn Sie also nicht TDD machen, bedeutet das, dass Sie ein Entwickler und kein Ingenieur sind? Naja, nicht so schnell.
Versuchen wir es noch einmal
Ok, also entweder man liebt diese Auszeichnung oder man hasst sie. Vielleicht haben Sie eine andere Möglichkeit, Code auf wissenschaftliche Weise zu schreiben und zu verwalten, der keine TDD erfordert. Das ist in Ordnung. Es gibt noch eine weitere Unterscheidung, die es wert ist, untersucht zu werden, die Ihnen vielleicht besser gefällt. Es wird eine Analogie verwendet, mit der die meisten von uns ziemlich vertraut sein sollten. Hochbau.
Nun, ich bin normalerweise der Erste, der sagt, dass das Schreiben von Software nicht dasselbe ist wie der Bau eines Hauses. Es gibt eine Vielzahl von Dingen, die die beiden Bereiche deutlich voneinander unterscheiden. Es gibt jedoch Ingenieure, Entwickler und Bauherren im Bereich des Hochbaus. Sie können eine nützliche Grundlage bieten, um zu verstehen, wie diese Begriffe im Allgemeinen verwendet werden.
Im Hochbau wählen Ingenieure die Materialien aus, verwalten die Implementierung von Baumethoden, überwachen den Bauprozess, verwalten die Planungs- und Entwurfsphasen, geben technisches Fachwissen für architektonische Zeichnungen und Entwürfe und fungieren als Bindeglied zwischen den verschiedenen Beteiligten, Auftragnehmern und Anbietern. Diese technische Expertise sollte auf wissenschaftlichen Grundsätzen beruhen.
Wenn es um Bauherren im Hochbau geht, bieten sie weniger technisches Fachwissen, sondern mehr Beschaffung, Verwaltung von Geldern und Aufsicht über die Auftragnehmer und Verkäufer, die den eigentlichen Bauprozess durchführen (die Bauherren).
Hier hat die Unterscheidung zwischen einem Entwickler und einem Ingenieur mit der Trennung zwischen technischer Expertise und der Umsetzung des entworfenen Designs zu tun.
Übertragen auf die Entwicklung von Softwareanwendungen scheint es, dass wir Ingenieure haben, die die Infrastruktur und die Tools auswählen, die Architekturmuster identifizieren, die am sinnvollsten sind, die Entwicklung der Software überwachen, technisches Fachwissen in das Design einbringen und als Bindeglied zwischen den Stakeholdern und Entwicklern fungieren.
Die Entwickler schreiben den Code unter Anleitung der Ingenieure, verwalten ihre Zeit ökonomisch (idealerweise) und stellen sicher, dass die Erstellung der Anwendung den Richtlinien der Architektur und des Ingenieurwesens entspricht.
Fazit
Also, was haben wir gelernt? Wir haben gelernt, dass das Ingenieurwesen eine Disziplin ist, die die Anwendung wissenschaftlicher Prinzipien erfordert. Der sicherste Weg, das wissenschaftliche Prinzip anzuwenden, ist die Verwendung von TDD. Solange wir jedoch Tests schreiben, die das Verhalten und den Zustand validieren, auch wenn es erst im Nachhinein geschieht, könnten wir uns als Ingenieure betrachten. Die Hypothesen- und Experimentierphasen werden einfach umgekehrt.
Wir haben auch gelernt, dass es beim Engineering mehr um Design und technisches Know-how geht, während es bei der Entwicklung um das Ressourcenmanagement bei der Implementierung des Designs geht.
Vielleicht ist dies die Ursache für einen Großteil der Verwirrung. Die meisten Entwickler müssen so viel herumfummeln und herausfinden, dass sie das Ingenieurdasein zurückentwickelt haben. Sie haben so viel herumgehackt, dass sie unbeabsichtigt eine Reihe von wissenschaftlichen Prinzipien übernommen haben, auch wenn sie nicht TDD sind. Aber eines ist sicher, wenn Sie TDD machen, können Sie sich als Ingenieur betrachten.
Durch den gezielten Einsatz von wissenschaftlichen Methoden und der strukturierten Anwendung von TDD können sich Softwareentwickler zu Software-Ingenieuren entwickeln, die Software mit mehr technischer Präzision und fundiertem Wissen gestalten. Die Unterscheidung zwischen Softwareentwickler und Software-Ingenieur sollte dabei nicht nur als Begriff betrachtet werden, sondern als unterschiedliche Herangehensweisen und Fachrichtungen innerhalb der Softwareentwicklung.