Being a developer is hard. Not only we have to know technical skills, but we also have lots of soft skills that we’ve to get good at.
In this article, we’ll look at the ways that we can get better as developers.
Build a Big Side Project
Side projects are great for practice. Bigger ones mean more practice. It’ll give us so much practice that whatever we used will become muscle memory.
We can build bigger apps like a Facebook or Reddit clone. If we’re building our own Facebook clone, then we can build all the features including chat and friends features.
If we’re going to build a Reddit clone, then we build out the subreddit and moderation capabilities.
These are examples of a big side project that’ll give us lots of practice. We can build it with the frameworks and languages that we like to learn more about and then so that we can understand them more.
Contribute to Open Source
Open source projects are everywhere and they all need help. So we should contribute to them so that we can learn and they can get help.
That way, we’ll learn about forking repositories, making pull requests, committing code, and more.
It also means that we can follow their conventions and guidelines.
Working on community packages is also different from working on a regular job so we can get different kinds of experience than a typical job.
Alternatively, we can build our own packages and reveal the source.
Look at Other People’s Code
Other people’s code provides us with wisdom that we probably don’t have. It’ll expose us to different styles of programming and show us things that we can do with a programming language, library or framework that we probably haven’t seen before.
If the code sucks, then we can also learn from them and avoid the bad practices that are exhibited in the code.
Understand Programming Design Patterns and Principles
There’re many design patterns and principles that we can look into.
Some principles include SOLID, KISS, YAGNI, MVC, and many others.
SOLID is a good one to know since it’s a good way to organize our code. It means that we divide our code into parts that do one thing.
Also, code shouldn’t open for modification but should allow for extension.
It also enforces designing code by contract by having a fixed interface while the code implemented it can change.
Abstractions are also encouraged and make high-level code independent of the low-level details.
KISS stands for keeping it simple, sweetie. It’s obvious, simple code is better than complex code if they do the same thing.
YAGNI stands for You aren’t gonna need it. It’s similar to KISS and it’s all about not adding code unless it’s necessary.
MVC is pretty much the standard pattern for back end apps with the model being the data layer, view for presentation, and a controller to connect the model and view together.
Learn High Demand Skills
This goes without saying. We can always learn high demand skills in areas that we enjoy working in so that we can get a job we like.
If it’s something we don’t like then we won’t enjoy it. And if it’s something that has no demand, then there’s no job that uses it.
So it has to be both together.
Design skills can be learned by anyone. We can focus on making things prettier by learning from designers and then applying when we’re developing UIs.
We’re building things for customers, so we should always empathize with the customer and build some that have good user experience so that they’ll enjoy using it.
Simplicity, usability, consistency are all important principles with user experience.
Building a big side project will give us plenty of practice until what we do becomes muscle memory.
Looking at other people’s code no matter if it’s good or bad. We just need to look at them and learn lessons from them.
If it has good parts then we learn them. If it has bad parts, then we learn not to do them.
Non-development skills like design and user experience are also important and we should learn them as well.