C++ is not always able to detect common parameter errors, especially for things like implicit conversions of numbers. Arguably Python’s option of keyword arguments make certain classes of parameter errors go away, too.

Several years ago I remember someone who (perhaps unwisely) wrote a C++ function with many floating-point values as parameters and a single default "bool". At some point the function was extended to have another float. The compiler did not catch calling code that failed to add an extra float; it simply allowed the formerly-flag arguments to be assigned to the new float argument instead. In fact, implicit conversion of parameters is such a common C++ problem that I occasionally define wrapping types for the sole purpose of being parameter types: then the compiler has to trip over them when they are used incorrectly and callers have to do some kind of explicit action to indicate what their values really are.

The cpp compiler would catch it only if the incorrect data was of a different type. Type specification and hinting only helps with the more egregious mistakes.

Type hints can catch most of these mistakes.

There are solutions for this: flowtype for js or mypy for python (preferably with python3.5+).

Sure, but most python code isn't annotated, right?

So this might be helpful for code you wrote, but not anywhere it interfaces with other peoples' code (which, in my opinion, is probably the most important place to check for type errors).

Or specifically to his example,

    from typing import Dict
    Foo = Dict[int:str]
    def __init__(self, name:str, balance=0.0):
        """Construct a Klass."""
        self.myfoos = {} # type: Foo

I _think_ that's right... close anyway

>Do people seriously only use a single language these days!?

Yes. In what bizarro world would one assume it's not so? By thinking that all development in the world resembles the company/work they do?

Tons of programmers only write C# or Java on Windows, and don't touch any shell scripting at all.

Tons of front-end developers only write Javascript.

Tons of statistics people only use R or 1-2 other statistics packages.

Tons of systems, drivers, embedded and OS people only C or C++.

Tons of game devs only write C++.

Tons of native mobile devs only write Swift, Objective-C or Java.

Some of them do occasional need to write some script to get something done, but it's hardly like the juggle between multiple languages.

And of course larger companies have specialized programmers for different domains, not some guy doing C++ AND admin stuff in shell AND some front-end JS etc.

The main product I work on is written in C++, so I spend most of my day looking at\writing C++ and also learning as much C++ as I can. I do use other languages for some minor tasks (python and c# for some automated test stuff and devopsish kind of work), but i dont use those languages as much as C++ nor do I invest as much effort into learning the ins and outs of those languages. So I consider myself a C++ programmer because its what I put effort into

Some people are far more specialized in what they work on.

- Apple's Swift codebase is 54.8% c++ [0]

- Microsoft's CNTK codebase is 57.6% c++ [1]

- Bitcoin's codebase is 68.6% c++[2]

- XBMC's codebase is 84.7% c++[3]

If you work on certain or specific types of projects, like ones making the tools that others use do their projects, then you are typically working more in only 1-2 languages at a time.

[0] https://github.com/apple/swift

[1] https://github.com/Microsoft/CNTK

[2] https://github.com/bitcoin/bitcoin

[3] https://github.com/xbmc/xbmc

Why do you jump between multiple languages all the time?

That's the same feeling I had when I was writing the article!