# Maieutics of computers 1/3

*How my computer started talking to me oddly…*

The good news in Computer Science is that even the most confusing code base is just another combination of the same Booleans. Any program in this world is a bunch of abstractions built on top of *zero *and *one*.

This is why we pretend that CS is not a science, and not even about computers.

It’s complexity-management crafts.

OK, it was an exciting introduction, so what?

My hypothesis is that even without knowing computers, we can rediscover them simply by communicating with them. We will let the machine reveal how it works, just as Socrates did with humans using his maieutics method.

And indeed, if we succeed, it may imply that informatics was discovered and not invented (Turing machine or Lambda Calculus included)!

*Prerequisites: understand Javascript Arrow Functions, Currying and the notions of function signatures*

## The Monist Universe

To begin, let’s imagine a universe without the **zero**, but only the **one**.

This kind of world does not offer much. But it was interesting to discover certain categories of knowledge, while putting everything in relation.

It is ultimately only a set of itself with only a relation to itself. Everything is equivalent in this world, this world is everything.

## The Binary World

It’s the computer world.

Its 2 values: 0, 1.

Their relationships: 0 to 0, 0 to 1, 1 to 0 and 1 to 1.

And the relationships between their relationships … let’s find out!

Do you feel a bit overwhelmed? It’s the language of the computer, not mine! I hope we will soon find a “sorry()” function.

As you can see, I have already thrown away what is not working (parameters unknown) or which is repeating.

And we can see that the number of relations (aka functions) is not directly related to the number of possibilities: we can refactor a little. In fact, if you work with the set {0} and the set {1}, you cannot factorize, and you have 4 relations: for each set, one with the other, one with itself . But if you consider the set {0,1} and its relations with itself, you end up with 3 signatures.

At the end, I tried to introduce this self_apply: it factorizes the idea of trying to pass a function to itself. I see no other combinations if we stick to one argument (unary functions).

## Next step

It’s just the beginning. To go further, my first idea was to work with a new set: {0, 1, 2}. But how will the computer find this 2? It can only play with switches: physical sets of {0, 1} and that’s it.

So the next step is just more switches: {0, 1} -> {0,1} -> {0, 1} and so on.

I am sorry. The next part can lose you as much as it overwhelmed me. And I’m not even sure it’s complete. Courage!

So let’s keep the unique things that we discovered.

Phew! it’s a lot of overwhelming and repetitive things.

And what is the main purpose of computers (apart from taking control of the planet and destroying humanity?).

Automate recurring tasks to avoid us headaches of course!

The next part will therefore be to find algorithms to generate all these curious possibilities (and be exhaustive), and to let the computer tell us what it can do!

And let him name his own stuff and teach him if we know an equivalent.

OMG, I can’t wait to see the monster born.