Become Intelligent: The 2 hidden powers to learn anything

Introduction

So you're trying to learn something new, maybe diving into a complex technical topic, and you've felt that you're just not "smart enough" to grasp it.

Maybe you've heard about people or have friends with "natural talent" who seem to pick things up instantly and making you feel at a natural disadvantage.

I used to be a firm believer in the notion of fixed intelligence and its tremendous impact on someone's life. That changed soon enough when I delved into my professional career.

I recently had this exact discussion with a friend, which inspired me to write down and share these thoughts. What if I tell you that learning is more about how you practice than any innate ability?

Pottery Class

There's a famous study from Art & Fear that perfectly illustrates this. A pottery teacher divided their class into two groups:

• Group A had to make one perfect pot by the end of the semester
• Group B had to make as many pots as they could, with quantity being the only goal

The teacher would only take the last pot made by Group B and compare it with Group A's only pot.

Interestingly, Group B, the "quantity" group, consistently produced better quality pots than Group A. Reason being they were learning through rapid iteration, making mistakes, and improving with each attempt.

Group A meanwhile got stuck in analysis paralysis, overthinking each decision, afraid to make mistakes.

I'm not a huge fan of pottery myself, but this pattern shows up everywhere in software engineering and technical learning.

How does this relate to Software?

Building a perfect pot is very similar to building a perfect system/project. Say you're building a new app from scratch.

If you're a beginner, you're highly likely to fall into the "YouTube tutorials" rabbit hole like i used to. The bottom line is that it makes you more of a passive learner, compared to actively trying, learning, and exploring what you need.

That pattern isn't limited to beginners, even experienced developers can get caught up in it. As a perfectionist, you might find yourself spending days researching architectural patterns like the outbox pattern, or planning elaborate load testing scenarios, before writing a single line of code for your system.

Learning TCP/IP

Taking something seemingly complex like understanding the TCP/IP stack. You could approach it two ways:

1. The "perfect pot" approach: Try to understand everything about TCP/IP in one go. Read the RFCs, study the theory, memorize all the header fields before writing a single line of code.

2. The "many pots" approach: Start by writing a simple socket program, maybe a basic echo server. Then iterate:

   • iteration 1: Basic connection handling
   • iteration 2: Add proper error handling
   • iteration 3: Implement keep-alive and connection timeouts
   • etc...

Each iteration teaches you something new about how TCP really works. You might write some buggy code, but each bug becomes a learning opportunity.

In the first approach, you might spend weeks reading about TCP window sizes and congestion control algorithms without writing a single line of code.

Meanwhile, the person making "many pots" has already learned these concepts (even if indirectly) through practical experience.

The Power of Interleaved Practice

Exploring another fascinating aspect of learning which helped me reshape my career. Starting with a simple study conducted with high school mathematics students.

Some researchers divided students into 2 groups learning how to solve geometry and algebra problems:

Group A (Traditional Approach):

• Learned and practiced geometry problems for two weeks straight
• Then switched to algebra problems for the next two weeks
• Each topic was taught and practiced in isolation
• Problems were grouped by type and solved in blocks

Group B (Interleaved Approach):

• Mixed geometry and algebra problems in each session
• Problems were presented in random order
• Had to identify the type of problem before solving
• Switched between different concepts frequently

When tested a month later, Group B significantly outperformed Group A, especially on problems they hadn't seen before.

B Students didn't just learn how to solve problems, they learned when to apply different solutions depending on the context.

This mirrors what happens in real software development. You rarely face problems in neat, categorized blocks. Instead, you might:

• Start building a user registration API, discover rate limiting issues, then learn about Redis
• Begin with a simple database query, notice it's slow, then dive into indexing and query optimization
• Create a basic file upload feature, encounter security vulnerabilities, then implement proper validation

The magic happens in these intersections. When concepts collide, your brain forms stronger connections. You start seeing patterns that wouldn't be visible if you learned each topic in isolation.

This is particularly powerful for those of us (like me 🙃), always struggling with sustained focus and procrastination. Mixing different concepts and practices throughout my day has helped me maintain engagement and avoid laziness.

You're essentially "hacking" your brain's natural tendency to seek novelty, turning what could be monotonous into an engaging learning experience.

What Now?

Understanding these concepts is one thing, but applying them in your daily life is where the real challenge lies.

• Small, incremental iterations allows you to motivate your brain while still learning one thing at a time!
• If you feel tired, blocked or steering away from your scoped and well defined goal, switch to an adjacent topic! Give your brain the freedom its requesting!

If you abide by those rules, you can build anything!