A simple explanation of simplicity. Chapter 1: Theoretically Easy

Simple explanation of simplicity

KDPV with areas which we should visit to answer the MAIN question.

Foreword

I often heard the advice: make it easier.

What does simple mean? When we say that object X is simple, what are our expectations for X? When we say that something is simpler than the other - how do we evaluate it?
')
What is easier:
“A small sentence of five words” or the word “Deoxyribonucleic”?
“6 * 5” or “481”?

Or so:
You have a settings screen. Five of them refer to the chart, the other five to notifications. Do you need to create separate items "schedule" and "notification" in the main menu? Or leave all 10 points on one screen? What will be easier for the user?

You can say it is subjective. That this is determined by a certain “sense of simplicity”, that for one person something can be simple, and for another, difficult.

Okay, then tell me, why does the teacher spend time trying to explain something easier? Why edit the text, trying to make it easier? Why do programmers spend time reviewing code trying to figure out which solution is easier to understand and extend?

If simplicity somehow correlates with our assessment, then the best strategy is persuasion. Let's make readers believe that the text is simple. Or colleagues, believed that our solution is not difficult.

Will this qualitatively change their interaction with the result of our work?

Not.

Your text will not be easier to read because it is considered simple. It will not be easier to work with your code, even if everyone around you thinks that its complexity is the same as that of a stool.

If you were told at the interview that the company has clean code and good documentation and you believe it, then it will not affect the simplicity of working with the code.
Moreover, even if the entire department believes that the code is written well and the docks are there, this will not affect the result either. Their belief about their code may be wrong.

If the code was spaghetti, it would be spaghetti. If the “documentation” is comments of the format “here I have added 2 numbers” - the code has no documentation.
And no desires, confidence, etc. will not help here.

This does not work for about the same reason ^{( ru , en )} , for which you cannot give 5 of your friends 1 cupcake if you only have 2 boxes of 2 cakes in each. Even if you will meditate for a year with the whole company on the fact that 2 + 2 = 5, the sad situation with cupcakes will not change it.

Again. There is an object, and some of its characteristics may make you think ^{( ru )} that it is simple. And if tomorrow your assessment changes and stops at the “difficult” mark, the object will not care.

It can be concluded that simplicity or complexity does not depend on our expectations. Rather, the object determines what characteristic we give it.

I wanted to understand what object I expect to see in reality, if I am convinced ^{( ru )} that it is simple. Conversely, what characteristics of a real object make me think that it is simple.
What for? Well, maybe this will make my life easier?)

Chapter 1. Theoretically easy

In this chapter, we will look at the following topics:

• How to ask questions, and why is it important? ( A sequence of questions )
• How are the objects, actions and their performers? ( Simplicity in action , Objective subjectivism )
• How to determine the complexity of the action? ( Simplicity in action . Probably simple. )
• What are systems and their models and why is this a convenient way to describe objects? ( Systematics Modeling )

At the end of the chapter we will talk a little about Occam's Razor ( Blade Runner ). An article on simplicity would look weird without mentioning this principle.

1.1 The sequence of questions

Our research begins with a question. To ask a question correctly is very important. Small retreat:

- Okay, Deep Thought, what is the MAIN CONDITION of SIMPLICITY?
- Need to think.
...
...
N million years later ...
- $$$<42.$

// Based on a beautiful book

We have the answer, but it gives nothing. All information about him is in the question, and the question was not too specific. We cannot prove that $$$<42$ - really the main condition and we can not show the opposite.

The question should limit the scope of possible answers.

“What is simple?” Is not a very specific question. Let's clarify it. At the beginning of the article we have already done part of this journey:

When we say that object X is simple, what do we expect from it?

According to my observations there are two main cases:

1. X is an object that does not break into its component parts. Here the word "simple" can be replaced by the word "elementary."
   
   This is a brick. And, in a sense, he is simple.
2. X is easy to do with the action we want. For example - a sofa is simple if we want to lie on it, and difficult if we need to raise it to the ninth floor.

The case when the object is elementary is understandable. But what if we are interested in complexity in the context of action?

Let's think about it. We perform actions with the object.

There are three main entities in this sentence:

• Actions - a description of what is happening.
• Performers actions - hiding under the word we.
• Objects are what the action is done with.

Then we are interested in the following questions:

• How to evaluate the simplicity of the action depending on the object with which it is performed?
• What is the relationship between an action and its performer?

We will answer them below.

1.2 Simplicity in action

Let's look at the action.

Ease of action is something that depends on its complexity. The more complex the action, the less simple it is - this is obvious. We come to the following question:

How to determine the complexity of the action?

What can we do with the action? We can break it into a sequence of others! The action “read the article” can be divided into: “read the first paragraph”, “read the second”, etc. In turn, they should be decomposed as “read the first sentence”, “read the second” ...



Similarly, we get to actions, the difference in the complexity of which will not be important for us and will not depend on the object with which it is performed (for example, read a letter). We call such actions elementary.

Then the complexity of the action for a particular object can be measured in elementary actions into which it is divided.

Actions are equivalent when they are broken up into identical sequences of actions.

What else characterizes the action?

Algorithm

Description of the sequence of actions that represent another action, I will call it an algorithm ^{( ru , en )} .

The algorithm can be described generally, for example:
Reading: read sentences until the end of the text.
In this form, reading is applicable to many texts.

However, as you understand, the number of actions “read sentences” will depend on the number of sentences in the text.

Result

Actions are performed for a reason; they lead to something. So let our actions have results!

The result is a change in the state of the system in which the action took place. You have pressed the switch, and its transition to the “on” state and the lights in the kitchen are the result of this action. You have read the word, and the result is a change in the state of your brain.

Different actions can lead to the same result.

Connection with objects

Let's go back to the objects. As we have said, you can perform different actions with them. We need a way to understand for which actions this or that entity is “intended”.

I will start with an example.

- And how do I carry this suitcase?
- He has a pen on the side!

The handle is a strip of leather on the outside of the suitcase, which was nailed with rivets. But in this case we do not care. We are worried that there is an object on the suitcase that can be held.

All such objects we will call handles. They can be at the cup, door, suitcase or bucket.



We have come to the conclusion that we have two descriptions of the handle from the example:

1. Like strips of leather, riveted on a suitcase.
2. As a concept of the subject for which you can take.

The first is the implementation description ^{( en )} .

The second is the interface description.

An interface is an object that stores information about how you can interact with an object that implements it.

What are they needed for? It's simple: most often we are not interested in how the object is implemented.
When we want to turn on the light - we are looking for the switch, and for us it doesn’t matter how it works, we only care that we can switch its on / off state.
When we see a button, we already know that it can be pressed.
When we are told that there is a pen somewhere, we already know that we can take it.
And it is very convenient.

Results

An action is a sequence of other actions that define its algorithm. The result of the action is some kind of system change.

The complexity of the action is equal to the number of elementary actions of its algorithm for a particular object.

The relationship between objects and actions defines the object's interface. It stores information about what actions you can take with the object.

Our next question is:
What is the relationship between an action and its performer?

1.3 Objective subjectivism

You may reasonably notice:

“But if you perform the same actions, the results may be different! If a professor of physics can fluently read an article on string theory and understand everything, then I will not achieve anything with the same approach. And to get a similar result, I’ll have to search for definitions through the word, read other articles and spend a lot more action.

This is a good point. I have an answer for it.

Like any task, ours have initial conditions. If you change them - you change the task itself. And this leads to the fact that its implementation requires different actions.

You are reading an article. Suppose that after reading a couple of pages, you put it off. Now, in order for the article to be read, you need to spend less action. But did this change the complexity of the article itself? Not. Changed the action that you will do with it. It was: “to read the article”, it became: “to scroll through the article to the moment where I finished, and to finish reading to the end”.

What should we do with actions then? We will fix the desired result. As we remember, you can come to him in different ways.

Further, we can break the performers into approximately identical groups. There are a limited number of such groups if we do not have an infinite number of performers.

Now for each group, we describe the actions that will lead it to the desired result.

We received a set of actions for each of the groups of performers. But now what to do with the complexity?

1.4 Probably easy

We have a set of actions. Each of them belongs to a specific group of performers. We know how to calculate the complexity of each of these actions for each specific object.

But what if we try to set the probability of the performer hitting one of the groups?
The task turns into a classical task on a theorever.

We have the magnitude of the complexity of the action. We have probabilities of performing each of the actions by a random person.

We can find the “mean” of our complexity. This is the so-called mathematical expectation ^{( ru )} . For this, we need to multiply each complexity of the action with the object by the probability of its occurrence.

Where to get these probabilities and how to break the performers into groups, if you don’t know yet who exactly will perform the actions with the object? Good question!

His consideration is beyond the scope of this article, but I will give one interesting example in my opinion.

You are the author. And your task is to write an article on the site which has thematic sections. When you post an article, it will be displayed in the general tape and the tape of the “own” section. The sections have subscribers, they make up a certain percentage of the site’s audience. General tape is shown to all. We will assume that the section subscribed understands its topic, and those not signed do not.
Let our paper be on physics. We analyzed the audience and know that the “physics” section was signed by 3% of the site’s audience. We learned that the probability that the subscriber of this section will go into an article from it is 80%. We also learned that the probability of visiting an article from a general tape is 5%.

Who is our potential reader and should we “optimize” an article for a person who is not subscribed to the “physics” section? In other words, what is the likelihood that our article is read by a person versed in physics?

So, attention, this probability is equal to ... About 33%.

Slightly more than two thirds of our potential readers do not understand physics, and we should take this into account.

How did it happen? In short: a high probability of visiting an article by a person versed in physics is compensated for by their small amount. A small chance of visiting the article from the general tape begins to play a significant role in our assessment. Want to know more about this? Here is a link to a good article about the Bayes theorem ^{( ru , en )} .
If you want to check:


We talked about the actions and those who perform them. Time to go to the last question.
We often used the word object, but it does not give us any information about it. We need some kind of description, abstract enough so that we can apply it to many entities, and informative enough so that we can work with it.

How to describe the objects with which we work?

1.5 Systematization modeling

I decided to try to summarize texts, tables, charts ... etc. But how to do that?

Let's go back a step and see how their “creation” happens, maybe it will help us.

We write the text. We have a certain idea, we formulate it in words and write it down. In this case, the idea can be not only in the form of other words. We can describe a picture, music, mathematical objects.

I am writing code. I have requirements that I “translate” into code. They can be expressed verbally or represent an image, such as a sketch of the interface.
We make the scheme. We have some objects, the relationship between which we describe this scheme.

There is something in common in these processes. We have some kind of system. We translate it into another system, without necessarily using the same “terms”.

It seems to me that the word “Modeling” is suitable for describing this process.

So, a model is a system that describes another system using specified notation (terms).

This definition pushes a reasonable question:

What is a system?

A system is a collection of some components. It is given by the set of their possible states and their current state. Components of the system I will often call objects.
They can be elements (something defined in advance) and other systems consisting of these elements. There are still such things as connections — they appear when we want to limit or determine the possible states of one object depending on others.

Example:
There is a system of 2 coins. One of them is “eagle”, the other is “tails”.
"Eagle" and "tails" are the elements of our system.

A coin is a subsystem that consists of the elements "tail" and "tails" and can be in one of these states. For the first coin:



Suppose that we cannot transfer coins and thus make changes to the system. In this case, our system can be described as:



If we can throw coins, then our system is described as:



There are dependencies between some systems. Suppose the state of the second coin cannot be equal to the state of the first one.

Then the set of possible states of coin 2, taking into account our limitation, is all previous possible states, besides that in which coin 1 is located.



In this case, we can say that the state of coin 2 determines the state of coin 1.

Now let's see what happens if we change the set of possible states of coins by adding an “edge” there.

We can make all the pairs for the states of coins 1 and 2.



In this case we are talking about restricting the possible states of the coin 2.

UPDATE:

I created a java coin implementation example. Here is the repository . In addition, it shows how to count the difficulty if you take the coin toss for an elementary action.

Back to the models

Model we call another system, which is the first display. In general, it can be built from other elements. The system model is a map, the system itself is a territory ^{( en )} . No one bothers to build models of other models. You can draw a map card ^{( en )} .

Let's try building models.

Let's start with the classics: black box.
You have: “input”, “exit” and box. You designate the components you would like to change to get the result as “input”, the components representing the result as “output”, and the rest as a black box. Such a model does not describe the internal dependencies of the system, but hides them. We do not know how the result is.



This approach is often used in cases where we want to study the work of a system, but at the same time we cannot “open” it. For example in psychology. We give people testiki, they solve them. We do not know what happens at the moment in people's heads. But, having collected enough data, it is possible to describe the device of a box which will give similar results. In the Machine Ex Homo section, we look at this in more detail.

Now we will build a model that displays the entire set of components and their possible states.

You live in ancient Greece. Your neighbor Zeno ^{( ru )} already got you. This Aidov son breaks into your house every evening with another brain-wielding riddle ^{( ru )} , and after that you spend a sleepless night in meditations. You need to sleep and for this you need to shut him up for at least a couple of days.

He last ran with the story of Achilles running after a tortoise ^{( ru )} . During this night, your eyes fell on one of the buckets. An interesting thought came to mind: to consider its aporia in a more detailed way, using buckets and stones.

You want to make sure that you have the opportunity to find out the position of Achilles and the tortoise in relation to the starting point, for each step of the tortoise. We have: a tortoise that walks, Achilles, which is 10 times faster than a turtle. And their initial positions: 1000 steps and 0 steps.

Our model does not yet know how to represent numbers. And it is absolutely impossible to discern where Achilles, where the turtle, where the path.

With the representation of natural numbers is simple : take a bucket, set the number of stones equal to this number.

Now we can describe the speed and the path. In the bucket that indicates the speed of Achilles will be 10 stones. In the bucket for the speed of the turtle - one stone. We now turn to the "buckets of the way . " In the turtle we will put a thousand stones, leave Akhillesovo empty. When the turtle takes a step, we will shift the stones from speed to go. Is it done?

Not yet. We have no paint to sign the buckets. Only stones. How to handle this?

Alternatively, we can put a turtle bucket "speed" to the right of its "bucket path." Do the same with the buckets of Achilles. And push back the buckets of the turtle. Now we know that in the “two buckets” combination - the right bucket is speedy, and the left one is the track bucket.

You are looking at two groups of two buckets. In order to find out which of the Achilles groups is you have to go, look in the bucket, count the stones in it, remember that Achilles’s speed is 10 steps, and conclude that Achilles has a bucket. And if we want to make some changes and make the speed of Achilles equal to the speed of the turtle? Then our way of checking for Achilles will stop working altogether!

Therefore, in front of buckets of speed and path, we put a "bucket of the name." Now it has become the most right. And let our rule look like this: if the bucket of a name is empty, then the buckets following it are turtles. And if there is a stone, then this group of buckets denotes Achilles.


I did not draw stones in S, but I think it is clear that for the first step the Achilles bucket is empty, and the turtle contains 1000 stones.

You are rejoicing. Now, Zeno will have to seriously think about why he decided that he could continue the stone-cutting process forever. At least you hope so.
Unfortunately, it did not help you improve sleep. Zeno didn’t really come the next evening, but now you yourself are deep in thought. Will the moment come when stones cannot be divided ^{( ru )} ?

Look, for each step we received some kind of state of each of the objects we considered. The position of Achilles corresponds to one bucket, turtles - another. For speeds the situation is similar. Our model fully describes all possible states of all objects of the simulated system.

Text is also a model of the system. The terms in this case are words. They are determined by their meaning, or set of meanings, which is limited depending on the context.
Our sensations are also a model that our brain creates on the basis of information coming from outside.

In short, the models you constantly face.

Do you still remember why we all did it? Just in case: we gave a definition for the model, then to calculate its complexity. The time has come, let's see how this can be applied.

You are a UX designer. Your task: to make the application settings page. You know that they will not change in the future. There are ten of them: five graphic and five notification settings.

You can leave them all on one screen. You also have an idea of ​​what can be done on the first screen with the “graphics” and “notifications” items, and a transition to the corresponding screen with five settings.



Let's assume that our user has a very bad memory and a habit of reading from top to bottom. But at the same time, he is still smart enough not to make a mistake with the section, in the case when we have grouped the options. He does not read the names of the screens and goes directly to the menu items.

We have only 10 settings, they can be displayed on the screen with a list, and the user simply sticks to the desired item. We believe that the user does not need to scroll the sheet in this case. On the other hand, if the user needed the settings from the end, it would be easier for him to find them, because he would not have to read the entire list, he would be able to skip half of the items he did not need.

Which model will give us a simpler interaction?

Actions that a user can take with a list item: read and poke into it. If you translate into the language of interfaces: the menu item has the properties of readability and poking ability. All the points are short, so the difference in the difficulty of their reading is neglected. We assume that the actions "to push" and "read" are elementary in our context. Their complexity is 1.

We expect the user to be equally likely to need any of the items. There is no sense in bringing up some of them.

Of course, you already have some guess about the answer. I suggest you write it down, as well as write down your confidence that your answer is correct. For example, on a scale from 1 to 10, where 10 is absolutely certain, 1 is not at all sure. You will need this data in order to compare them with the result. Under the spoiler "Solution" will be a poll. Unfortunately, Habr does not allow you to do polls anywhere in the text, so the link leads to Google form. There you can go through it and see the statistics on the overall results.

I advise you to take a pen, a piece of paper, open a calculator and calculate the complexity yourself. And only after that open the spoiler.


I inserted this example into the article at the stage of final edits. It was important for me to summarize what we were talking about. Link the information from previous chapters in an understandable form. So that you can easily imagine it and try to use what we talked about.

I was wrong. When I wrote this example, I thought I knew what the answer would be. And now I am pretty surprised. No that's not true. When I honestly did all the calculations, the result hit me very hard. About the following happened in my head:

- * Chorus * WE'RE MISTAKED ?!


...
...
...

I apologize for such a large digression and an example. Perhaps you are not ready to read further, and you want to think everything over again. And this is a good choice.

At the beginning there is a table of contents, you can bookmark the article and quickly return to this place.

Have you decided to continue? Then, we have the last topic of those that I wanted to raise.

1.6 Blade Runner

Most likely you know Occam's razor, but just in case I remind you:
“It is not necessary to attract new entities unless absolutely necessary.”

In general, this principle is interpreted as: of all the hypotheses, the one that is described by the shortest subprogram (or, more simply, the one that is shorter) is the most likely ^{( ru , en1 , en2 )} .

How it looks in real life:
If you turn on the light and the light bulb comes on, then the hypotheses may be:

1. The switch closed the electrical circuit and the current went through the light bulb.
2. The switch kicked a little gnome who connected the wires, causing the circuit to close and the current to go through the light bulb.
3. The switch kicked the little gnome who pushed the trolley in which sat a small dragon, who, frightened by the fiendish flame, which melted the solder, which connected the wires, caused the circuit to close and the current went through the light bulb.

Of these hypotheses, one that contains fewer entities, without a gnome, is preferable. If you turn on the light bulb when you hear a silent curse from the switch, the second hypothesis is preferable, because the former does not explain why the switch curses and the latter contains redundant entities.

I will be honest. When I first heard of Occam's Razor, I did not think about hypotheses. And her vague wording in verbal form led me to the idea that this is a general principle - reduce the number of entities that are in your system and everything will be cool.

I was very wrong .

But when I had a description of the simplicity of the system, I understood how to correct my misinterpretation of this principle. And make something useful out of it.

We have a system before and after some change.

If the difference between the difficulties before and after is greater than the complexity of the change process itself - this change is justified. It is understood that the change did not affect the result (at least on the part of it that we need). Call it ... a prerequisite for simplification.

Again:

The expected simplification of the system after the change should be greater than the complexity of the change itself.

If we denote the complexity of the change for$$C and , the complexity of the system is up to how$C_$$$C and after how$C$$$$C’$ then we get:

$$$C’ - C > C_$ .
We can also express a certain analogue of efficiency for our change.
$$$k = (C’-C)/C_$ .
If a $$k greater than one is a good, kosher change corresponding to the necessary simplification condition.$k$
If a $$k is less than 1, but more than 0 - this means that you simplify the system, but spend more time on it than get a profit.$k$
If a $$k is less than 0, then it tells you that such a change is not worth doing. You complicate.$k$

Why is it needed?Well, for example, you act in conditions where you have limited time and you would like to prioritize the changes you want to make. Changes with great$$k should be considered first.$k$

Example:

We have two texts, one with an example of the other without.

On the one hand, we have increased the volume of the text, thereby complicating it. But on the other hand, thanks to this, some readers will not go into Google “an example of an Occam's razor,” which is more complicated than just reading. If, by our estimation, there will be many such readers, then the introduction of an example will simplify our article.

We should not forget about the fact that we also did some actions to describe it, and they had their own difficulty. If we spent too much action, and the simplification was not enough - the introduction of our essence “does not pay off”.

Hmm, how is this all connected with Occam's razor?

Let's assume that we already have several systems. And their complexity directly depends on the number of entities (in the real world this is not always true, as we have already found out). The results of actions with these systems suit us.

Since the systems already exist,$$C and → 0 (you do not need to do anything in order to make changes to the system). Let's take a system with a minimum number of entities, and calculate$C_ \rightarrow 0$$$k relative to other systems. We will get that$k$$$k will be equal to minus infinity. From the point of view of simplicity, in such conditions, choose a system that is different from the one that contains the smallest number of objects - an infinitely foolish solution. This tells us that from all systems we should choose the one that contains the smallest number of objects.$k$ HmSuspiciously similar to Occam's Razor.

What else can be described using this condition?
For example, you can evaluate when it is worthwhile to apply various practices of improving code, and when it is meaningless.

In fact, if you write a task in a higher education institution, the code of which will be read once (or not read at all, but simply see how it works), then you should not worry about it so that it is well read.

But if you write for the OpenSource project, and hundreds of people will work with your code, or you write your project that you plan to develop, you should take care of its quality.

If you are writing a synopsis, you should evaluate whether you will need it in the future. If the teacher will check only its availability, and all the information is easier to find in Google, then why complicate it?

If you are writing an article - determine how you see the interaction with it. For example, this article is intended not only for a single reading. I tried to optimize it for a quick search. That is why under each part there is a “Short” spoiler and a table of contents at the beginning.

Eh, if we had a way to somehow describe how a person would read our model, and find the complexity of this model for reading. We could tell exactly how our actions will affect the complexity of this process and apply our theory in a huge number of practical problems.

Unfortunately, for this you need to create a general algorithm for people to read any model. If it seemed to you that this is a very difficult task - you are right.

Fortunately, I have already done some of this work.

In the next chapter, which will be called Machine Ex Homo, we will analyze how our brain works with information. We will talk about understanding and how information that we already know affects the perception of a new one. Let's look at the research of psychologists and neurobiologists in the field of studying human memory and create their own model of memory based on them. With its help, we will explain some interesting psychological effects, such as the effect of word frequency, edge effect, optical illusions. And there will be a lot more pictures.

In short - it will be interesting, I promise.


License:
CC BY-NC-SA 4.0