[Haskell-cafe] Dynamic typing makes you more productive?
nominolo at googlemail.com
Tue Mar 18 15:00:04 EDT 2008
On 18 mar 2008, at 19.47, Don Stewart wrote:
>>> From a recent interview with the guy leading Ruby development on
>> .NET at Microsoft:
>> "You spend less time writing software than you spend maintaining
>> software. Optimizing for writing software versus maintaining software
>> is probably the wrong thing to do. Static typing makes it harder to
>> maintain software because it's harder to change it."
>> Two years ago I would have agreed with that statement. Now - no way.
>> Make the compiler work for you. I've done a lot of Ruby development
>> and I would never use it for a project of more than 3 or 4 people.
>> It's an awesome language but I don't think it would scale to
>> programming "in the large." Any object can be modified at any time.
>> Determining where a particular method comes from can be an
>> exercise in
>> Sherlockian deduction. Give an organization of 100 developers that
>> much freedom and I can only imagine chaos would result.
> Agreed, maintainability is all about restricting the damage people
> can do, and making refactoring safer :)
> The kind of havoc a new programmer can create in a pure, strongly
> polymorphic chunk of code is tiny compared to an "anything goes"
> language scenario.
Well, that kind of sounds like new programmer = bad programmer (as
you talk about damage prevention). I guess you don't mean it that
way, but I think it's worth to try to make it clear that static
typing can help programmers new to the code easily check where things
are used and gives them the confidence that their changes won't
introduce unintended side effects. A careless programmer can still
break the whole program, just use "head" in a sufficiently hidden
place, so it's not about preventing people from wreaking havoc to
your code base *on purpose* but rather to give them a safety net. I
think this is a common misconception in static vs. dynamic flame wars
-- static typing is often dismissed as not trusting the programmer
and overly constraining his/her latitude.
More information about the Haskell-Cafe