Die Beziehung zwischen Softwarekompliziertheit und Softwarezuverlässigkeit

An enduring engineering problem is the creation of unreliable software leading to unreliable systems. One reason for this is source code is written in a complicated manner making it too hard for humans to review and understand. Complicated code leads to other issues beyond dependability, such as expanded development efforts and ongoing difficulties with maintenance, ultimately costing developers and users more money. There are many ideas regarding where blame lies in the reation of buggy and unreliable systems. One prevalent idea is the selected life cycle model is to blame. The oft-maligned “waterfall” life cycle model is a particularly popular recipient of blame. In response, many organizations changed their life cycle model in hopes of addressing these issues. Agile life cycle models have become very popular, and they promote communication between team members and end users. In theory, this communication leads to fewer misunderstandings and should lead to less complicated and more reliable code. Changing the life cycle model can indeed address communications ssues, which can resolve many problems with understanding requirements. However, most life cycle models do not specifically address coding practices or software architecture. Since lifecycle models do not address the structure of the code, they are often ineffective at addressing problems related to code complicacy. This dissertation answers several research questions concerning software complicacy, beginning with an investigation of traditional metrics and static analysis to evaluate their usefulness as measurement tools. This dissertation also establishes a new concept in applied linguistics by creating a measurement of software complicacy based on linguistic economy. Linguistic economy describes the efficiencies of speech, and this thesis shows the applicability of linguistic economy to software. Embedded in each topic is a discussion of the ramifications of overly complicated software, including the relationship of complicacy to software faults. Image recognition using machine learning is also investigated as a potential method of identifying problematic source code. The central part of the work focuses on analyzing the source code of hundreds of different projects from different areas. A static analysis was performed on the source code of each project, and traditional software metrics were calculated. Programs were also analyzed using techniques developed by linguists to measure expression and statement complicacy and identifier complicacy. Professional software engineers were also directly surveyed to understand mainstream perspectives. This work shows it is possible to use traditional metrics as indicators of potential project bugginess. This work also discovered it is possible to use image recognition to identify problematic pieces of source code. Finally, this work discovered it is possible to use linguistic methods to determine which statements and expressions are least desirable and more complicated for programmers. This work’s principle conclusion is that there are multiple ways to discover traits indicating a project or a piece of source code has characteristics of being buggy. Traditional metrics and static analysis can be used to gain some understanding of software complicacy and bugginess potential. Linguistic economy demonstrates a new tool for measuring software complicacy, and machine learning can predict where bugs may lie in source code. The significant implication of this work is developers can recognize when a project is becoming buggy and take practical steps to avoid creating buggy projects.Ein nach wie vor ungelöstes technisches Problem ist das Erstellen unzuverlässiger Software, was zu unzuverlässigen Systemen führt. Eine der Ursachen ist, dass Quellcode auf zu komplizierte Weise geschrieben wird, so dass es für Menschen zu schwierig wird, ihn zu überprüfen und zu verstehen. Komplizierter Code führt über die Zuverlässigkeit hinaus zu weiteren Problemen, wie z. B. erweiterte Entwicklungsanstrengungen und anhaltenden Schwierigkeiten bei der Wartung, was Entwickler und Benutzer letztendlich mehr Geld kostet. Vielfach schiebt man die Schuld an der Entwicklung von BuggySystemen auf das gewählte Lebenszyklusmodell. Das oft geschmähte "Wasserfall"-Modell wird besonders häufig beschuldigt. Als Reaktion darauf änderten viele Organisationen ihr Lebenszyklusmodell in der Hoffnung, diese Probleme zu beheben. Agile Lebenszyklusmodelle sind sehr beliebt und fördern die Kommunikation zwischen Entwicklungsteam und Endnutzern. Theoretisch führt diese Kommunikation zu weniger Missverständnissen, und ein besseres Verständnis sollte zu weniger kompliziertem und zuverlässigerem Code führen. Eine Änderung des Lebenszyklusmodells kann tatsächlich Kommunikationsprobleme lösen, insbesondere beim Verständnis der Anforderungen. Die meisten Lebenszyklusmodelle selbst befassen sich jedoch nicht speziell mit Codierungspraktiken oder Softwarearchitekturen. Da Lebenszyklusmodelle aber nicht auf die Struktur des eigentlichen Codes eingehen, sind sie bei der Lösung von Problemen im Zusammenhang mit Codekompliziertheit wenig hilfreich. Diese Dissertation behandelt mehrere Forschungsfragen zur Softwarekompliziertheit, beginnend mit einer Untersuchung traditioneller Metriken und statischer Analyse, um ihre Nützlichkeit als Messwerkzeug zu bewerten. Diese Dissertation etabliert auch ein wesentliches neues Konzept der angewandten Linguistik, indem sie auf der Basis der linguistischen Ökonomie ein Maß für Softwarekompliziertheit erstellt. Die linguistische Ökonomie beschreibt die Effizienz von Sprache, und diese Arbeit zeigt ihre Anwendbarkeit auf Software. Darin eingeschlossen ist eine Diskussion der Auswirkungen übermäßig komplizierter Software sowie des Zusammenhangs zwischen Kompliziertheit und Softwarefehlern. Als potenzielle Methode zur Identifizierung von problematischem Quellcode wird auch Bilderkennung mittels maschinellen Lernens untersucht. Der zentrale Teil der Arbeit konzentriert sich auf die Analyse des Quellcodes hunderter verschiedener Projekte aus unterschiedlichen Bereichen. Zuerst wird eine statische Analyse des Quellcodes jedes Projekts durchgeführt und traditionelle Softwaremetriken berechnet. Programme werden auch unter Verwendung linguistischenr Techniken analysiert, um die Kompliziertheit von Ausdrücken und Aussagen sowie die Kompliziertheit von Identifikatoren zu messen. Professionelle Software-Ingenieure wurden auch direkt befragt, um Mainstream-Perspektiven zu verstehen. Diese Arbeit zeigt, dass es möglich ist, traditionelle Metriken als Indikatoren für potenzielle Projektfehler zu verwenden. Sie belegt auch die Möglichkeit, vermittels Bilderkennung problematische Teile im Quellcode zu identifizieren. Schließlich beschreibt diese Arbeit die Entdeckung linguistischer Verfahren als neue Methode, Anweisungen und Ausdrücke zu identifizieren, die für Programmierer am wenigsten wünschenswert, da zu kompliziert sind. Die Hauptschlussfolgerung dieser Arbeit ist: Es gibt mehrere Möglichkeiten, Merkmale zu finden, die darauf hindeuten, dass ein Projekt oder ein StückQuellcode fehlerbehaftet ist. Herkömmliche Metriken und statische Analysen können verwendet werden, um ein Verständnis für Kompliziertheit und Fehlerpotenziale von Software zu erlangen. Die linguistische Ökonomie demonstriert ein neues Werkzeug zur Messung von Softwarekompliziertheit, und maschinelles Lernen kann vorhersagen, wo potenzielle Fehler im Quellcode liegen könnten. Das wesentliche Ergebnis dieser Arbeit ist, Entwicklern Werkzeuge zur Verfügung zu stellen, mit denen sie erkennen können, dass ein Projekt fehlerhaft wird. So können sie praktische Schritte unternehmen, um fehlerhafte Projekte zu vermeiden