Rethinking how we talk about types

I come from a background of functional programming languages.

Elm is such a language, and one that has inspired me in more than one way.

One aspect, that has initially surprised me, and then convinced me personally, is that they avoided using the term 'functional programming' at all.

Why did they do that?

Because the association to that term didn't reflect the reality of the matter.

Language does exist to express one self, and that the other person can understand you.

We humans are quick to categorize – we even see it in our code – and just as the business requirements change, does our terminology.

Or not. One of the core accusations that people bring up against object-oriented languages, as an example, is that they can't adopt quickly and with less effort to a change in structure. Things change, and the code that represents that, isn't possible to do so as well.

They stuck with their old view of reality, and I think humans are quite often just like that.

Now, instead of changing – someone could say mutating – the opinions of people - which turns out to be quite challenging ;) - we could pull off a trick from the book of Rich Hickey and just create a new description.

One that carries the old functionality, but endorses a new terminology.

I am talking about dynamic typing.

We are not a dynamically typed language.
That's at least what I propose.

And we are not even a gradually typed language.

Ruby and Python are gradually typed.
We have a far more advanced type system.

Implemented from the ground up.

The point is, that we can gain popularity by speaking about our unique type system, that is distinct from every other one.

People have made up their minds about dynamic typing, and it's not fitting the reality.

Probably not even towards traditional dynamically typed languages, and for sure not with Julia.

We need a word, that is reflective of the properties of our system, and one that is associated with positive affirmations.

Currently, dynamic typing is more seen as some kind of liability.

How about an optional type system?

The reason why Elm stopped talking about functional programming, because it hid the idea, that Elm did embody.

So based on the idea, that people connected to that word, functional programming was just convey objectively incorrect assumptions about the language.

And by that, the only purpose for communication has failed.
Even more so: It was turned on its head.

Better to say nothing, that to delude people into thinking, they have understood, while they have a deluded image of reality.

The suggestive meaning of dynamic typing is largely a misnomer, despite the surrounding evidence.

And instead of changing the perception of dynamic typing (much fun with that) I would just suggest to talk about it in some fashion, that truthfully expresses the core identity.

I would suggest rethinking, how we talk about features, and take Elm and others as an example.

Let's talk about our awesome optional type system.
Or anything else, that may be fitting.

Let's hear your suggestions ;)