When I decide I want to understand something, I become obsessed until I finally do. My latest attempt? . Static vs. Dynamic Typing ’s answers were confusing, long, and even contradictory. Turns out these terms are commonly misunderstood, so it makes sense that my search would prove difficult. I continued reading whatever I could find but nothing satisfied my hunger for something approachable and concise. Stack Overflow Compiled vs. Interpreted “When source code is translated” : Original code (usually typed by a human into a computer) Source Code : Converting source code into something a computer can read (i.e. machine code) Translation : Period when program is executing commands (after compilation, if compiled) Run-Time : Code translated before run-time Compiled : Code translated on the fly, during execution Interpreted Typing “When types are checked” will raise a type error in languages, such as Python and Go, because they don't allow for "type coercion": the ability for a value to change type implicitly in certain contexts (e.g. merging two types using ). languages, such as JavaScript, won't throw a type error (result: ). "3" + 5 strongly typed + Weakly typed '35' : Types checked before run-time Static : Types checked on the fly, during execution Dynamic The definitions of “Static & Compiled” and “Dynamic & Interpreted” are quite similar…but remember it’s “when types are checked” vs. “when source code is translated”. You need to separate these terms conceptually. Type-checking has nothing to do with the language being compiled or interpreted! Python Example Dynamic, Interpreted def foo(a): if a > 0: print 'Hi' else: print "3" + 5 foo(2) Because Python is both interpreted and dynamically typed, it only translates and type-checks code it’s executing on. The block never executes, so is never even looked at! else "3" + 5 What if it was statically typed? A type error would be thrown before the code is even run. It still performs type-checking before run-time even though it is interpreted. What if it was compiled? The block would be translated/looked at before run-time, but because it's dynamically typed it wouldn't throw an error! Dynamically typed languages don't check types until execution, and that line never executes. else Go Example Static, Compiled package main import ("fmt") func foo(a int) { if (a > 0) { fmt.Println("Hi") } else { fmt.Println("3" + 5) }} func main() { foo(2)} The types are checked before running (static) and the type error is immediately caught! The types would still be checked before run-time if it was interpreted, having the same result. If it was dynamic, it wouldn’t throw any errors even though the code would be looked at during compilation. Performance A compiled language will have better performance at run-time if it’s statically typed because the knowledge of types allows for machine code optimization. Statically typed languages have better performance at run-time intrinsically due to not needing to check types dynamically while executing (it checks before running). Similarly, compiled languages are faster at run time as the code has already been translated instead of needing to “interpret”/translate it on the fly. Note that both compiled and statically typed languages will have a delay before running for translation and type-checking, respectively. More Differences Static typing catches errors early, instead of finding them during execution (especially useful for long programs). It’s more “strict” in that it won’t allow for type errors anywhere in your program and often prevents variables from changing types, which further defends against unintended errors. num = 2num = '3' // ERROR Dynamic typing is more flexible (which some appreciate) but allows for variables to change types (sometimes creating unexpected errors). Did that clear things up for you? Let me know in the comments!
