Published on

My Story With Tech

13 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.

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.

My second (and also third/current) internship was 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).

Right now, I’ve been doing 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 coincides with a lot of the things I learned with compilers. More specifically, I find myself needing to perform parse tree traversals to extract bits and pieces from the code to validate. One example of this is being able to effectively extract all GraphQL queries from a piece of code, even when some are stored in strings and then evaluated later. I’ve also recently begun work on mitigating clever attempts at prompt-injection attacks on the AI-generated apps feature, which is also very interesting to me.

Closing

I still have some time before my current (as of writing this article) internship at Shopify ends, and much more time before I graduate from university. There’s still so much for me to explore in this space, and I’m excited to see where the future takes me :)