7 advices that I would give to my noob self as a developer

By Luís Simões, Senior Developer @Xpand IT

As we grow up, we all have to decide what we want to do for a living. What career do we want to follow? I assume that if you are reading this, we have chosen similar paths.

Being a software developer gives us the feeling that we can change people or companies lives overnight with our solutions, and that is amazing! However, when we start this journey, we could get a little overwhelmed about how big and different this field is.

Paul Robinson, principal engineer at CircleCI, has an interesting perspective about coding, in a blog post of his wrote — “Just another day writing tomorrow’s legacy code. Coding for a living is learning for a living.” — It is an excellent way to illustrate how quickly things change in this field and how well prepared you must be. Therefore, continually improving techs, methodologies and population needs, raise endless challenges for us developers.

Considering these words, and in an attempt to help you along the way, here are seven advices that I would give my noob self as a developer to ease the journey and keep on the right track.

There is a reason why your math teacher gave you so much homework assignments: math is all about practice. Continuous learning applies to software development domain as a whole. The more you practice, the more you learn, and the better you get. More importantly, you will be better prepared for more significant and difficult challenges.

A right way for practice is to challenge yourself to do something different, something that you know you should improve. Create a set of mini-projects of your own, maybe a hack for your everyday task that is really bothering you. This helps you in many ways: being creative, finding your own solutions, exploring new technology and fail without worries.

Don’t think you are a lost cause just because you messed up with your last commit. Don’t we tend to be afraid of seeing our code dressed in red? Or even worse: what if someone else sees it? It is not the end of the world!

Failure is typical, and we need to assume it to grow as developers and as team workers. Tackling your failures could be challenging but grants you the knowledge to prevent making the same mistakes again.

To prevent bug scenarios, the first and important recommendation for you is to idealise, plan and struck the principles about what you are going to do. This will reduce errors along the way. Is also essential to know how to use debug tools. They are essential to know where the error is and understand what happened. With it, you have a step-by-step tool helping you dig deeper until the source of the problem and, from that point, you can start thinking about how you will get it fixed.

It’s from the general knowledge that, when something is being built, it has to pass a bunch of phases: one of the crucial is to test the product. In software, you must test everything during the project. Don’t leave it to the end.

There is a software development methodology where testing is the base of everything. Maybe you have cross paths with TDD (Test Driven Development) methodology, which the first stage of development is to write your test cases and then write the code to pass them.

You don’t have to use TDD, of course, but you must test what you do despite the methodology you choose. You have many test techniques to apply during the process:

• Unit tests, that, from the code level, helps you to prevent possible bugs;
• Integration tests, to ensure that the feature you built works among the others in the application;
• Regression testing provides you with the ability to ensure stability on the App when requirements change.

Try to look at your current project and code some unit tests, just to realise how useful they can be. Applying test techniques during the project will help to raise software quality, reduces the probability of unexpected scenarios, certifies the project specifications and grants satisfaction from stakeholders.

Sam Morgan, the head of product at Makers, says something that you must keep in mind while writing code — “Your code has two users: the computer, and every other person who has to work with what you wrote.” — This means that probably you won’t be the only one seeing and working on that code you are about to write. Keep it clean and easy to understand for the next developer.

Think of your code as a set of drawers, keep them clean and organised. Here you have some tips:

• Try to organise your code as separately as possible.
• Identify, clearly, all the features you will build and create packages for each one. This will improve the scalability and maintainability of each feature, reducing possible impacts in other parts of the application that you did not change at all.
• Avoid rewriting the same code repeatedly, compile those functions that serve multiple purposes and create your utils base tool.

Also, you must document objectively the code you write along the way. It’s for your safety as well. In the future, it will be easier to look at it, and have a clearer idea of what you’ve done and why. Consider creating a technical overview of your solution and keep it up to date during the project. Try to document how you solve the project requirements and log every requirement change along the way. This will help you and others have a clear idea about the solution and ease the maintenance process.

If someone tells you to put salt in your coffee, I assume that you will not do it. Why? Because you understand that coffee will not taste good and you really need your coffee to stay sharp.

Understanding the big picture of a project will help you build a more robust solution, but also comprehend better how to integrate your pieces in the application.

Therefore, it is all about making a proper project analysis, finding the right questions to get started. Here you have some questions that, eventually, could help to understand better the purpose of the project and how helpful you will be:

1. What is the current behaviour of the application? What is going wrong?
2. What needs to change, functionally, to fix the problems?
3. How will changes affect real-life scenarios?
4. Are there any examples?

You must know that it is essential to identify how your solution works the way it does, on a technical point-of-view. Sometimes you will have to strive to do it, but that will bring many positive things. Try to comprehend how your code works together, not just being fascinated by the fact that it is working; after all, it is no magic show. Thus, you can find quick answers when something goes wrong. In other words, gives you the ability to realise why a specific technology is better for a purpose than others and gives you the knowledge to prevent, in advance, why something is not working correctly and why.

Every time you see yourself in a project meeting, it means that more tasks are on their way to your backlog. Do not panic. Nobody is looking for a juggler. You just need to keep in mind that you need to do one at a time!

It is almost sure that your project manager will give you the priorities perfectly ordered, but even within each task, you need to organise your thoughts and think of a plan to build it. For each task, it is essential that you “break” them into small ones, to give you guidance for developing the solution. This way, you are following a step-by-step workflow wherein you define how to start and how to finish it successfully.

As said earlier in this article, we see constant changes in technologies. What you know now may be different in the short term. The tech you use now will probably be suppressed by another trend that will be the next breakthrough of technology.

However, in the case of newbies like you, these changes could be a little more painful. Because you are just beginning the journey, and not only you but your superiors will need to realise where you can fit like a glove to get the best out of you.

So don’t be afraid to shift from one technology to another, or even from one business unit to another. This means that you will have the possibility to learn many different things and, with that knowledge, identify where your heart does feel more passionate. Keep up the hard work, embrace the change and face that change as your next step to evolving your skills.