There is an often quoted phrase in the programmers circles:
When the only tool you have is a hammer, everything looks like a nail,which basically states the same thing: the languages we programmers know and use influence the way we perceive reality.
That's a dangerous thing, because languages (programming languages) were only supposed to help up interpret information. Skewing our perception means we obviously don't even notice the wrong path we've taken.
Being multi-cultural -- that is, knowing multiple languages -- helps, as these may overlap and give you various perspectives on the information and thus make a better representation of the information. The end solution is also most likely to be better.
But I often wondered: shouldn't we at some point just stop trying to force our thoughts into some language and just start expression into another language altogether ? Into our language ?
Sure, learning a language might bring some "discipline" into minds; using it might help up programmers get along with each-other. But in the end a language should just give a programmer some new perspectives. The output should still be in our language.
I assume this is the reason most people think everybody else's code is shit: their internal interpretation doesn't map with the mapping inside the other programmer's brain. A younger you produced a lot of bad code by your current mapping.
Which basically means we are utterly unable to find a way to fully express our thoughts in a way other people would understand, agree and like. And by like I mean having a close mapping with the other (or just bring something totally fresh).
And this limitation doesn't just apply in relation with others but to ourselves.
Then, how should we function ? Each new problems brings into us a current solution with our present interpretation. Should we express this into something like a Domain Specific Language (DSL) ? Should each new problem be represented into a new Problem Specific Language ? (And sure, maybe PSLs at a given time might have something in common as they also represent us).
So what means that some code looks like shit then ? It means the chosen PSL is incomplete, somehow flawed or just not elegant enough compared with our current PSL. Rarely does code look like shit if we like the PSL and the solution is somewhat broken -- then it just has bugs or is incomplete, but we fix it while following the given PSL.
Won't this make cooperation really hard ? Well, not really as cooperation might change the PSL for the better. It will also force programmers to slow down a bit and try to first understand the PSL before understanding the solution. We do this anyway as even while using a common language there is always a meta-layer programmer-specific; only that this layer is sometimes obfuscated by the language used instead of being very prominent like in a PSL.
Maybe general purpose programming languages should stop existing and be replaced only by programming paradigms and concepts.