Watch Your Language

We’ve all seen the flame war posts about one language being faster than another. We’ve also seen  posts that attempt to speak about  runtime efficiency in more concrete terms yet still fall short. What these musings bring to light is a much broader concern that we as developers need to consider:  the formal study of programming language theory. Such study allows for intelligent discourse on the precise merits of a particular programming language in concrete terms rather than pontificating upon some set of possibly flawed benchmarks to justify the use of language x or y.  When we speak in concrete terms, we elevate the dialogue into a more scientific and useful context, a context that might in fact contribute greatly to development in general.
Without the basic knowledge of programming language theory we are left to the whims of what might be fashionable, popular or worse dictated by some other party with no consideration for the problem domain a particular language is best suited. One must not blindly assume that javascript is the best language for all things, just as one should not assume that python is the silver bullet. Mind you, I enjoy each language, and each language has its strengths and weaknesses.
As developers, our responsibility is to not only produce robust software that meets the specified user requirements within a set amount of budget, but we also need to consider implementation details which may lead to project success or failure. The devil is in the detail.  If we fail to consider language library support, grammar, syntax, readability, reliability, specification and verification we may exceed our development budget, miss crucial deadlines or outright fail in delivering the required functionality. If we are not aware of the limits of a language, we can’t compensate for them. We’ve either experienced or heard of projects that used a language where the developers were left grasping at reasons for why that language was used.
This is the cry for those who have had this formal training to keep current and for those who have not to gain it. The result will be higher quality software. It will also ensure that those who chose to roll their own programming language will have some background so that the language will truly be useful instead of a passing fancy.
The domain of programming language theory is vast. A foundational understanding of the concepts is what I propose. If after that exploration one is intrigued by the lambda calculus, all the better! Following are some links that will kick start the learning process: http://www.cs.cmu.edu/afs/cs.cmu.edu/user/mleone/web/language-research.html, http://www.eecs.ucf.edu/~leavens/teaching-prog-lang/home.html,
I know there are those who scoff at formal training and the notion of a degree in computer science. I’m not proposing everyone run out and get a degree in computer science, though it is a great way to quickly gain a foundation in computation. I am saying that we as the primary users of programming languages need to continue to learn and continue to push our comfort zone with learning. We also need to push one another to a higher level of thought than simply adding to the flame posts with name calling, hand waving and smoke.