When I joined Frogslayer as a Junior Developer last year, I knew the first thing I needed to learn was how to work on a project in a disciplined manner. For years, programming had been a hobby, a past-time, where I could jump from one project to another at a whim. I would frequently start a project, fix a couple of bugs, then flit to another. I had not been able to maintain enough discipline to start and continue many projects for long, and my computer was full of half-done attempts. Free from the chains of deadlines and estimates, my programming journey was guided purely by the whimsy of time.
However, I didn’t expect the other lessons I learned. My transition into developing professionally at Frogslayer allowed me to know a whole other side of programming – one of communication, intentionality, and organization.
Lesson #1: Communication and Confidence are Key
One of the greatest difficulties I had was figuring out how to fit into a team environment properly. I had yet to learn how to align my goals sufficiently with those of the team or how to ensure that I was not working at cross-purposes against them. I would worry that I was going in the wrong direction and solving the wrong problem. In my fear, I leaned a little too far into the other side of the ditch, constantly double-checking things with my teammates and distracting them from their tasks.
This was a difficult phase to work through and required that I build enough self-confidence in my abilities (especially as compared with and working alongside other programmers). I also had to improve my communication skills, understanding how to succinctly grasp the goal of the team without having to check over every minor thing.
Lesson #2: Haste Makes Waste
The second thing I unexpectedly struggled with was rushing to produce work. Much of my difficulty with this lay in the fact that I was anxious to get my tasks done, wanting to accomplish as much as possible. Frequently, I’d forget crucial details in my pull requests, forget to post images or check some important detail in a last-minute change.
As the saying goes, “haste makes waste.” I had never worked on something that had any deadline or outside dependency on it; I could do what I wanted when I wanted. When faced with the burden of others depending on me, I frequently rushed through tasks, not doing due diligence in verifying that what I had done worked properly and had not caused further bugs. I had to force myself to slow down, double-check my work and ensure that it was correct before submitting it.
Lesson #3: Balance Onboarding & Productive Work
The last lesson I’ve learned since transitioning from personal to professional projects is balancing learning about a project and accomplishing tasks in it. I realized I needed to know who in the project had subject matter experience or specific technical experience and with whom to propose ideas. I also had to discover how to properly communicate what I was trying to do to the rest of my team. I had to tame my natural arrogance in thinking that I always knew the right thing to do, but also realize that it wasn’t impossible that my propositions had some validity (and never bring them up at all).
This balance was the trickiest I have had to manage since becoming a junior developer. I am still trying to learn how to contribute to the project without attempting to take it over and try (and fail) to impose all my decisions on it.
I have learned that communication and discipline are vital to being a good team player in professional software development. Discipline is essential to get anything done, whether it be on the project itself or my own skills in working with others. Communication is vital to coordinating my efforts with others and learning from my mistakes. Although I have made many, I hope to continually learn from them, always growing and never decaying.