Teach Assembly online in English

Assembly is where a program stops being an abstraction. Every line is an instruction the processor actually carries out: copy this value into a register, compare two numbers, jump if the result was zero. There are no variables in the usual sense, only registers and addresses, and a loop is a comparison followed by a conditional jump back up the page. Most learners already know some C, Java or Python. What trips them up is keeping track of what sits in each register, what the flags say after the last comparison and where the stack pointer has got to. Push one value too many and the program crashes three instructions later, far from the line that caused it.

Assembly also comes in as many forms as there are processor families. One student needs x86-64 in Intel or AT&T syntax, another ARM for a single-board computer, a third MIPS or RISC-V for a computer architecture course, and a fourth AVR for a microcontroller on the workbench. A good tutor sees which one the student is facing and shows them what all of these share underneath.

Why we are looking for Assembly tutors who teach in English

Clasora shows students the tutors who teach in the language they use the site in. A student reading Clasora in English is shown tutors who teach in English, so if English is your teaching language, those are the students who find you.

The mnemonics look the same everywhere, but the explanation around them does not. A student taking a course in English needs a tutor who uses the same terms as their lecture notes: “addressing mode”, “stack frame”, “calling convention”, “two's complement”. When the words match, the student can carry what you showed them straight back to the assignment.

Clasora does not employ tutors, and this is an opening rather than a job. You work independently: you set your own prices and hours, and you teach as much or as little as you like. That might be a few sessions a week alongside your own development work, or enough hours for it to stand in for a job.

What teaching Assembly online on Clasora looks like

This opening is fully remote. Every lesson takes place online, and you teach from wherever you live.

Students book from your calendar. They only see the times you have marked as free, shown in their own time zone. You decide how much notice you need before a booking and how far ahead people can book.

Lessons run in the browser, and neither you nor the student installs anything to join. Screen sharing carries most of an Assembly lesson. You can assemble a short program and step through it one instruction at a time in a debugger such as GDB or x64dbg while the student watches the registers and flags change. For MIPS or RISC-V, simulators such as MARS or RARS show the registers, memory and code in one window. A whiteboard app is good for drawing the stack as it grows and shrinks with each push and call, and Compiler Explorer shows what a short C function turns into. The in-call chat is handy for pasting an address or an error message, and background blur keeps your room private.

Between lessons, each student has a conversation with you. They can send the source file that assembles cleanly and then crashes, and you can reply with an annotated version. Messages, files and shared links sit next to the sessions they belong to, so weeks later you can still find the stack diagram you worked through together. Your exercise sets can live in your personal file area, and documents can come across from Google Drive. If you plan your week in Google Calendar, it can sync with your Clasora calendar.

What students usually want help with

Registers and memory: moving data between them, and knowing when an instruction works on a value and when on an address.

Number representation: binary and hexadecimal, two's complement, signed and unsigned values, byte order.

Flags and jumps: how a comparison sets the flags, and how if statements and loops are built from conditional jumps.

Addressing modes: base, index, scale and displacement, and how arrays and structures are laid out in memory.

The stack and procedures: push and pop, call and return, stack frames, local variables and recursion.

Calling conventions: how arguments are passed, which registers a function must preserve, and how to call Assembly from C.

Bit manipulation: masks, shifts and rotations, and the logic instructions AND, OR and XOR.

System calls and interrupts: printing a string on Linux, and handling a timer interrupt on an AVR or ARM Cortex-M microcontroller.

Reading compiler output and disassembly: working out what a compiled program really does, for debugging, optimisation or security work.

Assignments and exams: writing a program to a specification, tracing code by hand, and tracking down a segmentation fault.

Who we are looking for

You write Assembly confidently for at least one architecture, and you can find your way around the manual for another.

You explain clearly in English, and you can translate a C loop into Assembly on the spot, then account for every line.

You can draw what memory and the stack look like at any point in a program, because that picture is usually what a struggling student lacks.

You stay patient when a program crashes for the fifth time, and you treat the crash as a clue.

You might work in embedded systems, operating systems, compilers or security, teach computer architecture, study computer science or electrical engineering, or have written code for a 6502 or a Z80 as a hobby.

You have a computer with a camera, a microphone and a steady internet connection, and your own assembler and debugger ready to share on screen.

You are 18 or older. Teaching experience helps, but it is not required.

What you get

No commission. Clasora takes nothing from the price you set.

Free to join and to publish. There is no subscription and no listing fee.

Your own prices. You set a price for each session length, and you can offer a free first session.

Your own hours. You choose your weekly hours and days off, the notice you need and how far ahead students can book.

A public listing page. Your listing is a page of its own that search engines can find, shown in the language each visitor reads, with your photo, an intro video, what you teach, the languages you speak and your price for each session length.

Reviews on what matters. Students rate you on knowledge, clarity and engagement.

Checked qualifications. You can add your degrees and certificates to your profile, and a moderator checks them.

Lessons in the browser. Video with screen sharing, background blur and in-call chat, with nothing for you or your students to install.

How to start

Create an account with the button on this page.

Publish a listing for Assembly.

Open your calendar and mark the hours you are free.

It takes a few minutes. You accept the terms when you become a tutor, and a moderator checks your listing before it goes live.

Questions tutors ask

Do I need to know every architecture?

No. Your listing says what you teach, so you can offer only x86-64, only ARM, or a microcontroller family you know well.

Can I teach people who have never programmed?

Yes, if you enjoy starting from binary, memory and a handful of instructions in a simulator. Most students already know a higher-level language, so say in your listing who your lessons suit.

How do students run code during a lesson?

The lesson itself needs nothing installed. You share your screen and run the code in your own environment, and the student can send you their files in your conversation before or after the session.

How do I get paid?

Card payments are not switched on yet. For now a booking is confirmed without a card, and you and the student settle payment directly between you. Clasora takes no commission on what you charge.