{"id":21072,"date":"2019-05-23T09:00:59","date_gmt":"2019-05-23T14:00:59","guid":{"rendered":"https:\/\/blog.planview.com\/from-student-to-junior-software-engineer-at-tasktop\/"},"modified":"2019-05-23T09:00:59","modified_gmt":"2019-05-23T14:00:59","slug":"from-student-to-junior-software-engineer-at-tasktop","status":"publish","type":"post","link":"https:\/\/blog.planview.com\/from-student-to-junior-software-engineer-at-tasktop\/","title":{"rendered":"From Student to Junior Software Engineer at Tasktop"},"content":{"rendered":"
\n
\"From<\/div>\n<\/figure>\n

The beginning of my experience as a Junior Software Engineer on one of Tasktop’s ‘Integrations Teams’ marked a definitive transition in the way I learned and practiced computer science and software development. <\/span><\/p>\n

With just a year at UBC’s Computer Science program and a couple of personal projects under my belt, I was initially uncertain of how my skills and experience would translate into a professional work environment. <\/span><\/p>\n

Were the concepts and principles I learned in school actually used in the industry? Were the complex algorithms that I drilled into my memory commonplace when developing a product? Was the amount of Java I learned enough to apply these skills in a real-world setting? Upon reflection, I now realize that the answers to these questions were neither a definitive yes or no. <\/span><\/p>\n

Though there were a bunch of skills that I still needed to enhance and develop, I found the material I learned in an academic setting served as a solid foundation to build my practical development skills at Tasktop. <\/span><\/p>\n

I was drawn to Tasktop because of its strong impact on the software development industry. With a strong interest in new and emerging technologies, I have always been intrigued with methods and technologies that work to increase the efficiency of how software is developed.  <\/span><\/p>\n

I began my co-op term at Tasktop with two weeks of boot camp-style training. I, along with a handful of other Jr. Software Engineers, was introduced to the fundamental concepts and tools on which Tasktop is built. It was also during this time that myriad tools, Tasktop-specific terms, and acronyms were thrown (albeit carefully) at us. <\/span><\/p>\n

While it was a challenge to remember every single concept or term stuck during the first two weeks, I found that these sessions were an excellent introduction to the realm of integrations, and was a helpful preview into the things we would encounter during a typical working day.<\/span><\/p>\n

Though I felt prepared to start developing, I can say that my first dive into Tasktop’s codebase was an intimidating one. The codebases I had encountered up until this point were no more than a few dozen classes large, and undeniably less complex. Though I generally enjoy reading code and taking the time to make sense of it, connecting all of the dots by reviewing the entire codebase would have been both impractical and inefficient. The solidification of the concepts and principles that drive Tasktop connector development was mostly done by diving right into the code, and learning-by-doing. <\/span><\/p>\n

As I slowly eased out of training and into an average working day, and with the guidance of my mentor, it was time to put myself to work. After a few pair-programming and shadowing sessions with my mentor, which allowed me to get the hang of a typical workflow, I slowly started working on my own tasks. I began with simple tasks that allowed me to become more comfortable with specific pieces of the codebase. As I gradually progressed to more complex bugs, tech debts, and user stories, the conceptual pieces started to fit together nicely. <\/span><\/p>\n

It is also very important to mention that my mentor, along with the members of my team, provided great support, which was crucial during the ramp-up period. Naturally, confusion was a familiar feeling during the introductory months. Luckily, for co-ops such as myself, Tasktop’s atmosphere is very collaborative and nurturing. <\/span><\/p>\n

Being part of a team consisting of more senior engineers who are equipped with many years of software development experience meant that if I ever faced with an issue or problem that I could not solve, it likely would not remain unsolved for long. If any questions came up, or if I required clarification, or I was just generally unsure about the task at hand, I could always turn to my teammates to provide valuable insight and advice. <\/span><\/p>\n

Over time, I felt the tasks that I encountered becoming a little less alien and a little less daunting than they may have been a few weeks prior, or even a few days before. I found this hands-on approach to development to be effective in helping me hone my skills. It also placed me in an environment which allowed me to translate the more academic, conceptual concepts I gained from school into a real-world development workflow. It was great to see familiar concepts like design patterns and principles, clean code, code review processes, and test-driven development in action. I definitely had, and still have, a lot to learn. <\/span><\/p>\n

The opportunity to learn through developing, whether it’s increasing one’s depth of knowledge of a particular integration, or learning a new tool to solve a problem, is embedded in the diverse nature of Tasktop’s product, and the broad range of tools with which it integrates. Since the various tools that Tasktop connects are constantly evolving, the tasks we are presented with are seldom repetitive and are a constant challenge our problem-solving skills. <\/span><\/p>\n

Further, I found that connector development is very much a perpetual balancing act between mapping dissimilar tools to a stable, common object model and making necessary concessions to accommodate for diverse, and oftentimes uncooperative APIs and third-party software. Because of this, programming decisions often require careful consideration and much debate, and are not made with haste. <\/span><\/p>\n

I have come to realize that the priority is delivering stable, high-performing software and features that will remain stable and high-performing in the long-term and this is what leads to the successful development of an impactful product. I have come to really appreciate these aspects of integration development at Tasktop, as there are always new problems to solve and many challenges to learn from. <\/span><\/p>\n

In addition to improving one’s programming skills, there are also many other opportunities to learn at Tasktop, including quarterly code jams, weekly lunch-and-learn forums, and guilds to expand one’s knowledge. Learning new things is very much encouraged at Tasktop, and it’s great that Tasktop provides many opportunities to do so. My time as a co-op at Tasktop has truly been an invaluable learning experience and a solid introduction to the software development industry, and I am a better developer today because of it.<\/span><\/p>\n

\n
\n

Table of Contents<\/p>\nToggle<\/span><\/path><\/svg><\/svg><\/span><\/span><\/span><\/a><\/span><\/div>\n