# Getting started with M68K

[Courses](https://asm-editor.specy.app/learn/courses.md) › [M68K assembly](https://asm-editor.specy.app/learn/courses/m68k.md) › Introduction

Web page: https://asm-editor.specy.app/learn/courses/m68k/introduction/getting-started

> Meet the Motorola 68000, see what assembly programming reveals about a computer, and preview the journey from machine fundamentals to interactive programs.

Overview of this topic: [Assembly basics](https://asm-editor.specy.app/learn/courses/assembly-basics/introduction/introduction.md)

The same topic in: [MIPS](https://asm-editor.specy.app/learn/courses/mips/introduction/getting-started.md), [RISC-V](https://asm-editor.specy.app/learn/courses/risc-v/introduction/getting-started.md), [Z80](https://asm-editor.specy.app/learn/courses/z80/introduction/getting-started.md), [x86-64](https://asm-editor.specy.app/learn/courses/x86/introduction/getting-started.md)

This course starts from ordinary computer literacy. Prior experience with assembly programming is
optional: every M68K idea used in the course is introduced here in the course itself.

## Meet the Motorola 68000

Motorola introduced the 68000 processor in 1979. It became the first member of a family often
called **M68K**, short for Motorola 68000. Versions of this family powered many well-known systems,
including the original Apple Macintosh, the Commodore Amiga, the Atari ST and the Sega Mega Drive
(called the Genesis in North America).

Those machines did very different jobs with closely related processors. A Macintosh used its
processor to run a graphical personal computer; a Mega Drive used one to run games. In each case,
the processor followed a sequence of small instructions and worked with values stored inside the
machine.

The 68000 remains a useful processor to study because its design is regular and its assembly
language is reasonably easy to read. It makes the activity inside a computer concrete. The ideas
you meet here—processor instructions, temporary working storage, memory, decisions and reusable
pieces of code—also appear in modern computer systems.

## What assembly programming does

A processor executes **machine code**: instructions encoded as numbers for one particular kind of
processor. M68K machine code belongs to the M68K family, just as ARM machine code belongs to ARM
processors.

Writing those instructions directly as numbers would be difficult to read and maintain. **Assembly
language** gives the instructions short, human-readable names. A tool called an **assembler**
translates the assembly source into machine code that the processor can execute.

An assembly program describes work in small, explicit steps. A step might copy a value, perform a
calculation or choose which instruction should run next. Larger behaviour grows from these small
operations. Tasks that look simple in a high-level language become visible as a sequence of choices
made by the programmer.

At a high level, the parts fit together like this:

```text
assembly source  ->  assembler  ->  machine-code program
                                           |
                                           v
                                  processor <-> memory
```

The **processor** carries out the program's instructions. It has small working areas called
**registers** for values it needs immediately. **Memory** holds the program and a much larger amount
of data. The course's simulator lets you watch these parts change as a program runs, turning events
that are normally hidden inside a computer into something you can inspect.

## Why learn at this level?

Assembly rewards careful thinking. You decide where values are kept, which operation happens now
and where execution continues afterward. That makes several everyday computing ideas easier to
understand:

- how programs become instructions a processor can execute;
- how data is represented and moved through a machine;
- how decisions, loops and function calls are built from simple operations;
- how software communicates with hardware and its surrounding system.

This perspective is useful when debugging difficult problems, studying compilers, working with
embedded systems or simply learning what higher-level languages arrange on your behalf.

## The journey through the course

You will begin by getting comfortable with the machine itself: its working storage, memory and the
basic vocabulary of its instructions. You will learn how the same stored data can represent
different kinds of values and how an instruction identifies the data it should use.

From there, you will combine instructions into useful behaviour. Comparisons and repetition lead to
programs that make decisions and process collections of data. Arithmetic and bit operations reveal
how the processor works with numbers at a fine level, while arrays and strings provide familiar
problems to solve.

The next stage is program structure. You will build reusable routines, pass information between
them and see how a program keeps track of work that is currently in progress. These ideas support
larger programs without hiding the machine underneath them.

Finally, programs will communicate with the world outside the processor. You will work with text,
input and graphics in the simulator, then examine how the processor responds when an event needs
special attention.

By the end, you will be able to read M68K assembly as a description of a running machine and write
programs that calculate, organize data, interact with input and produce visible results.

Next: [Data and address registers](https://asm-editor.specy.app/learn/courses/m68k/introduction/data-and-address-registers.md)