Undergraduate Teaching Assistant

Alongside my full-time Software Engineering coursework, I worked as a Teaching Assistant for SFWRENG 2GA3, Computer Architecture, at McMaster University.

My role was different from a traditional TA position because the course professor taught remotely for the entire semester. As a result, I took on additional responsibility for helping coordinate the in-person classroom experience and acting as a bridge between the remote instructor and the students physically attending lectures.

Rather than simply supporting students outside of class, I was present during lectures to make sure the course could operate smoothly on campus.

Facilitating a remote-taught course

Because the professor was teaching remotely, every lecture depended on the classroom technology and remote connection functioning correctly.

I was responsible for helping prepare the classroom before lectures and ensuring that the professor could effectively teach a room of students from off campus. This included helping coordinate:

• classroom setup
• lecture technology
• remote connection with the professor
• presentation and display setup
• audio communication between the classroom and professor
• smooth transitions at the beginning of lectures
• communication when technical or logistical issues occurred

My responsibility was essentially to make the physical classroom function as an extension of the professor's remote teaching environment.

The professor needed to be able to present material and interact with students as if he were physically in the room, while students needed a reliable way to communicate questions and concerns back to him. I helped make that possible throughout the semester.

In-person point of contact

Since the professor was remote, I became one of the primary people physically available to students during lectures.

When students had questions, I was available in the classroom to help clarify concepts, address confusion, and assist them with understanding the material. This was particularly important because students could not always interact with a remote instructor in the same way they would with someone standing at the front of the classroom.

I helped close that gap by providing an immediate in-person point of contact. If a question required clarification directly from the professor, I could also help facilitate that communication so that students remained connected to the instructor despite the remote course structure.

Supporting computer architecture concepts

Because I was supporting a Computer Architecture course, answering questions required me to be comfortable explaining technical concepts clearly rather than simply knowing the correct answer myself.

Computer architecture requires students to understand how software ultimately interacts with hardware and how the different components of a computer work together. When supporting students, I had to take technical ideas and explain them at a level appropriate for someone who was still learning the material.

This strengthened my ability to communicate engineering concepts in a way that was:

• technically accurate
• concise
• approachable
• adapted to the student's current understanding

One of the biggest lessons from being a TA was that understanding a concept and teaching that concept are two different skills.

Teaching required me to identify what part of the student's understanding was missing and explain the concept from that point rather than simply repeating the original explanation.

Acting as a bridge between students and the professor

The remote structure of the course also meant communication was especially important. I regularly operated between two sides of the classroom:

If students were confused about something during a lecture, I could help address the question directly or make sure it reached the professor. Likewise, if the professor needed something communicated or coordinated within the physical classroom, I was there to help facilitate it.

This required me to pay attention not only to the course material but also to the overall classroom environment. Instead of being responsible only for individual student questions, I had to help ensure that the lecture experience as a whole remained productive.

Classroom coordination and ownership

The unusual structure of the course required a greater level of independence than I initially expected from a TA position. Since the professor was not physically present, there needed to be someone in the classroom who could take ownership when something needed to be addressed locally.

That meant being proactive rather than waiting for the professor to notice an issue remotely. If something was preventing students from properly following the lecture, I needed to recognize it and help resolve it.

Over the semester, I became comfortable taking responsibility for the in-person side of the course while still respecting that the professor ultimately owned the lecture and curriculum. This taught me how to take ownership without needing to be the person formally leading the entire course.

Student support

A major part of the role was simply being accessible to students. Computer architecture can involve concepts that initially feel very different from the higher-level programming students are accustomed to.

When students asked questions, I tried to understand where their confusion was coming from before giving an explanation. Instead of immediately providing an answer, I learned to break problems into smaller pieces and guide students toward understanding the underlying idea.

This required adapting my communication depending on the person. One student might understand an explanation immediately through terminology from the course, while another might need the same concept explained through a simpler analogy or a more concrete example. That ability to adjust how I communicate technical information has been useful far beyond teaching.

Communication skills

Working as a TA strengthened a different side of my technical skill set. In software engineering, technical knowledge is valuable, but developers also constantly need to explain that knowledge to other people. That might mean explaining:

• an implementation to another developer
• an architecture decision to a team
• a technical limitation to a business stakeholder
• a system to someone onboarding onto a project

Teaching students exercised many of the same skills. I had to listen carefully to a question, determine what the person actually did not understand, and provide an explanation that was useful without unnecessarily making the concept more complicated.

Balancing teaching with engineering coursework

I held the TA position while simultaneously completing my own full-time Software Engineering coursework. This required me to balance my responsibilities as both a student and a member of the teaching team, staying prepared enough to support other students while continuing to manage my own academic workload.

That experience strengthened my:

• time management
• organization
• reliability
• communication
• technical confidence
• ability to manage responsibilities alongside competing priorities

It also gave me a different perspective on university courses. Instead of seeing a course entirely from the student's perspective, I gained insight into the coordination required to actually deliver one successfully.

What made this role different

This was not a traditional TA position where my involvement was limited to answering occasional questions outside of lectures. Because the professor was remote for the semester, I had a meaningful role in making sure the in-person component of the course functioned properly.

I helped coordinate lectures, set up the classroom environment, supported communication between students and the remote professor, answered technical questions in person, and acted as a consistent physical presence for students throughout the semester.

The experience required a combination of technical knowledge, teaching, communication, classroom coordination and independent responsibility. That combination made the position particularly valuable to me.

Skills I developed

What I took away from the role

Being a Teaching Assistant taught me that being technically strong is only one part of being a good engineer. You also need to be able to communicate what you know.

A concept that feels obvious after you have worked with it for a long time may be completely unfamiliar to someone encountering it for the first time. Helping students work through that gap forced me to become more deliberate about how I explain technical ideas.

The unusual remote structure of the course also taught me a lot about ownership. The professor trusted me to help maintain the in-person classroom experience while he taught remotely, which meant I could not simply wait for instructions whenever something needed attention. I had to recognize what students needed, help keep lectures running smoothly, and serve as a reliable connection between the students in the classroom and the professor teaching remotely.

That experience strengthened both my confidence communicating technical ideas and my ability to take responsibility in situations where I may not be the formal leader, but where other people still depend on me to help things run smoothly.