13 Pro Tips for Junior Web Developers

Whether you are fresh from varsity or just started with the world of web development, this article will give you some tips to make the journey a little easier. If you have any questions or feedback on the article, please do leave a comment at the bottom!

1. Plan before you code

Whatever project or task you are taking on, it's important to start with a plan. If you just jump in heads first, you will most likely end up building things that either don't work or isn't needed. Either way, you will be wasting time.

Any project is the sum of the tasks needed to complete that project. Therefore, to truly get the scope of the project, the best place to start is a Task Board. We use Active Collab and I highly recommend it. For a free alternative, check out Trello. Or check out these 10 Trello Alternatives. These "board solutions" allow you to create tasks and place them into different categories. Each task can store notes and comments from different developers. Here's an example of an Active Collab Board in action:

Active Collab Board

Columns can be created for "In Progress" or "Done", so you can easily see the status of tasks, but ultimately, how you use the board is entirely up to you. We have a wide range of different columns on our own different boards, depending on the need for the each specific project.

If you are working at a company, chances are there might already be a task board in place. That doesn't mean your planning stops there. Once a task is assgned to you, you also need to plan how you are going to complete that task. Depending on the type of task, there can be a range of tools you can use to plan better:

Designing a Database? Use a UML design tool like Yuml.me.

Building a website? Start with a wireframe with Moqups.

Perhaps you only need to solve a bug? In that case, make sure you understand the problem before you jump in. A pen and a piece of paper might be good enough to wrap your head around the problem. Only write your first line of code once you know exactly what is needed. And definitely ask for more instructions if you are unsure. It's almost always better than going ahead and building something that is wrong or not needed.

2. Stay up to date with popular technologies

I am not a big fan of Wordpress, but it's still a tool I have spent time mastering because of its popularity:

There is a good chance you will come across Wordpress in your career, even if it's just to set up a temporary blog. Similarly, I can say the same about other frameworks like Laravel and Symfony. And of course, Drupal. It might even be worthwhile to dabble a bit with Joomla. But the important thing is to identify a few popular applications and learn the basics of each.

Learning about all of these will not only mean you can actually write code for these platforms, but it also means you can learn about the different ways these solutions are put together. A very big part of being a programmer is knowing which tool is the best tool for the problem at hand, and if you only know one tool, you won't be able to suggest other solutions, nevermind implement them. Be open to learning new technologies!

3. Read the error messages

Many developers tend to get an error message and then switch back to see if they can change something in their code to fix the error message, without ever even reading the message. The first thing you must do when you encounter an error message is to try and understand the error message. Read what the message says and follow the stack trace. It will tell you the exact line where the error is originating from, giving you the first clue you need to start solving the error.

Drupal Stack Trace

If you simply switch back and guess what the problem is, as many developers often do, you might still solve the problem, but it will slow you down in the long run. If you take time to understand the error messages, you will immediately know whether you made a typo or if perhaps something more serious is wrong. Take time to understand the error messages that pop up when you develop.

4. Read the documentation

Just about every Programming Language, CMS or Framework has its own documentation. If it doesn't, you should seriously consider switching to an underlying solution that provides decent documentation. Then make use of that documentation. If you are asking questions like: "What does this function do?", or "What parameters does this function take?", then you are probably not resorting to your most valuable resource as a developer: the documentation. And if you choose the right IDE (see point 4) you can have your documentation built into your programming environment, meaning the answer is literally a click away.

Developers not reading documentation is a major frustration for other developers. There is no such thing as a stupid question, but there certainly are lazy questions. Sometimes it's pretty obvious that no effort was made to use the tools available to find the answer. Don't be that guy. Make sure you have tried all you can before bugging other developers. This can be difficult when you are very new, so if you really do ask other developers for the answer, try to understand how they went about solving the problem so in future you at least don't ask them about the same thing twice.

5. Invest in a good IDE (Integrated Development Environment)

If you are programming in Notepad++, Sublime or any other basic text editor that does not offer advanced features like code completion and integrated documentation, there's a good chance you are not working as fast as you could be working. The switch might be frustrating at first, as you would need to learn how the new IDE works, but ultimately you would save hours and improve the quality of your code, which will make it worthwhile.

I have used NetBeans for a very long time and I still do if I need to work on Java projects. But as I primarily write PHP code, I switched over to PHPStorm for PHP Projects about a year ago. It costs 199 USD per year (which is about N$3000 per year or N$250 per month). The price initially scared me away, but now I can't live without PHPStorm. If you code in PHP, I highly recommend trying it. The first month is free, so you will have ample time to test it and make sure it's for you.

If you don't program in PHP, there's a good chance NetBeans has you covered, which is free. But do some browsing around before settling on a single solution.

6. Learn to love Git

Git is an amazing piece of technology that if used correctly, can reward you with a worry-free deployment environment and many other benefits. The problem is that Git can be a little intimidating at first, particularly the concept of "branches". This will take practice, but for starters, make sure you understand the concept of a "master" branch and how to merge up and down between other environments.

The best way to learn Git is to create your own Git repository. This guide sums up the process quite nicely.

If you want to set up your own git server locally, the easiest solution I can recommend is GitBlit. But you can also just use a public account from Github. Here at Namhost, we store our code in-house, but many companies prefer to make use of Github, so a Github account is a great place to start. Also, it's free to host public code repos.

PRO TIP: If you use Github, try to keep it professional. If you manage to write code that you can post publically on Github, it can be a fantastic reference on your CV.

7. Learn from others (... you don't know everything)

"The only true wisdom is to know that you know nothing."
- Socrates

As you transition from Junior Developer to Intermediate, to Senior, you'll realise at each level, just how little you knew when you were on the previous level. You will probably also notice that your confidence levels have changed over that period. Junior Developers are famously overconfident. Over time, this confidence generally drops. That is because it is normal to feel like you know less, the more you realize how there is to know. That doesn't mean you should lose your confidence completely. It just means that you need to be mature enough to realise that you do not know everything and use the opportunity to learn from your peers. Don't always think you know better.


8. Processes are there for a reason

How deployments happen, where logs are kept, how SSH keys are used or even how your firewall must be configured on your computer. There are always reasons why a company wants these things done n a certain way. Don't assume things are just being done because the company is being overly cautious or is "stuck in the past". Processes often ensure security in ways that you might not understand until you have become more familiar with the system.

9. Know your limits and avoid burnout

You are likely to find it easier to work until 3 AM when you are in your twenties, compared to when you are in your thirties. And I do feel you should use your twenties to work on more projects and to ultimately learn as much as you can, but it can easily become very unhealthy to constantly work odd hours. Focus on the basics to avoid burnout:

  • Sleep enough hours (most people can easily get away with 7 hours)
  • Eat healthy foods (and avoid junk food and overeating)
  • Exercise (even if it's just 30 minutes a day)

Sounds simple, doesn't it? Then why is it so difficult?! You need to figure that out for yourself. Everyone is different. All I know is that I've told myself every excuse in the book. The reality is that I haven't met a single person who said: "I don't have time for exercise", who actually really didn't have time. Or who ate fast foods, because they "don't have time to make food". There's always an excuse. Stop making excuses and you'll not only live a healthier and happier life, but you'll also definitely avoid burnout.

10. Understand the real-world impact of your code

It's important to have a deep understanding of programming, but programming is ultimately only a tool used to influence the real world. You are using it to build systems for humans. Whether that system is a website where users log in to perform actions or a backend process that users never see, it is ultimately about connecting code with the real world.

If you don't understand how your code affects the real world and the people that use it, you are not going build elegant solutions. If you work at an investment company but don't know anything about Retirement Annuities, you'll probably have a hard time writing useful code. Whatever the business, you still need to understand how the company works and operates. That way you can make sure the code you write will function correctly when implemented. Always take the time to learn more about the company and not just the code you are writing.

11. Don't follow instructions unless it's in black and white

E-mail and chat solutions, like Skype, have made it a lot easier to go back and find out who didn't follow an instruction properly. It's not always fun to have to say, "But you said so and so", but sometimes it's the only way to reach a conclusion. For that reason, always make sure you do have confirmation of an instruction in some or other written form before you perform an action. It can be an e-mail, or a chat log or preferably, by having all the information on the related ticket on your scrum board.

PRO TIP: If you work at a company that doesn't have a scrum board, be it Trello, Active Collab, Jira, or anything else, then you really should encourage them to use one, even if you are the only employee.

PRO TIP 2: We primarily use Active Collab. It's worth every penny. But for something free, or maybe for smaller projects, Trello is perfect.

PRO TIP 3: Check out "git blame". It allows you to see exactly who committed a piece of code and what message they left when they changed that piece of code!

12. Code can get ugly... very ugly

Did you stumble upon a piece of code that you can't believe is as bad as it is? Code is often ugly and lacks the elegance that hindsight can provide. I've been guilty of it myself, finding a piece of code saying, "What on earth happened here?", and then 4 hours later you realise why no one has touched that particular piece of code.

Don't jump to conclusions when you see bad code. Investigate it and make sure you understand it before you try to improve it.

13. Treat people with respect

This is just a general life-rule. No one wants to help someone who isn't respectful. And part of that respect is to also give credit where credit is due. If someone helped you, mention it to them. Or if someone really taught you something amazing that had a drastic impact on your life, give them a thank you when no one is around. It makes the world's difference.


Share this Post

Leave a comment