How to Read Other People's Code and Understand Everything

Start at the end
Open only the files you need
Understand what functions do and black-box test them
Focus on the functions you need and ignore the rest
Trace the sequence of actions in the functions you need
Carefully analyze each function and step through each line of code
Comment out a piece of code if its logic is not entirely clear
Write an additional function to test your guesses
Conclusion

Free Python Course ➞ Mini-course for beginners and experienced coders. 4 cool projects in the portfolio, live communication with the speaker. Click and find out what you can learn in the course.

Learn more

About the author

This section is dedicated to the author, who creates unique content that promotes development and learning. The author has extensive experience in his field and strives to share knowledge and ideas with readers. His work covers a variety of topics, including current trends, helpful tips, and practical recommendations. Each article is written with the audience in mind and aims to help readers achieve their goals. The author believes in the power of information and its ability to change lives for the better, so he always strives to provide high-quality and verified data.

Implements design solutions using programming.

Eight techniques that help me truly understand other developers' code

Reading other people's code can be a challenging task, especially if it is written in a unique style or using specific approaches. However, there are several techniques that significantly simplify the process. First, it is important to pay attention to the code structure. Well-organized code with clear variable and function names makes it easier to understand its logic.

Second, the use of documentation and comments is an integral part of the process. Comments help understand the developer's intentions, and documentation provides a general overview of the functionality. Third, it is worth considering the team's coding style. Familiarization with accepted standards can significantly speed up understanding.

The fourth technique is using code analysis tools. Linters and static analyzers help identify errors and improve readability. The fifth technique is active code testing. Running and modifying code allows you to see it in action and better understand its functionality.

The sixth technique is participating in code reviews. Discussing with colleagues not only helps identify shortcomings but also share experiences. The seventh technique is feedback. Don't hesitate to ask questions of the developers whose code you're reading. Finally, the eighth technique is practice. The more you read other people's code, the easier it becomes.

Using these techniques, you can significantly improve your skills in reading and understanding other developers' code.

A translator is a specialist who translates texts from one language to another. A professional translator doesn't simply replace words, but conveys the meaning and style of the original. Essential translator skills include a deep knowledge of languages, cultural nuances, and the ability to adapt the text to the target audience.

Translation services cover various fields, including technical, legal, medical, and literary translation. Each of these areas requires specific knowledge and experience to ensure high-quality translation.

Modern technology also plays a significant role in the work of translators. The use of specialized software and online resources significantly simplifies the translation process and improves its accuracy. However, even in an automated environment, the human factor remains indispensable, as only a professional translator can take into account all the nuances and context.

If you need a high-quality translation, choose an experienced specialist who can guarantee the accuracy and relevance of the conveyed message.

Oleg Shcherbakov is a well-known figure in his field. His achievements and experience make him an outstanding specialist. Oleg actively participates in various projects, sharing his knowledge and skills. His approach to work is based on thorough analysis and strategic planning. Oleg Shcherbakov also actively collaborates with colleagues and clients, which contributes to the creation of successful and long-term relationships. Thanks to his expertise, he has become an authority and a source of inspiration for many.

Reading other people's code is a challenging task that often takes more time than writing new code. When applying for a job, you may be asked to review an existing codebase or fix errors in someone else's code. You may also be required to add new functionality. Many developers feel confused or unsure when performing such tasks. However, don't worry: it's natural to have difficulty understanding other people's thoughts. It's important to remember that every developer faces similar challenges, and with time, you will become more comfortable navigating other people's code.

Even with complex tasks, there is always an opportunity to start with something simple. In this article, I'll share the methods that help me effectively tackle this problem.

Start with the End in Mind

If you need to code a search component with a complex filtering system on the frontend, it's important to understand how users interact with this component and how it functions in the interface. Explore different use cases and test them to evaluate the effectiveness and usability of the system. This will allow you to optimize the code and improve the user experience, as well as ensure higher rankings in search engines.

If you need to code a server-side search API that returns results in different formats depending on the specified parameters, start by examining the allowed parameters. Learn how different parameters affect the format and content of the API response. This will help you optimize queries and obtain the most relevant data for your project.

After completing your experiments, it is important to record all the findings and observations related to the code implementation. This will help organize the data obtained and simplify further work on the project. Documenting the process will not only allow you to capture valuable ideas but also return to them in the future for analysis or reuse. Make sure all key aspects are described in detail to avoid misunderstandings during further development.

As you work with the code, you may have many questions. Don't try to find answers to everything at once, but focus on solving each question individually. This approach will help you solve problems more effectively and improve your understanding of the code.

You want to understand how objects interact on the front end, for example, how the first filter affects the second, and the second affects the subsequent one. You are also interested in the implementation of the mechanics on the back end, in which selecting a parent product category results in the display of a nested subcategory, while selecting other categories displays a flat subcategory structure.

When reviewing any data, it's important to focus on how the desired result is achieved. This allows for a deeper understanding of the processes and mechanisms behind the metrics. Analyze the methods and strategies used to achieve success to gain a more complete picture.

Open Only the Files You Need

Once you've tested the final result and verified that the code functions correctly in the UI, move on to a more in-depth analysis. If the repository has a logical structure with clearly named folders and components, you'll easily be able to find all the necessary files for further investigation. This approach not only speeds up the development process but also helps avoid errors related to improper file hierarchy.

Understand what functions do and black-box test them

Each function has clear responsibilities, and it is important to understand them. It is recommended to approach this process in stages.

Study unit tests. This is one of the most effective ways to understand the functionality of each function, as unit tests clearly demonstrate the input data and the expected result, allowing you to verify that each function works correctly. However, it is worth noting that unit tests may not always be available. If you encounter difficulties or have questions, consider alternative methods for obtaining information.

Study the comments attached to each function. If there are explanations in the code, read them carefully. However, don't blindly rely on these comments—be sure to compare their description with the actual behavior of the code. If there are no comments or tests in the code, proceed to the next analysis method.

A logical assumption can be made and verified. If the developer follows established standards, the function name should reflect its purpose. For example, a function named generateImageUrl typically returns an image URL. Based on the function name, you can make an educated guess and then review the code to confirm that it actually generates an image URL. This helps ensure the readability and maintainability of the code, and makes it easier for other developers to understand.

If this does not bring results, send three emails, as the system administrator did in the joke.

Focus on the functions you need and ignore everything else.

When analyzing the impact of the first filter panel on the second and the second panel on the third, you can ignore functions that are not relevant to the current step, such as generateImageUrl. Focus on functions directly related to your task, such as loadX, loadY, triggerSearch, and others. This will allow you to more effectively achieve your goal and improve the data filtering process.

Trace the sequence of actions in the functions you need.

Reading code is different from reading a book. It's impossible to simply read code from start to finish, assuming it executes sequentially. To understand the execution sequence, it's helpful to use the console.log command. This tool allows you to trace the values and logic of the code, significantly simplifying the process of analyzing and debugging programs. Understanding the structure and order of execution of code is key to effective programming.

For function X: console.log(«I am at loadX»).
For function Y: console.log(«I am at loadY»).
For function Z: console.log(«I am at loadZ»).
For function triggerSearch: console.log(«I am at triggerSearch»).

The resulting sequence would be: loadX, then triggerSearch, followed by loadY, then triggerSearch again, followed by loadZ and finally triggerSearch. Other variations are also possible, such as: loadX, loadY, then triggerSearch, then loadZ and ending with triggerSearch.

Carefully analyze each function and go through each line of code

Study your workflow and carefully analyze the code of the required functions line by line. It is important to record all possible paths and branches, such as if, else, and other constructs, within functions. This approach will provide a better understanding of the code logic and help identify potential errors. Effective log documentation will also facilitate further debugging and optimization of the code.

It is recommended to conduct various transformations using the happy flow method and other flow testing techniques. Start with searching without applying filters, then add only a second filter and continue in the same spirit. After completing testing, be sure to analyze the execution log for information about possible problems and improvements. This will help optimize the process and improve the quality of testing.

Now you have an understanding of how the code functions. This knowledge allows you to deeper understand the principles of programming and the interaction of its various components. Understanding code is key in software and web application development. By mastering it, you can create more efficient and reliable solutions and improve your development skills.

Comment out a piece of code if its logic isn't entirely clear

If, after carefully reviewing the code, I discover something unclear, I comment out those lines and analyze the implications. This allows me to understand what functionality might be affected and what errors might arise. This approach helps me effectively identify problems and improve code quality.

After making changes, it's possible that some checkboxes in the filter drop-down list may not load. However, now you know exactly which piece of code is responsible for this function. Go back to point 6: you've understood how the code works, which will allow you to analyze and correct it more thoroughly.

Write an additional function to test your insights

At this point, I'm developing a random function called createFilterLabels that uses elements of other developers' code. This allows me to check that I've grasped all the necessary concepts and mechanics.

Conclusion

To improve your skill at reading other people's code, many people recommend more practice. While this is indeed important, it is much more effective to read code in the correct sequence. The right approach to studying code can significantly speed up the process of mastering new technologies and improve your understanding of programming logic. Start by analyzing the project structure, studying the main modules and their interactions, and then move on to smaller parts. This will help you better understand the overall context and logic of the code you've developed. The more systematically you approach reading code, the faster you can develop your skills and become a more confident developer.