Becoming a good developer is not easy. Over the past two years while mentoring some of my more junior colleagues, I have been looking for ways to raise their skill level as quickly as possible. There are many approaches to mentoring, but each of them takes a lot of time to understand and implement. Therefore, I have tried to make a relatively brief summary of what I personally consider the most important.
At the outset, I would like to mention that my heart belongs to the development of, specifically iOS mobile applications. So in the article you might find some links and tips that directly relate to iOS. However, I believe there is still definitely value for everyone and finding an equivalent for your platform should not be a problem.
1. Keyboard shortcuts
Keyboard shortcuts create the clear advantage of a faster workflow. A few minutes of searching and learning shortcuts can save you hours in the long run.To get started, I would recommend becoming familiar with the shortcuts for starting and building the project, opening a file by name, or perhaps moving a line of code.
Do you have a task at work that you do over and over again? Time to automate it! It could be about a project build and sending it to the client, downloading translations or generating reports. Such tasks, in addition to being time-consuming and making you feel like a trained monkey, are also prone to human error. And there is nothing worse than making a mistake at the beginning of the process and being forced to start all over again. You can automate these tasks yourself, using bash scripts or with the help of fastlane, which was primarily created for automation of (but not only) the creation of iOS applications and help to easily create certificates or upload build apps to the store.
Templates are another way to save time during routine work. If you're using VIPER, MVVM, or another form of architecture, you're probably using boilerplate code. This kind of code is repeated constantly, but it needs to hold the selected architecture and technical solution together, so it’s very important. We can create a template for practically anything we need. Most IDEs will have templating support built right into them. Another advantage besides saving time is that across the project, the code will be ordered in the same way and have the same naming and formatting, which will increase the readability of the entire project.
4. Project versioning
Another powerful tool in the hands of the developer. For most programmers, versioning is synonymous with the system software - Git. Even in the hands of a beginner, it can be great for creating functional "checkpoints" that can be returned to.
When working with versioning, I recommend using some of the popular GUIs (Sourcetree, Kraken , etc.), which facilitate conflict resolution and eliminate the need to remember individual commands. At the same time, it provides a way to easily look line by line at the changes made.
5. DRY, KISS, YAGNI
A few simple principles that are worth following to increase code readability.
DRY - Don't Repeat Yourself
- We should avoid duplicate code.
KISS - Keep It Simple Stupid
- A simple and straightforward solution is better than a complex one. Straightforward things will be more understandable and easier to maintain.
YAGNI - You Ain't Gonna Need It
- We don't create more than we need.
- We are not afraid to remove old and unnecessary code. Experience tells us that unused code won’t ever be needed again, or everything around it will change so much that it won't be usable anyway. And even if it ends up being usable, we can always roll it back using Git.
6. Number of lines of functions and classes
The only rule with hard numerical limits on this list. A class should have a maximum of 300 lines and 40 functions. Exceeding the first number is for me, a sign of a poorly set architecture on the project and insufficient distribution of class responsibilities.
Long functions lead to less readable and editable code. Such a function is also more difficult to reuse and you can easily find yourself copying parts of the code.
7. Code readibility
Unreadable code will be difficult to modify, errors in it will be almost undetectable, and the info pertaining to what it should do and how it works will be lost. It is important to realize that I am not making the code readable just for others but also for myself. What may seem perfectly understandable and clear to me now will seem like foreign code to me in a few months.
As for specific recommendations - naming variables, functions, and classes appropriately is one of the best weapons a developer can have to make their code understandable to others. I would also recommend doing a code review with your team, because it is great to get feedback on the readability of your code.
8. Try new things
The last advice is quite simple, try new things and don't be afraid :). Trying new things in a progressive industry such as programming should be the natural course. No one wants to just rest on their laurels. Therefore, he should always have a supply of new ideas and procedures on how to do things better.
In conclusion, I would like to say: "Nothing is set in stone" and everyone has to find what suits them. If a subject interests you, try to find out more about it or ask your colleagues about what they use and how they do it. And if you want to find some colleagues like that, check out what open positions are available here at MeguMethod!