Better poly than sorry!

About me

I've been programming for as long as I remember. I started making a living on programming in 2004, which gives me "more than a decade of experience in the industry" - whatever that's worth. I also never stopped coding purely for fun and have some pet-projects published.

My progression through programming langauges and technologies, both professional and hobbyist, looks roughly like this:

Now I'm working with Python, JavaScript/LiveScript at day and with whatever cool language I can find at night. There is a list of languages I investigated to some extent here.

I sometimes write something interesting in a Hacker News comment.

There are some very old repositories on Launchpad, but I'm mostly putting code on Github right now.

About polyglot programming

Polyglot programming, as I understand the term, is about using many languages simultaneously, in the same project. Not necessarily in the same file, but that's allowed, too (but the tooling for this still sucks too much for this to be practical, I think).

There are many (potential) downsides to this approach and general consensus seems to be that they outweight positive aspects. I disagree. While introducing more languages may pose a problem in some cases, it can be also a great productivity boost if done correctly.

Like every tool, polyglot programming needs to be used rationally. It won't do you any good to write your software in multiple languages without analysing the need for them and how they fit together and to the problem domain.

Different languages, however, differ in expressive power in general and - which is more important in expressive power for particular use cases. Language designers are most often optimizing for some use case and they mostly succeed. Almost every programming language has a particular niche that it excels in.

The key to real polyglot programming is to recognize when you're tasked with a problem that some language solves particularly well and only after that using this language and integrating it with the rest of the system.

To do this you must have at least basic knowledge about many different languages. It's best to know at least one language per programming paradigm well or very well. Or, as someone else put it :

Modern polyglot developers do not memorize dozens of programming languages. Instead, they learn the peculiar terminology used with each language and then use this to search for their answers.

In general you should strive to know as many different languages as you can. Languages differ along a couple of axes, where one is supported paradigms, the other typing discipline, the other compiling vs. interpreting and so on.

Thinking about it some more leads to PLT (Programming Language Theory) rather naturally. After you learn a couple of languages you start to see some common patterns emerge. You'd like to know what these patterns are called, and that makes you read a lot of academical stuff on languages. But that comes later: first, at least for me, is a belief that it's practical and beneficial to use different languages in different situations.