How to be an Exceptional Software Engineer

When we talk about outstanding developers, we often think of individuals who possess comprehensive knowledge in their field. They are capable of answering any question, proposing ideal solutions to problems, quickly adapting to new projects, identifying pitfalls, and providing resolutions to unusual bugs while also explaining their causes.

Undoubtedly, these abilities stem from excellent technical skills and years of experience, which encompass various scenarios that enrich their knowledge base. However, aside from technical expertise, what other qualities distinguish great developers? Why do some make rapid progress while others remain stagnant?

In my opinion, one of the main qualities is innate curiosity. It is the genuine interest in understanding how things work, why they function in certain ways and not others. It is this curiosity that drives certain individuals to delve deeper into the intricacies of a problem, while others may settle for solving it at face value.

Currently, there is an abundance of online resources providing descriptions and solutions to various technical tasks and issues. Often, one can simply search for a problem and find a step-by-step solution. An average developer might apply the solution without much thought. However, an exceptional developer will strive to comprehend the underlying problem and identify the root cause behind why something did not work initially but now does.

Why is there a memory leak? How does memory management operate? How do queues function, and so on?

Curiosity compels individuals to continually seek a deeper understanding of how things are structured. They do not merely utilize frameworks or libraries; they comprehend their inner workings and the reasons behind them. They do not perceive steps or solutions found online as "magic" but instead grasp what is happening "under the hood."

By understanding what occurs "behind the scenes," developers can write more optimized and less error-prone code.

Many developers rely on typical solutions without understanding why a particular approach is good and another is not. This approach is not ideal and can result in bugs emerging within a project.

Consequently, when something does not function as expected (for instance, due to slight deviations in project conditions compared to those described in a typical solution), lengthy troubleshooting may ensue, often leading to workarounds unless a more experienced colleague points out the issue and suggests the correct approach.

By the way, for the same reason, I do not recommend inexperienced developers to actively utilize various AI tools that assist with code writing. Without a full understanding of what the code does and why we are implementing it in a certain way, there is a high probability of introducing bugs in the end.

Another important aspect is proactivity and a desire for continuous improvement. It entails having a healthy sense of perfectionism. Rather than waiting for someone to request an improvement, it involves offering suggestions for enhancement. Continuously asking oneself, "How can I make it better?" This mindset includes staying updated with industry news, new technologies, and solutions, constantly learning and applying knowledge in practice. It also means keeping track of the project's status and providing timely updates. Additionally, I would emphasize the importance of understanding the problem, not just implementing what is requested. An experienced developer will propose a solution to the problem (not necessarily technical), whereas an inexperienced developer may immediately start coding what is requested without delving into the underlying reasons.

Let's consider the following problem that arises in a project: In the admin panel, the WYSIWYG editor truncates long links when inserted. Consequently, the manager cannot add the necessary promotional banner that would lead users to the promotion page. The manager assigns the task to a developer to add support for long links in the WYSIWYG editor. The developer estimates that it will take at least two days, or perhaps even three (it's a small feature, but it requires modifying someone else's library). A typical developer will proceed with the task immediately after receiving approval from the manager. However, an exceptional developer will pause and ask themselves: What problem are we actually solving? Who uses the admin panel? How frequently do they add such long links? The problem is that the manager needs to be able to add a link to the desired page through the admin panel. Only project managers use the admin panel, and their number is very limited (three people). They rarely encounter situations where they need to add such long links (almost an isolated case). In the end, is it worth investing so much time in an almost isolated case, or can we approach the problem differently? The problem can be resolved much more simply by suggesting to the manager to use a link shortening service. As a result, the problem will be resolved, and we will save a significant amount of development time that can be allocated to more critical tasks. This is just a small example, but it illustrates how experienced developers not only carry out assigned tasks but also approach them from a problem-solving perspective.

The surrounding environment plays a crucial role. The circle of communication and the company you work for are highly significant. You can spend years "struggling" in a small company that focuses on typical projects and make no progress. Coupled with internal inertia, this results in wasted years without any advancement. I have encountered individuals with extensive experience (e.g., 8 years in development) and a very limited knowledge base that barely reaches the level of an average developer. On the other hand, when a person joins a company with skilled specialists, diverse projects, and challenging tasks, they begin to progress more rapidly. I have worked with individuals who became highly skilled developers in 3-4 years. However, this is not always the case. It is crucial that the person themselves have a desire to learn something new. Without the willingness to learn and grow, it is challenging to facilitate progress. Some individuals find it more comfortable to remain at the same level, working on uncomplicated routine tasks without pushing themselves.

The last point I would like to emphasize separately is organization and attention to detail. It is not just about writing code but writing documented code. This entails organizing pull requests (PRs) and the workflow. Even if the project is small and a person is working on it alone, they still add meaningful issues for each task, work in separate branches, and open PRs as if they were part of a team. They also document the code and provide meaningful messages in commits and PR descriptions. It may appear to be a minor aspect, but it reflects a systematic and organized approach, which is crucial when collaborating in a team on a large project. There are numerous such details, and they all distinguish exceptional developers from ordinary ones.

To some extent, all these points can be attributed to soft skills. I intentionally did not include technical skills here because that is a topic for a separate article.

To summarize, what makes some engineers good and others outstanding?

Advanced technical skills/knowledge + experience.

How to achieve this?

1. Constantly improve in your field. Thoroughly study what you work with, becoming an expert in that area. Keep up with innovations and updates, and follow other experienced developers in the field and their publications.
2. Study development principles such as patterns, algorithms, memory management, operating system structure, and lower-level programming languages. This will truly help you understand how everything is structured and works. For example, if you work on the frontend, it will be useful to know how the browser renders a page, how V8 works, and what event queues, event loops, and thread pools are.
3. If there are no complex projects or heavy workloads at the moment, either work on your own pet projects or participate in open-source projects. This will help you improve your skills regardless of your work tasks.

Ability to solve problems, not just tasks.

How to achieve this?

1. Develop analytical thinking. Enhance your ability to break down complex problems into smaller, manageable components. Identify patterns, devise algorithms, and think critically to find efficient solutions.
2. Solve tasks and examine solutions. Regularly participate in coding challenges on different platforms. These exercises help improve your problem-solving skills and expose you to different types of programming problems.

Desire to constantly learn and strive for continuous improvement.

How to achieve this?

Find your own reason (motivation) for growth and development.

Organized and systematic approach in everything (from code organization to descriptions in PRs and code documentation).

How to achieve this?

Train yourself to be attentive to details. Push yourself to follow a systematic approach even for small tasks or when working alone. Always do the work as if someone is watching and evaluating you. Be your own observer.

I hope this helps! Let me know if you have any further questions or need additional assistance.

---

originally posted on linkedin.com