Just as important are:
- 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
The advantage of dynamic languages isn't that you get your coding done 5x faster, because most projects don't actually spend all that much time coding. It's that you can do 5x as many iterations in the same amount of time, which changes the way you approach your interaction design.
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.
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!?
Types contribute greatly to the verbosity and line noise of Java. They also are a big part of the reason design patterns and complex hierarchies are abused in the language. The duck typing that is common in dynamic languages can be a tremendous help for the reuse of code. Open classes also enable code to be reused in ways that had not been intended. These are dangerous features, but used effectively they can result in great productivity.
But I can't see anyone putting those languages on equal footing. Merely being "dynamic" in some sense is insufficient.
Further, the author says, 'I never really considered the “why” of Java, as that would interfere with my unbridled hate. ', leading me to think there's been very little investigation into different type systems.
This comes off as simply "I like Rails over Java".
I should point out that my lack of consideration of Java was more due to my perception of it being C++ (a language that I have written far too much of) without all the fun or peril.
You are entirely correct that it isn't the type system that makes a language, but it does provide a convenient if highly inaccurate way to speak broadly about a set of languages.
Java can be written concisely. However, it's fighting against the language, and most of the libraries will prevent you from doing so. That said, it's perfect for consultingware for the same reason: I can't think of a better platform than Spring to develop customized applications based on a common platform. Write a piece of new business logic in a series of classes and maintain an xml file for each client.
Mind you, the side project I'm working on is in java because it's going to develop into a business for small and medium sized businesses who often are comforted by the idea of hundreds of thousands of people who already work in the domain.
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.
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.
Or even worse, taking 5-10 mins to wade through library code to figure out what to call obscure_helper_function() with.
Then I spend about one hour trying to narrow down how I call the thing incorrectly. I also search for the error message, which prompts an upgrade of psycopg2 for a bug. Doesn't help. In the end, I realize that the calling convention I use is wrong and I should have called the thing differently.
This kind of problem is trivially mitigated with any static type system which is just a little stronger than what Java or C buys you (ocaml, Haskell).
In 4 we get the dynamic invocation, multimethods and the equivalent of Python's getattr/setattr (or ruby's method_missing) functionality.
I have ported a small project back from Python to C# 4 and there are very few places left where the Python code is more concise. In some places the C# is much clearer than Python, so it's a bind I would say.
For most of my projects I cannot use Python anyway because it's simply too slow and uses too much memory, so I'm glad that there is a fast statically typed language that I actually start to like.
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).
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.
"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.
And so on.
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.
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.
There, fixed the title for you. ;-)
I'm no Java supporter, but all those bits about "better programmers" and "average programmers" was a bit much.