As a computer science student, I obviously fixed bugs in code before. However, the first one I had to fix at FreeAgent felt significantly different from the corrections I had to make in my university assignments and other small projects. I think that was because whenever I worked on a project, I either wrote the whole code or the project contained just a few files. That meant I could skim through the code, fully understand it and know what each method and variable was. After a few hours of working on it, I could probably recall all that information from memory. However, working on a large codebase like FreeAgent’s was a completely different experience.

Starting with a bug

Opening the code felt a bit overwhelming. There were many files, all in different folders within folders and named using a system I didn’t know. I quickly learnt not to worry about most of the files, just the ones I was interested in modifying. If I needed any information about some variable, it was easier to check it when I needed it. I also learnt how much time I can save and how much simpler it is to search for the file or keyphrase I need instead of looking for it manually. That might not be significant with five files containing a couple of lines of code each, but as soon as that increases, the time it takes to search grows rapidly.

The process

The projects I usually work on at university are small, so I wasn’t worried if I did something wrong. If I messed up the code too much, I would have to recreate a few lines of code in the worst-case scenario. Maybe a bit annoying but not too time-consuming. When working on a bug in FreeAgent, I was worried about not ruining anything by adding or deleting the wrong line of code. However, there are lots of processes in place to prevent you from crashing something by accident. I ran into a lot of problems because it was the first time I had used most of the programs, and I hadn’t programmed in Ruby before. However, all my co-workers helped me through any problems I encountered. 

Finished and fixed

Finally, my changes passed all the required tests. It felt very satisfying and exciting when I managed to send off the code to fix the bug and moved the card with the task to the “Done” column. After a short celebration with virtual confetti falling down my screen, I was ready to face the next problem.

Lessons and observations

The whole experience showed me that programming as a job is even more different from university assignments than I had thought. However, I believe both have their appeal. University assignments allow you to discover and try out a wide range of algorithms in smaller, more isolated environments. And coding during an internship is more satisfying because of the real-life problems. It also showed me how significant the coding rules are, which didn’t seem that important when I was working on the small projects at university.