When I started at Atomic Object, I had a real problem. I’d switched my university major from electrical engineering to computer science my junior year, and I was out of my depth. Technical concepts flew like birds over my head and my teammates could hear the whistle. I needed to catch up, and fast.
While I was really behind then, the feeling of being behind never quite fades away as a software developer. New technology is infinite, and we are finite in comparison. It’s easy to get overwhelmed by all the new information pouring over us like a raging river.
Part of our problem is we make some bad assumptions about learning. In my case, I assumed learning new technologies required deep dives lasting two to three months.
Deep dives have some problematic qualities. They encourage silos, lack flexibility, and move slowly.
After a few months of trying deep dives, my manager Jesse Hill suggested I try shallow dives. These are quick 20-30 minute dives into a technology.
Unlike deep dives, shallow dives are:
Shallow dives are interconnected because their speed allows them to overlap. In a shallow dive, we trade depth for connection.
As an example, below is my timeline for deep dives vs. shallow dives.
In my three-month deep dive, I only managed one topic. In my three months of shallow dives, I cross-pollinated nine of them.
The cross-pollination of ideas is what makes the trade of depth for connection worth it. Thanks to how we learn, this cross-pollination of ideas has compounding value that wins out in the end. To read more about this compounding interest, check out the constructivism theory of learning. The gist is more connections between topics equals higher quality learning.
The final property of shallow dives is flexibility. Because of their short time horizon, they can adapt to your project needs. When I needed to upgrade Apollo on my project, I was able to do a quick shallow dive to level up.
Deep dives do have an advantage: technical depth. There is real value to long engagements with single topics.
Yet shallow dives do not preclude us from doing deep dives. Many shallow dives can be chained together to form a sort of incremental deep dive which retains flexibility with depth. These chains can be fascinating. In my case, I’ve chained shallow dives on Deno, Node, and .Net to develop a broad and deep understanding of run times.
What would you learn if you knew it only took 20 minutes? What shallow dives would you chain together?