My Journey as a CSE 12 Teaching Assistant at UCSC

Teaching RISC-V Assembly to the Next Generation of Computer Scientists

This academic year I had the privilege of serving as a Teaching Assistant for CSE 12: Computer Systems and Assembly Language at the University of California, Santa Cruz. The experience has been one of the highlights of my PhD program. It pushed me to deeply understand RISC-V assembly, strengthened my passion for teaching, and connected me with over a hundred students taking their first steps into low-level programming.

CSE 12 at UCSC is a core course taught by Prof. Marcelo, and it introduces students to the fundamentals of computer systems using RISC-V RV32I as the primary assembly language. The course is hands-on, system-focused, and extremely rewarding to teach.

Starting My TA Role: A Summer of Remote Teaching

I began my TAship journey during the Summer quarter, where everything was conducted entirely remotely. Even though I had never taught a full class before, the remote format became a good opportunity to experiment with:

• structured lab walkthroughs
• annotated RISC-V examples
• live debugging of student code
• breakdowns of ISA concepts
• walkthroughs of the RARS simulator

Despite being virtual, students were very engaged. Many of them had never written assembly before, so my goal was to make the learning curve as approachable as possible.

I focused heavily on connecting concepts to intuition:

• Register vs memory distinction
• Why RISC-V has only 32 registers
• Immediate formats
• Stack operations
• Function calls and calling conventions
• The meaning behind every instruction format

Remote TA’ing taught me to communicate clearly and visually. Screensharing RARS, writing live comments, and drawing diagrams helped students grasp ideas they had previously found intimidating.

Transition to Fall: Teaching In Person

The Fall quarter was my first time taking these lessons into an actual classroom. Now the teaching experience was completely different — better, more interactive, more spontaneous, and more rewarding.

During my in-person sessions, students could walk up to me, ask questions on the spot, show their laptops, and debug code line by line.

Below is one of the pictures taken during my live session, as I walked students through their first full RISC-V programs in RARS:

During the session I explained:

• How RARS loads and runs an RV32I program
• The role of the Program Counter
• How the assembler expands pseudo-instructions
• How the “Data” and “Text” segments are managed
• What registers like sp, ra, and a0–a7 do

Students were excited to see assembly “come alive” in a simulator instead of being just abstract instructions.

Here is another moment captured during the session while debugging a student program:

(Insert Image 2 here – RARS code visible on the projector)

What CSE 12 Teaches — And How I Help Students Understand It

Since I know the course structure well, I summarized the key topics I guided students through:

1. The RISC-V RV32I Base ISA

We spent a significant portion on the fundamentals:

• R-type, I-type, S-type, B-type, U-type, J-type formats
• Register naming conventions
• Arithmetic instructions
• Logical operations
• Memory loads and stores
• Branching
• Jumping
• Immediate handling
• Machine-level bit layouts

My approach was to always link theory to execution. After explaining an instruction format, we would immediately assemble and run a program in RARS. Students could see the register file updating in real time, which made concepts click instantly.

2. Memory, Data Segments, and the Stack

I emphasized memory organization, because this is where most students struggle.
We covered:

• .text vs .data vs .bss
• Global variables
• Stack allocation
• Alignment
• Why stack grows downward
• Frame pointers and function call structure

I noticed many students initially tried writing assembly in a “C-like” mental model. My job was to help them switch to low-level thinking: understanding that nothing happens unless the programmer makes it happen — from loading arguments to saving return addresses.

3. Function Calls and Calling Conventions

One of the hardest but most important parts was explaining the RISC-V calling convention:

• a0–a7 for arguments
• ra for return address
• s0–s11 as saved registers
• The role of the stack during nested calls

To make this intuitive, I walked the class through a full example of a function call, showing:

• stack pointer movement
• storing registers
• restoring values
• returning control flow

Pairing this with RARS’s “Memory → Stack visualizer” made it much easier.

4. Debugging Assembly Like an Engineer

This was one of my favorite skills to teach.
I worked hard to give students the thought process behind debugging, not just the steps. We walked through:

• reading register dump outputs
• tracing PC jumps
• checking branch conditions manually
• validating immediate sign extension
• verifying memory accesses
• catching off-by-one pointer mistakes

Several students told me later that this was the moment assembly finally felt “real".

My Teaching Philosophy During the TAship

Through these two quarters, I discovered that my teaching style naturally gravitates toward:

1. Clarity first

Break down instruction formats and concepts until students can explain it back in one sentence.

2. Visual understanding

Use RARS, diagrams, live annotations, and example runs.

3. Connecting theory to systems

Explain why RISC-V conventions exist, not just the rules.

4. Encouraging exploration

Motivate students to try out variations, test their own ideas, and experiment safely.

5. Patience and mentorship

Never rush students. Assembly is hard. I meet them where they are.

This approach created an environment where students felt comfortable asking questions and making mistakes — essential for low-level programming.

Working With Professor Marcelo

Prof. Marcelo has been incredibly supportive. His structure for the course, clarity in slides, and carefully designed labs made TA’ing a joy. He encourages student-driven learning and gives TAs freedom to shape lab sessions in their own style.

As one of the two TAs handling the labs this quarter, I always felt trusted to help steer students in the right direction. His guidance helped me become a better teacher.

Why I Love TA’ing RISC-V

Teaching RISC-V feels meaningful. It is not just another architecture — it is the architecture shaping the future of computing. Helping students understand it from the ground up gives them a skill that stays relevant for years.

Seeing students go from:

• “Assembly is scary”
  to
• “Wow, I actually executed my own program”

is extremely rewarding.

Looking Ahead

I hope to continue teaching for future quarters. Each session helps me grow, and every group of students brings new energy and curiosity. I also hope to introduce more advanced RISC-V topics, like:

• compressed instructions
• basic pipeline intuition
• real hardware simulators
• connecting assembly to compilers

Teaching has become a core part of my PhD journey — something I genuinely enjoy and will continue pursuing.

Final Thoughts

Being a CSE 12 TA has changed how I understand learning, teaching, and communication. It has strengthened my fundamentals in RISC-V, boosted my confidence as an educator, and reminded me why I chose this field.

Most importantly, it showed me how fulfilling it is to help students take their first steps into systems programming.

If you are a student reading this:
Keep exploring. Ask questions. Experiment. Assembly teaches you things no high-level language can.

And if you are another TA or instructor:
Thank you for helping students build the foundation of computer science.