Type systems (strong & static) are the best!

I used to be into dynamic languages, and they still have their place.

But for a huge, dozens-of-people project, catching an error at compile time saves hours or even days compared to catching it at runtime. Especially if maintenance overtakes new development.

So use a language with a proper type system, and use it properly!

• Non-nullable types.
• Immutable references and collections separate from mutable ones (or no mutable ones).
• Don't put everything in naked strings, ints and floats. Use Name, Currency, Id<Person>
• If you validate something, change it's type (e.g. SafeString), so that all your downstream code knows it can be trusted. Or/and put anything unsafe in a special type.
• Obviously generics, but I guess every serious static language has that now?
• Tagged union types (enums where each option can take different values of any type) and exhaustivity checks on switch/when/match/... statement. (if you only know Java enums, it's not that).
• Type inference; it's 2018.

There's a lot more like lifetimes or dependent types, but this is not a book (and I'm still learning myself).

Tremendously useful. I use TypeScript, and it is stellar.

I don't understand why people hate on static typing. Honestly I think it's because they're too stubborn to learn. For large projects, static typing is indispensable. And for a language like TypeScript, you still retain all of the flexibility of a dynamically typed language if you need to go so fast that including types is burdensome.

I program in Haskell. Haskell has a strong static type system. I'll present an answer from a subjective point of view. See this Software Engineering StackExchange answer for a more technically detailed answer.

• As a haskell programmer, I always write down the type of a function before implementing the function itself. That way, just by looking at the function itself, I can tell what it does. This habit forces me to determine the "type" of mathematical objects when I am studying usual mathematics.
• By looking at the types, I can tell the structural complexity of the function, and whether it involves actions, such as changing states of the outside world.
• The type system catches a lot of errors, and in the haskell community, there is a saying "If it typechecks, it must be correct".
• Even if I do not explicitly write down the types of my function, most of it is still automatically inferred and errors are caught.
• The type system is very rich. Not only does it support polymorphic functions, but it lets you specify functions that take polymorphic functions.
• I can define algebraic data types, which means that if I am doing some, say file handling, I could actually define values Open and Closed. Sure, this is like an enum in C, but things like Open == 0 don't make sense in Haskell.
• A Haskell programmer who wants to denote a lookup function that searches for some string in a text file will type his string as Maybe String, indicating that the String may not be found and will return Nothing in that case. He won't return a garbage value or -1 like C programmers.
• Algebraic Data Types support recursion, which means that implementing data structures like trees are way more elegant.
• Typeclasses let me distinguish between ad-hoc and parametric polymorphism.

Finally, this is not something about Haskell in particular, but as a mathematics student interested in logic, I enjoy the connection between proofs as programs and types as propositions. This is the basis for proof assistants such as Coq.

I find that the dynamic type stuff creates errors at times so I prefer typing. I don't mind dynamic typing for small tools and utilities but for serious code in mission-critical systems, cryptography, etc... I see no reason to be using dynamic typing.

Check this out: lists.linuxfoundation.org/pipermail/bitcoin-dev/2…

Nuff said.