Important Attributes of an Experienced Programmer: Work and Behavior by@ivandovhal

Important Attributes of an Experienced Programmer: Work and Behavior

Read on Terminal Reader
react to story with heart
react to story with light
react to story with boat
react to story with money
There are different approaches to defining the required set of skills of a programmer. Requirements vary depending on the company, project, and team you work with. An experienced programmer is one who not only knows the theory but works with real practical problems; knows how to find solutions to non-standard problems. There are some other important qualities such as a love of programming and a desire to work. The rest of the features that I will describe can be split into two categories: technical knowledge and personal traits. For Frontend developers, it is React, Angular, and Vue.
Ivan Dovhal HackerNoon profile picture

Ivan Dovhal

Technical Lead at Innovecs, a digital transformation tech company

This article will be especially useful for novice engineers, as well as those who want to cultivate engineering Leadership, seek growth, and reach new heights. Candidates will also find out what is expected of them at technical interviews and the selection criteria employed at these interviews.

The programmer’s "living brain" or the basic skill set of an experienced developer

There are different approaches to defining the required set of skills for a programmer. Requirements vary depending on the company, project, and team you work with. The most common defines an "Experienced" programmer as one who not only knows the theory but successfully works with real practical problems; knows how to find solutions to non-standard problems.

Apparently, all experienced programmers have one important feature in common: the ability to search for relevant information. There are some other important qualities such as a love of programming and a desire to work. If someone has no desire to work, then even impressive experience and talent will be useless. At work, I crossed paths with those who were well versed in technology, but reluctant to work.

Basic programmer skills involve good memory, the ability to focus and learn new technologies, and logical thinking. In short, an experienced programmer should have a "living brain" that operates well. You can't go on without it. These important characteristics determine your propensity for programming as a profession since childhood.

The rest of the features that I will describe can be split into two categories: technical knowledge and personal traits. If technical knowledge can be acquired in various training, and courses and honed in practice, personal qualities (or soft skills) are not so easy to acquire if they go against a person's nature. In any case, experienced programmers make their own way and learn a lot in these two areas.

It is clear that an experienced programmer is well versed in one or more technologies and a few frameworks. But, before mastering a particular technology, the programmer acquires knowledge of the basic architecture of systems and networks, data structures and algorithms; system administration, and Computer Science in general. Both system administrators and DevOps follow this path. In terms of programming as such, it is important to understand data structures and algorithms, abstractions of technology, and the OOP principles.

After learning a certain language, a programmer proceeds to study frameworks and libraries. These are higher abstractions that unite smaller ones. For Frontend developers, it is React, Angular, and Vue.

The following points outline the inner workings of an ideal programmer’s ‘living brain’

🔴 Profound understanding of technology and finding the best approach

An experienced programmer should know several technologies and apply the best approaches. This knowledge is not superficial but mastered in practice. A systematic approach allows you to see the project’s big picture; perceive it as a whole rather than partially, and then pick the best approach for its development. The concepts of productivity and efficiency are sometimes confused. You can finish the project quickly, but make many mistakes, and debugging will take more time than a careful step-by-step development process.

Speed ​​is not always a sign of Senior Engineer qualification. Instead, result-orientation is an integral feature. The efficiency of actions and moves weighs more than numerous lines of code and speed. Finding an approach to project development where quality and speed are balanced is within the power of an experienced engineer.

🔴 Remaining mindful of the UX

A good habit of a programmer is to be constantly mindful of the user experience — thinking about how the program will look from the user's point of view, and whether it will be convenient and clear.

You don't have to be a designer to predict how a feature will work. It will also be useful to master code testing to avoid errors in the development process.

🔴 Commitment to the technical process

Following the technical process can be deemed a good habit of any programmer, especially an experienced one. This is a crucial nuance. Before changing a variable or function, you need to check where it is being used.

You need to delve into the technical documentation; this will help avoid foolish mistakes and save time and the Tech Lead’s nerves. Well, experienced people know this and teach others 🙂

🔴 Writing readable code that is easy for others to work with

This skill derives from the previous one. It will be easy for everyone to work on the project given that the technical process is thoroughly followed. Remember that others might also work with your code, therefore, write as if you did it for yourself. Your “crutch” can boomerang back. It is better to test and regularly refactor your code, be thoughtful about what you call variables and functions, and think about others.

Choosing the right technology for the project is a crucial skill. Experienced programmers sometimes insist on using technologies they are used to even when the rest of the team will have a hard time with it. Instead, you should make decisions that factor the whole team; consult, discuss and coordinate your actions with others.

🔴 Qualitative analysis and development of architecture

To qualitatively analyze and understand architecture, you need to know the theory and have enough practical experience. A Senior Engineer is able to perform a comprehensive requirements analysis and develop a software architecture with effective implementation at various levels.

At the same time, it is essential to strike a balance between program readability and development efficiency. To avoid problems at the planning stage, an experienced programmer knows different technologies and is able to choose the right one.

🔴 Ability to explain schematically

For experienced programmers, and especially for Tech Leads, the ability to explain information about the principles of technology graphically and using simple diagrams is a very useful skill.

Charts, graphs, and diagrams provide a holistic view of both the technology and the project. The visualization system approach simplifies the work of the whole team. In this way, Tech Leads can convey the full picture to others.

🔴 Creating an effective workflow

Experienced engineers distinguish between team performance and their own. To boost the team’s efficiency, they build a workflow or choose new technologies, such as automatic deployment.

Also, they try to encourage other programmers on the team to learn more and analyze their mistakes during the code review.

Healthy perfectionism, or how to write quality code and not die at work

An experienced programmer is well aware of the importance of achieving business goals and is able to balance implementation and code quality. After all, if you delve into code quality, one task can take a month, and you can keep redoing things until your last days, bringing the whole project to perfection. But in order for the business to grow, you need to find a balance between quality and customer requirements.

There are programmers who focus only on business tasks and fill their code with ‘crutches’. I used to work on one project, which had to be completely shut down after 2 years of development because each new feature took a month to implement. That ‘stew’ of approaches and technologies was simply impossible to work with. That's how the desire to do faster leads to sad results.

I knew programmers who went deep into code quality and got stuck on one task for 2 months. Honestly, I was surprised that they kept their jobs. Ultimately, the task turned out to be insurmountable. That means, finding a balance is vital.

Perfectionism is close to my heart. However, there has to be a healthy approach without overdoing things. Usually, people do not change. Even at interviews, I notice such people and understand that working with them will be challenging.

The following points highlight the perks of healthy perfectionism

🔴 Ability to work in a team

By default, it is clear that team players are valued in any project. This speaks to their non-confrontational nature, and the ability to take responsibility, communicate and be reliable.

You can have your own opinion and still listen to others.

🔴 Confidence in complex tasks

Experienced programmers are confident, but not stubborn. They are not afraid of hard tasks, because they have already reached a certain level of expertise and have sufficient technical knowledge, allowing them to deal with complexities.

Experienced engineers can plan a project from different perspectives, provide good advice and stay result-oriented from framework development to coding. Such people are highly valued in the team; it is a pleasure to join them in professional battles. You can always learn something.

🔴 Constant desire to develop and find the necessary information

Again, experienced engineers are well-versed in several frameworks and are able to work with numerous technologies. And for this, you need to constantly evolve, and look for opportunities to learn new things outside of work. Experienced people learn quickly, and grasp new trends that are necessary for their work. Some engineers think that it is enough to learn only from their own mistakes. Indeed, in practice, you gain a lot of knowledge, but you need to deepen it based on other people's experiences. Today there is enough information online, you can really learn a lot.

Probably, mastering a project’s domain would be an additional advantage. For example, if you are in a Fintech project, you are expected to understand the software’s value from a business perspective and to know certain functional processes in that area.

🔴 Ability to keep balance

When a project is under development, various unforeseen situations can occur, and bugs can surface. They take inexperienced programmers by surprise and corner them. Experienced engineers know that everything must be solved with a cool head because panicking and yelling will not help. Although, perhaps, the bugs were caused purely by human factors.

An experienced programmer will find an alternative solution while maintaining balance. It is easier to find a non-standard solution to a problem calmly than emotionally.

🔴 Ability to share knowledge and give feedback

Ideally, experienced programmers share knowledge with others; participate in webinars, conferences, and hackathons. Sharing knowledge from a book or someone else's theory is one thing, and contributing your own experience- your past ‘pains’- is another. Networking is truly helpful, even though some might not enjoy it.

An experienced programmer knows how important it is to give feedback on others’ work. This gives junior professionals an opportunity to understand their potential growth areas, what to fix and what mistakes to avoid.

Timely feedback is about transparent management and effective communication. It is good if the programmers in the position of Team Lead understand and practice this.

🔴 Ability to admit your mistakes

Another good feature of an experienced programmer is admitting mistakes. This ability means one knows how to take responsibility. Mistakes are an opportunity to learn a lesson and gain valuable experience for the future. Instead of taking the blame for someone else’s bugs, Tech Lead can give useful insights during code review, and tell how to solve a specific problem.

Experienced programmers will definitely not throw a junior ‘under the bus’ and point the finger at the newbie’s fault. The whole team works, and everyone has their own area of ​​responsibility. Someone’s fooling around impacts the entire team. Keeping that in mind makes it easier to build trust and transparent relationships.

Fails that Seniors cannot allow

Fails can be both technical and human. For example, if an employee does not go to work regularly, it is a human factor.

As for important technical failures, I did not encounter such, because I did not often work with programmers below the Senior level. Obviously, the possible failures of Senior and Junior engineers lie in different dimensions.

I would call it a failure to send code to a repository without running a test. It is best to automate this process, as it is done in our company. Another failure is code ‘crutching’. Sometimes there is a desire to make code quickly, but if this accelerated process degrades the quality, it will become apparent in the future.

There are various approaches to code quality. SOLID principles must definitely be considered. If you do a polymorphic function, you need to make sure that it does not break the areas where it is already used. When making any code corrections, you need to consider what the consequences will be and how they will affect you in general.

Not following the technical process is a programmer’s failure. In the context of my team, it is creating pull requests, running a code quality test, conducting functional tests, and checking tasks that you do yourself. If you follow the technical process designed in the company, the failures will be minimized. However, I should admit that not all companies have properly configured processes, and this may also be a prerequisite for future failures.

In general, I think that Seniors’ failures derive from laziness, and Juniors’ failures come from inexperience and inattention. Juniors’ errors surface where you least expect them. The work of a Junior, as such, is a continuous failure in the beginning, which must be constantly corrected. But that is what Juniors are for.

Senior's laziness looks like being used to a process, and trusting it, thinking, “well, then I'll fix it later”. Often it does not always end well, but still ends better than in Junior’s case🙂

“Fakers", or Distinguishing between experienced and inexperienced programmer

Inexperienced programmers can be identified in two stages: first, during an interview, and secondly, and worst of all, during work, if you missed the "faker".

Questions that help me assess a programmer’s experience:

  • Years of experience
  • How many of them were dedicated to working with specific technology;
  • A series of highly specialized questions aimed at determining the depth of knowledge of technology and framework;
  • Questions about the basics of language skills.

This is the first portion of questions that help to determine how knowledgeable a person is and the prospects of working together. If a candidate gets confused at this stage, things will only get worse.

It happens that a programmer has 5 years of experience and is well-versed in 10 technologies, but when you ask basic questions from this list, there might be no answers. The same is likely to happen with a set of questions from the next block.

During technological interviews, I do not give complex algorithmic tasks, because the interview is always stressful, and I would hate to aggravate it. Even if a developer is used to working with certain technologies, forgetting how to perform certain tasks is normal; nobody is perfect. The depth of knowledge and swift problem-solving are the things to focus on.

Overall, we assess both soft skills and hard skills during interviews. The technical block of questions differs depending on technology and the project.

Evolution from Junior to Senior: Development Tips

Some programmers have mentors who provide advice and guidance. I did not have all that. I studied on my own and found the necessary information by myself. Although I received a degree in economic cybernetics and already knew the basics, while reading the philosophy of Java, it was difficult to understand the new abstraction.

At one time Java Rush courses helped me a lot; everything was easily explained, and I could practice right away. But it's not about the front end.

This is what helped me become a programmer. I studied the rest from the official technical documentation, as well as looked for information in free video courses. That was enough for me.

At the same time, it is a mistake to think that getting a degree in a course will open the door to an IT company. Without knowledge, this piece of paper is pointless. Attending courses for the sake of a diploma makes no sense.

To some extent, you can get structured information, but you have to remember it and it must be the basis and start for your future growth. One of the features of a good programmer is the ability to find quality information.

If you can do it, everything will be fine. But if you expect someone to spell it out for you, then you are very wrong. I would recommend self-development and browsing available online courses. And if you already work as a programmer, you can take Udemy courses, the ones you need for your job.

The more experience a developer gains, the more one realizes the importance of development in the area of Engineering Leadership. And this is not only about those engineers who already manage teams; but also about ones who are always abreast of trends, learning new things, and comprehensively developing their hard and soft skills to share their knowledge and competence with others.

react to story with heart
react to story with light
react to story with boat
react to story with money
. . . comments & more!