What are your tips for junior developers in their learning path?
Allow me to congratulate you on making it to being a Junior developer. That means that you have learned how to code well enough to be hired to write software professionally. You are no longer a student or an intern but have taken the first step in your career. The question now is how best to progress in your career.
Believe it or not, if you do your job as a Junior developer well for a few years, people will promote you to being a Mid-Level developer just as a reward for time-served. You don't have to learn anything new at all. You only have to deliver your commitments on time with a high degree of quality, and providing your team likes working with you, you'll eventually get promoted to a Mid-Level developer. To say it another way, if you fail to grow your skills at all as a software developer, you will probably still get promoted to a Mid-Level developer.
Being promoted to a Senior Engineer, however, is a different situation entirely. As a Junior engineer, your mentality should not be to get promoted to a Mid-Level engineer, but to a Senior Engineer, which is an entirely different mindset. Where the line between a Junior developer and a Mid-Level developer is fuzzy, the line between a full developer and a Senior developer is sharp.
Senior developers are supposed to be highly effective and very efficient, which means they know the right thing to do, and how to do it quickly. They should be able to take on ambiguous and ambitious features by themselves, in rapidly evolving circumstances, and still deliver on time. Senior developers are expected to learn the skills they need when they need them and not require the company to provide training for them. They should be excellent communicators, valuable team players, and reliable executors. The bar for a senior developer is very high, and to make sure that you will eventually be able to cross that bar, you need to begin investing in yourself on your first day as a Junior developer.
Investing in yourself is the best investment you can make as a software developer. A software developer makes their living by developing software, and the better you are developing software, the more career options you will have. All you have to know to be a Junior developer is how to code, but knowing how to code is only a small part of learning how to develop software. Being able to get a computer program to do what you want is only one of many aspects of getting a feature into production. Collaborating on requirements, refactoring existing code, figuring out the best testing strategy, doing just enough up-front design to get started, but not so much as to be paralyzed are just some of the areas that separate coding from software development.
Developing software is a vast topic, and the industry is still figuring out the best ways to do it, which makes it challenging when deciding on the best way to learn software development. Fortunately, there is a two-pronged strategy that should establish a firm foundation no matter what the future of software development looks like:
Study to build up your knowledge.
Practice to build up your experience.
To become a junior developer, you had to learn how to code, but you did not necessarily learn how to develop software. One way to characterize the difference between coding and software development is:
Coding - Being able to write syntactically correct code to implement a feature that meets specific requirements.
Software Development - Being able to apply your knowledge of coding effectively and efficiently within the context of running a business.
You can also think of the difference in terms of being able to cook vs. working in a restaurant:
Cooking - Being able to follow recipes and applying techniques to produce meals.
Restaurant - Being able to apply your knowledge of cooking effectively and efficiently within the context of running a business.
The caveat of "effectively and efficiently" is necessary, because if your work is not effective (you don't do the right things) or not done efficiently (you waste time) then the likelihood of keeping your job long-term decreases.
To become a junior developer, you had to learn how to code. There is a dizzying array of learning materials to learn how to code today, too numerous to mention. Unfortunately, for software development, much of the best information is still only available in books - long and sometimes dull books.
Over time, the same quality of information on software development in books will begin to transition to online courses. However, so far, this transition has been slow only due to market demand: there is an overwhelming demand for resources on learning how to code, and practically no need for learning software development. Indeed, most developers think software development is a process such as Scrum, and don't realize that Scrum barely scratches the surface of software development.
Which books you study to learn software development depend on your interests. For example, I was very interested at the start of my career in learning how to build increasingly complex enterprise applications, so my interests lead me to the following books (among others):
Clean Code - Bob Martin
Design Patterns - Gamma, Helm, Johnson, and Vlissides
UML Distilled - Martin Fowler
Refactoring - Martin Fowler
Extreme Programming Explained - Kent Beck
Test-Driven Development: By Example - Kent Beck
Patterns of Enterprise Application Architecture - Martin Fowler
Domain-Driven Design - Eric Evans
Working Effectively with Legacy Code - Michael Feathers
Enterprise Integration Patterns - Hohpe and Woolf
My progression into the platform architect I am today would be impossible without the foundations these books gave, and even 20 years later, it seems few online learning materials exist that are as concise and well written. I hope this situation changes shortly, but for now, I believe studying seminal works in the form of textbooks are still the best way to learn software development.
Practicing software development requires you to build things on your own. Indeed, you will do some of this during your day job, but there's no guarantee you will be practicing doing the right things in the right way. Often, you will find yourself thrust into a codebase rife with poor coding practices in the middle of a dysfunctional project. In situations such as this, you run the risk of picking up bad habits that will stay with you your entire career. The antidote to this is to build applications in your free time.
There is quite a bit of debate around the necessity of coding outside of work hours. People complain that it will lead to burnout and a lack of work-life balance, and these concerns must be taken into consideration - especially for people with families. Spending time coding when you should instead be spending quality time with your spouse, or playing with your kids, or attending to aging parents is a long-term recipe for disaster. When it's all said and done, your legacy will not be how you code but the life you lived. If you sacrifice the latter for the former, you will look back on your life with regret, and it will be too late to regain ill-spent time.
Having said that, if you're a Junior developer, the odds are that you don't have the responsibilities of a family, and you should be spending your evenings in a coffee shop surrounded by textbooks as you try to develop progressively more difficult apps. Will you have to maintain this level of diligent self-investment your entire career? Perhaps not as frequently, but there will be a need for continuous self-improvement as technologies evolve and change. Is it a critical aspect of progressing beyond a junior developer? I believe it is. Is there a shortcut to study and practice as a formula for establishing a solid foundation upon which you can build the rest of your career? If there is, I am not aware of it.
Neil writes a lot more about the softer side of software development over at neilonsoftware.com. Check it out!