This blog post was originally written and published on the inDrive blog. Want to work with us? Check our vacancies!

I'm addicted to learning and sharing knowledge. But it was not always like that. I always understood the profit of education, but for a long time didn't get any reason to spend time on sharing.

Knowledge sharing has many forms: teaching, mentoring, blogging and attending meetups and conferences. Even an explanation to people of you your professional area your job. One of my colleagues worked in a Cloud Security firm. Once, his old mother asked:

‐ What is your current job, son?
‐ Well, we secure the Clouds.
‐ Why are they paying you for this?

As you can see, even words have different meanings for people. Sharing something you know can require extra effort, but it can also provide additional benefits for your own.

Today I want to share my reflections about what teaching gave to me personally (and I hope will provide to you).

I still remember the feelings and thoughts which stopped me from starting to share.

Lack of Purpose and Motivation

This was the first and the biggest one. Why should I spend my time when I have so much to do and learn by myself. But in fact, this was caused by another thought.

What Can I Teach? Google / StackOverflow Knows Everything

The Internet is full of information in all possible forms. Free and paid, text and videos, superficial and deep. Do I really know something that is not there yet? And if I can find answers to my questions and solutions to my problems, everybody can, right? And again, it was not the root cause.

Fear

It's always easy to sit quietly on the sidelines, so nobody will notice you. Because when we start to say something, there is always a chance that we are wrong, and somebody will start to argue. We are all scared of judgment. And in my experience, this is always the main obstacle - overcoming our fear. Later I realized that this was Trap #1.

The Trap of Underestimation

I will call traps states that are easy to fall into and very difficult to escape. So trap number one is an underestimation of one's own knowledge. "I don't know much; someone already teaches all this," and so on.

I began to overcome this trap (still not understanding what I was trapped in) by accident. I connected to several IRC (Internet Relay Chat) chats and the developer forum when I needed help. But gradually, I began to answer and help people myself in part I knew well. And then the discoveries began.

The Discovery of the Mess in My Head

The first discovery was that the knowledge in the head was in absolute disarray. The paradox is that this mess is quite suitable for practical use. But to explain something coherently, you need to thoroughly dig.

The cause of that lies in the way we obtain our experience. Quite rarely do we have an academical learning process when things are learned from bottom to top step by step. In real life, we often compile solutions from pieces of knowledge and practical discoveries, and our mind stores them connected but with very blurry context.

But when I transfer this knowledge, I need to put it into logically sorted sentences, which requires clarifying the fog of the context I have in my head.

The Discovery of Wordlessness

Relatively fast, I understood that it's pretty hard to put things from my mind into understandable words. I can quickly provide the solution to the problem, but it's much trickier to explain all the details and get the right words to make it sensible.

The Discovery of Obscure. The Obvious is not Obvious

The most striking thing for me was that ideas and concepts that seemed evident to me, almost axiomatic and known to everyone, are by no means like that. But their obviousness gave me considerable gaps in explanations for others.

Our mind doesn't like excessive complexity and aims to simplify things. So, it removes the trail of how we learned something, primarily when it was obtained from practical experience. It's like it makes git squash from time to time.

The Benefit of Classification and Structuring

All this led me to the need to work on myself. I had to systematize, classify and structure my knowledge. To do this, I made plans, wrote out definitions, and just tried to write intelligible textual descriptions.

After that, it turned out that more than simple systematization was needed. For each area, and each task, it was necessary to look for the correct and most effective form of submission. Moreover, it was necessary to remember about showiness because a clear but boring presentation needs to be corrected.

The Benefit of Search for Information

This gave rise to the following link - the need to expand my understanding of the topic, look for additional information, and read other people's articles and materials. In other words, to teach others, you have to study yourself. So some time passed, and I learned a lot and rejoiced at what a fine fellow I was.

The Trap of the Overestimation

And then I fell into a new trap. This is the feeling that you have finally gnawed Mjolnir out of the granite of science, that you have great power in your hands and in your head, and you need to spread it. And you start broadcasting. Not to explain, not to teach, but to broadcast one's knowledge like a radio, without any feedback.

The Discovery of a Feedback. Gotta Learn to Listen

Fortunately, I quickly noticed something was wrong, and knowledgeable people suggested that it was essential to collect feedback and, in general, build the process in the form of a dialogue, not a monologue. And it turned out that in addition to improving the methods, it also gave unexpected results.

The Benefit of Unexpected Angles in Looking at the Problem

The way how we see the world, including the problems that we face, is the superposition of our own experience. Often this leads to a particular route of looking at the issues and how we solve them. But most of the problems have multiple, almost infinite solutions. And since other people have different experiences, they can have a very different point of view and don't get why we choose ours. And there is nothing so refreshing as a new point of view.

Due to another experience, people start asking a very unexpected question. This brings us to the Discovery of obscure again - things we thought were obvious are not. A clear example of such a question for me was, "Why should I place a return in the function?" My first reaction was - "What do you mean, why? It's obvious!" But no, it's not. Can you easily explain why? =)

The Benefit of Unexpected Difficulties in Phrasing

I will continue the example with the function. How many ways to explain function to the newbie do you know? At the very beginning, I had only a single form. But after explaining this in my first programming courses, I found out that many people need help to get this concept. More of that explanation that was fine to one person didn't work with another. And the opposite. Since then, I have been required to create about a dozen various ways to describe the same knowledge.

The Benefit of Patience

Being calm when explaining something over and over again is a convenient skill, but it is tough to obtain. It requires a lot of practice but also brings many benefits since it overall affects your work and private life.

The Trap of Routine and Repeatability

We love to make things that we are good at. We are starting to do them again and again. But unfortunately, satisfaction from doing them reduces, and one day we are hitting the point where we begin to feel boringness and tiredness. We want to do something new and refresh the process. But what else can we teach people if we already set up all our knowledge on educational reels?

Welcome to The Spiral of Cognition

At this point, you are underestimating your knowledge again, so you are trapped in the trap of underestimation. Way out of this trap is entirely the same - you need to start searching for the problems you know how to solve but have yet to try to teach somebody or explain the solution. This may be in the same area but at another level of complexity or in another field. Just keep seeking, keep sharing =)

By the way, is there something that stops you from writing a blog post? =)

Hydrocephalus is the buildup of fluid in the cavities (ventricles) deep within the brain

Source: Wikipedia

In medical history, there is one notable case: in July 2007 French 44 years old man was diagnosed with Hydrocephalus, with about 90% of his brain destroyed by liquid. And he was still able to live an almost healthy life.

It is incredible how brain cells slowly took responsibility for destructed parts and kept almost all functions! Of course, the process was prolonged and happened for 30 years, but still — an excellent example of sustainability. It became possible because of efficient information exchange between brain cells.

But let's try to apply this example to organizational structure. What will happen if one of your organization's "cells" disappears? If you lose all the information it contains will also disappear. Will any other "cell" will be able to take the first one functions? And if 10% of cells? And according to 10x thinking behavior, let's make a high bet - will your organization survive if 90% of cells are lost? Even if we will admit that we will replace them with new ones.

Each organization is a complex and multilevel organism — many people, teams, departments, and many dependencies. It is an excellent example of a live social network. And as any social network, it requires the flow of information to stay alive.

There are different levels of information - global, department-level, local, and even personal. I define Organization Knowledge as a summary of all this information spread across the company. And as with any flow, information spread can have bottlenecks and leakages, leading to various troubles.

For leaders, one critical task is to sustain the organization's structure. As engineers, we can compare it to a very complex mechanism. Let's take a rocket, for example. Rocket is working in a very unfriendly environment, and there are few possibilities to fix something on the run. That's why in such situations, engineers make duplicated schemas and nodes. If one will unexpectedly break - there is always a hot replacement.

Unfortunately, too often, I met situations when organizations had a lot of processes and knowledge in the hands of a single person or a small team. Get to know SHOK (Single head of knowledge) - one of the management anti-patterns. More broadly, it is known as Bus Factor.

So, how can we fight this dysfunction?

As always, we need to start with identification if the problem exists. I prefer the Johari Window model framework applied against all proper functions for all people in the company. Initially, this model was designed for better self-awareness and social representation, but it is also handy for knowledge spread analysis.

First, we need to identify the list of all critical functions in our business. It is quite a challenging but required task by itself. In fact, if you don't have such a list, you are already in trouble =) You will need to bring all your departments' heads together to build it as soon as possible.

Let's take the simplified example based on the Engineering department. Imagine you have agile methodology applied to the development lifecycle. We will skip planning and estimation of the tasks and will take only implementation and delivery:

• Task implementation (coding part)

• Quality Control

• User Acceptance testing

• Backup

• Deploy

Once again - this is an oversimplified model, but I hope enough for an example.

So, we have the list. Now we can make a simple form to collect information across the company. There are many tools for collecting data, but for this example, I used Google Forms and Google Spreadsheet.

The form is relatively simple due to the oversimplification of our example. In real life, it will be much longer.

As you can see, there are two sections: "Can do" and "I know a guy." And no, "I know a guy… who knows a guy… who knows another guy" (c) does not work. Only direct relations =)

An outcome spreadsheet will look like this:

Honestly, I'm not a spreadsheet pro, so my methods are probably not brilliant. But they work for me =) BTW. I will be glad if you will send me a more elegant solution. So.

My goal is to create a Bubble Chart to visualize the high-level state of knowledge in the company.

On another sheet, I'm creating a new table with a list of all functions and columns representing Known/Unknown to self, Known/Unknown to others, and the bubble size.

For self & Others, I'm using such formulas:

# Self
=IF(COUNTIF('Form Responses 1'!$C:$C, "*" & A2 & "*"), 1.5, 0.5) + RAND()/3*IF(RAND()>0.5, -1, 1)

#Others
=IF(COUNTIF('Form Responses 1'!$D:$D, "*" & A2 & "*"), 1.5, 0.5) + RAND()/3*IF(RAND()>0.5, -1, 1)

Awful… But work in most cases =)

Since Google Forms stores multiple checkboxes answers to a single cell as a string separated with a comma, I'm just using a substring search to identify if any responder selected an option.

Why 1.5 and 0.5? I'm creating Bubble Chart with an x/y axis from 0 to 2, so 0.5 and 1.5 are just the centers of squares I receive. And to not let all bubbles overlay, I'm adding a random shift.

The formula to calculate bubble size is almost similar. The more people select this option - the bigger bubble we need.

=COUNTIF('Form Responses 1'!$C:$D, "*" & A2 & "*")

As an outcome, we will have a chart like this:

The Upper left square is the "Open area." It means that at least some people marked both - they can do this function by themselves and know somebody who can do it also. Functions in the area are safe, and ideally, all bubbles should be here. The more people mention this function, the more giant bubble we have.

The lower left square is the "Hidden area." Some people know how to do this, but nobody knows who else can. But even if the bubble is massive, there is a communication issue since nobody is sure that this function can be done by somebody else.

Upper right - “Blindspot”. Everybody thinks that somebody else can do this, but nobody really mentioned that can — a hazardous situation.

And the last one - "Unknown." Oops. Nobody can, and nobody can mention somebody. Have something in this area? Time to panic - something is going very wrong =)

Of course, this is not the ideal representation of reality, but it gives you an overall view of the situation. It can help you to identify weaknesses and knowledge loss in your processes. The more granular questionaries you will have, the better results you will obtain. This method works better if you collect function and data on a team level.

As I mentioned, identification of the problem is the very first step. And at this point, we have a general overview and can initiate the process of handling knowledge gaps and weaknesses. How to do this we will talk about in the following articles.

Start to collect data, and stay tuned!

Do you often see I’m goal-oriented/ We are searching for the goal/result-oriented in CVs and job descriptions? I saw this quite often. More of that, for a long time I regularly said that about myself. But later, I discovered that this is more tricky than it seems.

Let's look deeper into people's brains and the psychological aspect of people's motivation. Wikipedia provides such a description:

Motivation is the reason for which humans and other animals initiate, continue, or terminate a behavior at a given time.
…
Motivation is derived from the word 'motive,' which denotes a person's needs, desires, wants, or urges.
https://en.wikipedia.org/wiki/Motivation

From the first view, it seems completely ok. But the devil is in the details.

Goal orientation

First of all, let’s assume - according to the term explanation, everybody is goal-oriented! And the real difference is made by the goal for which a person is oriented for.

Person's needs, desires, wants, or urges

Source: Wikipedia

Everybody is more or less familiar with Maslow's hierarchy of needs. It represents the hierarchy of personal needs, most often visualized as a pyramid with the most basic requirements at the bottom. Until lower levels are not covered, the higher levels will not be the case for an exact person.

In my experience, pyramid order can differ from person to person, but this applies only to high-level elements in most cases.

Let's see how this relates to goal orientation in practice.

I Want vs I Need

Imagine you are performing an interview, and the candidate says he/she/they is very interested in helping people in your product area. Sounds cool and very matching to what you are searching for, right? But after that, a person starts asking many questions about salary, insurance, paydays, etc. There is nothing wrong with these questions, but you need to be aware because if there are a lot of questions like this, a person does not feel safe.

He/she/they wants to belong (3d level in the pyramid) but needs safety (2nd one).

What does this mean in practice? In practice, this can mean that the main goal person will be oriented toward is keeping his\her\theirs position in the company beyond everything else. And keeping safe can lead to a lack of proactivity, standing up for his/her/their own opinion, and everything risky.

Once again - this is not bad by itself, and more of that - it can be useful for your company because such people can be very loyal (until events do not threaten their safety). But if they see (or even imagine) a possible threat, they will act to avoid it but not to meet company goals.

My main point here is that you should be aware of real goals of the person.

If the goal is to work less and get paid more - a person can do everything to be visible and verbal, but the outcome will be significantly low.

If the goal is to be pleased - a person can do overtime work and help everybody around in the prejudice of their tasks.

If the goal is to obey responsibility, a person can make everything to delay decisions, waiting for somebody to decide.

What to do?

Unfortunately, there is no (or I don't know) stable framework for identifying people's subconscious needs during hiring interviews. But I can share some tips&tricks from my experience.

First of all, you will need an Active Listening skillset. Long story short - this is a pack of techniques to improve the information you hear. People often say much more than they want and even more than they say. Nonverbal cues and emotional reactions - there is much information beyond the words.

Don't ask questions. Tell stories and ask for stories. Storytelling is an efficient technique to activate more brain parts. And it works in both ways - it also improves the involvement of the listener and teller. So, by telling a story, you will activate a person's brain, and by asking for a story, you will let him not answer bordered questions but include more personal interests and emotions.

Ask about a person's life and way into the profession - roots can say a lot.

Conclusion

Goal orientation is not so clear-cut since every action is goal-oriented. But the goal can be very different.

What you are really searching for is Business goals oriented person who has all basic needs covered (some of them by your company, by the way). But this is also not the best case. Business goals are quite often described as KPIs. And sometimes, meeting KPI does not lead to company profit and product value.

What is the best case? IMO - end-customer goals orientation is the best you can find. This means that person will think about solving real customers' issues.

But, as I already said, this is possible only when low-level needs are fully covered. And this is not a fixed state. The company should have a process and environment for permanent monitoring of the personal condition of employees for early identification of any changes in their needs.

If the company wants to have really motivated and end-customer-orientated employees, it should be end-customer-orientated by itself and, in the meantime - employees orientated.

Love your employees as well as your customers! ❤️

However, understanding how memory is allocated in an application is always helpful. Let's see what possibilities we have with a small Django project as an example.

So we have a simple data model:

class Department(models.Model):
    title = models.CharField(max_length=120)

class Course(models.Model):
    title = models.CharField(max_length=120)
    department = models.ForeignKey(Department, on_delete=models.CASCADE)
    description = models.TextField()

class Lesson(models.Model):
    title = models.CharField(max_length=120)
    datetime = models.DateTimeField()

    course = models.ForeignKey(Course, on_delete=models.CASCADE)

And a dozen views that return JSON. Let’s review how memory will be consumed.

First of all, we need to see the overall picture. Let’s take the memory-profiler package.

It has a handy decorator that allows us to view memory dynamics in any function. Let's check one of the views:

from memory_profiler import profile

@profile
def get_lessons(request):
   lessons = list(Lesson.objects.all())

   data = []
   for lesson in lessons:
       data.append({
           'title': lesson.title,
           'datetime': lesson.datetime.isoformat()
       })

   dump = json.dumps(data)
   return HttpResponse(dump, content_type="text/json")

By default, @profile outputs results directly into stdout. And it looks like this:

Line #    Mem usage    Increment   Line Contents
================================================
    29     59.7 MiB     59.7 MiB   @profile
    30                             def get_lessons(request):
    31     66.6 MiB      6.9 MiB       lessons = list(Lesson.objects.all())
    32                                 
    33     66.6 MiB      0.0 MiB       data = []
    34     69.1 MiB      0.3 MiB       for lesson in lessons:
    35     69.1 MiB      0.3 MiB           data.append({
    36     69.1 MiB      0.2 MiB               'title': lesson.title,
    37     69.1 MiB      0.3 MiB               'datetime': lesson.datetime.isoformat()
    38                                     })
    39                             
    40     70.6 MiB      1.5 MiB       dump = json.dumps(data)
    41     71.3 MiB      0.7 MiB       return HttpResponse(dump, content_type="text/json")

Absolute values are not as important as Increment. Alas, it is not always descriptive. For example, filling a list with data dictionaries in a loop will give an increase of 2.5Mb, although the sum of the increments shows only 1.1Mb.

If we want to check for a memory leak, data within a single call is not enough. We need to collect some statistics. And for this memory-profiler has executable mprof. It collects data and then generates charts like this:

Unfortunately, memory-profiler does not show deep details, so here another library comes to the help - pympler.

It allows us to get statistics about different data types. Let's look at an example:

from memtest.models import Lesson
from pympler import tracker
tr = tracker.SummaryTracker()
lessons = list(Lesson.objects.all())
tr.print_diff()

Let's check what was created in memory when we received 10050 Lesson records from the database:

                                     types |   # objects |   total size
========================================== | =========== |
                               <class 'str |       20172 |      1.30 MB
                              <class 'dict |       20206 |      1.89 MB
                              <class 'list |        9977 |      1.00 MB
                               <class 'int |       21891 |    598.59 KB
  <class 'django.db.models.base.ModelState |       10050 |    549.61 KB
             <class 'memtest.models.Lesson |       10050 |    549.61 KB
                 <class 'datetime.datetime |       10050 |    471.09 KB
                              <class 'type |           9 |      9.68 KB
                              <class 'code |          41 |      5.97 KB
                           <class 'weakref |          25 |      1.95 KB
                       function (<lambda>) |           9 |      1.20 KB
                 <class 'method_descriptor |          12 |    864     B
                 <class 'getset_descriptor |          10 |    720     B
                         function (as_sql) |           5 |    680     B
                 <class 'collections.deque |           1 |    632     B

We have a lot of strings. But it's okay - web protocols are mostly text.

But we have even more dictionaries. And their number is directly proportional to the number of records that we get — each instance has __dict__ attribute. Also, we can see that for each Lesson instance there is also one django.db.models.base.ModelState (the class that stores the state of the instance) and datetime.datetime due to the presence of a DateTimeField in the model.

It is curious that if we get not only Lessons, but also related data using select_related, the picture of memory consumption will change:

tr = tracker.SummaryTracker()
lessons = list(Lesson.objects.select_related("course__department").all())
tr.print_diff()

                                              types |   # objects |   total size
=================================================== | =========== |
                                       <class 'dict |       70409 |     10.01 MB
                                        <class 'str |       50323 |      7.87 MB
           <class 'django.db.models.base.ModelState |       30150 |      1.61 MB
                                        <class 'int |       51233 |      1.37 MB
                                       <class 'list |        9980 |      1.00 MB
                  <class 'memtest.models.Department |       10050 |    549.61 KB
                      <class 'memtest.models.Lesson |       10050 |    549.61 KB
                      <class 'memtest.models.Course |       10050 |    549.61 KB
                          <class 'datetime.datetime |       10050 |    471.09 KB
                                       <class 'type |           9 |     10.05 KB
                                       <class 'code |          41 |      5.97 KB
  <class 'django.utils.datastructures.ImmutableList |          28 |      2.22 KB
                                    <class 'weakref |          19 |      1.48 KB
                          <class 'method_descriptor |          12 |    864     B
                          <class 'getset_descriptor |          10 |    720     B

The memory allocated for dictionaries has significantly increased. This is logical — after all, there are many more instances of various classes now. And for each instance, there are at least 2 dictionaries - for the instance itself and for ModelState.

You can find a lot of interesting and unexpected things in memory usage which will help to make your application more compact and effective. So I strongly recommend you to play with memory-profiler and pympler from time to time.

In the conclusion, here is a “small” image picture of the object graph of one Lesson instance, generated using the objgraph library =)