/becoming-a-software-engineer

A short guide on how to improve your professional skills within the software engineering industry

Becoming a better Software Engineer

A short guide on how to improve your professional skills within the software engineering industry

Introduction

On this article we will talk about some of the habits and good practices that are important for your professional performance and improvement of your skills, whether you are starting your journey or even if you are an already experienced software developer.

Talking about the boring but yet important stuff.

Soft skills, i know that talking about this might result on crazy sleepness but yet, they are very important even to the point that they are a subject of their own. and this abilities will help us to achieve the goals that we set up for ourselves, they can be helpful not only for our careers but also for our personal lives outside work

we are not going to dive deeper into the subject here, but we are going to mention some of the skills (or at least the ones that i find most helpful) :

  • Communication: Effective communication is key, our environment as software developers demands us (or at least most of the time) to work in groups/teams we have to learn how to transmit concise and concrete ideas, provide information, listen carefully to our peers. thus making this one of the most used skills in our field.

  • Teamwork: As we mentioned before, we (at some point) are going to be part of a large team. and that is why there is the need of working well with others. this doesn't mean that you have to agree with everyone else's ideas, yet having different points of views on the table will help us to build better software.

  • Problem solving: This is related to your capability of solving critical problems (not only on a technical level). when approaching problems, we have to see them objectively even if it is one that we created our selves by accident. one thing to keep in mind is that we don't have to deal with such problems by ourselves. most situations would need a teamwork effort to solve them, is always better to ask for help to a coworker that can give you a different perspective to the problem from their point of view.

  • Time management: As a personal note, I'd say that this is one of the crucials. you have to be smart with your time management. this will allow you to organize your time and therefore make the best out of it.

Now to the good part

Most of the things that we learn throughout life are from experiences. And how do we gain experience on certains technical skills that are required to perform proficiently, consistently. we gain this knowledge from exposure, exposure to the tools, concepts and practices that will allow us to improve our skillset and thus allowing us to become better craftsmen of our profession. here I'm going to list some of the hard skills that any software engineer needs to become proficient at, in order to deliver high quality software:

  • Know your programming paradigm: wheather it is object-oriented, functional or structured. you need to dive deeper into the theory, concepts and practices of your programming language. for example since I'm a mobile applications developer, i work a lot with kotlin and swift which are object-oriented programming languages (of course they have some functional features but we mainly treat them as object-oriented) this forces me to know their OOP features. such as encapsulation, polymorphism, inheritance, abstractions, know the difference between a class and an objects.

  • Design patterns: okay they are several, maybe borderlines the too much spectrum but these patterns attempts to solve different problems and/or situations, their main purpose is to add order and intention to our code, so for example if we see a builder pattern, we already now that the author of that piece of code only wants us to interact to the api through its builder, and not spend too much time trying to figure out what is the purpuse of that piece of code. So I'm just gonna list the ones that I use the most:

    • Most known OOP patterns: Builder Pattern, Factory Pattern, Singletons, Delegation Pattern, Observer Pattern, Repository pattern.

    • Architectual patterns: this is more related to the way that we organize several pieces of code that handles different responsibilities -> Model-View-Controler, Model-View-Presenter, Model-View-Viewmodel, VIPER (View-Interactor-Presenter-Entity-Router).

    patterns are a subject of their own. we are not going to dig into their concepts, this is just a mere reference so we can start looking into them.

  • S.O.L.I.D.: The S.O.L.I.D. programming principles were conceived by Robert C. Martin, better known as Uncle Bob. in an attempt of reducing the entropy that systems might gain over time. making the code more understandable, flexible and maintainable.

  • Unit Testing: Whether you develop through a test driven technique or you write your test at the end of the implementation of the methods, this is a very common way to add another layer of validation to the code we are implmenting. in fact most of the architectual patterns that we mentioned before were thought in order to let us test easier our code.

  • Code Review: This is one of the most important aspects one can develop. having the practice of analyzing and understanding someone else's code is beneficial to us. it can expose us to new techniques and concepts. which would allow us to be more critical about our code and in time be critical about others code. keep in mind that code reviewing should be open. there are no dumb questions. we expose the code and is in everybody's intention to make it better.

  • Coding Style Conventions: Following coding conventions makes our code more understandable for others, making the proccess of code reviewing or even debugging faster. there are severeal coding conventions that apply to different languages, techniques and situations. the best approach is to have your team to agree on following one coding convention.

  • Contribute to OSS: One best practice for software developers is to contribute to OSS. Contributing to open source software will allow you to develop most of the skills listed above. since most of the popular projects have very rigorous steps and standards that you need to follow in order to contribute. the best way to start contributing to a public repo i would say is to start easy. just pick some public repo here on github, and start doing some unit testing. or bug reporting.

Tips and Tricks

Just a small list of personal thoughts

  • Find a resourceful way to learn new things: learning new things can become cumbersome, and there is a lot of stuff out there, lately for me I have two main resources of information, Podcasts and official blogs/docs from apple and google regarding Mobile App Development.

  • Apply new concepts with basic examples: When learning a new topic, first try to internalize the subject. then try to apply the new concept into a simple example.

  • Always finish what you started: This is more of a reference to a personal habit, consider this cicles are meant to be completed at some point, even if it takes you years to accomplish a personal goal, it is better for you to push yourself to complete them, you will find ease of mind by doing so.

  • Don't be shy: Some people are way too intimidated (or proud) to ask for help rememember that we as software engineers make best decisions by actively discuss issues, approaches, ideas. so if you find yourself stuck. just ask your co-workers for help.

  • You can't know everything: I know that this might seems overwhelming regarding all the information that was listed here, (in fact this is just the tip of the iceberg) internalizing all of this would take years, that is why you have to take it one step at a time. pick a subject study it well. and then move to the other one. don't try to understand everything at once.

References

Books: