Polyglot programming and the benefits of mastering several languages

I generally enjoy picking up new languages. It's always a chance to see how other language designers worked around common programming tasks. It's also great because you get exposed to an entire set of tools that may be unfamiliar to you.

I'm a fan of polyglots.

Thank you for clarifying my point, and attaching precise terminology to it!

Come to think of it, that's probably why people mistakenly think that Lisps are so hard. The syntax is scary, and easy to bikeshed - even though most of their semantics (for CL and Scheme, at least) are really easy, and very similar to Python.

I know people hate language wars and always reply with “Use the best language for the job.” but wouldn’t it be great if there was a language that could do it all optimally (or at least adequately).

Then we can focus on just one language to master and don’t have to keep in our heads a jumble of languages.

> Fascinated by the concept of polyglot programming, I decided to make good use of the fact that I know several exceptionally experienced developers and take a closer look at the topic.

The author selected only “polyglot” programmers so of course they would sing its praises. Or did the author expect them to say, “well I have experience with these 15 different frameworks, but I’d say 12 of them were a waste of time... meh.” You might make an off-hand comment on that on HN, but you typically won’t do that when you are being interviewed because of your seniority or whatever. That’s like downplaying things on your résumé.

Not that I personally think that being a “polyglot” is bad. But we need to distinguish between two things:

1. Mastering a wide breadth of programming ideas expressed through different languages 2. Knowing or having experience with implementing a lot of stuff

(2) might simply require being a polyglot because different domains and different fields use different languages. But (2) does not imply (1): you might have experience with eight different programming languages that are very much alike (only really differeing in third party libraries, perhaps), so you haven’t really gotten the chance to be a “polyglot” in the multiple paradigms sense of the word.

Basically any modern, turing-complete, and non-esoteric (eg. Brainfuck) language fulfills the "at least adequately" part. So it comes down largely to preference and style of the language itself. I can't stand C# code or that the language uses Allman style over K&R because I truly find Allman style more difficult to read. I shouldn't - the difference is very minor - and although I work with a C# codebase in my day-to-day work I always struggle parsing the code quickly compared to languages where K&R style won out.

Now "optimally" is an entire can of worms because there are some aspects where you need to make mutually exclusive choices. You can optimize A or B but not A and B for multiple sets of A and B. So you'll end up with multiple languages or multiple flavors of a single language where decisions were made to optimize for varying sets of A and B. A and B can even be simple things like "How easy is it to footgun yourself?". Should you make code that is more boilerplate/difficult to write in order to prevent people from footgunning themselves or do you expect your developers to be more experienced and allow them to write more succinct code but having to be aware of and avoid potential footguns themselves? There are a lot of domain-specific languages for precisely the kinds of trade-offs are made that certain fields want/need. For example, mathematics domain languages tend to be 1-indexed instead of 0-indexed.

By the way that language is LISP.

[0] Just in case anyone is unfamiliar with Allman/K&R styles mentioned you can see examples on Wikipedia: https://en.wikipedia.org/wiki/Indentation_style