Why Dynamic Languages are a Startup's Secret Weapon

This is just a coincidence, however. Static typing is not where Java fails; Java fails because the language lacks key abstractions and is very verbose as a result. There are plenty of statically-typed languages that are as concise as Perl/Python/Ruby; Haskell immediately comes to mind. (Scala is also good, and compatible with your existing Java.)<p>Java is an advantage for the corporate world because it lets them look for products and services by filtering on a single word. This advantage has made it very popular.

Part of what's unfortunate about the attitude of a lot of people in the dynamic language community (honestly, Ruby attracts this far more than Python for some reason) seems to be a complete lack of understanding of why anyone would do anything differently. The same is true the other way, where Java programmers reliant on their IDEs can't imagine working without one, and vice-versa.<p>Used properly, static typing hurts you in some ways (verbosity, certain kinds of inflexibility) but helps you in other ways (static checking, better tools for discoverability and refactoring). As other people have pointed out, Java itself is also hampered by a lack of a few simple things, like closures and type inference, that could easily be added to the language and that other statically-typed languages have. The JVM is also hampered by the lack of hotswap to let you make changes to a running system at the very least in development, but even that limitation is being worked on by someone as part of the OpenJDK project (who knows if it'll ever make it to the official JDK, though).<p>There are situations where the tradeoffs are worth it, and situations where they're not. Anyone declaring the superiority of language X in all situations would do well to really try to talk to people who use other languages and understand their strengths and weaknesses instead of just dismissing them as relics of the past or slave laborers.

The thing is that this article makes a lot of assertions and then doesn't provide any compelling evidence for me to believe them. Ex:<p>"Java makes doing dangerous (or interesting) things painful." Why? "It protects programmers from themselves." How? "If nothing else, it allows bad code to be isolated and encapsulated away from the rest of the system, protecting the other workers." Huh? Isn't this design, not language? "This comes at the cost of velocity." Huh? The tradeoff isn't immediately present to me.<p>And so on.

I'm inherently weary of anyone who claims that dynamic languages with loose types are the end all be all.<p>I can only speak from experience with PHP, but at some point your app+framework is just so big that I've almost wanted to sacrifice some development time for a little type safety. It really sucks not having a guarantee that somefunction() will always return an array of some object.<p>Or even worse, taking 5-10 mins to wade through library code to figure out what to call obscure_helper_function() with.

The language of choice is but one of many links in the "secret weapon" chain.<p>Just as important are:<p><pre><code> - the proficiency of the programmers, regardless of language - the repository of reuseable code, whether public or private - the startup's skill in analysis, design, testing, and deploying - the domain knowledge in the market space - the unassailability of the market position </code></pre> I'll take a java startup good in these things over a rails shop that isn't.

As someone who used to program mostly in Java, but now works mostly in Ruby and Lua, I can say that I enjoy programming in Ruby and Lua more than Java. But I think I was still a fairly productive programmer before I made the switch.<p>I'm not sure how much of this is due to the languages themselves or the sort of overall culture of how software is developed in each one. You can have 500 character class names and factories that make factories that make factories in both Ruby and Java, but you only see people doing that in Java.<p>Since many projects end up using a lot of preexisting code in the form of open source or commercial libraries, if the language you're using has a culture of convoluted hierarchies like Java developers often seem to create, then you're going to inherit that pain if you use that software, and it will likely slow you down.

When people say "dynamic languages" what is it that they mean? The typing system? If so, how can typing really effect productivity as drastically as this article (and other people I've heard) claim?<p>It seems to me that what is really at play here is good language design, good libraries, good sample code, good tutorials, a good community. I honestly don't understand how a statically typed language would be at such a humongous disadvantage to a dynamically typed language.<p>I ask in ignorance. I spend most of my day in Java and I hate it, but I rarely curse the types... What am I missing here!?

I have never found the act of typing code to be the big time sink. The big problem is devising the algorithm for what you are doing, properly selecting libraries and understanding how maintainable the approach you are using is (patterns). Maybe I am in the minority, but the biggest time sink for me is fundamental mistakes I would make regardless of the programming language I am using. I do prefer a dynamically typed language with lambda expressions, though.... certainly faster and more fun.

Why Better Languages than Java are a Startup's Secret Weapon.<p>There, fixed the title for you. ;-)

When the smug from this post gets hit by George Clooney's speech, it will be a perfect storm of self-satisfaction.<p>I'm no Java supporter, but all those bits about "better programmers" and "average programmers" was a bit much.

Java is just as productive in my opinion, when built and edited in a command line environment. Using Eclipse slows things down quite a bit (but speeds up things like refactoring). I've found myself no more productive with Python since I end up having to find the syntax/type bugs in runtime rather than compile time.

For myself, using C# in the corporate world and Python for my personal projects, I enjoy developing more in Python, and I am therefore more productive (or at least I feel that way.)