Die zunehmende Komplexität moderner Softwarestrukturen bringt Softwareentwickler immer mehr in Bedrängnis. Die Komplexität von Software macht die Arbeit von Entwicklern anstrengend, da die Planung, Erstellung und das Testen von Produkten immer schwieriger wird. Die Einführung neuer Sicherheitsanforderungen führt zu Frustration bei Administratoren und Benutzern. In den meisten Fällen sind kompliziert und komplex nicht voneinander zu unterscheiden, aber nicht in diesem Fall. Komplexität deutet darauf hin, dass etwas schwer zu verstehen ist, aber mit der Zeit und bei entsprechender Anstrengung kann es schließlich erkannt werden. Auf der anderen Seite steht Komplexität für die Verbindung zwischen mehreren Entitäten. Wenn die Anzahl der Entitäten zunimmt, nehmen auch die Verbindungen enorm zu und erreichen einen Punkt, an dem es unpraktisch ist, sie zu kennen und zu verstehen.
Dementsprechend erhöht ein übermäßiges Maß an Komplexität in der Software das Risiko, versehentlich die Verbindungen zu blockieren. Etwas, das die Wahrscheinlichkeit der Einführung von Fehlern bei der Implementierung von Änderungen erhöht, kann die Verbesserung der Software praktisch unmöglich machen.
Software-Komplexität
Die Komplexität von Software bezeichnet die Schwierigkeit, Software zu warten, zu analysieren, zu testen, zu modifizieren und zu entwerfen. Je höher die Komplexität, desto anspruchsvoller ist es, die Software zu lesen und zu warten, und desto größer ist die Wahrscheinlichkeit, dass Fehler und Defekte auftreten. Softwarekomplexität ist eine Technik, die eine bestimmte Gruppe von Code-Merkmalen ausdrückt. Diese Merkmale konzentrieren sich darauf, wie Ihr Code mit anderen Teilen des Codes zusammenhängt.
Die Softwarekomplexität gilt als ein wesentlicher Bestimmungsfaktor für die Kosten der Softwarewartung. Eine höhere Softwarekomplexität bedeutet, dass Wartungs- und Verbesserungsprojekte länger dauern, viel mehr kosten und zu mehr Fehlern führen. Die Softwarekomplexität eines bestimmten Systems ist eine der wichtigsten langfristigen Auswirkungen der bei der ursprünglichen Entwicklung verwendeten Tools und Ansätze. So führt beispielsweise der Einsatz neuer CASE-Ausrüstung zur Entwicklung von schlecht strukturierter Software. Die Folgen dieser schlechten Struktur werden Sie zu spüren bekommen, wenn es an der Zeit ist, das System anzupassen.
Arten von Software-Komplexität
Die Komplexität von Software wird mit der Entwicklung der technischen Industrie immer mehr zu einem Problem. Als Entwickler verbringen Sie häufig viel Zeit mit dem Schreiben, aber noch mehr Zeit verbringen Sie mit der Pflege dieses Codes. Wie oft stellen Sie fest, dass der Code so unübersichtlich geworden ist, dass Sie ihn fast nicht mehr verstehen können? Um zu verstehen, wie man mit der ständig zunehmenden Komplexität umgehen kann, ist es wichtig, die drei grundlegenden Arten von Softwarekomplexität zu unterscheiden.
Wesentliche Komplexität
Wesentliche Komplexität findet sich in der Regel in dem Geschäftsfeld, in dem Sie arbeiten. Sie ist mit dem Problem verbunden und kann nicht entfernt werden. Sie haben mit den Regeln der Geschäftspolitik zu tun, die die Geschäftsabläufe in spezifischerer Weise steuern. Wenn Sie sich bemühen, diese Regeln anzuwenden und ihre Verarbeitung zu automatisieren, stoßen Sie auf verschiedene Ebenen der Komplexität. Die Tatsache, dass Unternehmen in der Regel äußerst undurchdringliche Umgebungen sind, macht das Problem, das Sie zu lösen versuchen, von Natur aus komplex. Die wesentliche Komplexität ergibt sich aus den Eigenschaften des zu lösenden Problems und kann nicht eingegrenzt werden.
Egal, wie sehr Sie sich bemühen, diese Komplexität lässt sich nicht vermindern, denn die Geschäftspolitik, die die Bearbeitung eines Schadensfalls regelt, sieht 15 verschiedene Schritte vor. Daher können Sie die Regeln nicht klären, indem Sie einige Schritte auslassen und die Bearbeitung auf einige wenige grundlegende Schritte reduzieren. Unterm Strich ist die notwendige Komplexität unvermeidlich und in erster Linie der eigentliche Grund, warum Sie als Softwareentwickler tätig sind.
Unbeabsichtigte Komplexität
Diese Komplexität bezieht sich auf die Lösung eines Problems, die direkt damit zusammenhängt, wie Sie sich entscheiden, es zu lösen, und hat weniger mit der Art der Komplikation zu tun. Wenn Sie eine Strategie wählen, um ein Problem zu lösen, das mehr Komplexität und Arbeit erfordert, ist das zufällige Komplexität. Es könnte die Wahl Ihrer Softwareentwicklungswerkzeuge sein und das, was Sie bei der Entschlüsselung des Problems auf den Tisch legen. Diese Komplexität ist der Situation, die Sie lösen sollen, nicht inhärent, sondern hat sich versehentlich eingeschlichen. Unbeabsichtigte Komplexität äußert sich in schlechtem Design oder Struktur, Code und mangelhaften Softwareentwicklungsverfahren. Die einzige Möglichkeit, unbeabsichtigte Komplexität zu beseitigen, besteht darin, ihre Quelle zu eliminieren.
Sie können eine zufällige Komplexität nicht absichtlich herbeiführen. Schon der Name sagt alles: „zufällig“. Sie tritt manchmal auf, wenn Sie:
- Möchten Sie eine neue Sprache oder ein neues Tool verwenden, um ein Projekt zu bewältigen, das nicht geeignet ist?
- Sind Sie gezwungen, ein bestimmtes technisches Paket zu verwenden?
- Mangel an Wissen über die akzeptabelsten Praktiken zur Entschlüsselung dieses speziellen Problems.
Ursachen für Komplexität in Software
Das grundlegende Problem von Software ist die Komplexität. Software ist ein groß angelegtes System, das aus Hunderten von Mikrodiensten besteht, die sich gegenseitig aufrufen und voneinander abhängen. Viele Aspekte der Software sind möglicherweise nicht ganz klar definiert. Hier erörtern wir einige der entscheidenden Ursachen, die zu Komplexität in der Softwareentwicklung führen, wie unten aufgeführt.
- Die Wahl der falschen Tools. Gelegentlich haben Sie es entweder eilig, loszulegen, oder Sie lieben es einfach, ein bestimmtes Tool zu verwenden, wenn Sie an Code arbeiten. Nehmen wir an, Sie arbeiten an einer vierseitigen Website, die Ruby on Rails oder eine RESTful Web-API erfordert, aber Sie bestehen darauf, die Website mit Objective C zu erstellen. Nicht, dass Objective C effektiv oder gut genug wäre, aber es wurde einfach für das falsche Problem implementiert. Das kann zu Komplexität in Ihrem Code führen.
- Systeme auf Systemen aufbauen – Systeme werden hierarchisch formuliert. Bankensysteme werden zum Beispiel auf Internet-Software aufgebaut, die auf Telekommunikationssoftware basiert. Telekommunikationssoftware dezentralisiert die Kauf- und Entscheidungsbefugnis intern und extern aufgrund der entscheidenden agilen Rekonfiguration der Cloud. Dies führt auch zu Softwarekomplexität.
- Die Anwendung der falschen Abstraktionen. Von Zeit zu Zeit entdecken Sie Software, die sich auf ein bestimmtes Vokabular bezieht, z.B. Bibliotheksdatensätze, aber in einer anderen Sprache geschrieben wurde, z.B. in einem CMSes Posts-Datentyp. Die Abstraktion ist gut, aber sie ist nicht die richtige. Alles wurde durch die Notwendigkeit, die Inkonsistenz zwischen den beiden Konzepten zu manipulieren, noch viel schwieriger.
WERKZEUGE ZUR REDUZIERUNG DER KOMPLEXITÄT DER KODIERUNG
Die in einem System enthaltene Funktionalität und die Integration zwischen seinen Teilsystemen beeinflussen offenkundig die Komplexität des Systems. Eine ideale Stabilität zwischen den Funktionen und der Koordination innerhalb eines Systems ist erforderlich, um eine geringere Komplexität zu erreichen. In der realen Welt können Sie die Software nicht immer einfach halten. Typischerweise neigen Anwendungsattribute, die einen geschäftlichen Nutzen bieten, dazu, komplex zu sein. Viele Wege konzentrieren sich jedoch darauf, die Komplexität für Ingenieure zu verringern. Neben der Nutzung von Microservice-Architekturen können auch andere Ansätze genutzt werden, um die Komplexität in Ihrer Anwendung zu minimieren.
Software-unterstützte Entwicklung
Dabei handelt es sich um die Fähigkeit, Tools zu nutzen, die in der Regel durch künstliche Intelligenz und Techniken des maschinellen Lernens unterstützt werden, um Sie beim Schreiben von Code zu unterstützen, Probleme im Code zu diagnostizieren und die Gesamtkomplexität des Codes zu kontrollieren. Dieser Ansatz ermöglicht es Ihnen, genaue und schnelle Tests durchzuführen, die die Komplexitätsrate minimieren, da Bugs leicht zu erkennen sind und den Entwicklungsprozess verkürzen. Unternehmen wie GitHub nutzen KI, um Entwicklern zu helfen, zuverlässigeren Code mit weniger Fehlern zu schreiben.
Einrichtung einer internen Plattform
Die zunehmende Komplexität hat viele Unternehmen dazu veranlasst, ein internes Plattformmodell einzuführen. Das interne Plattformteam ist damit betraut, die wichtigsten Tools von Ingenieuren zu bewerten, Vorlagen zu strukturieren und ihren Produktionsprozess zu erleichtern. Das Team konzentriert sich auch auf Funktionen wie Sicherheit, Finanzoperationen und Governance, um die kognitive Belastung der einzelnen Entwickler zu verringern.
Die Lösung für eine akzeptable interne Entwicklerplattform besteht darin, das Gleichgewicht zwischen Selbstbedienung für Entwickler, die mit der Arbeit beginnen möchten, und Abstraktion der kleineren praktischen Aufgaben zu wahren, ohne die Entwickler einzuschränken.
METRIKEN ZUR SOFTWAREKOMPLEXITÄT
Je höher die Komplexität, desto anstrengender ist es, den Code zu pflegen und zu lesen, und desto mehr Fehler und Defekte werden Sie finden. Die Messung der Softwarekomplexität kann Ihnen helfen, das Problem zu verstehen und anzugehen, solange es noch klein ist. Die folgenden Metriken können zur Bewertung der Komplexität herangezogen werden.
Zyklomatische Komplexität
Diese Metrik basiert auf der Graphentheorie und anderen mathematischen Definitionen. Die zyklomatische Komplexität misst die strukturelle Komplexität des Codes. Diese Metrik schätzt die Anzahl der linear unabhängigen Pfade durch ein Programm. Ein linear unabhängiger Ansatz ist eine schicke Umschreibung für einen eindeutigen Pfad, bei dem Sie Schleifen nur einmal zählen. Operationen wie IF, DO und SELECT stellen bedingte Logik dar und machen das Programm schwerer verständlich. Je mehr solcher Prozeduren im Code vorhanden sind, desto mehr logische Verzweigungen beherbergen sie und desto höher ist die zyklomatische Komplexität.
Diese Kennzahl kann mit der folgenden Formel ermittelt werden
V(G) = e – n + 2p
Wobei: e = die Anzahl der Kanten im Graphen ist
n = Anzahl der Noten im Diagramm
p = Anzahl der verbundenen Komponenten
Wartungsfreundlichkeits-Index
Damit wird ein Indexwert zwischen 0 und 100 berechnet, der die relative Wartungsfreundlichkeit des Codes angibt. Mit anderen Worten, diese Metrik misst, wie wartungsfreundlich Ihr Code ist. Je höher der Wert, desto besser ist die Wartbarkeit Ihres Codes. Der Wartbarkeitsindex wird als eine Formel aus SLOC (Source Lines Of Code), zyklomatischer Komplexität und Halstead-Volumen berechnet.
Halstead Metriken
Die Metrik schätzt, wie viele Sachinformationen im Quellcode vorhanden sind, einschließlich der Anzahl der Variablen und wie sie im Quellcode, in den Funktionen und Methoden verwendet werden. Es wird spekuliert, dass ein Programm umso komplexer ist, je mehr unabhängige Elemente im Code vorhanden sind und je mehr von ihnen verwendet werden. Diese Metrik hängt von der Code-Ausführung und ihren Maßen ab, die statisch aus den Operatoren und Operanden im Quellcode berechnet werden.
Halsteads Metrik kann mit der folgenden Formel berechnet werden
Schwierig = L / V
Wobei: L = Programm Level
V = Programmvolumen
Die Formel zur Bestimmung der Programmstufe L lautet:
L = (2 + n2*) *log2 (2 + n2*)
Dabei gilt: n1 = Anzahl der Operatoren
N2 = Anzahl der Operanden
Das Programm zur Bestimmung des Programmvolumens V lautet:
V = (N1 + N2)* log2 (n1 + n2)
Wobei: N1 = Gesamtzahl der Operator-Ereignisse
N2 = Gesamtzahl der Operandenvorkommen
Objektorientierte Design-Metriken
Quantitative Metriken für objektorientiertes Design konzentrieren sich normalerweise auf Klassen- und Designmerkmale. Sie ermöglichen es den Entwicklern, Software in einem frühen Stadium der Entwicklung zu bewerten und zu verstehen, wie man die Komplexität minimieren und die Wartbarkeit verbessern kann.
AUSWIRKUNGEN DER SOFTWAREKOMPLEXITÄT
Auswirkung der Komplexität auf die Fehlerquote.
Das Ziel, warum wir Entwickler uns über die Komplexität aufregen, hängt mit wichtigeren Merkmalen des Softwareentwicklungsprozesses zusammen. Je schwieriger der Code zu verstehen ist, desto wahrscheinlicher ist es, dass Programmierfehler unentdeckt bleiben. Wenn ein Programm schwer zu testen ist, werden Fehler nicht entdeckt, bevor die Software funktioniert.
Sie erwarten hohe Fehlerquoten in Programmen, die eine hohe Entscheidungsdichte aufweisen (mit ihrer gleichmäßig verteilten Anzahl von Entscheidungspfaden zum Testen auf Fehler). In solchen Systemen werden wahrscheinlich neue Fehler erzeugt.
Auswirkungen der Komplexität auf die Wartungskosten
Die Komplexität von Software wirkt sich direkt auf die Wartungskosten aus. Je anspruchsvoller ein komplexes Anwendungssystem zu warten ist, desto mehr Kosten entstehen bei der Wartung, die einen Großteil des Entwicklungsprozesses in Anspruch nimmt. Die Softwarewartung wird als ein Produktionsverfahren betrachtet, dessen Inputs Computerressourcen und Arbeit sind und dessen Output ein verbesserter Code ist. Arbeitsstunden sind wesentlich bedeutender als Computerressourcen, und beide lassen sich nur in geringem Maße ersetzen. Das Hauptaugenmerk liegt auf den Arbeitsstunden, die den größten Teil der Kosten ausmachen.
EIN MITTEL GEGEN DIE KOMPLEXITÄT IN DER SOFTWAREENTWICKLUNG
Auch wenn Microservice-Architekturen umfangreichere und komplexere Anwendungen erstellen, entlasten sie die Entwickler von der Arbeit. Microservice-Architekturen erzeugen eine komplexere Anwendung als eine entsprechende Anwendung, die als Monolith aufgebaut ist. Das bedeutet jedoch nicht, dass die Arbeit des Entwicklers komplizierter ist.
Komplexität der Microservice-Architektur.
Die Microservices-Architektur ist eine DevOps-Methode, die eine dynamischere und agilere Technik für die Ausführung, Entwicklung und Verwaltung von Anwendungen bietet, indem sie mit modularen Komponenten im Gegensatz zu einem monolithischen Aufbau arbeitet.
Viele gehen davon aus, dass Microservices alle Probleme mit der Softwarekomplexität lösen können. Sie können jedoch nur fünfzig Prozent dieser Probleme allein rehabilitieren. Um die andere Hälfte zu lösen, müssen Sie Microservices mit den neuesten DevSecOps-Praktiken kombinieren und Ihr Unternehmen in die ultimative Killermaschine verwandeln.
Microservices ermöglichen es Unternehmen, täglich eine Million Implementierungen durchzuführen, das System bis ins Unendliche zu skalieren, die Komplexität der Codebasis zu minimieren und Ressourcen zu sparen. Microservices verlagern die Komplexität von den Diensten auf die Plattform, das Ignorieren des Faktischen führt zu suboptimalen Ergebnissen. Viele Unternehmen haben monolithische Anwendungen entwickelt, nur um dann festzustellen, dass sie zu komplex werden. Als Entwickler, der in einer einzigen Codebasis arbeitet, ist es mühsam, unabhängig voneinander Funktionen hinzuzufügen und Fehler zu beheben. Dies schränkt in der Regel die Anzahl der Projekte ein, an denen Sie in einer einzigen Anwendung arbeiten können.
Microservices machen eine Anwendung weniger komplex, indem sie bestimmte Teile davon entfernen. Wenn Sie die Anwendung in verschiedene Module aufteilen, versuchen Sie, die Komplexität aufzuteilen, um die Anzahl der Entwickler zu minimieren, die an einer einzigen Codebasis arbeiten. Die Aufteilung kann so erfolgen, dass Sie eine organisierte Komplexität entwickeln, die leicht zu verstehen ist.
Das Modell der Softwarekomplexität
Die Ursachen der Komplexität wurden bereits in der Einleitung dieses Kapitels erörtert. Die Komplikation verleiht dem Projekt eine inhärente Komplexität, und dann entsteht im Laufe des Designs und der Phase des Softwareentwicklungsprozesses mehr Komplexität. Auf der Grundlage dieses Modells vereint sich die Komplexität mit anderen Faktoren, um die Fehleranfälligkeit und den Umfang des Programms zu bestimmen. Die Diskussion über das Wesen, die Quellen und die Auswirkungen von Softwarekomplexität sowie ein theoretischer Rahmen für eine grafische Darstellung des Konzepts der Softwarekomplexität wurden ebenfalls bereitgestellt.
SCHLUSSFOLGERUNG
Viele Unternehmen müssen sich mit Softwarekomplexität auseinandersetzen, und die Ansätze, die Sie bei der Bewältigung dieser Komplexität anwenden, werden die Zukunft Ihres Unternehmens beeinflussen. Es gibt verschiedene Möglichkeiten, die Softwarekomplexität zu bewältigen. Ansätze wie die Einrichtung einer internen Plattform und die Standardisierung externer Dienste im gesamten Unternehmen könnten gute Strategien sein.
Auch wenn Microservice-Architekturen die Softwarekomplexität erhöhen, bieten sie den Vorteil, dass sie die kognitive Belastung und die visuelle Komplexität für den einzelnen Entwickler minimieren.
