Introduction

When it comes to familiarizing yourself with a new codebase, there are many different approaches that can be taken to accomplish this task.

In this blog post, I will offer a few tips to aid you in tackling this problem.

Types of Applications

The first point to take note of is the type of the application that you are trying to work with. Different applications require different approaches.

Procedural Application

When it comes to a procedural application, the simplest way is to follow the flow of the application. Take note of the entry point and follow the function calls that take place.

Backend Monolith

In a monolith application, ideally the codebase is divided into separate components, where each is responsible for a different set of functionality. Within these components are different endpoints. You can think of them as separate procedural applications, where each endpoint has its own flow that needs to be followed and studied.

Microservices Application

In a microservice application, it is important to not only understand what each individual microservice is responsible for and its functionality, but also to understand how these microservices interact with one another and what contracts exist between them.

Frontend Application

In a frontend application, there are pages or views in the application, and each page or view supports a different set of functionalities. Understand the functionalities of each page or view and take note of how the navigation is done within the application.

Software Architecture

Another point to take note of when understanding a codebase is how the software is structured and its interaction with different components.

Folder Structure

Knowing how the codebase is divided is an important point when it comes to navigating the project. A good codebase follows a certain pattern of how the files are organized. Understanding this pattern will help you quickly navigate and find the part of the application that you are looking for.

Design Patterns

Knowing what design patterns are used within an application will help you not only understand the codebase itself, but also when it comes to adding new functionalities, you will be able to work within the same design pattern that the existing functionality uses.

For instance, if you recognize that a certain part of the application employs a factory design pattern, you can apply the same pattern when you need to implement a new functionality within that part.

Dependencies

There are times when the application has different dependencies, such as other libraries written internally. By understanding these dependencies and the underlying functionalities of those libraries, you will be able to know how different parts of the system interact with one another. This would be important when it comes to tackling different bugs.

Working With the Codebase

Just like everything else in software development, the best way of learning and understanding a codebase is to work with it. It is during this type of interaction with an application that you get to learn the ins and outs of it and get a firm grasp on the way that it operates.