Static and Dynamic Typing

For static typed programming languages, variables must be defined as a certain type before they are used. Java, for example, would be confused if you simply began a program with x=5. Instead, you must declare what the type of variable x is, like this:

			int x;
			x = 5;
		

You can also simply declare it as int x =5 (either is fine, but one is usually more fitting than the other depending on the context.) For a dynamic typed program, such as Ruby, the type does not need to be declared. Let's say I wanted to create a method that takes an array as input. The method declaration would be something like:

			def method (input)
				some_value = input[0]
			end
		

So what type of array is the input? Strings? Ints? Pandas? Who's to say? Ruby don't care! That's why it's dynamic. I can call method([1, 2, 3]), or I can call method(["a", "b", "c"]), or I can call method([panda1, panda2, panda3]). (This last one assumes that I have for some reason created a Panda class and have created 3 Panda objects). This seems great, because I can call method(input) and have the return value be an int, a string, or an object.

Now, it really gets crazy when you consider this: the way this method is set up, input could even be a word! If I call method("word"), then the return value some_value will be "w".

What if we tried to do this with Java? To declare a similar method, we would have to declare that it is an array using [], and we would have to declare it as one of these:

			method (String [] input){
				String s = input[0];
				return s;
			}
		

It seems to set so many unnecessary boundaries. It just seems like an overly strict parent, doesn't it? No fun at all? Unless, maybe its annoying stiffness is actually there to help us. If I have not yet declared input as a variable, Java will freak out because it does not recognize it. But that can be helpful. Consider the following code in Ruby:

			some_value = 9;
			x = 1;
			som_value = 9 + x;
		

What if, while coding in Ruby, I made a typo the second time and typed "som_value"? I would be left with two variables: some_value and som_value, so now some_value = 9 and som_value = 10. That's going to confuse things later when I refer to some_value, expecting it to be 10.

Java, or any static typed language, proves to be advantageous in this case. In addition, sometimes it's harder to keep track of what a method should take in or return. If I want to create a method that takes an array of integers and returns the average value, strings have no business in that method. Sometimes the return value HAS to be a certain type, and that's harder to control in dynamic typed languages. Sometimes in Ruby I think to myself, "Wait, I have no idea what argument this method wants! Strings? Ints? Pandas?" And then I miss Java, where everything was so clearly spelled out.

I initially was really annoyed with Ruby, finding its loose, dynamic capabilities almost immoral. It was the harlot of programming languages. Maybe that's too harsh of an analogy. I guess if Java is the strict parent, then Ruby is Lorelai from Gilmore Girls. But now, I see the value of both static typed languages and dynamic languages. You need both strict boundaries and freedom. Eat your vegetables, but still have fun on the weekends. Or something.