Published on

My Story With Tech

17 min read

Introduction

Programming as a passion, hobby, and career pursuit has been a part of my life for a decently long time now. There have been many different events through the years that have pulled me in different directions within this field, and I thought it would be nice to document for those interested—and for myself to update as a journal of sorts as I move forward in life.

Table of Contents

The Early Days

Scratch

The gateway into programming for me, and what started it all, came during a summer camp shortly after fifth grade. There, I was introduced to Scratch, a game engine of sorts developed by MIT that functioned solely through “block programming”. That is, function calls, variable declarations, and any control flow logic would be represented as visual blocks that you can drag and snap into place like pieces of Lego. It was a very intuitive way to code games, and I was instantly hooked.

I’d always loved making things as a kid, whether it would be free-form Lego creations (I would often decompose Lego sets and meld them into my own oddly themed models—think Lego Star Wars painted bricks mixed with yellow pieces taken from a Lego City dump truck formed into a plane piloted by a fish-headed minifigure from a Lego Atlantis set) or I’d create cardboard boats, rubber band guns, or anything that could be feasibly made with cut up Amazon boxes and a hot glue gun.

Scratch then became another outlet to freely create, and it became special to me because I loved playing video games, but also because I could access it almost anywhere and share my creations with almost anyone. The feeling of being able to tinker on creations at home, at school, day or night was incredibly liberating. I didn’t have to deal with cleaning up my messes or waiting until I could be in my room to sit on the ground and pick apart Lego sets.

So, I spent hours and hours making games and then sharing those games with my friends and other classmates. It caught on to such an extent that people would be playing my games during indoor recesses or any free time, which was an incredibly rewarding thing to experience. Throughout all of sixth grade and into seventh grade, I would continue making Scratch games and was entranced by the idea of using code as an outlet to create things. If you happen to be curious, you can still go to https://scratch.mit.edu/ and search up “penguin__person” in the search bar to see what games 12-year-old me came up with.

Web Development

After discovering Scratch and the wonders of programming, I had a desire to learn a “real” programming language. So, in seventh grade, I remember searching “easiest coding language to learn” on Google and coming across something called HTML. I guess for technicality sake, HTML isn’t really a programming language in the same sense that imperative languages like Python or C++ are. However, going from dragging and dropping blocks, any form of coding that involved typing text felt like hacking into the matrix to me.

For a couple of years, until high school, I spent time learning the ins and outs of HTML (and then shortly after styling with CSS). It certainly felt like a whole different ball game compared to looking at colourful blocks inside the Scratch code editor. However, it still felt undeniably rewarding. Seeing plain text in a code editor being transformed into styled webpages with pictures and links felt like utter magic (and even now in university, after learning the basics of how code is tokenized, parsed with a context-free grammar, then semantically checked and transformed into machine code or some other form, it still feels like magic how it all works).

Although I had learned how to make webpages in HTML and stylize them with CSS, I didn't actually get any further than looking at my creations locally in a browser. I was still unequivocally clueless on how code is deployed or served on the internet—that leap would come later.

High school

Web Development (but for real now)

My frequent sessions of learning web development (and overall time invested in anything programming related) sort of waned as I started high school and began to get preoccupied with keeping up in school, making new friends, and adjusting to the radically new environment. However, in tenth grade, I joined a small non-profit organization that focused on free education for children to adult ages. The founder and owner of that organization was also the same person whom I had taken a few extracurricular classes from when I was in elementary school. She needed a website for this new non-profit, and knowing me quite well, asked if I wanted to develop that website for her.

I enthusiastically agreed, both excited to get back into the world of programming and also because it meant securing a pretty lucrative source of volunteer hours I could count towards my diploma. It was here that I learned how to deploy my first actual website. Now tasked with delivering a real product that needed to be accessed by anyone on the internet, I had ample motivation to dig into exactly how domains work, what DNS records and DNS servers were, and how different services could host static web files. Within a couple of months, I had finished a pretty basic but functional website written entirely with plain HTML and CSS. I then figured out how to transfer ownership of a domain name (that the founder had already purchased) and then hosted the static site on Namecheap because I was cheap and it was in the name—pun not intended.

This then marked my first real piece of “production” code, and in the process, I also learned what git was and how I could use it to organize/save my progress. The actual GitHub repository for that site is private (and to be honest, I’m not even sure if I remember the logins for the account I used at the time). The non-profit itself is also not as active anymore, but you can still view the site at best-edu.ca. It is by no means the prettiest and could definitely use a modern overhaul, but I think it still served its purpose well. As a bonus, you can also still find an old tenth-grade photo of me in there too.

Hackathons

The spring of tenth grade marked my first-ever hackathon. I actually didn’t even know about the concept of a hackathon until a friend asked me if I wanted to try one with him. We literally signed up for the first one we could find (and this was also during the COVID-19 lockdown era, so there were a plethora of online hackathons), but naively didn’t look into the hackathon itself too much. So, we ended up in a European hackathon/summit that was intended for the brightest global industry minds. Now, why they let in some random high schoolers with next to no experience, I will never know. Unsurprisingly, we did not finish our product and ended up so demoralized that we didn’t even make a submission.

Nevertheless, my hackathon journey did not end there, and the following summer, I teamed up with more friends to tackle an actual student-oriented hackathon. We developed a productivity web app with features like goal tracking and a built-in Pomodoro timer, and at the time, I was actually quite proud of how it turned out. We hosted it using Firebase, and this was also the first time I was exposed to implementing server-side functionality and dealing with a database. That being said, the code was still entirely in the frontend as Firebase took care of all the actual work in the backend. That original web app is still hosted here https://thyme-9d8e1.web.app/, although the actual sign-in functionality (and consequently the rest of the app) has since broken.

I participated in one more hackathon in the summer before grade twelve, in which my friends and I created a stock trading emulator that used YouTubers as a stand-in and would query for their analytics (subscribers, views, etc) to calculate their “stock price”. This was my first exposure to using external API’s, and thus having to deal with managing API keys (in which I quickly learned that YouTube API had some annoying rate limits). Between the last hackathon and this one, I had also learned of the existence of frontend frameworks and how much more powerful they can be in creating complex web views compared to sticking with plain HTML, CSS, and JavaScript.

Paralleling my initial endeavour into web development, I searched “easiest JavaScript framework to learn” and up popped Vue. So, in this hackathon, I made my very first full Vue app. However, I later learned React, as it seemed to be much more popular and used it in future hackathons (and in this very website!).

Coursework

High school also marked the first time I took any formal computer science course. I learned the basics of control flow logic (although I was already quite versed in that field at this point), recursion (which I had heard of but was still confusing to me), and object-oriented programming (which I had no concept of at the time). It was through taking these courses that I started to get a taste of the theory and craft behind programming, which intrigued me beyond just the practicality of making cool stuff. Both final projects (for the eleventh-grade and twelfth-grade versions of the course) involved making a game, which was also a nice full-circle moment in that making games is what kicked off my journey into this discipline. My sixth-grade self would have been amazed to see me code a full game, complete with a GUI, in Java.

This interest in grasping the theory behind programming would be more than satisfied going into university, and I even find myself a little exasperated at just how deep we go sometimes (I’m looking at you, CS 245).

University (present)

More Coursework

Having gone through nearly three years of university coursework now, I have a much more confident grasp on the underlying mechanisms that drive computers and programming languages themselves. I also feel more confident in my ability to write good-quality and future-proof code. As pretty much all of the courses have been mandatory so far, I haven't had much opportunity to focus on one specific aspect of computer science. That being said, a lot of the low-level-oriented courses intrigued me more, especially one course I took on compilers. Perhaps it was the way it was structured—the entire course revolved around incrementally building your own fully functional compiler—but I really enjoyed learning about the incredibly complex machine that a compiler is and picking apart the many layers that dictate how they work. To me, they seem like the most magical part of programming. They are what translates human-understandable code into 0s and 1s to be whizzed through microscopic transistors sitting on incredibly complex datapaths that modify existing 0s and 1s or spit back new 0s and 1s at lightning fast speeds that now represent the changes and stuff the code originally described (I'm simplifying here not only for brevity but because I also still don't have a full grasp of how everything works—and I'm excited to continue learning more). Moving forward, I think going deeper into compilers would be cool, and there is, in fact, an upper-year compilers course that I can take!

Internships

Being in a co-op program at university as well, I also have had the opportunity to partake in multiple internships, and going through my program, I will have the opportunity to partake in many more.

CIBC

My first internship was at CIBC (the Canadian Imperial Bank of Commerce), and it was my first time working with an enterprise-level codebase. As I was writing software for one of the largest commercial banks in Canada, there were quite understandably many rigorous standards, testing phases, and general practices that I had to get used to upon working in this environment. This was where I first learned of the importance of writing unit tests with good coverage and of writing deep integration tests as well. It is also where I learned of the general principles behind writing secure APIs and providing good documentation. To be honest, it was a very slow experience actually shipping any code, and it did frustrate me at times. However, I did take away valuable knowledge on good design principles as well as general industry-level coding standards, and most importantly, the level of rigour required to guarantee undeniably robust code.

Shopify

My second (and also third) internships were at Shopify. This was a complete 180 from the environment at CIBC. Here, I learned how to ship fast and to fix things fast. Gone were the long QA processes or week-long staging environment test cycles. At Shopify, I could write code and literally have it deployed to production within ten minutes. This utter contrast taught me that different companies can have vastly different cultures, and that there can be many different ways you can approach writing and maintaining industry-level code. I would say, however, that I definitely preferred the Shopify style of programming. It sort of brought me back to the unrestrained creative freedom that enticed me into the world of programming in the first place. That being said, it wasn’t completely loose, and I certainly did still learn and hone my craft in creating maintainable and good quality code.

Another thing that I’ve appreciated about Shopify as well is how diverse the work is. I’ve been able to work on a production-level React codebase, a Rails server codebase, and a Python LLM model evaluation codebase, all within a matter of weeks. It’s because of this diversity that I’ve been able to hone in on what interests me more in this field, and what I perhaps do not like doing (I’ve ascertained that working with a massive React codebase is quite the nightmare for me—I find it hard to stand how many layers I have to trace through and all the complex states and asynchronous functions I have to keep track of).

I also did a lot of work with server-side validation of LLM-generated code as part of a broader project to allow users to AI-generate their own Shopify apps, and this coincided with a lot of the things I learned with compilers. More specifically, I found myself needing to perform parse tree traversals to extract bits and pieces from the code to validate. One example of this was being able to effectively extract all GraphQL queries from a piece of code, even when some were stored in strings and then evaluated later. I also worked on mitigating clever attempts at prompt-injection attacks on the AI-generated apps feature, which was very interesting to me.

Compass Data & AI

My fourth and most recent internship was at Compass Data & AI (CDAI), the data and ML division of the Compass Group (a large multinational food service company). Strangely enough, this experience was almost another 180 from Shopify. If Shopify had a brisk and rather liberating culture around shipping, then CDAI was absolutely blazing. Part of the reason for this was because I primarily worked in internal tooling and infrastructure at CDAI, and most of the code that I worked on were new pipelines, cloud resources, dev tools, and so forth. Consequently, there wasn’t a “prod” that I had to worry about, and most of the work that I did carried very low risk of disrupting any critical products. So, this all accumulated in me being able to push up a pr and have it shipped in literally under a minute (as my team was also quite close knit and very quick on reviews—especially on small prs).

My work at CDAI was also a complete pivot from much of the work that I’ve done prior. This was the first time I truly delved into infrastructure work, having spent every past internship essentially working on fullstack development. I found it fascinating figuring out the underlying services and pieces that actually make production apps run reliably and securely. It felt like gaining another perspective on the software ecosystem, and being able to understand what was largely blackbox prior. It was a pretty liberating feeling facing a deployment error or CI failure and knowing that it was 100% in my power to fix it instead of being confused and sending a screenshot or log dump in a slack help channel.

Most unique of all however was the sheer amount of reform and change that happened while I was working at CDAI. During the first couple of weeks there, the company (or at least the CDAI division of the company) felt almost analogous to a startup. There were very few set standards, and a lot of POCs and experiment apps. Most of the developers were more data scientists by trade than software engineers, so there were a lot of questionable “production” apps being written (one of which, somehow, had a completely unauthenticated endpoint which just contained a Gemini API key).

With all this, there was a huge push towards more rigorous standards across the board, and I got to be a big part of enforcing those standards and creating the tooling and infrastructure to enable it. Pretty much any large tech company will have their own standards and rules that you have to learn and conform to. I think it was really cool being one of the people making those rules for future developers, and seeing the decisions and debates about how to balance development velocity with quality. It was because of this unique environment, that I felt that I was able to learn so much about what makes software truly enterprise grade, and how to design workflows and developer tooling around that standard. Another thing that came out of being in the middle of a massive overhaul was that I was handed an incredible amount of agency and ownership on my own work, and frankly trusted to make good decisions about new CI pipelines, checks, and infrastructure. It’s what led me to being able to completely design, build, and share a new MLOps pipeline for scheduled jobs for attribution ML models. Having the privilege to tackle it almost completely on my own allowed me to learn so much about how ML models are trained, organized with version control, served, and monitored. All while also considering modularity and transparency of the pipeline itself to allow for it to accommodate the needs of all developers far into the future.

Closing

As of writing this now, I still have two more internships to go in my degree, and I have yet to decide what aspect of software to pursue. Having experience with fullstack development, and now infrastructure, and DevOps/MLOps, I feel that the one frontier I haven’t explored in true depth yet is ML and data work (funnily enough, despite being at an ML/data company). I’ve already tried taking a stab at it with a personal project (proseparse.com) — which I will likely write a piece on in the near future.

However, irrespective of the domain of software, all I truly want is to work at a new place, to learn new things, and to meet cool new people.