The way to learn a new stack is not to learn a new stack unless you have a depth of knowledge in at least one.

Don't just learn a new stack because it's popular or the latest trend. In the past 10 years of my career, I've moved from one tech stack to another, from Python to JavaScript, then Angular, React, and even picked up GraphQL while working at Microsoft.

When you have depth in one tech stack, it becomes easy to learn a new one quickly and efficiently. So how can you build depth?

Understand the "why".

When Python exists, what is the need for JavaScript? If Django is available, why was Node.js created? What's there in Node.js that's not there in PHP? You get the idea.

When you know why a tech stack or framework was created, you understand the design choices of the author. From small libraries to bigger frameworks, a single design framework is followed throughout almost all the time.

To start the process, it is a good idea to watch talks by the creators and authors themselves. You can even look into the talks of senior developers of that stack. As an example, you can watch this podcast where the creator of TypeScript talks about the gap that the language fills.

When you understand the "why", it gets easier to pick up the stack because you understand why the author made a certain choice or what he thought while building the stack. This process takes practice and won't happen all at once. But it's worth the effort.

Build small apps.

The next step is to build small applications in the language you want to go deep in. A simple to-do app also works. But you need to spend time writing code and pushing it to GitHub.

When I was learning Node.js back in 2015, I did the same. No one ever looks at that repository. But it is a useful time machine that I can go back to.

Building an app in the framework also creates your Proof of Work, or is at least a start in the direction. It brings in motivation that is enough to push through the journey of learning.

Moreover, when you write code, you get familiar with the syntax. The dexterity you gain helps understand the next level of the semantics of the language better.

Write production-level code.

Now you can't learn how to write production-level code through tutorials. The way to do it is by watching the talks of developers at conferences and reading their blogs.

You can create a list of such developers on Twitter and follow and interact with them as well. They might not always talk about the tech stack but they will surely share insights from time to time. And when you interact with them for long enough, you can even directly ask your questions - of course, considering that you have already done your research and tried to find the answers.

Best practices

Most people who know a tech stack rarely know its best practices. And this is where you start to set yourself apart. When you have spent time on all the previous steps, you understand the design choice and you can solve prod-level problems, you become the expert in the team who can educate others.

Find out podcasts where deep discussions about languages, frameworks, tech stacks, etc. happen. Listen to them on 1.5x or 2x when you are walking, in the gym, etc. You will not just build depth and learn the best practices of the language but also become aware of the future of the framework and where it is heading.

All this while, don't forget to take notes just like you used to do in school or college. When you subconsciously spend time learning one framework and follow a methodical approach, you will truly become an expert in the field.

Read source code.

Now that you have covered the four steps (and this is important), you can start reading the source code of the tech stack. It will take time to reach this level where you can read and understand the source code. But this is where you will start deriving real joy and satisfaction from.

Vertical skilling is what builds craftsmanship. When you spend so long on the stack and enjoy the process of learning, you naturally become curious and want to explore how the stack was created. Then you replicate the APIs and write your own, smaller version. You can write your own React, Redux, React router, GraphQL, and whatnot.

But you need to follow the process.

Vertical skilling takes time, so it is important to follow a structured approach. This involves spending time on best practices, tutorials, and apps, and following a set method.

By going deep into a particular technology, you'll unlock new powers that will set you apart and establish your expertise in the field.

Till next time

If you liked the newsletter issue, subscribe and share it with your friends and family. Ensure that you mark the address as important so that you don't miss out on any future issues.

---

​