When I joined Atomic Object this past year, I was immediately thrown onto a large project that had already been going for over a year. As you can imagine, the codebase was already very large and fleshed out. As an entry-level developer, this was quite overwhelming at the beginning. Every time I opened up VScode and loaded up one of our repositories, I felt like I was lost at sea.
As time went on things got a little better, but I still felt lost daily. This was especially embarrassing when working paired with senior developers who knew the codebase like the back of their hands. I knew I needed to make a change. So, in my next team sync, I asked one of the developers what to do about this problem. My coworker gave me some solid advice. She told me to try “drilling” through the codebase.
What she meant was picking a starting point (typically in the frontend) and following it all the way through to the backend to gain some bearing. This ended up being insanely useful to me.
As I started using this drilling method, I began to understand some of the reasons it’s such a great way to get acquainted with a large codebase. Here are some ways it can help.
Drilling teaches you how things connect.
One of the hardest parts about learning a new codebase is that, when working in it day to day, you are typically thrown in somewhere you’ve never been before. By picking points and drilling through the code, you can start to make a mental map of how things connect. As time goes on, you’ll find you know where you are when you jump into a story more often.
Drilling shows defined patterns.
Another difficult aspect of starting on a new project is the fact that every project has different patterns and techniques to follow. Exploring the code during your free time can help you start understanding the architectural patterns of the code. That means when you start creating new things, you know where they should go and how you should create them.
Drilling helps you understand boundaries.
On my project, we have a few code repositories that all connect to each other. At first, it was hard to wrap my head around where one codebase ended and another began. When traveling from one end of a repository to another, though, you can start to get a gauge where and how they connect.
Drilling teaches you how certain tools work.
Another challenge I faced when starting my first project was understanding all the different technologies we were using in our codebase. I also had to get a grasp of how they all worked together. By drilling through, I started to understand much better how tools like Axios and Express work and how they can help communicate between repositories.
Build confidence by drilling through the codebase.
I highly recommend drilling for all these reasons. Drilling the codebase can help to answer many questions without having to reach out to someone. For this reason, I believe it also can help you build confidence as an entry-level developer. Next time you’re jumping into a new work item, you’ll be glad you tried it!