How to graduate from being a “junior” developer
“Junior” — the first rung on a developer’s career ladder — is the one we’re all in a hurry to get past. While distinctions between what a “junior,” “intermediate” or “senior” developer may vary, opinions are unanimous when it comes to a few specific points.
A junior developer is someone who has yet to demonstrate his or her ability to consistently produce quality work, be it in front of a project leader during a client meeting, the client’s technical team during implementation, or a more experienced developer during code review.
If you’re a junior developer, we’ve got a few tips to help you avoid sending bugs into production and to ensure that the ones that do escape your attention aren’t fatal. These tips will bolster your confidence and independence, and, ultimately, show your supervisors that you’re truly deserving of the title of “Intermediate Developer.”
Tips for junior developers
Learn to backtrack
Own your code: Get comfortable with a code version management tool, like Git or SVN. For instance, learn their basic concepts and have a clear branching system, making sure you know the most common operations and leave relevant comments.
When it comes to messing up with a DBMS (database management system), don’t even think about touching production data until you can do the following:
- export data to create a copy, and.
- perform a rollback (that is, cancel changes)..
Unless you can execute these operations in your sleep, don’t touch data! Lost data means lost time and money, or worse.
Learn to debug your code
All contemporary languages allow you to do things like monitor code during execution and to add breakpoints and console outputs. They allow you to delve quickly into projects in progress and learn their structure, and they are indispensable for debugging your own code. A variety of such techniques and tools are available, depending on the language you want to use.
Just as knowing how to read and write doesn’t make you a writer, knowing how to code doesn’t make you a developer. Write your code so that it’s readable for machines and humans alike. Humans will generally read code to change or correct it, and there’s no guarantee that you’ll be around to explain it. So, follow the golden rule: create self-explanatory code. Read up on the subject at hand and learn about the best and worst practices in your field (for example, names of variables and methods, further nomenclature, indentation and documentation).
Test code before sending it
The quality assurance (QA) team can catch many balls you'll drop, but they won’t go fishing them out of the bottom of a lake for you! As developers we are the people most closely acquainted with the code and can assess the impact of our changes. You can validate the number of instances in which the modified method is called up within a few seconds by using a good IDE, which will avoid bugs down the line for the QA team, the client and users.
Once we developers say that our code is ready, we have to be confident that it is, in fact, ready.
Best foot forward
Become more detail-oriented
The best developers do everything humanly possible to ensure that they complete the task as instructed, asking for clarification as necessary. There’s a reason someone took the trouble to write specifications. It’s up to the developer to make sure that those specs are followed to the letter.
Effective developers provide thoughtful solutions, not the first solution that comes to mind. They take pride in their work and see that it’s entirely completed before sending it for review to colleagues, clients or others to avoid wasting their time. Their work is always dependably good.
The first step to solving a problem is acknowledging that the problem exists. Developers learn from their own mistakes and those of their team. And since everyone makes mistakes, the chances to learn are endless! Better a glitch detected and corrected than a glitch that slips by without mention.
Roll with the punches
Normally, developers are not involved in each-and-every decision made during a project. Respected developers are those who are willing to admit that they don’t know everything. They can live with the fact that their proposed solution won’t always be the one that’s chosen since there are more experienced people on their team. While their solution might seem like the best one to them, it may not suit the client simply because of budgets, deadlines or legal (and other kinds of) restrictions. So don’t get offended, it’s not personal!
Developers take part in discussions, but learn mostly by listening. Since all projects involve at least two people, they have to learn to work professionally with others. They ask questions to clear up grey areas and keep the project moving forward. When they learn something new that could be useful to others, they document it and share it.
Tackling a problem as a group is sometimes the best solution. Two brains are better than one: hence innovative developers use “pair programming” approaches. Sometimes, even a rubber duck is better than nothing! (See the Rubber Duck Debugging method.)
Developers make the best impression when they accept that it isn’t up to their more experienced colleagues to teach them, but that it’s up to them to learn. They know, for example, that projects may demand they locate and assess the quality of information along with learning it on their own.
Clients change their minds, sometimes after weeks of work. It’s frustrating, but that’s life. Every change of tack may cost money, and the client will be well aware of that fact. Effective developers know that it’s best to ask why a change was necessary so that they can avoid it happening again by advising future clients.
Focus on the big picture
The best developers maintain an overall vision of the entire project to analyze needs, advise the client, and don’t get emotionally attached to the part of the project they’ve been specifically tasked to complete. They look beyond the task at hand. They may have been working on a task for days, but are able to set it aside to take on another, more important and urgent priority. With an eye to new tasks coming down the pipe, they are constantly reassessing priorities.
Curiosity is the last, but by no means the least important personal attribute of great developers, as technology is evolving at an ever-increasing pace, thanks to open source libraries. Developers have to accept change, and even seek it out. Otherwise, their talents quickly become obsolete. This rule holds true at every hard-earned rung of the job ladder. And you can be sure that employers are always looking for developers who are continually updating and improving upon their skills sets.