How would you keep improving as a software developer? The obvious answer is improving your technical (programming) skills. However, the component that is often overlooked is improving your soft skills. Soft skills are just as important as your technical skills. Your soft skills are what influences your people skills, social skills, communication skills, character traits, attitudes, career attributes, emotional intelligence and much more.
My goal in this post is to offer some tips about what I do to improve myself in both technical and soft skills.
Design and Architecture
Breakdown Problems
One of the most common advice that really works. Take a complex problem and break it down into small pieces. Solve each small pieces and put everything back together to get your solution to a complex problem.
Software is a Tool
Remember you are developing software in order to solve a problem. The type of frameworks or programming languages that you used to get there is irrelevant. Do not get too caught up in choosing which technologies to use.
Plan Before You Code
Plan out your code before you actually code anything. You can write out pseudocode on a whiteboard or paper. It may seem like a waste of time, but it really does help a lot. For example, it starts up your brain to think about the problems and help spot out any potential issues in your design before you write any code. This will save you time because you will run into fewer issues when you do the actual coding.
Understand Your Architecture
You have chosen to implement your application in a specific environment. You should understand what happens in the environment that you have chosen. You need to know what happens in the front end, back end, data store, the operating system, and hardware. It is a lot of information, but between development to production, knowing this information will save you a lot of headaches.
Learning Languages and Tools
Learn Enough to Start
Sometimes you may block yourself from starting because you are focusing too much on reading books and resources first. The problem with reading too many books and resources before you start coding is that most of what you read will be forgotten. This is because you do not truly need that information at that time. Learn the basics to get you started then come back to the books and resources with questions.
Focus on Learning How To Program
Do not focus on learning programming languages. There are too many out there and is growing in number day-by-day. Instead, focus on learning programming techniques, problem-solving, and analytic skills. These type of skills are transferable regardless of what programming language you use.
Choose the Simpler Programming Language
The more complex a programming language is the more cognitive load it is on your brain. When possible, choose the simpler language and save that energy for the problem-solving.
Avoid Reinventing the Wheel
Chances are that there may already be a library for what you need. It is better to use that library, which has been tested than to develop your own. Not only do you save time, you can focus more on reaching the solution.
Know Your Tools
If you are using certain programs repeatedly such as an IDE (Integrated Development Environment), you should familiarize yourself with its hotkeys and shortcuts. In the long run, it will save you plenty of time.
Code Maintainability
Write Readable Code
Write code that is easy to comprehend. Imagine if you have to revisit the same codebase after a year. Would you be able to understand what you were doing? In addition, other developers will likely see your code and work with it too.
Avoid over Generalizing
Reusable code is helpful and important, but they are not always worth the time. Overgeneralized code is usually harder to maintain and is more prone to cause bugs. If your code only needs to do one task, it is okay to hardcode it.
Learn to Have Effective Variable Names
Naming your variables is a skill in itself. When your variables have meaningful names it helps convey what you are trying to do. The same goes for function names. When variables and function names are meaningful, they are considered self-documenting, which helps eliminate the need for excessive comments.
Learn to Debug with Print Statements
Sometimes, you may not have a sophisticated debugger available to you. However, in most development environments you will almost always have the ability to output text to console or file.
Maintain Up-To-Date Documentations
With any projects you will work on, it is highly likely that there is documentation for them. The problem with documentation is that most developers do not update them or they wait until the end to write them. At that point, they probably have forgotten half the information. Instead, you should document any changes as you go. This ensures that the documentation is up-to-date and is as detailed as possible since the information is still fresh in your head.
Technical Debt and Development Process
Keep It Simple
Whenever you have an option between a complex solution or a simple solution always opt for the simple one. A simple solution is easy to work with. You can use the simple solution as a base foundation for a working solution and then iterate it to make it more efficient.
Testing
Within the context of your project, learn how much testing is required. Too little testing can make your code unreliable and unsuitable for production. However, too much testing would delay production and end up wasting time.
Deliver Code in Chunks
You should commit your code in small working chunks and include a detailed message along with it. This will help other developers understand what it is that you try to do. It also helps in finding bugs that are caused by that commit.
Bug Hunting
Bugs will happen and hunting them down will take some time. Be prepared to spend hours hunting for one bug.
Productivity
Set Large Chunks of Time for Focused Coding
This is the time when you are really getting things done. During this time, you are in the “zone” and writing code without interruptions. Schedule any meetings or replying to email outside of these set time frames that you set for yourself.
Take Breaks
Taking breaks is good for you. It helps to refresh your mind from the cognitive load that programming has on it. This allows you to continue developing in a refreshed state oppose to a worn-out one.
Communicate
Communicate what you plan to do each day. Talking about your approaches with others will help you see it in new ways. Chances are that your team will have some ideas that you would have never thought of on your own. This leads to faster problem-solving.
Googling
Googling effectively is a crucial skill as a developer. When learning how to do something you have not done before chances are you will need to go through multiple iterations to find an optimal solution. However, googling allows you to find some optimal solutions to the problem you are solving while reducing the number of iterations you will go through. Not only are you saving time, you are also learning from the collective intelligence of the developer community.
Soft Skills
Admit You Do Not Know
You should not be ashamed to admit that you do not know something. As a developer, you are often solving new problems that have not been solved yet. When you try to hide the fact that you do not know something, it only hurts you and slows down the learning process.
Emotionally Detach from Your Code
It is easy to be attached to your code when it resulted from hours of your hard work. Unfortunately, there will be times when your hard work needs to be scrapped. This can happen from bad technical decisions or unforeseen limitations with certain technologies. Starting over is difficult, but is especially difficult if you are attached to your code.
Teach
It does not matter what stage you are in your career. Even if you are a novice in programming, you are knowledgeable about something and can talk about it in a unique way that you understand it. This can be helpful to other novices because you are explaining it to them in their own language.
When you are teaching what you know to others, you are also teaching yourself. Being able to teach others is a mark that indicates that you really understand a subject.
Embrace Failures
Failures are common in software development and the sooner you accept it, the easier it is for you to leverage failures. Failures is not always bad because it provides you with feedback and helps lead to better results. In addition, failures are learning opportunities because now you know what works and what does not.
I hope you found this helpful. If so, share it with others so they can benefit as well.
Is there something else you believe would be a great addition to the post? Are you already doing some of these tips and want to share your results? If so, feel free to leave a comment, send me a tweet, or send me an email at steven@brightdevelopers.com.
To stay in touch, you can follow me on twitter.