This is going to be a two-parter about how Junior Developers gain technical proficiency and the advantages and disadvantages of each method. For this part, I'll talk about gaining technical proficiency through experience. In my next post, I'll talk about gaining technical proficiency through self education.
As Junior Developers, often our number one enemy is lack of technical proficiency. Our lack of technical proficiency is often the key reason that we make mistakes, that we feel dumb, and that we aren't as productive as the more experienced programmers. These side-effects of our lack of technical proficiency directly result in our not always working on the most exciting projects or with the most cutting-edge technologies.
While at times, most Junior Developers may bristle at the idea of not being at the forefront of their companies' projects, as a Junior Developer, you must view the situation from your boss' perspective. The more important the project, the more likely the chances that your lack of technical proficiency may lead to any number of mistakes. This mistake could simply be writing bad code or could result in the loss of absolutely critical user data. With that in mind, you can see that it's more time- and cost-effective for your boss to put you on smaller, less mission-critical projects or to have you doing routine maintenance on current projects. Your boss likely hopes that through working on smaller side projects you will gain the technical proficiency needed to work on the bigger and more exciting projects.
So now you ask the very obvious question: How can I get me some of that technical proficiency?! Very simply, there are two ways to gain technical proficiency: Experience and self-education. In this article, I will discuss the advantages and disadvantages of learning through experience. Next time I'll hash out self education.
Experience arguably produces the most gains in a Junior Developer's technical proficiency, and for good reason. Experience can teach lessons that self-education cannot. Experience reveals whether or not those high-level theories you learned in college or read in other developers' blogs are truly practical and usable in the real world. Experience teaches a Junior Developer which tools work best for a certain job and how to better use those tools. Experience can even be second-hand, as talking to a senior developer can yield some of the best advice and practices that the Junior Developer has ever come across.
There exists, however, one very ugly side to experience, and probably the chief cause of instantaneous bowel-emptying: Mistakes. A Junior Developer's lack of experience will very often cause him to make mistakes. The mistakes are usually benign in nature and are expected of someone with his level of experience. For example, maybe the Junior Developer wrote inefficient code that called the database too many times, or perhaps introduced a logic flaw into a piece of code he was maintaining, or left a WHERE clause out of an UPDATE statement. These problems can easily be fixed with a little guidance (and a visit to the transaction log!).
Unfortunately, not all experience-related mistakes are fixed so easily. Many times have Junior Developers caused major problems that may have cost the company thousands or even tens of thousands of dollars. Such mistakes not only damage the company financially, but they severely damage the Junior Developer's confidence. In a perfect world, the boss would remain calm and realize that such problems result from the Junior Developer's lack of technical proficiency and experience, but in the real world, ass-chewings, finger-pointing, and even being sent home for the day are possible end-games for such serious mistakes.
The making of such mistakes can not only cost the company lots of money and seriously shake the confidence of the Junior Developer, but they put a large strain on the boss-employee relationship held between the Junior Developer and the Team Lead (or Project Manager, or whatever title is used at your company). By making such a huge mistake, the Junior Developer violates the trust of the Team Lead, since the Team Lead in essence delegates the programming jobs for which he does not have time to his developers and Junior Developers. When anyone messes up, that trust is violated, but when a Junior Developer messes up, the effects are more profound, since there's not much trust there to begin with.
The best advice I can give about gaining technical proficiency from experience consists of one central tenet: Always be able to undo whatever you're doing. Just as importantly, be sure that you know how to undo it. If you can sort of cushion yourself against your own mistakes by always knowing that you could undo your last goof-up, then you'll be able to experiment a little more freely and program with a little more peace of mind. Be weary when you begin working in an area where you're not particularly knowledgeable about how to undo your own mistakes.
There exist many other facets of experience and its effects on technical proficiency that I will visit throughout many posts, but those are the chief pros and cons, at least in my mind. Next time, I'll talk about self education, that double-edged sword that can offer great gains in technical proficiency, at least if you find some some that's actually applicable in your real-world situations.