Reg first:

I am going to challenge you now. I am not trying to provoke a fight, I honesty want YOU to go away and say hmmm. Why is it that you are trying to paint me as such an absolutist, that when I say “I like static typing but I’m currently achieving my personal goals with a dynamic language” that I must be against static typing?

The question I put to you is this: could it be that YOU are the one who sees the world in right and wrong, black and white, correct and incorrect? If that’s the case, there is nothing wrong with your beliefs. I am not saying you should relax and blur the lines between good and bad in your mind.

Guess what? I’ve been doing most of my programming recently in Perl. For the things I’ve been doing- reading simply structured text files (csv, pipe seperated, fixed length, etc.) and tossing them into a database, or connecting to the database and firing SQL at it, or reading data from the database and spitting out simply formatted files, perl has a lot to recommend it, and is a better tool for the job than Ocaml. Ocaml would be better than Java or C++ for this job, but that’s damning with faint praise, IMHO. So, by the criteria you’re using to paint me as painting you as an absolutists (which is working, by the way- see Steve Vinoski’s blog), I too hate static typing.

Um, right.

I’ve gone and reread all three posts posts (yours, mine, and the original) just now. And I did paint with too broad of a brush, and I apologize. In my defense, I was a) tired, and b) had passed up commenting on the original article, thinking “Reg is already on my case about flaming about static typing, and if I respond to this one he’ll be right”. But then you went and called the article “The best question asked this week”, and I let fly. But for the original posting, I was spot on. Consider the following quote:

The point of this story is that trying to prove the correctness of computer programs is a lot like trying to solve a set of partial differential equations. It works great on small trivial programs, but is incredibly hard and costly on anything resembling a real world software system.

It’s hard for me to interpret that as anything except being anti-static-typing (static typing being a weak form of code proofs, and there being a very strong cross over between the Hindley-Milner static typing crowd and the code proofs crowd).

The bigger the system, the more important I feel static typing, and at the extreme even code proofs, are. Proofs that the code does at least what is it intended to do, even if it doesn’t do what it needs to. Because the larger the system, the more likely there will be unintended interactions, and the greater the complexity. Frankly, we humans suck at writting programs that do what we intend them to do, in all environments and for all inputs. Mostly does what we intend it to do, in most environments and with most inputs, yeah. Occassionally, and with heroic effort. But most programs are riddled with memory leaks, security holes, crashes, corruption, and just general suckiness.

And, by and large, most programmers don’t admit that- and don’t admit that there is any thing computer science- the actual academic stuff- might have to teach them about making programs that don’t suck quite so badly. In fact, many programmers are not just indifferent to theory, they’re outright hostile to it. You don’t have to spend too much time on slashdot to find this hostility, and it shows up even on digg and reddit. In either case, huge tracts of theory are not only not know by most programmers, most programmers don’t even know it exists.

While I’m on the subject, Saphirecat, go take a look at Software Transactional Memory. Haskell has done exactly that, used it’s type system (and purely functional programming)_to allow it to prove that there are no race conditions. Ocaml doesn’t have this, but that’s because Ocaml isn’t that advanced of a language- the core of Ocaml (the Caml language) is 20 years old (Caml predates Java), and SML, the language Ocaml is based on, is over 30 years old (SML is older than C++).

But this hostility to theory is having a cost. As Java seems to have been nominated the ultimate in “theory” languages by the theory-hostile, the industry as a whole is undoing what little help theory has played in making programming more usefull. It’s not just typing- Java’s GC is almost as bad (I have a post brewing on that). GC doesn’t have to be complicated and slow, people.

But this has given me something of an itchy trigger finger on the subject- especially considering I too was once an ignorant sot. I learned Ocaml because I had set out to write “a better Java than Java”, and people kept telling me that I should learn a functional programming language, as it’d improve the language I was designing. To make a long story short, I learned Ocaml, which turned out to be (in every possible way) a better language than what I was designing, so my language went the way of the smallpox virus (extinct and not missed). You can probably scare up some good quotes by me from my days on comp.lang.java.advocacy, if you’ve a mind to.

“OK. Now go and write static type declarations that prevent your program from having any race conditions. I’ll wait.”

So your “can’t do it” example ends up cutting both ways. Typical languages don’t have declarative lock-taking (it’s all imperative code) so they can’t have any declarative means to make assertions about those locks. It also seems like if the compiler has enough knowledge to check deadlocks and race conditions, then it has enough knowledge to take locks for us in the first place, and we wouldn’t have to worry about it ourselves.

I chose that quote because I think that two people comparing and contrasting Ocaml vs. Ruby probably have a lot in common.