Tips on How to Get Through Your First Year as a Junior Developer

Image by StockSnap from Pixabay

Regardless of whether you have just finished your computer science degree or if you are self-taught, your fist year in software development can be exciting yet daunting. This article will provide advice on how to make the next twelve months easier and more enjoyable.

  1. You don’t have to know everything

If you have completed any sort of degree, boot camp or online course, you will have all the knowledge to be able to code. But, when it comes down to the actual job of a coder, you will need additional skills:

  • Understanding which is the appropriate technology to solve problems
  • Reading code written by others
  • Design patterns
  • The ability to test code
  • CI/CD, source control, branching strategies
  • Appreciating software development strategies
  • Teamwork

Maybe you already have experience in some of these areas, which is great. However, if you don’t, there is no need to panic. Everybody in your working environment understands that you are t in a junior role. At the end of the day, as IT is continuously changing, to some extent, all developers are still learning.

  1. It’s good to ask questions

It’s Murphy’s Law that all of your enthusiasm on your first task only leads to an error message because there is something wrong with your code. You know you are going to have to ask someone but it’s just so embarrassing. Nobody is going to think you are an idiot, on the contrary, most people are going to be willing to lend you a hand.

You will win more points by asking questions than sitting around wasting time and being unproductive. Use the support that is available to you.

  1. Learn from Code Reviews

The first time a senior developer reviews your code is very similar to being called into the head teacher’s office. You are waiting for a list of negatives and criticism. In fact, code reviews are excellent learning opportunities. Particularly at this stage, the more feedback you receive, the better it is for your career.

Never forget your first code review. One day you might be in a senior position reviewing a junior’s code. Think about how you felt and how much you improved from the session.

  1. Break each task down into manageable bites

The size of your first task might be small, or relatively large. Some will want to jump straight in, while others may feel overwhelmed. In either situation, take a step back and make a plan, break the job down into smaller, manageable tasks. Use the traditional pen and paper to write down the steps.

  1. Keep it simple

This isn’t specific to software developers but every new job we start we feel like we can make huge differences and change the system for the better. You might want to write elaborate code to solve a problem. In reality, you might find yourself overcomplicating things, creating a code that is harder to maintain, more open to bugs and lengthen the time to complete the task.

In order to keep it simple, you need to make sure the code works, refactor it to make it easier to read, and finally optimize it so that it is faster. It might be worth writing some failing tests (Test Driven Development) for good test coverage.

  1. Learn how to write clean code

Being able to write clean code will keep you ahead of other junior software developers. To write clean code you should:

  • Follow the S.O.L.I.D principles
  • Ensure the code is testable and maintainable
  • Check it is easy to read and follow

While any developer can write code, only brilliant programmers can write clean codes that humans can read. For more advice on how to write clean code, many developers turn to Clean Code: A Handbook of Agile Software Craftsmanship by Robert C Martin.

  1. There may already be a solution

While racking your brain for a solution to a problem, it is possible that somebody has already come up with a solution. You can look for existing packages and libraries or browse sites like GitHub and StackOverflow.

Now, you can’t just copy and paste somebody else’s code, but you can use it to discover a particular design pattern or understand why it’s written in a certain language. Looking at someone else’s code may help you to see the drawbacks of the code.

Letting your team know you are going to search for libraries or packages may start some interesting conversations about solutions they have seen/found.

  1. Learn how to read code

Our job has been made to look like we quickly type lots of code as it comes out on over-sized screens. Outside of TV and film, we actually spend more time reading code than writing it. Adding to code or fixing defects requires you to understand the codebase. The only way to do that is to read it. Here are some things to look out for when reading code:

  • The design patterns
  • How methods, classes, and variables are named
  • How comments are used
  • The structure of project files
  • The tests used and how they are structured

Again, GitHub and StackOverflow are good places to start reading code. You can also try repositories in your source control and code challenge websites like

Some bonus tips

  • Have fun and enjoy your job. You are one of the lucky few who can say their job is their passion.
  • Learn the language, not the programming language, but the terms and expressions developers use.
  • Familiarize yourself with your IDE, hotkeys, and shortcuts. Customize it.
  • Work with bugs helps you to learn about codes.
  • Listen to all the advice people give you, write it down if necessary
  • If you have any free time, use it to take on some side projects, it will increase your learning and improve your CV.
  • Participate in work events, make yourself part of the team.