First go read this story: Electric meat. Next look at and study this comic: Ingenuity of Sorts. Finally watch this video: Testing Distributed Systems with Deterministic Simulation
The common thread that binds them all is something about complex adaptive systems where people, tools, and culture interact. I don’t have a single word for that something so I’ll just describe it. Limitations often become institutionalized and workarounds are encoded both culturally and through the tools that people use day to day. This phenomenon is almost unavoidable. It might even be something that is inherent in the structure of any complex enough and adaptive system with a delayed feedback loop. Here are some manifestation of that abstract process in programming.
Java is verbose and statically typed. This is more of an aesthetic thing and it might have something to do with the structure of the brain but people don’t seem to like verbosity. They hate it so much that all enterprise Java frameworks are a variation of a dependency injection system coupled with an annotation-heavy tag system. Doing things that way is slightly less verbose than doing it completely in Java but not by much. This is one reason no one writes Java without an IDE. The amount of introspection required to make sense of all these frameworks is impossible to keep in one’s head so you pretty much need some kind of graphical representation of what is going on. This is also a really good example of Greenspun’s tenth rule. People wanted to get around the restrictions of the type system and they did. There were enough escape hatches and people learned to use them. The irony is that Java’s type system is actually not so bad but it is apparently not dynamic enough for most work and so XML and introspective wiring is the lesser of the two evils.
Python has no private instance members. If you step back and think about it there is a certain elegance to this design choice except people still managed to introduce them. There is a pythonic way to program and it is a lot like a culturally defined type system. Private members are prefixed with an underscore (
_) and I think extra private members are prefixed with a double underscore (
__) and are called magic members. If you want magic in your programming language then Python is the way to go. In fact, no dynamic language is immune from this. After a while the community settles on some rules to tame the complexity of the dynamism allowed by the language. Ruby has the Ruby way of (meta)programming and I think Perl has similar cultural restrictions.
Haskell is immutable, strongly typed, and lazy. There is again a certain elegance to the design choices except that doing imperative and effectful things is unavoidable. For a long time Haskell did not have a solution for effectul computations until Eugenio Moggi used monads to give categorical semantics to all sorts of effects like i/o and exceptions that previously had been swept under the rug. It was a good idea at the time and people ran with it. Now there are monads for anything and everything except that there is one small problem, monads don’t compose. The one language designed with compositionality as a guiding principle has at its core a concept that is inherently non-composable. You need all sorts of higher-order type level trickery to get around this and there is no shortage of ingenuity in the Haskell ecosystem to get around the problems of monad composition to deal with effectful computations. Any high-powered Haskell library is bound to have types of the form
(Typeable (Cofree f a), Typeable1 f, Data (f (Cofree f a)), Data a) => Data (Cofree f a). That one is actually kinda tame but you don’t have to go very far to run into something that is inscrutable as far as types are concerned. Throw template Haskell and all the extension pragmas into the mix and you can spend a decade learning this stuff and still have plenty left to learn. Haskell is a lot more like Java than people would like to admit. The inscrutable types are a workaround for stuff that Haskell makes very hard to express because the types get in the way.
There are more examples but that should be good enough for now. I’ve basically stopped paying attention to any marketing related to programming languages and frameworks because when you dig in deep enough you start to see the electric meat and institutionalized beatings, shocks as features, and all the ingenious adaptations.