Lohnt es sich, statisch zu tippen?

Ich fing an, in Python hauptsächlich dort zu programmieren, wo es keine Typensicherheit gibt, und wechselte dann zu C # und Java, wo es gibt. Ich stellte fest, dass ich in Python etwas schneller und mit weniger Kopfschmerzen arbeiten konnte, aber andererseits sind meine C # - und Java-Apps viel komplexer, so dass ich Python vermutlich noch nie einem echten Stresstest unterzogen habe.

Die Java- und C # -Camps lassen es so klingen, als ob die meisten Menschen ohne die Art von Sicherheit auf alle möglichen schrecklichen Fehler stoßen würden und es wäre mehr Ärger als es wert wäre.

Dies ist kein Sprachvergleich. Behandeln Sie daher keine Probleme wie kompiliert oder interpretiert. Lohnt sich die Schriftsicherheit, um Entwicklungsgeschwindigkeit und Flexibilität zu erreichen? WARUM?

an die leute, die ein beispiel für die meinung haben wollten, dass dynamisches tippen schneller ist:

"Verwenden Sie während der Entwicklung eine dynamisch geschriebene Sprache. Dadurch erhalten Sie ein schnelleres Feedback, kürzere Bearbeitungszeiten und eine schnellere Entwicklung." - http://blog.jayway.com/2010/04/14/static-typing-is-the-root-of-all-evil/

Es ist eine Art Mythos, dass sich Programmierer nicht um Typen in dynamisch getippten Sprachen kümmern müssen.

In dynamisch getippten Sprachen:

• Sie müssen noch wissen, ob Sie mit einem Array, einer Ganzzahl, einer Zeichenfolge, einer Hash-Tabelle, einer Funktionsreferenz, einem Wörterbuch, einem Objekt oder was auch immer arbeiten.

• Wenn es sich um ein Objekt handelt, müssen Sie wissen, zu welcher Klasse es gehört.

• Das Zuweisen eines dieser Typen zu einer Variablen oder einem Funktionsparameter, von dem ein anderer Typ erwartet wird, ist fast immer ein Fehler.

• Auf einer niedrigeren Ebene müssen Dinge wie die Anzahl der Bits oder die Anzahl der vorzeichenbehafteten und nicht vorzeichenbehafteten weiterhin berücksichtigt werden, wenn Sie beispielsweise ein TCP-Paket auffüllen.

• Sie können auf Probleme stoßen, wenn Sie eine Null bekommen, bei der Sie wirklich eine leere Zeichenfolge wollten. Mit anderen Worten, Sie debuggen immer noch Typenkonflikt-Fehler. Der einzige wirkliche Unterschied ist, dass der Compiler die Fehler nicht abfängt.

• Ich würde argumentieren, dass Sie nicht einmal viel Tipparbeit sparen , weil Sie in der Regel in Kommentaren dokumentieren möchten, welchen Typ Ihre Funktionsparameter haben, anstatt ihn in Ihrem Code zu dokumentieren. Aus diesem Grund sind Kommentarblöcke im Doxygen-Stil in der Praxis im gesamten dynamisch getippten Code weitaus beliebter. In statisch getippten Sprachen werden sie meist nur für Bibliotheken angezeigt.

Das heißt nicht, dass sich das Programmieren in dynamisch getippten Sprachen nicht angenehmer anfühlt , da der Compiler nicht immer auf Ihrem Rücken ist und erfahrene Programmierer keine Schwierigkeiten haben, die Art von Fehlern zu finden und zu korrigieren, die statisches Tippen ohnehin verursachen würde Dies ist jedoch ein völlig anderes Problem als die angebliche Steigerung der Effizienz oder die Verringerung der Fehlerrate, für die dynamische Typisierung auch bei statischer Typisierung am besten geeignet ist.

Je stärker die Typen werden, desto mehr können sie dir helfen - wenn du sie richtig verwendest, anstatt sie zu bekämpfen. Entwerfen Sie Ihre Typen so, dass sie den Platzbedarf Ihres Problems widerspiegeln, und es ist wahrscheinlicher, dass logische Fehler zu Typenkonflikten während der Kompilierung führen, als dass es zu Laufzeitabstürzen oder zu unsinnigen Ergebnissen kommt.

Haftungsausschluss: Ich bin ein Typ-Liebhaber;)

Ihre Frage ist schwer zu beantworten: Was sind diese Kompromisse ?

Ich nehme ein extremes Beispiel: Haskell , es ist statisch geschrieben. Vielleicht eine der am stärksten typisierten Sprachen überhaupt.

Haskell unterstützt jedoch die generische Programmierung in dem Sinne, dass Sie Methoden schreiben, die mit jedem Typ arbeiten, der einem bestimmten Konzept (oder einer bestimmten Schnittstelle) entspricht.

Darüber hinaus verwendet Haskell Type Inference , sodass Sie den Typ Ihrer Variablen nie deklarieren müssen. Sie werden beim Kompilieren statisch berechnet, so wie ein Python-Interpreter sie beim Ausführen des Programms berechnen würde.

Ich habe festgestellt, dass die meisten Leute, die sich mit statischer Typisierung beschäftigen, sich tatsächlich über etwas anderes beschwerten (Ausführlichkeit, Schmerzen beim Wechseln eines Typs zu einem anderen), aber Haskell weist keines dieser Probleme auf, während sie statisch getippt sind ...

Beispiel für die Kürze:

-- type
factorial :: Integer -> Integer

-- using recursion
factorial 0 = 1
factorial n = n * factorial (n - 1)

Abgesehen von der eingebauten Unterstützung ist es schwierig, kürzer zu werden.

Beispiel für generische Programmierung:

> reverse "hell­o" -- Strings are list of Char in Haskell
=> "olleh"
> reverse [1, 2, 3, 4, 5]
=> [5,4,3,2,1]

Beispiel für Typinferenz:

> :t rever­se "hell­o"
:: [Char]

was kann einfach berechnet werden:

• "hello"ist eine Liste von Char(ausgedrückt als [Char])
• reverseangewendet auf einen Typ [A]gibt einen Typ zurück[A]

Probieren Sie es in Ihrem Browser aus

Ich mag sowohl statisch als auch dynamisch typisierte Sprachen. Die zwei größten Vorteile der Typensicherheit sind für mich:

1) Was eine Funktion tut, lässt sich oft aus ihrer Typensignatur ableiten (dies gilt insbesondere für funktionale Sprachen wie Haskell).

2) Wenn Sie signifikante Änderungen vornehmen, teilt Ihnen der Compiler automatisch alles mit, was Sie tun müssen, damit alles funktioniert. Wenn ich etwas in C ++ umgestalte, ist meine Prozedur oft einfach a) den einen Teil zu ändern, den ich ändern möchte, und dann b) jeden Kompilierungsfehler zu beheben.

Persönlich finde ich, dass Typensicherheit mir hilft, mich in meinem aktuellen Job schneller zu entwickeln. Der Compiler führt einen Großteil der Überprüfung der Integrität für mich durch, fast während ich tippe, sodass ich mich mehr auf die von mir implementierte Geschäftslogik konzentrieren kann.

Das Fazit für mich ist, dass ich, obwohl ich etwas an Flexibilität verliere, etwas Zeit gewinne, die sonst aufgewendet würde, um Typprobleme aufzuspüren.

Es gibt eine Menge starker Meinungen rund um die Debatte, aber dies ist offensichtlich keine Frage der Meinung, sondern eine Frage der Fakten . So sollten wir in der empirischen Forschung suchen . Und die Beweise dafür sind klar:

Ja , statisches Tippen ist die Kompromisse wert - und zwar nicht nur ein wenig, sondern tatsächlich im Wesentlichen . Tatsächlich zeigen solide Beweise, dass statische Typisierung die Anzahl der Fehler im Code um mindestens 15% reduzieren kann (und dies ist eine geringe Schätzung, der tatsächliche Prozentsatz ist mit ziemlicher Sicherheit größer). Das ist eine erschreckend hohe Zahl: Ich denke, selbst die meisten Befürworter der statischen Typisierung hätten nicht gedacht, dass dies einen so drastischen Unterschied ausmacht.

Bedenken Sie Folgendes: Wenn jemand Ihnen sagte, dass es eine einfache Möglichkeit gibt, die Fehler in Ihrem Projekt über Nacht um 15% zu reduzieren, sollte dies ein Kinderspiel sein. ¹ Es ist fast die sprichwörtliche Silberkugel.

Die Beweise werden in der Arbeit To Type or Not to Type: Quantifying Detectable Bugs in JavaScript von Zheng Gao, Christian Bird und Earl T. Barr vorgestellt. Ich ermutige alle, es zu lesen, es ist eine gut geschriebene Arbeit, die beispielhafte Forschung präsentiert.

Es ist schwer, genau zusammenzufassen, wie rigoros die Autoren ihre Analyse durchgeführt haben, aber hier ist ein (sehr grober) Abriss:

TypeScript und Flow sind zwei auf JavaScript basierende Programmiersprachen, die, obwohl sie ansonsten kompatibel bleiben, Typhinweise und statische Typprüfung hinzufügen. Dies ermöglicht es, vorhandenen Code nach Typen zu erweitern und ihn dann zu überprüfen.

Die Forscher sammelten in GitHub in JavaScript geschriebene Open Source-Projekte, untersuchten behobene Fehlerberichte und versuchten, jeden der gemeldeten Fehler auf einen Code zu reduzieren, der von der statischen Typprüfung von TypeScript oder Flow abgefangen werden würde. Dies ermöglichte es ihnen, eine Untergrenze des Prozentsatzes der Fehler zu schätzen, die durch statische Typisierung behoben werden konnten.

Die Forscher haben strenge Vorkehrungen getroffen, um sicherzustellen, dass bei ihrer Analyse ein nicht typbezogener Fehler nicht als typbezogen eingestuft wird. ²

Im Vergleich zu früheren Studien weist diese neue Studie besondere Stärken auf:

• Es gibt einen direkten Vergleich zwischen statischer und dynamischer Typisierung mit wenigen (wenn überhaupt) Störfaktoren, da der einzige Unterschied zwischen JavaScript und TypeScript / Flow in der Typisierung besteht.
• Sie führen eine Replikation über mehrere Dimensionen durch, indem sie TypeScript und Flow (dh verschiedene Typsysteme) überprüfen und die (manuelle) Typanmerkung von verschiedenen Personen reproduzieren lassen, um die Fehler zu beheben. Und das über eine Vielzahl von Codebasen aus verschiedenen Projekten hinweg.
• Das Papier misst den direkten Einfluss der statischen Typisierung auf behebbare Fehler (und nicht auf etwas vageere Qualität).
• Die Autoren definieren ein strenges Modell dafür, was und wie im Voraus gemessen werden soll. Darüber hinaus ist ihre Beschreibung unglaublich klar und lässt sich leicht auf Fehler analysieren (es ist immer dann gut, wenn sich eine Forschungsarbeit für Angriffe öffnet: Wenn keine Angriffe ihre Argumente eindämmen, kommt sie noch stärker zum Vorschein). ³
• Sie führen eine ordnungsgemäße Leistungsanalyse durch, damit ihre Probengröße ausreicht und ihre anschließende statistische Analyse luftdicht ist.
• Sie sind zu konservativ, um störende Erklärungen auszuschließen, und messen nur einen einzigen beweglichen Teil. Darüber hinaus beschränken sie ihre Analyse auf Fehler, die durch das Einbeziehen von Typen sofort behoben werden können, und schließen alle Elemente aus, die möglicherweise ein erweitertes Refactoring erfordern, um das Eingeben zu ermöglichen. In Wirklichkeit ist der Effekt plausibel viel größer, aber sicherlich nicht kleiner als von ihnen berichtet.
• Und schließlich finden sie keine leichte Wirkung, sondern einen erstaunlichen Unterschied. Trotz ihrer zu konservativen Vorgehensweise stellen sie fest, dass selbst am unteren Ende des 95% -Konfidenzintervalls mindestens 10% der Bugs mit minimalen zusätzlichen Typprüfungen einfach verschwinden würden.

Sofern das Papier keinen fundamentalen Fehler enthält, den noch niemand entdeckt hat, zeigt das Papier schlüssig einen großen Vorteil der statischen Typisierung, und das fast ohne Kosten. ⁴

Historisch gesehen hat die Erforschung der Schreibdisziplinen in der Programmierung einen schwierigen Anfang genommen, da die Beweise für eine lange Zeit überhaupt nicht klar waren. Der Grund dafür ist, dass es nicht einfach ist, systematische Experimente durchzuführen, um den Effekt der statischen und dynamischen Typisierung zu untersuchen : Ein systematisches Experiment muss den Effekt, den wir untersuchen, isolieren. Und leider können wir die Wirkung der Schreibdisziplin nicht einschränken, da sie an die Programmiersprachen gebunden ist.

Es tatsächlich waren Programmiersprachen , die sowohl statische als auch dynamische Typisierung in verschiedenen Dialekten erlaubt (zB VB mit Option Strict Onoder Offoder statisch Lisp eingegeben). Diese waren jedoch für einen direkten Vergleich nicht gut geeignet, vor allem, weil es keine ausreichend großen Codebasen gab, die einen direkten Vergleich ermöglichten. Bestenfalls könnten wir sie in „Laboreinstellungen“ vergleichen, in denen Testpersonen eine Aufgabe in der statisch oder dynamisch typisierten Variante der Sprache zufällig lösen.

Leider modellieren diese künstlichen Programmieraufgaben den realen Gebrauch nicht gut. Insbesondere sind viele von ihnen von geringem Umfang und lösen ein genau definiertes Problem, das auf einer halben Textseite zusammengefasst werden kann.

Zum Glück ist dies in der Vergangenheit der Fall, da TypeScript, Flow und JavaScript mit Ausnahme der statischen Typisierung in der Tat die gleichen Sprachen sind und es einen umfangreichen realen Datensatz mit Code und Fehlern gibt, aus dem Sie Beispiele erstellen können.

_{¹ Inspiriert von einem Zitat aus dem Originalpapier.}

_{² Ich bin damit nicht ganz zufrieden: Eine der Hauptstärken statisch typisierter Sprachen besteht darin, dass scheinbar typunabhängige Probleme auf eine Art und Weise formuliert werden können, die statisch typisiert werden kann. Dies wandelt viele logische Fehler in Typfehler um, was die Fehlerrate, die durch statisches Tippen aufgefangen werden kann, drastisch erhöht. In der Tat werden in der Veröffentlichung typunabhängige Fehler grob klassifiziert, und ich behaupte, dass ein großer Prozentsatz dieser Fehler tatsächlich durch statische Typisierung aufgefangen werden könnte.}

_{³ Ich lade jeden ein, insbesondere Befürworter des dynamischen Schreibens, zu versuchen, nicht adressierte Fehler in der Analyse zu finden. Ich glaube nicht, dass es viele gibt (wenn überhaupt), und ich bin zuversichtlich, dass kein möglicher Fehler das Ergebnis wesentlich verändern würde.}

_{⁴ Ich vermute, dass die tatsächlichen Kosten für die statische Eingabe in realen Großprojekten nicht vorhanden sind, da sie dann zu einem natürlichen Bestandteil der Architektur werden und die Planung möglicherweise sogar vereinfachen . Das Beheben statischer Typfehler ist zeitaufwändig, jedoch weitaus weniger als die später entdeckten Fehler. Dies wurde ausführlich empirisch untersucht und ist seit Jahrzehnten bekannt (siehe zB Code Complete ).}

Lohnt sich die Schriftsicherheit, um Entwicklungsgeschwindigkeit und Flexibilität zu erreichen?

Das hängt also wirklich davon ab, was Sie tun. Wenn Sie beispielsweise Backup-Systeme für Flugzeuge programmieren, ist Typensicherheit wahrscheinlich der richtige Weg.

Dynamische Sprache vs Statische Sprachprogrammierung sind wirklich zwei verschiedene Tiere. Beide erfordern einen grundsätzlich unterschiedlichen Ansatz. Sie können meistens eine Methode für die Annäherung zwischen statisch und dynamisch portieren, verlieren jedoch die Vorteile der anderen.

Es ist wirklich eine Denkweise. Ist einer besser als der andere? Das hängt wirklich davon ab, wer du bist und wie du denkst. Die meisten Leute, mit denen ich zusammenarbeite, würden niemals eine dynamische Sprache anfassen, wenn sie nicht müssten, weil sie der Meinung sind, dass zu viel Raum für Fehler ist. Sind sie falsch, das zu denken? Nein, natürlich nicht, aber es bedeutet, dass sie erkannt haben, dass ihr Ansatz zur Anwendung ihres Codierungsstils in einer dynamischen Umgebung nicht funktioniert. Andere Leute, mit denen ich zu Benutzergruppen gehe, sind genau das Gegenteil. Sie empfinden die statische Typisierung als zu umständlich, da sie sich nur eingeschränkt mit bestimmten Arten von Problemen befassen können.

Ich kann ehrlich sagen, ich springe viel zwischen JavaScript und C #. Nun, das Wissen und Arbeiten in beiden Sprachen beeinflusst den anderen in gewissem Maße, aber in Wahrheit sieht der Code, den ich in beiden Sprachen schreibe, völlig anders aus. Sie erfordern einen anderen Ansatz, weil sie sich grundlegend unterscheiden. Was ich herausgefunden habe ist, dass, wenn Sie denken, "Mann, das ist so viel schwieriger, dies in X-Sprache zu tun", Ihre Herangehensweise wahrscheinlich ein wenig abweicht. Hier ist ein Beispiel, die Leute sprechen über die "pythonische" Art, Dinge zu tun. Was es bedeutet ist, dass es eine Möglichkeit gibt, wie die Python-Sprache ein Problem einfacher macht. Eine andere Vorgehensweise ist im Allgemeinen schwieriger und umständlicher. Sie müssen über den Haufen von Wissen, wie eine Sprache funktioniert, hinwegkommen, damit sie wirklich für Sie funktioniert. Es'

Kürzlich wurde eine ähnliche Frage gestellt: Dynamische oder statisch getippte Sprachen für Websites

Um den Kern meiner Antwort zu wiederholen:

Wenn die Systeme größer werden, sorgen statisch typisierte Sprachen für Robustheit auf Komponentenebene und damit für Flexibilität auf Systemebene.

Ja, Java ist streng getippt und ja, Java ist zum Kotzen (keine Beleidigung. Es ist schrecklich. Tolle Plattform und Ökosystem, aber eine der schlimmsten Sprachen aller Zeiten (die tatsächlich verwendet werden)).
Aber daraus zu schließen, dass strenges Tippen nur ein Trugschluss ist. Es ist so, als würde man auf PHP zeigen und auf dynamisches Tippen schließen (wieder nichts für ungut. Es verbessert sich langsam, das gebe ich dir).

Persönlich mache ich den größten Teil meiner Entwicklung in haXe , das ein statisches Typensystem hat. Es ist nicht nur aussagekräftiger als das von Java und erfordert viel weniger Aufwand aufgrund von Typinferenz, sondern es ist auch optional. Sollte es Ihnen jemals in die Quere kommen, umgehen Sie es einfach.

Die Schriftsicherheit ist eine Funktion (dies ist etwas, was viele vermeintlich anspruchsvolle Sprachen nicht richtig verstehen), mit der Sie verhindern können, dass Sie sich in den Fuß schießen .
Und über jede erfolgreiche dynamisch getippte Sprache wäre einfach besser, wenn Sie die Option hätten, Ihren Code-Typ nach Belieben überprüfen zu lassen.
Zum Beispiel hat es mir sicherlich Spaß gemacht, mit Ruby zu experimentieren, aber das lag hauptsächlich daran, dass Ruby vollständig objektorientiert ist, was völlig orthogonal zur Präsenz eines Systems vom Typ Kompilierungszeit ist.

Ich denke, die Behauptung, dass statische Typsysteme unübersichtlich sind, beruht lediglich auf dem Mangel an Kenntnissen über gute statische Typsysteme. Es gibt eine Reihe von Sprachen, die es richtig machen, obwohl sie eine von ihnen sind und wohl nicht einmal die besten in dieser Hinsicht.

Beispiel haXe Code:

class Car {
    public function new();
    public function wroom() trace('wroooooooom!')
}
class Duck {
    public function new();
    public function quack(at) trace('quackquack, ' + at + '!')
}

function letQuack(o) o.quack();
letQuack(new Car());
letQuack(new Duck());

Dies führt zu einem Fehler bei der Kompilierung:

Car should be { quack : Void -> Unknown<0> }
Car has no field quack
For function argument 'o'
Duck should be { quack : Void -> Unknown<0> }
Invalid type for field quack :
to : String -> Void should be Void -> Unknown<0>
For function argument 'o'

Man kann nicht wirklich behaupten, dass ich mich sehr um die Typensicherheit bemühen musste.

Zu sagen, dass Sie keine Schriftsicherheit brauchen, weil Sie Tests haben, ist noch idiotischer. Das Schreiben von Tests ist langweilig und wiederholt sich. Und ich möchte wirklich keinen Test schreiben, nur um herauszufinden, dass eine Instanz von Car nicht quaken wird und eine Ente jemanden braucht, an dem man quaken kann.

Am Ende des Tages werden Sie feststellen, dass unabhängig davon, wie viel Sie die Overhead-Sicherheit gekostet haben, diese letztendlich amortisiert wird (sogar in Java - obwohl dies vielleicht nicht so bald der Fall ist).

Aus irgendeinem Grund mache ich nicht mehr so ​​oft Fehler in Bezug auf den Typ eines Objekts. In Sprachen wie C # mache ich eher Fehler im Zusammenhang mit Laufzeitumwandlungen als einen vom Compiler feststellbaren Sicherheitsfehler, der normalerweise durch die gelegentliche Notwendigkeit verursacht wird, die Statizität einer statischen Umwandlung zu umgehen getippte Sprache. Wenn ich Ruby schreibe, deutet der Code in der Regel ziemlich stark auf den Typ eines Objekts hin, und die Verfügbarkeit einer REPL bedeutet, dass ich bereits experimentell überprüft habe, ob die gewünschten Methoden / Attribute vorhanden sind, oder dass ich einen diesbezüglichen Komponententest durchführe im grunde das selbe, daher stoße ich auch selten auf typensicherheitsprobleme in ruby.

Das heißt aber nicht, dass statisch typisierte Systeme nicht besser sein können als sie.

Innerhalb statisch typisierten Sprachen, die Art System zählt tatsächlich eine Menge als auch. Zum Beispiel erhalten Sie mit so etwas wie der Some-Monade in funktionalen Sprachen (Typ <Some>: = yes x | no) Prüfungen zur Kompilierungszeit, die im Wesentlichen die gefürchtete NullReferenceException verhindern, die in den meisten Typsystemen üblich ist. Wenn der Mustervergleichscode ausgeführt wird, werden beim Kompilieren Fehler angezeigt, die darauf hinweisen, dass Sie die Nullbedingung nicht verarbeiten konnten (wenn Sie diesen Mechanismus zum Deklarieren des Typs verwenden). Sie reduzieren ähnliche Arten von Fehlern auch, wenn Sie in F # den Pipeline-Operator |> verwenden.

In der Hindley-Milner-Tradition der statischen Typisierung können Sie Dinge erstellen, die weit mehr als nur die Garantie bieten, dass ein Typ die Schnittstelle X unterstützt. Wenn Sie diese Dinge einmal haben, würde ich sagen, dass das statisch typisierte System eine Menge wird wertvoller.

Wenn dies keine Option ist, können mit Design By Contract-Erweiterungen für C # weitere Mechanismen hinzugefügt werden, die den Wert des statischen Typsystems erhöhen, aber dennoch mehr Disziplin erfordern als einige dieser Funktionsparadigmen.

Es hängt davon ab, ob.

Menschliche Versagensmodi sind oft statistisch. Eine strenge Typprüfung verringert die Wahrscheinlichkeit einiger menschlicher Fehler (die zu fehlerhaftem Code führen). Aber nur weil Sie scheitern können, heißt das nicht immer, dass Sie scheitern werden (Murphy nicht standhalten).

Ob diese Reduzierung der potenziellen Ausfallwahrscheinlichkeit die Kosten wert ist, hängt davon ab.

Wenn Sie Code für ein Kernkraftwerk oder ein ATC-System schreiben, ist möglicherweise eine Reduzierung des menschlichen Versagens äußerst wichtig. Wenn Sie schnell Prototypen für eine Website-Idee erstellen, für die es keine Spezifikation gibt und deren Konsequenzen nahezu null sind, kann die Reduzierung der Fehlermodi oder -wahrscheinlichkeiten Ihnen möglicherweise etwas bringen oder auch nichts, kostet Sie jedoch möglicherweise Entwicklungszeit (mehr Tastenanschläge usw.). und in Gehirnzellen, die durch das Auswendiglernen der aktuellen Art (en) abgelenkt werden.

In Lisp wurden viele sehr komplizierte Systeme geschrieben, und ich habe noch keinen von Lisper gehört, der sich darüber beklagt hat, dass sie statisches Tippen wollten. Als ich damit gearbeitet habe, erinnere ich mich an keine Probleme, die mich sehr verlangsamt haben, die ein statisches Typsystem (und Sie können Typen in Common Lisp statisch angeben) festgestellt hätte.

Darüber hinaus scheinen die gängigen statisch typisierten Sprachen nicht gut geeignet zu sein, um Fehler abzufangen. In ein Layout entwerfen, was wichtig ist , dass eine bestimmte Anzahl eine vertikale Messung auf der Seite ist, nicht , ob es int, unsigned, float, oder double. Der Compiler hingegen markiert häufig Typkonvertierungen, die er für unsicher hält, und lässt mich gerne eine vertikale Messung und die Anzahl der Zeichen in einer Zeichenfolge hinzufügen. Diese Schwäche des statischen Typsystems war die ursprüngliche Idee hinter Simonyis ungarischer Notation, bevor sie in hässliche Nutzlosigkeit verwandelt wurde.

Typen sind Einschränkungen für Schnittstellen, daher sind sie eine Teilmenge dessen, was Sie mit Komponententests testen möchten, und daher sind viele Kompromisse ähnlich:

• Statische Typen geben eine frühere Rückmeldung darüber, ob der Code die Anforderungen erfüllt, die vom Typensystem ausgedrückt werden können, und verzögern die Rückmeldung von der Erstellung eines minimal funktionalen Objekts (z. B. Kunden-Feedback oder Tests auf höherer Ebene).
• Das Wissen, dass der Code bestimmte Anforderungen erfüllt, kann das Refactoring und Debuggen vereinfachen, erhöht jedoch auch den Aufwand für sich ändernde Schnittstellen und Anforderungen.
• Insbesondere wenn eine statisch getippte Sprache keinen Zwang aufweist, bietet sie zusätzliche Sicherheit gegen Code, der für Daten verwendet wird, die Fehler verursachen würden (wodurch die Notwendigkeit von Bedingungen und Behauptungen verringert wird). Bei übermäßig restriktiven Einschränkungen muss der Benutzer jedoch mehr Code schreiben, um seine Daten in eine zu massieren akzeptable Form (z. B. explizite Typumwandlung).
• Explizite Typanmerkungen können das Verständnis beim Lesen von Code erleichtern oder den Code mit redundanten oder unnötigen Informationen überladen.
• Je nach Implementierung kann dies die Knappheit beeinträchtigen. Dies hängt davon ab, ob Typanmerkungen erforderlich sind oder abgeleitet werden, wie gut das Typsystem generische Typen / Schnittstellen ausdrücken kann, welche Syntax Sie verwenden und ob Sie auf Einschränkungen testen möchten, die vom Typsystem (dh vom Typsystem) ausgedrückt werden können Der gleiche Test ist als Sprachmerkmal wahrscheinlich knapper als als ein Komponententest, aber Sie haben möglicherweise nicht vorgehabt, ihn zu testen.
• Zusätzlich (jedoch unabhängig von TDD) können statische Typen die Optimierung der Kompilierungszeit unterstützen. Dies geht zu Lasten der Typprüfung (und nimmt sich Zeit, um sie zu überprüfen und die Optimierungen durchzuführen). Eine bessere Optimierung kann durchgeführt werden, wenn die Daten auf Typen beschränkt sind diese Karte gut auf Hardware. Dies erleichtert die Entwicklung von Code mit Leistungsanforderungen, kann jedoch zu Problemen bei Code führen, der diese Einschränkungen nicht erfüllt (siehe Punkt 3).

Zusammenfassend würde ich argumentieren, dass dynamische Sprachen für das Prototyping besonders nützlich sind. Wenn Sie jedoch sicherstellen möchten, dass Ihr Code korrekt ist, sollten Sie ein starkes Typensystem bevorzugen.

Ja definitiv. Eine Sache, die Sie feststellen werden, wenn Sie sowohl stark typisierte Sprachen als auch Python (Python ist stark typisiert) verwenden, ist, dass der am besten geschriebene Code in dynamischen Sprachen ohnehin den gleichen Konventionen folgt wie stark typisierter Code. Dynamische Typisierung ist sehr nützlich für die Serialisierung und Deserialisierung, aber für die meisten anderen Dinge trägt sie nicht viel zum Vorteil bei. Und wenn der größte Teil Ihres Codes nicht mit der Serialisierung zusammenhängt, warum sollten Sie dann die kostenlose Fehlerprüfung aufgeben?

Morgan, ich habe eine interessante Idee für Sie: statische + dynamische Eingabe. Sie erwähnten Python, C # und Java. Wussten Sie, dass es sowohl für .NET als auch für Java einige ziemlich gute Python-Ports gibt? In beiden Fällen können Sie über die Ports die Bibliotheken dieser Plattformen verwenden und / oder mit vorhandenem Code zusammenarbeiten. Dies gibt Ihnen mehrere Möglichkeiten:

1. Bewahren Sie Legacy-Code in einer statischen, unflexiblen Sprache auf. Verwenden Sie Python für neue Sachen.
2. Verwenden Sie Python, um neue Inhalte auf ausgereiften Plattformen zu erstellen. Kodieren Sie die Komponenten, die Sie behalten möchten, neu in der ausgereifteren Sprache.
3. Verwenden Sie die dynamische Sprache für Teile, die Sie häufig ändern.
4. Verwenden Sie möglicherweise die dynamische Sprache, um mit Ideen wie dem Ändern von laufendem Code zu spielen.
5. Tun Sie alles in der dynamischen Sprache, mit Ausnahme der kritischen Teile, in denen Sie die stark typisierte Sprache verwenden.

Ich habe diese Ansätze bereits in den späten 90er Jahren verwendet, um die Schwierigkeiten bei der Entwicklung in C / C ++ zu umgehen. Ich brauchte die nativen Bibliotheken und manchmal Leistung. Ich wollte jedoch die bessere Syntax, Flexibilität, Sicherheit usw. Der Trick bestand also darin, sie sorgfältig zu kombinieren, um die richtigen Kompromisse zu erzielen. In der Praxis war es oft besser, als den gesamten Sprach- und Legacy-Code für eine andere Sprache / Plattform herauszuwerfen.

(Hinweis: Eine Antwort hat es bereits gesagt, aber ich möchte auch noch einmal betonen, dass dynamisches Tippen! = Kein / schwaches Tippen. Viele dynamische Schriftsysteme verwenden starkes Tippen im Inneren. Die Art, wie ich über die Dynamik eines Schrifts nachdenke, ist die folgende Ein Variablentyp wird zur Laufzeit ermittelt, benötigt keine Typanmerkung und / oder kann sich zur Laufzeit ändern.

Sie werden keine wirklich objektive Antwort darauf erhalten, aber meiner Erfahrung nach ist die Typensicherheit von unschätzbarem Wert, bis Sie TDD beherrschen. Sobald Sie einen umfassenden Bericht über Komponententests haben, in dem die Tests vor dem Code geschrieben wurden, wird die Überprüfung des Compilers zu einem Problem, das sich Ihnen tatsächlich in den Weg stellt.

Ich sehe, dass diese Frage häufig gestellt wird, und ich denke, dass Ihre Softwarequalität (und das Fehlen von Fehlern) mehr mit Ihrem Entwicklungsprozess, der Architektur Ihres Systems und dem Engagement von Ihnen und Ihren Kollegen für die Codequalität zu tun hat.

Mein letzter Job war hauptsächlich die Python-Entwicklung. Ich habe für ein großes internationales Webhosting-Unternehmen gearbeitet und wir hatten Entwicklerteams in den USA, Kanada und Südkorea. Benutzerdefiniertes Python-Webframework für die Front-End-Kunden-App, mit dem die Benutzer ihre Domainnamen und Webhosting-Konten verwalten konnten. Backend: alles Python auch. Python-Webdienst, um mit einzelnen Servern zu kommunizieren, um beispielsweise eine neue Webhosting-Site bereitzustellen, ein neues Blog zu erstellen und DNS-Einträge in unserem System für Namensdienste zu erstellen. usw. usw. In meinem aktuellen Job sind Client-Apps alles in Java. Unser Hauptprodukt ist eine Mischung aus Java und Flash. Benutzerdefiniertes Java-Webframework für unsere älteren Apps, Wicket für unsere neueren internen Tools.

Nachdem ich in beiden Bereichen gearbeitet habe, muss ich sagen, dass mich diese Frage jedes Mal stört, wenn ich sie sehe. Wenn Sie eine dynamisch getippte Sprache verwenden und Ihren Code tatsächlich testen, sind Sie in Ordnung. Wenn das System gut konzipiert ist und Sie den Standards folgen, wird es Ihnen gut gehen. Es gab nie viele Fehler, die auf das Fehlen von Compiler-Prüftypen zurückzuführen waren. Die meisten Fehler waren logische Fehler, genau wie mein Java-Job heute.

Lohnt sich die Schriftsicherheit, um Entwicklungsgeschwindigkeit und Flexibilität zu erreichen? WARUM?

Statische Typisierung bedeutet eine Steigerung der Geschwindigkeit und Flexibilität der Entwicklung über den gesamten Lebenszyklus der Software hinweg. Es reduziert den Gesamtaufwand und die Unannehmlichkeiten, verschiebt jedoch einen Großteil des Aufwands und der Unannehmlichkeiten vorab, wo dies wahrnehmbarer ist. Die Einstiegshürde für Arbeitscode ist höher, aber sobald Sie diese Schranke überwunden haben (indem Sie die Typprüfung bestanden haben), ist das Erweitern und Verwalten dieses Codes sehr viel weniger arbeitsaufwendig.

In der Softwareentwicklung wird es immer einige Kopfschmerzen geben, weil:

• Die inhärente Komplexität dessen, was Sie erreichen wollen

• Die inhärente Fehlbarkeit des Menschen, insbesondere wenn man bedenkt, dass wir mehr Fehler machen, wenn wir versuchen, etwas Komplexeres zu tun

Früher oder später müssen Sie sich etwas Zeit nehmen, um diese Herausforderungen anzugehen. Daran führt kein Weg vorbei. Die statische Typisierung adressiert diese Herausforderungen eher früher als später. Früher ist besser als später, denn je später Sie einen Fehler entdecken (keine Frage von ob , sondern wann ), desto mehr kostet es, diesen Fehler zu korrigieren.

Die Behebung eines von einem Typprüfer gemeldeten Fehlers kostet viel weniger als das Debuggen einer zur Laufzeit ausgelösten typbezogenen Ausnahme. Wenn Sie die Typprüfung auf die Laufzeit verschieben, wird das Problem nur unter den Teppich gekehrt.

Dies ist nur meine eigene Meinung, aber nein, ich denke nicht, dass sich Typensicherheit lohnt. Nicht einmal für eine Sekunde.

Ich war lange Zeit Entwickler. Beginnen Sie mit C ++, C # und wechseln Sie dann zu Javascript (Frontend und Backend über node.js). Seit ich in Javascript entwickle, ist meine Produktivität in die Höhe geschnellt, bis ich mit typbasierten Sprachen tatsächlich erschwert werde. Ich bin auch gegen das Kompilieren, ich möchte, dass jetzt alles zur Laufzeit läuft. In den interpretierten Sprachen habe ich meine Liebe zum Programmieren gefunden.

Bei den Typen sehe ich einfach keine Vorteile. Ich sehe Typen jetzt genauso wie die Speicherverwaltung. Völlig unnötig. Die Sprachen von morgen sollten den Entwickler vollständig davor schützen, etwas über Typen zu wissen. Der Computer sollte die Typen verstehen und den Entwickler davon abhalten.

Hier ist ein Beispiel. Ich habe gerade Swift (Apples neue Sprache) verwendet, in der Hoffnung, dass es tatsächlich seinem Namen vor einem Tag gerecht wird, und habe versucht, Folgendes zu tun: var n = 1/2 hat nicht funktioniert. Ich dachte, was ist hier los? und dann wurde mir leider klar, dass ich var n tun musste: Float = 1/2. Dies erinnerte mich daran, wie sehr ich Typsysteme hasse und wie sehr sie eine unnötige Verschlechterung darstellen.

Ich würde sogar noch einen Schritt weiter gehen, um zu sagen, dass ich nicht einmal benutzerdefinierte Typen (wie z. B. Klassen) möchte. Ich will überhaupt keine Typen. Alles was ich will ist var und Objekte. Wo jedes Objekt als beliebiges Objekt verwendet werden kann. Und Objekte sind dynamisch und verändern sich ständig. Wo wird es ein Laufzeitproblem, was funktioniert und was nicht.

Entwickler lieben es zu sagen, dass lose geschriebene Sprachen für große Projekte nicht gut sind. Aber ich würde sagen, es ist das Gegenteil. Stark typisierte Sprachen sind für große Projekte schrecklich. Und wenn Sie sagen, Javascript funktioniert bei großen Projekten nicht, fragen Sie Uber bei einem Unternehmen über 40 Milliarden, das sein gesamtes Backend auf node.js / javascript oder Facebook ausführt, das mit PHP begann.

In Bezug auf statisch typisierte Sprachen ist dies für die heutigen schnellen Iterationen nicht gut. Hier ein einfaches Beispiel: Sie haben 10 Entwickler, die an einem .NET-Projekt mit einem Continuous Integration Server arbeiten, ein Entwickler hat einen Fehler gemeldet und der gesamte Build ist fehlerhaft, obwohl die 10 Entwickler an verschiedenen Dingen arbeiten, die jetzt alle gestoppt sind und warten für den beleidigenden Entwickler, um seinen Fehler zu korrigieren. Sprechen Sie über effiziente nicht wahr? Auf diese Weise sind Typsystem- / statische Sprachen voneinander abhängig und machen Ihren Code voneinander abhängig. Skriptdateien sind jedoch niemals voneinander abhängig. Wenn es ein Problem mit einem der Skripte gibt, das die Produktion nicht anhält, werden alle Probleme, die Sie sehen, der Laufzeit überlassen. Und die Laufzeit hört nie auf. Es bricht niemals. Es könnte eine falsche Ausgabe erzeugen, aber es tut nicht '

JA.

Ich habe in PHP-Anwendungen gearbeitet, in denen Typen nicht so "stark" sind wie in Java oder C #. Normalerweise beendete ich die "Typensimulation", um schlechte automatische Konvertierungen oder die Validierung von Daten zu vermeiden.

Dynamic Type Languages ​​eignen sich für Betriebssystemskripte und schnelle kleine Apps, nicht für komplexe Apps.

Zusammenfassung: Wenn ich zwischen einer Programmiersprache "Schwacher Typ" oder "Dynamischer Typ" oder einer Programmiersprache "Starker Typ" für eine komplexe Geschäftsanwendung wählen muss, wähle ich die Programmiersprache "Starker Typ" .

Ich denke, es lohnt sich, einen Schritt zurückzutreten und zu überlegen, wann dynamisches Tippen Probleme verursacht.

Ein Fall ist, dass eine Code-Verzweigung überhaupt nicht getestet wird, aber offen gesagt, dass Code, der niemals getestet wird, wahrscheinlich fehlerhaft ist, unabhängig davon, ob dynamische Typisierung verwendet wird oder nicht.

Ein anderes subtileres Problem ist jedoch die unvollständige Substituierbarkeit.

Wenn ein Typ nur völlig falsch ist, wird dieser wahrscheinlich schnell erkannt, es sei denn, es wird nie ein bestimmter Codepfad verwendet.

Wenn ein Typ hingegen ein unvollständiger Ersatz ist, funktioniert der Code möglicherweise meistens, bricht jedoch auf subtile Weise ab, die erst viel später erkannt werden.

Zwei der häufigsten Programmiertypen sind Zahlen und Zeichenfolgen. In vielen dynamischen Sprachen sind sie unvollständige Substitute füreinander. Wenn Sie in Javascript oder PHP eine Zahl angeben, bei der ein String erwartet wird, oder umgekehrt, wird Ihr Programm ausgeführt, ohne einen Fehler auszulösen, kann sich jedoch auf subtile Weise schlecht verhalten.

Python hat vermieden, dass bestimmte Probleme, Zahlen und Zeichenfolgen in keiner Weise einander ersetzen, und der Versuch, eine zu verwenden, bei der die andere erwartet wird, führt normalerweise zu einem raschen Ausfall.

Das Problem der unvollständigen Susbstituierbarkeit konnte jedoch nicht vollständig vermieden werden. Verschiedene Arten von Zahlen können unvollständige Substitute für einander sein, ebenso wie verschiedene Arten von Sequenzen.

Was ich hier bekomme, ist, dass es meiner Meinung nach nicht möglich ist, die Vorteile und Kosten der statischen und dynamischen Typisierung auf generische Weise zu vergleichen, da meiner Meinung nach sowohl die Vorteile als auch die Kosten von der jeweiligen Variation der statischen oder dynamischen Typisierung einer Sprache abhängen Verwendet.