What previous posters are trying to explain is that static typing is a whole raft of unit tests provided to the developer by the compiler for very little cost… This is a good thing… The majority of bugs occuring are the stupid ones that the moment they are pointed out to the developer have them blushing… Inappropriate type usage falls into this bracket.

Also mentioned, knowing (or discovering) what an object can do is essential for any platform catering to an OO paradigm. It´s not optional. Either that knowledge is implicit in what the developer knows, or explicit in either documentaion or declaration… Checking that you can do what you´re trying to do to an object at compile time is a good thing. Again, it eliminates a lot of common errors that even the most gifted programmer can make.

Now people could come in with valid arguments from a variety of language camps as to why outside an OO paradigm different approaches may be safer or more productive… Ruby isn´t one of those camp. It´s a relatively staright forward, multi-purpose, multi-paradigm but largely OO mainstream langauge. It really isn´t that funky or special, and certainly is not special enough to be offering enough to dodge the benefits of static typing.

If you´re a loan hacker coding your dream for the next dot-com giant web service, then use whatever you want however you want. If you plan on participating in projects that span years, with many people you have to consider the maintainance of a large codebase by lots of people… Static typing starts to look really compelling then… Yes you can do it, and do it very well in Ruby, but you can´t brush aside the cost of not having static typing as being of no consequence.

If I´m breaking an interface that another developer is relying on in a completely different part of the codebase that I´ve never even been in, I´d prefer it if the compiler told me… Yes I shouldn´t be modifying an interface in a breaking way, but maybe I´m only mediocre, maybe I´m tired after a tough week, maybe I have a hangover.

I know how many stupid mistakes I make day-to-day, hour by hour. I know how many stupid mistakes I make, because the compiler warns me.

100% agree. The last 6 months (which is about when I started seriously investigating functional programming languages and concepts) have made me feel like I’ve wasted 5 years “doing it wrong”.

But, as you’ve found - applying functional techniques to ruby and java has made me much more productive, and produce much more succinct and readable code.

If only there was a hoogle for java/scala…

“What is the specific, exact problem therein? Which are your data nodes (or “types”) you have a problem with?”

I will answer briefly here, and will also try to post about it soon.

My problem basically boils down to it’s hard to understand what a piece of code is doing without knowing the types. In Ruby, before you can reason about what some code is doing, you need to reverse engineer the types, often by looking at calling code, and trying to deduce parameters, etc.

Take for example, a parameter to a function called tags. What type is it? Who knows? Well calling code might, but throw in a few Rails plugins and try and work it out.

Sometimes “tags” are instances of the Tag class and sometimes they’re strings. Which is it in this case? I could obviously whack some debugging code in there to find out, but that’s a massive waste of time and completely inefficient. Now if this code was well isolated and tested it may be easier to deduce.

I’ve heard it said that dynamic typing gives you extra freedom, which static typing prevents. However I’ve been writing Ruby professionally now for about 8 months (longer on a non-full time basis) and I’ve only really experienced this benefit once. While this was a nice thing, it didn’t buy me more than about 30 seconds of time over what a static language would offer. And the downsides are significant.

That’s a problem of those languages, not of type checking. Read about type inference, use Scala, Haskell, Ocaml, hell even C# has a bit of inference if you want to start gently. You can’t write off all type checking as useless if you won’t look further than Java. Well you can, but you won’t look sane.

It appears you don’t understand the type-checking or no type-checking issue very well and sound like a type-checking fanboy mouthing off.

One problem with type-checking is in most languages it requires more code. As code size increases so can the bug count. That is, type-checking can actually increase bugs.

Another problem is type-checking catches a relatively small class of errors (in most languages usually doesn’t even catch all type-related errors) that are really quite trivial. Serious bugs would be the ones the type checking doesn’t catch.

Unit tests need to be written either way.

Regarding #3: Unless you have 100% code coverage, which nobody does, your unit tests won’t necessarily catch all simple syntax errors. I do a lot of python coding, and one of most annoying things is silly failures due to typos that could’ve been easily caught by a compiler.

I suggest giving statically-typed type-inferring languages a try–they don’t force you to make up anything baroque. OCaml and Scala are both good examples.

The reason people don’t grasp that is because #3 is something you just made up out of thin air. Dynamic language programmers don’t write unit tests to solve the same problems compilers catch. Tests are written to verify the intended functionality. The type of errors that are typically caught by the compiler in, say, Java show up just as quickly at runtime in the vast majority of cases.

The fact is that when people write software, they don’t just pass parameters around willy nilly. It’s usually very simple to infer the type of any variable at any time. So why should we have to declare the type of everything if it’s intuitively obvious? And more importantly why should we build baroque structures to allow us some sort of multiple-type flexibility when what we want to do is conceptually simple?

Now it should be clear that what I’m talking about here is Java. I don’t have anything against static typing in general because I’m not familiar with enough languages. I know that static typing per se doesn’t need to preclude doing many of the simple and useful things we do in Ruby that are painful and obtuse in Java.