1st principles approach – Everything you need to know

What is 1st principles approach?

It is a methodology for problem solving. The process is fairly simple

1. Break down the problem into smallest possible aspects
2. Question all your biases one by one for each such chunk and eliminate all until you reach something axiom like. Socrates questioning about things is very similar to this step
3. Solve the problem with the axiomlike/ fundamental facts and tackle the problem ground up.

This method of problem solving existed long ago. Socrates questioning is a concept that comes very close to the 1st principles approach. In simple words, questions which reflect curiosity and which are fundamental to the very existence of the problem needs to be asked. We know for a fact that the brain tricks us into fitting solutions into baskets to such an extent that it even makes assumptions on what’s possible and what is not.

Where to use this approach?

This method of solving is generally used in a construct where you need a well thought solution. In cases where quick decision making is needed like in solving trivial problems, this approach would seem time consuming.

Why use this approach?

When we try to solve hard problems, our basic innate tendency is to rely on our assumptions. These assumptions have a diverse mix of validated and unvalidated reasonings. This tendency results in closed box thinking and the solutions starts to follow a very specific pattern which is nothing but a resultant of our closed box thinking. This approach is useful when maximum velocity in reaching to solution is required. (As software engineers, this looks like a go to approach. Right?)

This is a basic value proposition as we climb the years of experience ladder. It helps us be grounded and come up with better solutions.
We have become very accustomed to making opinions and biases based on other’s experiences of the same problem. While that might work in trivial cases but in difficult problems, it might fail.

How to apply the 1st principles approach to problem solving?

Problem 1:

Migrate an old codebase to a newer codebase

Solution without using the 1st Principles approach

The first things that generally come to someone who has a habit of consistently delivering outputs is the action part to the problem statement. They have assumed that using the latest codebase or latest libraries are best for code. For eg. They will come up with a migration plan with the latest libraries available and put it to action and achieve it.

Solution using the 1st principles approach

The programmer will question the basic reason for this need. Let’s see a hypothetical conversation below:

Programmer: “Why there is a need for the migration?”
Manager: Because having the latest technology is better and it is a long pending technical debt
Programmer: But why having latest technology is better?

What would you answer, if you were the manager? Let me know in the comments.

If you notice , the basic questioning, leads the manager to reassess his thought as it is challenged. There could be two outcomes to this questions:

1. If the need of migration was not well thought or was artificially brought in, then it will save a lot of development time for the company.
2. If there was a need for migration, there would be a definitive answer to why the migration was needed.

For starters, the need for migration could be due to security vulnerabilities and end of support to the previous codebase libraries. There could be multiple such reasons.

This would help the programmer to select a platform/library/language which actually solved the problem and mitigates it for a longer period of time without having to make a lot of side effect. Coming to this conclusion, itself will require a lot of basic questioning and a competent solution will emerge as a result

Problem 2:

You need to test whether a feature is working or not

Solution without using 1st principles approach:

The basic approach to this in some companies is that the tester will ask the developer about the features developed and then create the test cases. If there is a change in code, the tester will update the test cases accordingly and testing will happen

Solution using 1st principles approach

The tester will write the test cases after knowing ” Why the feature is needed?”. The testcases that the tester writes would be around validation of the features that is needed. If the testers have to ask the developer for requirements, they should question even that bit to relevant authority. Why should testers ask the features list from developers? If the developer updates the code, the test case should will not change. If they change, then the basic integrity questions of why the feature is needed needs to be questioned.

Problem 3:

System design problems asked in interview

Solution without using 1st principles

An interviewee would just come up with a generic design which just caters to the problem at hand told by the interviewer.

Solution using 1st principles

The interviewee will deliberately ask basic questions to the interviewer on the primary goal (the why of solution design), scalability, persistence etc and then use that information to come up with a good design.

Conclusion

The 1st principles approach is a mindset that can be applied to various parts of our everyday lives and this is especially valid for people who want to stay relevant and innovative throughout their lives. As we grow older, we are trapped by dogma and we start carrying it with us into our solutions. This principle allows us to challenge a lot of though process to come up with better ideas.

There are few good articles I found that have elaborated the same idea in a slightly different way which is in terms of how already successful people solve their problems

First Principles: The Building Blocks of True Knowledge