Static typing means the type of a variable is known at compile time. This means that either you have to specify the type, or the compiler has to infer it (usually both). You also can't change the type of a variable. Many languages, such as Java, C, C#, Go, and Swift use this.
What are the pros and cons of a statically typed language?
Some pros:
Some cons:
Simplicity. It makes it harder to learn.
Code duplication. It can lead to code duplication with similar functionality on different types, especially when the language lacks polymorphism or generics.
Often while writing scripts in dynamically-typed languages such as JavaScript or Lua I find myself type-checking code manually:
function add(a, b) {
assert(typeof(a)=="number"&&typeof(b)=="number")
return a+b
}
In statically-typed languages none of this is necessary making some code simpler.
The Zen of python says "Explicit is better than implicit". Every function or container has some expectation about what types you can put in and which ones will not.
It makes sense to just write that down explicitly, either as checked static types, unchecked gradual types, or as something like a doc comment.
A function may work just fine on a wide variety of different types. For example, a function that adds two things may work just as well on integers, floats, strings, and arrays. You can define interfaces or traits and implement them for every type you want to support but it's a lot of work just to prove that a function works that you know works anyways.
Even worse, sometimes a function works just fine on many types but it wasn't considered when the function was written so there is no easy way to make it accept a interface instead, especially if the function is from some third party package that can't be modified. Just allowing any type that supports the required operators and methods solves this issue.
First of all, there is no such thing as "static typing". There are lots of type systems and type checkers, which in general use some combination of code inspection (static) and runtime checks (dynamic). It's not a binary choice. More importantly, type systems have other attributes that may well be more important than static vs. dynamic. Both C and Haskell can be qualified as statically typed, but they are very different!
That said, I find explicit type specification (usually with static checking) useful when I write code in a problem domain that I understand well enough to know what types to choose for my data. On the other hand, I find the obligation to fix types a real nuisance when I do exploratory coding, i.e. coding to help me understand a new problem domain.
