nosewheelie

Jay Fields (someone whose comments I’ve come to respect) ignites yet another debate about type systems in Static typing considered harmful.

Given a good test suite the return on investment simply does not justify the use of static typing.

In 5 years, we’ll view compilation as the weakest form of unit testing. — Stuart Halloway

Type verification provides very little confidence that an application works. The little confidence it does provide comes at the cost of being confined by the type system. Verifying types is better than testing nothing at all. But, only verifying types is insufficient for application development.

Now I don’t know a great deal about type systems [1], but I know enough to know that the arguments going around appear to have been formed without knowing a great deal about type theory and what a good type system can do (I’ve heard it called arguing in a bubble).

Phillip Calçado takes it further in Static Types for Long Feedback Cycles?, noting that there has been a debate amongst ThoughtWorkers about this issue. I feel that Phillip also draws some invalid conclusions, such as asserting that a type system cannot ensure that a class fulfils its contract [2]. One of his commentors, David, makes the same comments that I’m making, that a lot of this debate stems from a lack of knowledge about what a type system actually is, talking about more advanced type systems that those we may be used to in our day jobs:

Of course I’m not talking about shonky rubbish like Java or C#’s type system but rather languages which have Hindley-Milner style type systems with inference like Haskell, ML and what not.

For a more reasoned post about this see Ricky Clarkson’s Stop Sitting On The Type Fence. The post is getting a bit old now, and Ricky’s been active in the Scala community, so I’m not sure if he still holds all these views.

My take on all this is that it’s possible to have your cake (static typing) and eat it too (all the goodness that dynamically typed languages provide). To take Scala as an example (Haskell would be better, but my knowledge of it is limited), you get static typing with type inferencing (albeit moderately weak ATM), so a lot of boilerplate goes away. You also get flexibility in the language, so you can write funky DSL style code till your heart’s content. The only thing you don’t have in Scala (as compared to Ruby) is decent metaprogramming, though I’m told there’s work in progress on this front.

For those that want to explore this a bit more, see What To Know Before Debating Type Systems and Types and Programming Languages.

[1] I know enough about type systems to be dangerous.
[2] Actually this is probably technically true, you’d need a theorem prover to do this, and potential need to solve the halting problem, but, we can get closer in practice than say Java’s type system.