Stranki

Analogy: (What It’s Like)

The current way we teach can lead to “swiss cheese” holes being left in our understanding, and also developing over time (e.g. if you cram for a test, the holes will develop after). If a learning a subject “flat” then these “swiss cheese holes” wouldn’t be such a problem.

Let’s consider an analogy, what if we were laying the foundations for 5 houses and had a 10% chance of messing it up. Then our success rate would be:

0.9*A + 0.9*B + 0.9*C + 0.9*D + 0.9*E = 90%.

But what if we were making a 5 storey building, and our chance of messing it up at any layer was 10%? then we would get this probability that the building would not fall down:

0.9*A * 0.9*B * 0.9*C * 0.9*D * 0.9*E = 59%.

In practice, “Hard Skills” like mathematics and programming are more like skyscrapers and very few reach their full potential (in my opinion) because defects at the lower layers prevent higher layers being built upon them. The fundamental goal of this software is to develop a method for discovering such defects as easily/rapidly as is mathematically possible. Once the defects are discovered, the user can then resolve them one by one, and build their skyscraper of knowledge to new heights!

Diagram:

Let’s imagine that the structure of our understanding looks like so:

Here the red is used to indicate skills which we know that we don’t know (because we tried to use them and failed at the task). Blue is used to indicate skills which we are unsure of our comprehension of. In reality, with something like mathematics, this structure will be a lot wider and lot taller. But this shouldn’t prevent us from using this as our example.

Let’s consider a few naive approaches to discovering the “swiss cheese holes” first, and then consider the new approach. In both naive approaches, the dependencies between there different bits of knowledge are not explicitly known, and so our meta-understanding of the subject looks more like this:

We do still have a general feeling for the order in which things happen, so we can maybe move from the bottom up to try and find what it is we down understand. We test the first row on the bottom in order and find this:

This looks promising that we understand at least some of the subject so we test the second row from the bottom in order too:

This seems to be helping us determine the fundamentals we have missed out on, but it looks like we’ve got most of them, what if from the beginning we had tested from the top instead, would that have been more informative?

Unfortunately not!

The problem with both of these naive (and also what is currently practiced!) techniques is that they are a pure brute force approach to determining what the person knows, so it will require the user to go through one by one to discover the final form of their comprehension of the subject:

It’s worth noting, that there’s doesn’t even exist a list of exercises for this level of stupidity/brute-force! The questions in textbooks are not labeled as to which core skills they are testing, so in reality the student who wants to go back and test their competencies will need to do probably 10-20x as many questions as the “ideal” scenario described above!

The key idea for Stranki is to have the dependencies mapped clearly between the different ‘skills’, as this prevents you having to resort to the brute force method described above and instead utilize the structure to quickly determine what the user knows.

Example: Experience The Idea

To get a better idea about what I mean when talk about the ‘structure’ of knowledge or the ‘dependencies’ between skills, let’s look at an example of eliminating the variable ‘z’ by combining the two equations below:

1. 111 = 8x + 2y - 5z
2. 75 = -3x + 3y - 3z

This would normally form part of a bigger problem, but for the sake of brevity I will keep it constrained to this part of the problem (which typically solves for all ‘x’, ‘y’, and ‘z’).

In order to eliminate the variable ‘z’, we are exercising the higher level skill “cancel an unknown from two linear equations by combining them” but this will also exercise the lower level skills of “multiplication”, “expansion of brackets”, “subtraction” and “addition” (to name a few).

The first step of exercising the skill “cancel an unknown from two linear equations by combining them”:

1. Choose what to multiply each equation by
   1. Will multiply 111 = 8x + 2y - 5z, by -3
      1. These both require an understanding that 3 * 5 = 5 * 3 and probably a lot of other stuff too!
   2. Will multiply 75 = -3x + 3y - 3z, by -5

-3 * 111 = -3 * (8x + 2y - 5z) -5 * 75 = -5 * (-3x + 3y - 3z)

1. Combine the two equations together using addition or subtraction such that the factor multiplying ‘z’ will be positive in one and negative in the other
   1. Will choose to subtract equation 1 from equation 2.
      1. This requires an understanding of “subtract” both in the concrete sense of numbers and also in the more abstract sense of algebra
      2. This also requires an understanding of why you can combine equations in this way.
      3. You can probably think of more dependencies just to do this step!

111 * 3 - 5 * 75 = 3 * (8x + 2y - 5z) - 5 * (-3x + 3y - 3z)

1. Perform the multiplications on the left side
   1. Understanding of the algorithm for multiplication.
      1. Ability to add numbers together
      2. Likely a knowledge of your times tables will come in handy (speed wise)

333 - 375 = 3 * (8x + 2y - 5z) - 5 * (-3x + 3y - 3z)

1. Expand the brackets on the right side

333 - 375 = (3 * 8x + 3 * 2y - 3 * 5z) + (-5 * -3x + -5 * 3y -5 * -3z)

1. Perform the multiplications
   1. This will require an understanding of negative * negative = positive
   2. This will require an understanding of the algorithm for multiplication
      1. This will require and understanding of single digit addition
      2. Also knowledge of your times tables will likely be helpful

333 - 375 = 24x + 6y - 15z + 15x + -15y + 15z

1. Group the terms on the right (optional step)

333 - 375 = (24x + 15x) + (6y - 15y) + (15z - 15z)

1. Perform the additions and subtractions on the result of the multiplications
   1. This requires double and single digit addition and subtraction on the right
   2. This requires triple digit subtraction on the left

-42 = 39x - 9y

1. Make the constant term positive
   1. Know that this is a convention
   2. Know to change x to the right once it is negative (another convention)

42 = 9y - 39x

We could go even deeper on the dependencies like “be able to count to 10”, or something like that, but I’ve left that out because my main point was to illustrate what I mean when I say that skill ‘A’ depends on skill ‘B’. It means that skill ‘A’ actively and completely relies on the use of skill ‘B’. So for example, ‘multiply three digit numbers by hand’ relies on the use of the skill ‘add two numbers together’. So it can be said that if you know how to ‘multiply three digit numbers by hand’ then you know how to ‘add two numbers together’. It can also thus be said that if you do not know how to ‘add two numbers together’ then you do not know how to ‘multiply three digit numbers by hand’.

This is the key to Stranki. It is so simple, but the absence of such simple information has led to a terribly stupid way of doing things.

Full Technical

(The Actual Idea!)

You’ll finally see the actual idea at the end of this section, so hang in there!

So, now that we can see why dependencies are so important and also what they are, let’s consider a few ways of determining the state (understood or not understood) of the nodes in the skill dependency tree:

#1: Top Down

In this mode we start from the top and work our way down it’s brute force for the first two levels of the dependency tree.

But then when we test our understanding of ‘j’, we find that we understand it!

This is super informative because it must also mean we understand ‘p’, because ‘p’ is required to understand ‘j’:

But we can also apply this reasoning to ‘v’ and then ‘B’ too!

So for the price of one skill we have determined four! That’s more like it!

We then test our understanding of ‘k’ and find that we understand ‘k’ too:

Which then gives us ‘q’ for free, as it is required to understand ‘k’.

We then continue on much the same like so:

#2: Bottom Up

We seemed to have a bit of a slow “brute force” start with Top-Down, what if we did bottom up instead?

#3: Guaranteed Reward

There are awesome moments in both of these approaches where because of the known structure/dependencies of the skills, we can use the fact that we’ve validated that we know a skill to imply we know its dependencies or vice versa, where the fact that we don’t know a skill means we can imply that we don’t know the skills which depend on knowing this skill.

Lets write two numbers on each of the skills in the skill dependency tree. The first number will be the number of skills which depend on that skill and the second number will be the number of skills that skill depends on itself

Full Version With All Steps:

Short Version With Progress Only

In this version, there is only one picture given per question answered by the user. This was not done with the Top-Down or Bottom-Up or ‘unstructure’ approaches because it would have been extremely tedious!

Conclusion

There is a lot left to do to make this “good idea” into “useful software”. I won’t go into the details as I’m sure you can come up with ideas yourself, but regardless I do think the fundamental gist of the idea has real potential, and I’m looking forward to pursuing it when my main side project is done (which might be a year or more away!).