it-swarm-eu.dev

Welche Programmiersprache erzeugt die wenigsten schwer zu findenden Fehler?

Welche Sprache ermöglicht es Ihrem durchschnittlichen Programmierer Ihrer Meinung nach, Funktionen mit der geringsten Anzahl schwer zu findender Fehler auszugeben? Dies ist natürlich eine sehr breite Frage, und ich interessiere mich für sehr breite und allgemeine Antworten und Weisheiten.

Persönlich finde ich, dass ich sehr wenig Zeit damit verbringe, nach seltsamen Fehlern in Java und C # -Programmen zu suchen), während C++ - Code verschiedene wiederkehrende Fehler aufweist und Python/ähnliche seine eigenen gemeinsamen und dumme Fehler, die vom Compiler in anderen Sprachen erkannt würden.

Außerdem fällt es mir schwer, funktionale Sprachen in dieser Hinsicht in Betracht zu ziehen, da ich noch nie ein großes und komplexes Programm gesehen habe, das in vollständig funktionalem Code geschrieben ist. Ihre Eingabe bitte.

Bearbeiten: Völlig willkürliche Klärung des schwer zu findenden Fehlers: Die Reproduktion dauert mehr als 15 Minuten oder die Suche und Behebung mehr als 1 Stunde.

Verzeihen Sie mir, wenn dies ein Duplikat ist, aber ich habe zu diesem speziellen Thema nichts gefunden.

54
Magnus Wolffelt

Je leistungsfähiger das Typsystem der Sprache ist, desto mehr Fehler werden beim Kompilieren selbst abgefangen.

Die folgende Abbildung vergleicht einige der bekannten Programmiersprachen hinsichtlich der Leistung, Einfachheit und Sicherheit ihrer Typsysteme. [ Quelle ]

alt text

* Berücksichtigung der Fähigkeit, unsichere Konstrukte zu verwenden.

C # wird aufgrund des Schlüsselworts "unsicher" und der zugehörigen Zeigermaschinerie in die unsichere Zeile eingefügt. Wenn Sie diese jedoch als eine Art Inline-Fremdfunktionsmechanismus betrachten möchten, können Sie C # in den Himmel stoßen.

Ich habe Haskell '98 als rein markiert, aber GHC Haskell als nicht rein aufgrund der unsicheren * Funktionsfamilie. Wenn Sie unsicher * deaktivieren, springen Sie entsprechend auf GHC Haskell.

58
missingfaktor

Meiner Meinung nach hilft Ihnen Haskell dabei, einige häufige Fehlerquellen zu vermeiden:

  • es ist rein funktional: Funktionen können keine (unbeabsichtigten) Nebenwirkungen haben, was die Multicore-Programmierung einfacher und weniger fehleranfällig macht
  • es ist stark typisiert: Sie können nicht z. Mischen Sie versehentlich die Werte bool, char, int und float
  • es ist statisch typisiert: Viele Programmierfehler werden beim Kompilieren abgefangen
  • null ist nicht Teil der Werttypdefinitionen: Auf diese Weise vermeiden Sie das Milliarden-Dollar-Fehler
  • es gibt viele vorgefertigte Funktionen höherer Ordnung, die Sie wiederverwenden können, anstatt Ihre eigenen, möglicherweise fehlerhaften Implementierungen zu schreiben
  • es hat einen Garbage Collector: Speicherfehler werden fast beseitigt (mit Ausnahme von "Speicherplatzlecks" aufgrund seiner faulen Bewertungsstrategie)
20

Traditionell sind die Race-Bedingungen in Multithread-Anwendungen am schwierigsten zu finden

  • fast unmöglich zu reproduzieren
  • kann sehr subtil sein

Daher brauchen Sie Sprachen, die den Parallismus für Sie so weit und unauffällig wie möglich verwalten. Diese sind noch nicht Mainstream. Java macht einige, aber lassen Sie mit dem schwierigen Teil.

Nach meinem Verständnis benötigen Sie eine funktionale Sprache, da die "keine Nebenwirkungen" das sind, was in erster Linie dazu führt, dass die beiden Aufzählungspunkte verschwinden. Ich habe gesehen, dass daran gearbeitet wird, Haskell transparent zu einer effizienten Multithread-Sprache zu machen, und ich glaube, dass Fortress von Grund auf als effiziente Parallelsprache konzipiert wurde.


Bearbeiten: In Java Executors werden noch mehr schwierige Teile behandelt. Sie müssen die einzelnen Aufgaben an die Callable -Schnittstelle anpassen.

18
user1249

Ada ist so konzipiert, dass so viel wie möglich zur Kompilierungszeit und nicht zur Laufzeit abgefangen wird. Dies bedeutet, dass das Kompilieren eines Programms in Ada häufig etwa zehnmal länger dauert als das Äquivalent in Java sagen, aber wenn es kompiliert wird, können Sie viel sicherer sein, dass ganze Klassen von Fehlern werden sich nicht manifestieren, wenn das Programm ausgeführt wird.

13
Mark Pim

Zuerst eine Definition: Ein schwer zu findender Fehler, so wie ich ihn verstehe, ist ein Fehler, der reproduziert werden kann, dessen Ursache jedoch schwer zu finden ist.

Der wahrscheinlich wichtigste Aspekt ist das, was ich als Enge bezeichnen würde, d. H. Wie weit kann ein Fehler entkommen, wie groß ist der Umfang, den ein Fehler möglicherweise beeinflussen kann. In Sprachen wie C kann ein Fehler, z. Ein negativer Array-Index oder ein nicht initialisierter Zeiger kann buchstäblich alles überall im gesamten Programm beeinflussen. Im schlimmsten Fall müssen Sie also alles überall überprüfen , um es zu finden die Quelle Ihres Problems.

Gute Sprachen in dieser Hinsicht unterstützen Zugriffsmodifikatoren und erzwingen sie auf eine Weise, die es schwierig oder unmöglich macht, sie zu umgehen. Gute Sprachen ermutigen Sie, den Umfang Ihrer Variablen einzuschränken, anstatt es zu einfach zu machen, globale Variablen zu haben (z. B. "Alles, was nicht explizit deklariert ist, ist eine globale Variable mit einem Standardtyp und -wert").

Der zweite wichtige Aspekt ist Parallelität. Rennbedingungen sind im Allgemeinen schwer zu reproduzieren und daher schwer zu finden. Gute Sprachen bieten benutzerfreundliche Synchronisationsmechanismen, und ihre Standardbibliotheken sind bei Bedarf threadsicher.

Damit ist meine Liste bereits vervollständigt. Andere Dinge wie starkes Tippen helfen dabei, Fehler beim Kompilieren zu erkennen, aber diese Fehler sind später wahrscheinlich nicht schwer zu finden.

In Anbetracht dessen würde ich sagen, dass Java und C # sowie viele andere Sprachen in der JVM- und .net-Welt geeignet sind, um schwer zu findende Fehler zu vermeiden.

7
user281377

Da Excel das am häufigsten verwendete DSL ist, werde ich mich für Excel entscheiden. (natürlich ohne VBA)

Es passt zur Rechnung:

  • Es ist immer einfach zu reproduzieren (hier ist eine Tabelle - es funktioniert nicht)
  • Es ist ziemlich einfach, den Fehler zu finden, da er völlig "funktionsfähig" ist. Beginnen Sie mit der Zelle, die falsch ist, und verfolgen Sie alle Abhängigkeiten zurück.
7
Scott Whitlock

Dies ist eine schwierige Frage, da die meisten Fehler nicht die Schuld der Sprache selbst sind, sondern die Schuld der Entwickler, die Fehler bei der Verwendung der Sprache machen.

Ich glaube, es gibt verschiedene Aspekte von Sprachfunktionen, die die Wahrscheinlichkeit von Fehlern beeinflussen:

  • Interaktivität - Dynamische Sprachen mit REPLs fördern die Interaktion/das Experimentieren mit laufenden Programmen und viel kleineren Code-/Testzyklen. Wenn Sie der Meinung sind, dass Iteration ein guter Weg ist, um saubere, einfache Lösungen zu finden und Fehler zu erkennen/zu beseitigen, würde dies tendenziell interaktive Sprachen bevorzugen.

  • Ausdruckskraft - Wenn der Code kürzer ist und weniger Komplexität aufweist, ist es einfacher, Fehler/Logikfehler zu erkennen.

  • Typensicherheit - Je mehr Überprüfungszeit überprüft wird, desto mehr Fehler werden vom Compiler abgefangen. Daher ist Typensicherheit im Allgemeinen eine gute Sache. Diese sind jedoch normalerweise keine schwer zu findenden Fehler - selbst in einer vollständig dynamischen Sprache führt der falsche Typ in einer Datenstruktur normalerweise zu einem sehr offensichtlichen Laufzeitfehler, und TDD greift diese Art fast immer auf von Fehlern.

  • Unveränderlichkeit - Viele harte Fehler sind auf komplexe Wechselwirkungen des veränderlichen Zustands zurückzuführen. Sprachen, die Unveränderlichkeit betonen (Haskell, Clojure, Erlang), haben einen enormen Vorteil, indem sie Mutabilität vermeiden

  • Funktionale Programmierung - Funktionale Ansätze zum Schreiben von Code sind in der Regel "nachweislich korrekter" als objektorientierter Code mit komplexen Folgen von Effekten/Interaktionen. Ich habe die Erfahrung gemacht, dass FP hilft, knifflige Fehler zu vermeiden - ich glaube, es gibt irgendwo akademische Forschungen, die ich derzeit nicht finden kann, die dies belegen.

  • Parallelitätsunterstützung - Parallelitätsprobleme sind besonders schwer zu erkennen und zu debuggen, weshalb dies so wichtig ist. Alles, was manuelles Sperren erfordert, ist letztendlich zum Scheitern verurteilt (und dies schließt so ziemlich den objektorientierten Ansatz zur Parallelität ein jeder). Die beste Sprache, die ich in dieser Hinsicht kenne, ist Clojure - es hat einen einzigartigen Ansatz zur Verwaltung der Parallelität, der Software-Transaktionsspeicher mit unveränderlichen Datenstrukturen kombiniert, um ein neuartiges, zuverlässiges und zusammensetzbares Parallelitäts-Framework zu erhalten. Weitere Informationen finden Sie unter http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey

7
mikera

Je weniger mächtig eine Sprache ist, desto weniger Möglichkeiten haben Sie, Ihren eigenen Fuß zu schießen.

Hochsprachen wie Java und C # erzeugen weniger Fehler als Niedrigsprachen wie C++.

Trotzdem glaube ich, dass Java ist sicherer als C #. Java ist künstlich begrenzt, so dass ein durchschnittlicher Programmierer ohne fortgeschrittene Kenntnisse es beherrschen und stabile Programme produzieren kann.

5
user8685

Welche Sprache ermöglicht es Ihrem durchschnittlichen Programmierer Ihrer Meinung nach, Funktionen mit der geringsten Anzahl schwer zu findender Fehler auszugeben?

Meiner Meinung nach Delphi. Da die Sprache auf Pascal basiert, ist sie einfach und intuitiv genug, damit der durchschnittliche Programmierer (oder sogar unerfahrene Programmierer) sie leicht erlernen kann Durch die Unterstützung der Bibliothek sind die meisten Fehler leicht zu finden.

  • Starke Typisierung und ein strenger Compiler, der viele häufige Fehler abfängt.
  • Intuitive Syntax, die keine häufigen Fehler fördert. ("Der letzte Fehler der Welt", if (alert = RED) {LaunchNukes;}, wird beispielsweise nicht kompiliert.)
  • Ein gut gestaltetes Objektmodell, das viele der häufigsten C++ OOP Fehler) beseitigt.
  • In die Sprache integrierte Grenz- und Bereichsprüfung reduziert das Risiko von Sicherheitsproblemen drastisch.
  • Wahrscheinlich der schnellste bekannte Compiler, der Ihre Produktivität steigert und es schwieriger macht, Ihren Gedankengang zu verlieren, während Sie auf einen Build warten.
  • Der Debugger Der Debugger von Visual Studio möchte so sein, wie er aufwächst.
  • Die direkt im Speichermanager integrierte Leckverfolgung macht das Auffinden und Beheben von Speicherlecks trivial.
  • Eine große, ausgereifte Standardbibliothek, die vorgefertigte und vorab getestete Möglichkeiten bietet, um allgemeine Aufgaben zu erledigen, ohne eigene, möglicherweise fehlerhafte Implementierungen erstellen zu müssen.
  • Wird mit nützlichen Tools wie einem leistungsstarken Protokollierungssystem und einem Profiler geliefert, um das Aufspüren von Problemen zu vereinfachen.
  • Starke Community-Unterstützung für häufig auftretende Probleme, die nicht in der Standardbibliothek enthalten sind, einschließlich einer leistungsstarken Parallelitätsbibliothek von Drittanbietern .
3
Mason Wheeler

Eine zu berücksichtigende Sache ist die Bearbeitungszeit.

In den letzten fünf Jahren habe ich hauptsächlich Webanwendungen in Java (JSF, Seam usw.) entwickelt. Vor kurzem habe ich einen neuen Job bekommen und wir verwenden Perl (mit Katalysator und Elch).

Ich bin in Perl viel produktiver als in Java.

Ein Grund dafür ist, dass keine Kompilierung und (Hot-) Bereitstellung erforderlich ist. Ich finde auch, dass das Schreiben von Anwendungsfällen einfacher ist, da es iterativer durchgeführt werden kann. Und die Frameworks in Java scheinen unnötig komplex zu sein, zumindest für die Projekte, an denen ich beteiligt war.

Ich denke, die Anzahl der Fehler in meinem Perl-Code ist mehr oder weniger gleich der Anzahl der Fehler in meinem Java-Code, es könnte sogar höher sein. Aber ich finde es einfacher und schneller Finden und beheben Sie diese Fehler.

2
slu

Vielleicht könnte es eine Idee geben, die Anzahl der verfügbaren Tools für die statische und dynamische Code-Analyse für jede Programmiersprache zu untersuchen. Je mehr Tools für eine Sprache verfügbar sind, desto wahrscheinlicher ist es, dass die Sprache entweder bei Benutzern sehr beliebt ist oder bei der Erzeugung schwer zu findender Fehler sehr beliebt ist. Ich kann Google jedoch nicht dazu bringen, mich auf eine Studie zu diesem Thema hinzuweisen. Es sollte auch beachtet werden, dass einige Sprachen wie C verwendet werden können, um die zugrunde liegenden Hardwarefehler sowie den Verschleiß der Hardware im Alter zu umgehen.

1
vpit3833

Anstatt über Sprachen zu sprechen, sollten Sie über Sprachfunktionen sprechen

  • Java zwingt Sie, über Ausnahmen nachzudenken (Würfe ...), und Sie müssen diese Ausnahmen entweder veröffentlichen oder behandeln. Verhindert das wirklich, dass ich Fehlersituationen vergesse, oder verwende ich mehr Ausnahmen, die von SystemException abgeleitet sind und diese Behandlung nicht benötigen?
  • was ist mit "Design by Contract" (http://en.wikipedia.org/wiki/Design_by_contract), das mich dazu zwingt, über Vor- und Nachbedingungen nachzudenken? Ich habe gelesen, dass das jetzt mit c # -4.0 möglich ist.
1
k3b