Regardless of which position one takes with regard to StaticVsDynamic
typing debates, it appears that large corporations gravitate toward StaticTyping
. Languages like CobolLanguage
, and JavaLanguage
seem to gain corporate preference over languages like LispLanguage
, and PythonLanguage
Some say that StaticallyTyped
languages work best for unmotivated programmers who want the machine to catch their mistakes but don't care about productivity; while DynamicallyTyped
languages allow RAD and make lean, mean, and clean code in the right hands but messes in the wrong hands. This is probably an oversimplification, but it may spark ideas about the decades-long corporate preference pattern for StaticTyping
languages rein in bored cubicle-dwellers? Do managers accustomed to bureaucracies just feel more comfortable with explicit formalism?
On the one hand, I'd guess that the sort of managers who want the sort of IllusionOfControl you get from huge spec-docs also like this sort of stuff. On the other hand, this sort of debate might just be internal to the programming communities; I don't know many non-programmer managers who ever get involved in religious disputes like this one.
has an interesting perspective on the sterile StaticVsDynamic TypeChecking
debate. On http://www.artima.com/weblogs/viewpost.jsp?thread=4669
, he points out that the productivity benefits of DynamicTyping
must be balanced against the organizational benefits of being able to explicitly specify contracts and partition APIs. [See TypesAreContracts
.] Given that most corporations tend to still be using some form of WaterfallMethod
, or at least doing BigDesignUpFront
, then being able to use StaticTyping
to define explicit contracts is clearly advantageous. Organizations with architects designing applications using UnifiedModelingLanguage
will tend to find it easier to ask those guys to specify types on their ClassDiagram
s rather than write UnitTest
On another note, PaulGraham
pontificates about StaticTyping
(among other things) in his essay "Hackers and Painters," http://www.paulgraham.com/hp.html
. Among other juicy quotes, Graham says, "Big companies win by sucking less than other big companies."
It's probably because StaticallyTyped
languages have one more tick on their feature matrices...
It's pretty clear programming languages are not selected based on feature matrices. Things like bounds checking, type inference, parameterized types, closures, and GarbageCollection appear in few, if any, of the "corporate languages'" check boxes. -- BillTrost
Sure they are. It's just that management's feature matrices look a lot different than programmers'. Fine, then. Please enlighten us all about what management's feature matrices for ProgrammingLanguages look like. References would be fine.
The matrix would probably contain items such as: Is everyone else using this? Is this language backed by large, stable software vendors? Will it be easy and cheap to get hold of an ArmyOfProgrammers who already have experience with this?
, types check YOU!
Same as here, then. After all, the purpose of types is to detect human errors. Hmm. StaticTypingConsideredOrwellian? ...
Yes, but not without tradeoffs.
This sounds as if corporations consciously selected typeful languages, but they don't. Most corporations only consider a single language, which is C, C++, C# and Java. (You think that's four, not one? Do you also think, the decision makers in corporations would be able to tell the difference?) That this language has types is just a conincidence. Would tapes matter, corporations could use Eiffel, Sather, or D, all of which have better static typing than C and are superior in every aspect.
The sad truth is, corporations don't like static typing at all. They just don't care.
See also: BondageAndDisciplineLanguage