Not sure why this blog post showed up again, but it did, and it was another good read.
What resonates most with me are the following nuggets:
- The implication appears to be that anyone in the real world, if only they’re using Java, writes well structured and maintainable code. I think the real world has a few surprises in store for people who think that way. As the saying goes, real programmers can write Fortran in any language.
- The overall design of large Java systems will tend to be more convoluted than that of almost any system written in a dynamic language, simply because the contortions forced by Java require larger overall designs. Java buries the intention of code under a thick layer of implementation details and typing bureaucracy. Programmers are drilled to execute the requisite gruntwork in repeatable, predictable ways. Moreover, doing so conditions them to design their own system to cater to these reflexes. A maintainance programmer who comes in later will therefore easily be able to make changes to the mortar of an application. Unfortunately, that does not ensure good high-level designs nor does it translate to easy refactoring of convoluted architecture. Dynamic languages abstract away huge swathes of gruntwork and require less structure. This means small systems have small implementations, which directly translates to better maintainability. The price is a loss of exemplary structure and of conditioning, which requires better innate architectural skills and stronger discipline when building larger designs; neither are strong points of the average programmer. However, designs in such languages aren’t frequently large, because the language does not require large architecture for modestly sized systems – which the majority are.
I've been in a serious funk over Java for the last six months or so (just a light funk for the last decade). It's been hard for me to explain to people why, since it's more of a gut feel thing to me, but this post definitely captures some of it.